[ffigen] Support for passing/returning Structs by value. (#134) (#163)
diff --git a/pkgs/ffigen/CHANGELOG.md b/pkgs/ffigen/CHANGELOG.md index 4fcb483..1345b70 100644 --- a/pkgs/ffigen/CHANGELOG.md +++ b/pkgs/ffigen/CHANGELOG.md
@@ -1,3 +1,6 @@ +# 2.0.0-dev.1 +- Added support for passing and returning struct by value in functions. + # 2.0.0-dev.0 - Added support for Nested structs.
diff --git a/pkgs/ffigen/README.md b/pkgs/ffigen/README.md index 4eb22ec..3956835 100644 --- a/pkgs/ffigen/README.md +++ b/pkgs/ffigen/README.md
@@ -373,8 +373,6 @@ ## Limitations 1. Multi OS support for types such as long. [Issue #7](https://github.com/dart-lang/ffigen/issues/7) -2. Function's passing/returning structs by value are skipped. [Issue #3](https://github.com/dart-lang/ffigen/issues/3) -3. Structs containing structs will have all their members removed. [Issue #4](https://github.com/dart-lang/ffigen/issues/4) ## Trying out examples 1. `cd examples/<example_u_want_to_run>`, Run `pub get`.
diff --git a/pkgs/ffigen/example/libclang-example/generated_bindings.dart b/pkgs/ffigen/example/libclang-example/generated_bindings.dart index 616826f..0edbcb9 100644 --- a/pkgs/ffigen/example/libclang-example/generated_bindings.dart +++ b/pkgs/ffigen/example/libclang-example/generated_bindings.dart
@@ -16,6 +16,32 @@ /// The symbols are looked up in [dynamicLibrary]. LibClang(ffi.DynamicLibrary dynamicLibrary) : _dylib = dynamicLibrary; + /// Retrieve the character data associated with the given string. + ffi.Pointer<ffi.Int8> clang_getCString( + CXString string, + ) { + return (_clang_getCString ??= + _dylib.lookupFunction<_c_clang_getCString, _dart_clang_getCString>( + 'clang_getCString'))( + string, + ); + } + + _dart_clang_getCString? _clang_getCString; + + /// Free the given string. + void clang_disposeString( + CXString string, + ) { + return (_clang_disposeString ??= _dylib.lookupFunction< + _c_clang_disposeString, + _dart_clang_disposeString>('clang_disposeString'))( + string, + ); + } + + _dart_clang_disposeString? _clang_disposeString; + /// Free the given string set. void clang_disposeStringSet( ffi.Pointer<CXStringSet> set_1, @@ -161,6 +187,19 @@ _dart_clang_CXIndex_setInvocationEmissionPathOption? _clang_CXIndex_setInvocationEmissionPathOption; + /// Retrieve the complete file and path name of the given file. + CXString clang_getFileName( + ffi.Pointer<ffi.Void> SFile, + ) { + return (_clang_getFileName ??= + _dylib.lookupFunction<_c_clang_getFileName, _dart_clang_getFileName>( + 'clang_getFileName'))( + SFile, + ); + } + + _dart_clang_getFileName? _clang_getFileName; + /// Retrieve the last modification time of the given file. int clang_getFileTime( ffi.Pointer<ffi.Void> SFile, @@ -276,6 +315,403 @@ _dart_clang_File_isEqual? _clang_File_isEqual; + /// Returns the real path name of \c file. + /// + /// An empty string may be returned. Use \c clang_getFileName() in that case. + CXString clang_File_tryGetRealPathName( + ffi.Pointer<ffi.Void> file, + ) { + return (_clang_File_tryGetRealPathName ??= _dylib.lookupFunction< + _c_clang_File_tryGetRealPathName, + _dart_clang_File_tryGetRealPathName>('clang_File_tryGetRealPathName'))( + file, + ); + } + + _dart_clang_File_tryGetRealPathName? _clang_File_tryGetRealPathName; + + /// Retrieve a NULL (invalid) source location. + CXSourceLocation clang_getNullLocation() { + return (_clang_getNullLocation ??= _dylib.lookupFunction< + _c_clang_getNullLocation, + _dart_clang_getNullLocation>('clang_getNullLocation'))(); + } + + _dart_clang_getNullLocation? _clang_getNullLocation; + + /// Determine whether two source locations, which must refer into + /// the same translation unit, refer to exactly the same point in the source + /// code. + /// + /// \returns non-zero if the source locations refer to the same location, zero + /// if they refer to different locations. + int clang_equalLocations( + CXSourceLocation loc1, + CXSourceLocation loc2, + ) { + return (_clang_equalLocations ??= _dylib.lookupFunction< + _c_clang_equalLocations, + _dart_clang_equalLocations>('clang_equalLocations'))( + loc1, + loc2, + ); + } + + _dart_clang_equalLocations? _clang_equalLocations; + + /// Retrieves the source location associated with a given file/line/column + /// in a particular translation unit. + CXSourceLocation clang_getLocation( + ffi.Pointer<CXTranslationUnitImpl> tu, + ffi.Pointer<ffi.Void> file, + int line, + int column, + ) { + return (_clang_getLocation ??= + _dylib.lookupFunction<_c_clang_getLocation, _dart_clang_getLocation>( + 'clang_getLocation'))( + tu, + file, + line, + column, + ); + } + + _dart_clang_getLocation? _clang_getLocation; + + /// Retrieves the source location associated with a given character offset + /// in a particular translation unit. + CXSourceLocation clang_getLocationForOffset( + ffi.Pointer<CXTranslationUnitImpl> tu, + ffi.Pointer<ffi.Void> file, + int offset, + ) { + return (_clang_getLocationForOffset ??= _dylib.lookupFunction< + _c_clang_getLocationForOffset, + _dart_clang_getLocationForOffset>('clang_getLocationForOffset'))( + tu, + file, + offset, + ); + } + + _dart_clang_getLocationForOffset? _clang_getLocationForOffset; + + /// Returns non-zero if the given source location is in a system header. + int clang_Location_isInSystemHeader( + CXSourceLocation location, + ) { + return (_clang_Location_isInSystemHeader ??= _dylib.lookupFunction< + _c_clang_Location_isInSystemHeader, + _dart_clang_Location_isInSystemHeader>( + 'clang_Location_isInSystemHeader'))( + location, + ); + } + + _dart_clang_Location_isInSystemHeader? _clang_Location_isInSystemHeader; + + /// 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 ??= _dylib.lookupFunction< + _c_clang_Location_isFromMainFile, + _dart_clang_Location_isFromMainFile>('clang_Location_isFromMainFile'))( + location, + ); + } + + _dart_clang_Location_isFromMainFile? _clang_Location_isFromMainFile; + + /// Retrieve a NULL (invalid) source range. + CXSourceRange clang_getNullRange() { + return (_clang_getNullRange ??= + _dylib.lookupFunction<_c_clang_getNullRange, _dart_clang_getNullRange>( + 'clang_getNullRange'))(); + } + + _dart_clang_getNullRange? _clang_getNullRange; + + /// Retrieve a source range given the beginning and ending source + /// locations. + CXSourceRange clang_getRange( + CXSourceLocation begin, + CXSourceLocation end, + ) { + return (_clang_getRange ??= + _dylib.lookupFunction<_c_clang_getRange, _dart_clang_getRange>( + 'clang_getRange'))( + begin, + end, + ); + } + + _dart_clang_getRange? _clang_getRange; + + /// Determine whether two ranges are equivalent. + /// + /// \returns non-zero if the ranges are the same, zero if they differ. + int clang_equalRanges( + CXSourceRange range1, + CXSourceRange range2, + ) { + return (_clang_equalRanges ??= + _dylib.lookupFunction<_c_clang_equalRanges, _dart_clang_equalRanges>( + 'clang_equalRanges'))( + range1, + range2, + ); + } + + _dart_clang_equalRanges? _clang_equalRanges; + + /// Returns non-zero if \p range is null. + int clang_Range_isNull( + CXSourceRange range, + ) { + return (_clang_Range_isNull ??= + _dylib.lookupFunction<_c_clang_Range_isNull, _dart_clang_Range_isNull>( + 'clang_Range_isNull'))( + range, + ); + } + + _dart_clang_Range_isNull? _clang_Range_isNull; + + /// Retrieve the file, line, column, and offset represented by + /// the given source location. + /// + /// If the location refers into a macro expansion, retrieves the + /// location of the macro expansion. + /// + /// \param location the location within a source file that will be decomposed + /// into its parts. + /// + /// \param file [out] if non-NULL, will be set to the file to which the given + /// source location points. + /// + /// \param line [out] if non-NULL, will be set to the line to which the given + /// source location points. + /// + /// \param column [out] if non-NULL, will be set to the column to which the given + /// source location points. + /// + /// \param offset [out] if non-NULL, will be set to the offset into the + /// buffer to which the given source location points. + void clang_getExpansionLocation( + CXSourceLocation location, + ffi.Pointer<ffi.Pointer<ffi.Void>> file, + ffi.Pointer<ffi.Uint32> line, + ffi.Pointer<ffi.Uint32> column, + ffi.Pointer<ffi.Uint32> offset, + ) { + return (_clang_getExpansionLocation ??= _dylib.lookupFunction< + _c_clang_getExpansionLocation, + _dart_clang_getExpansionLocation>('clang_getExpansionLocation'))( + location, + file, + line, + column, + offset, + ); + } + + _dart_clang_getExpansionLocation? _clang_getExpansionLocation; + + /// Retrieve the file, line and column represented by the given source + /// location, as specified in a # line directive. + /// + /// Example: given the following source code in a file somefile.c + /// + /// \code + /// #123 "dummy.c" 1 + /// + /// static int func(void) + /// { + /// return 0; + /// } + /// \endcode + /// + /// the location information returned by this function would be + /// + /// File: dummy.c Line: 124 Column: 12 + /// + /// whereas clang_getExpansionLocation would have returned + /// + /// File: somefile.c Line: 3 Column: 12 + /// + /// \param location the location within a source file that will be decomposed + /// into its parts. + /// + /// \param filename [out] if non-NULL, will be set to the filename of the + /// source location. Note that filenames returned will be for "virtual" files, + /// which don't necessarily exist on the machine running clang - e.g. when + /// parsing preprocessed output obtained from a different environment. If + /// a non-NULL value is passed in, remember to dispose of the returned value + /// using \c clang_disposeString() once you've finished with it. For an invalid + /// source location, an empty string is returned. + /// + /// \param line [out] if non-NULL, will be set to the line number of the + /// source location. For an invalid source location, zero is returned. + /// + /// \param column [out] if non-NULL, will be set to the column number of the + /// source location. For an invalid source location, zero is returned. + void clang_getPresumedLocation( + CXSourceLocation location, + ffi.Pointer<CXString> filename, + ffi.Pointer<ffi.Uint32> line, + ffi.Pointer<ffi.Uint32> column, + ) { + return (_clang_getPresumedLocation ??= _dylib.lookupFunction< + _c_clang_getPresumedLocation, + _dart_clang_getPresumedLocation>('clang_getPresumedLocation'))( + location, + filename, + line, + column, + ); + } + + _dart_clang_getPresumedLocation? _clang_getPresumedLocation; + + /// Legacy API to retrieve the file, line, column, and offset represented + /// by the given source location. + /// + /// This interface has been replaced by the newer interface + /// #clang_getExpansionLocation(). See that interface's documentation for + /// details. + void clang_getInstantiationLocation( + CXSourceLocation location, + ffi.Pointer<ffi.Pointer<ffi.Void>> file, + ffi.Pointer<ffi.Uint32> line, + ffi.Pointer<ffi.Uint32> column, + ffi.Pointer<ffi.Uint32> offset, + ) { + return (_clang_getInstantiationLocation ??= _dylib.lookupFunction< + _c_clang_getInstantiationLocation, + _dart_clang_getInstantiationLocation>( + 'clang_getInstantiationLocation'))( + location, + file, + line, + column, + offset, + ); + } + + _dart_clang_getInstantiationLocation? _clang_getInstantiationLocation; + + /// Retrieve the file, line, column, and offset represented by + /// the given source location. + /// + /// If the location refers into a macro instantiation, return where the + /// location was originally spelled in the source file. + /// + /// \param location the location within a source file that will be decomposed + /// into its parts. + /// + /// \param file [out] if non-NULL, will be set to the file to which the given + /// source location points. + /// + /// \param line [out] if non-NULL, will be set to the line to which the given + /// source location points. + /// + /// \param column [out] if non-NULL, will be set to the column to which the given + /// source location points. + /// + /// \param offset [out] if non-NULL, will be set to the offset into the + /// buffer to which the given source location points. + void clang_getSpellingLocation( + CXSourceLocation location, + ffi.Pointer<ffi.Pointer<ffi.Void>> file, + ffi.Pointer<ffi.Uint32> line, + ffi.Pointer<ffi.Uint32> column, + ffi.Pointer<ffi.Uint32> offset, + ) { + return (_clang_getSpellingLocation ??= _dylib.lookupFunction< + _c_clang_getSpellingLocation, + _dart_clang_getSpellingLocation>('clang_getSpellingLocation'))( + location, + file, + line, + column, + offset, + ); + } + + _dart_clang_getSpellingLocation? _clang_getSpellingLocation; + + /// Retrieve the file, line, column, and offset represented by + /// the given source location. + /// + /// If the location refers into a macro expansion, return where the macro was + /// expanded or where the macro argument was written, if the location points at + /// a macro argument. + /// + /// \param location the location within a source file that will be decomposed + /// into its parts. + /// + /// \param file [out] if non-NULL, will be set to the file to which the given + /// source location points. + /// + /// \param line [out] if non-NULL, will be set to the line to which the given + /// source location points. + /// + /// \param column [out] if non-NULL, will be set to the column to which the given + /// source location points. + /// + /// \param offset [out] if non-NULL, will be set to the offset into the + /// buffer to which the given source location points. + void clang_getFileLocation( + CXSourceLocation location, + ffi.Pointer<ffi.Pointer<ffi.Void>> file, + ffi.Pointer<ffi.Uint32> line, + ffi.Pointer<ffi.Uint32> column, + ffi.Pointer<ffi.Uint32> offset, + ) { + return (_clang_getFileLocation ??= _dylib.lookupFunction< + _c_clang_getFileLocation, + _dart_clang_getFileLocation>('clang_getFileLocation'))( + location, + file, + line, + column, + offset, + ); + } + + _dart_clang_getFileLocation? _clang_getFileLocation; + + /// Retrieve a source location representing the first character within a + /// source range. + CXSourceLocation clang_getRangeStart( + CXSourceRange range, + ) { + return (_clang_getRangeStart ??= _dylib.lookupFunction< + _c_clang_getRangeStart, + _dart_clang_getRangeStart>('clang_getRangeStart'))( + range, + ); + } + + _dart_clang_getRangeStart? _clang_getRangeStart; + + /// Retrieve a source location representing the last character within a + /// source range. + CXSourceLocation clang_getRangeEnd( + CXSourceRange range, + ) { + return (_clang_getRangeEnd ??= + _dylib.lookupFunction<_c_clang_getRangeEnd, _dart_clang_getRangeEnd>( + 'clang_getRangeEnd'))( + range, + ); + } + + _dart_clang_getRangeEnd? _clang_getRangeEnd; + /// Retrieve all ranges that were skipped by the preprocessor. /// /// The preprocessor will skip lines when they are surrounded by an @@ -478,6 +914,33 @@ _dart_clang_disposeDiagnostic? _clang_disposeDiagnostic; + /// Format the given diagnostic in a manner that is suitable for display. + /// + /// This routine will format the given diagnostic to a string, rendering + /// the diagnostic according to the various options given. The + /// \c clang_defaultDiagnosticDisplayOptions() function returns the set of + /// options that most closely mimics the behavior of the clang compiler. + /// + /// \param Diagnostic The diagnostic to print. + /// + /// \param Options A set of options that control the diagnostic display, + /// created by combining \c CXDiagnosticDisplayOptions values. + /// + /// \returns A new string containing for formatted diagnostic. + CXString clang_formatDiagnostic( + ffi.Pointer<ffi.Void> Diagnostic, + int Options, + ) { + return (_clang_formatDiagnostic ??= _dylib.lookupFunction< + _c_clang_formatDiagnostic, + _dart_clang_formatDiagnostic>('clang_formatDiagnostic'))( + Diagnostic, + Options, + ); + } + + _dart_clang_formatDiagnostic? _clang_formatDiagnostic; + /// Retrieve the set of display options most similar to the /// default behavior of the clang compiler. /// @@ -506,6 +969,59 @@ _dart_clang_getDiagnosticSeverity? _clang_getDiagnosticSeverity; + /// Retrieve the source location of the given diagnostic. + /// + /// This location is where Clang would print the caret ('^') when + /// displaying the diagnostic on the command line. + CXSourceLocation clang_getDiagnosticLocation( + ffi.Pointer<ffi.Void> arg0, + ) { + return (_clang_getDiagnosticLocation ??= _dylib.lookupFunction< + _c_clang_getDiagnosticLocation, + _dart_clang_getDiagnosticLocation>('clang_getDiagnosticLocation'))( + arg0, + ); + } + + _dart_clang_getDiagnosticLocation? _clang_getDiagnosticLocation; + + /// Retrieve the text of the given diagnostic. + CXString clang_getDiagnosticSpelling( + ffi.Pointer<ffi.Void> arg0, + ) { + return (_clang_getDiagnosticSpelling ??= _dylib.lookupFunction< + _c_clang_getDiagnosticSpelling, + _dart_clang_getDiagnosticSpelling>('clang_getDiagnosticSpelling'))( + arg0, + ); + } + + _dart_clang_getDiagnosticSpelling? _clang_getDiagnosticSpelling; + + /// Retrieve the name of the command-line option that enabled this + /// diagnostic. + /// + /// \param Diag The diagnostic to be queried. + /// + /// \param Disable If non-NULL, will be set to the option that disables this + /// diagnostic (if any). + /// + /// \returns A string that contains the command-line option used to enable this + /// warning, such as "-Wconversion" or "-pedantic". + CXString clang_getDiagnosticOption( + ffi.Pointer<ffi.Void> Diag, + ffi.Pointer<CXString> Disable, + ) { + return (_clang_getDiagnosticOption ??= _dylib.lookupFunction< + _c_clang_getDiagnosticOption, + _dart_clang_getDiagnosticOption>('clang_getDiagnosticOption'))( + Diag, + Disable, + ); + } + + _dart_clang_getDiagnosticOption? _clang_getDiagnosticOption; + /// Retrieve the category number for this diagnostic. /// /// Diagnostics can be categorized into groups along with other, related @@ -526,6 +1042,43 @@ _dart_clang_getDiagnosticCategory? _clang_getDiagnosticCategory; + /// Retrieve the name of a particular diagnostic category. This + /// is now deprecated. Use clang_getDiagnosticCategoryText() + /// instead. + /// + /// \param Category A diagnostic category number, as returned by + /// \c clang_getDiagnosticCategory(). + /// + /// \returns The name of the given diagnostic category. + CXString clang_getDiagnosticCategoryName( + int Category, + ) { + return (_clang_getDiagnosticCategoryName ??= _dylib.lookupFunction< + _c_clang_getDiagnosticCategoryName, + _dart_clang_getDiagnosticCategoryName>( + 'clang_getDiagnosticCategoryName'))( + Category, + ); + } + + _dart_clang_getDiagnosticCategoryName? _clang_getDiagnosticCategoryName; + + /// Retrieve the diagnostic category text for a given diagnostic. + /// + /// \returns The text of the given diagnostic category. + CXString clang_getDiagnosticCategoryText( + ffi.Pointer<ffi.Void> arg0, + ) { + return (_clang_getDiagnosticCategoryText ??= _dylib.lookupFunction< + _c_clang_getDiagnosticCategoryText, + _dart_clang_getDiagnosticCategoryText>( + 'clang_getDiagnosticCategoryText'))( + arg0, + ); + } + + _dart_clang_getDiagnosticCategoryText? _clang_getDiagnosticCategoryText; + /// Determine the number of source ranges associated with the given /// diagnostic. int clang_getDiagnosticNumRanges( @@ -540,6 +1093,31 @@ _dart_clang_getDiagnosticNumRanges? _clang_getDiagnosticNumRanges; + /// Retrieve a source range associated with the diagnostic. + /// + /// A diagnostic's source ranges highlight important elements in the source + /// code. On the command line, Clang displays source ranges by + /// underlining them with '~' characters. + /// + /// \param Diagnostic the diagnostic whose range is being extracted. + /// + /// \param Range the zero-based index specifying which range to + /// + /// \returns the requested source range. + CXSourceRange clang_getDiagnosticRange( + ffi.Pointer<ffi.Void> Diagnostic, + int Range, + ) { + return (_clang_getDiagnosticRange ??= _dylib.lookupFunction< + _c_clang_getDiagnosticRange, + _dart_clang_getDiagnosticRange>('clang_getDiagnosticRange'))( + Diagnostic, + Range, + ); + } + + _dart_clang_getDiagnosticRange? _clang_getDiagnosticRange; + /// Determine the number of fix-it hints associated with the /// given diagnostic. int clang_getDiagnosticNumFixIts( @@ -554,6 +1132,59 @@ _dart_clang_getDiagnosticNumFixIts? _clang_getDiagnosticNumFixIts; + /// Retrieve the replacement information for a given fix-it. + /// + /// Fix-its are described in terms of a source range whose contents + /// should be replaced by a string. This approach generalizes over + /// three kinds of operations: removal of source code (the range covers + /// the code to be removed and the replacement string is empty), + /// replacement of source code (the range covers the code to be + /// replaced and the replacement string provides the new code), and + /// insertion (both the start and end of the range point at the + /// insertion location, and the replacement string provides the text to + /// insert). + /// + /// \param Diagnostic The diagnostic whose fix-its are being queried. + /// + /// \param FixIt The zero-based index of the fix-it. + /// + /// \param ReplacementRange The source range whose contents will be + /// replaced with the returned replacement string. Note that source + /// ranges are half-open ranges [a, b), so the source code should be + /// replaced from a and up to (but not including) b. + /// + /// \returns A string containing text that should be replace the source + /// code indicated by the \c ReplacementRange. + CXString clang_getDiagnosticFixIt( + ffi.Pointer<ffi.Void> Diagnostic, + int FixIt, + ffi.Pointer<CXSourceRange> ReplacementRange, + ) { + return (_clang_getDiagnosticFixIt ??= _dylib.lookupFunction< + _c_clang_getDiagnosticFixIt, + _dart_clang_getDiagnosticFixIt>('clang_getDiagnosticFixIt'))( + Diagnostic, + FixIt, + ReplacementRange, + ); + } + + _dart_clang_getDiagnosticFixIt? _clang_getDiagnosticFixIt; + + /// Get the original translation unit source file name. + CXString clang_getTranslationUnitSpelling( + ffi.Pointer<CXTranslationUnitImpl> CTUnit, + ) { + return (_clang_getTranslationUnitSpelling ??= _dylib.lookupFunction< + _c_clang_getTranslationUnitSpelling, + _dart_clang_getTranslationUnitSpelling>( + 'clang_getTranslationUnitSpelling'))( + CTUnit, + ); + } + + _dart_clang_getTranslationUnitSpelling? _clang_getTranslationUnitSpelling; + /// Return the CXTranslationUnit for a given source file and the provided /// command line arguments one would pass to the compiler. /// @@ -978,6 +1609,33 @@ _dart_clang_getTUResourceUsageName? _clang_getTUResourceUsageName; + /// Return the memory usage of a translation unit. This object + /// should be released with clang_disposeCXTUResourceUsage(). + CXTUResourceUsage clang_getCXTUResourceUsage( + ffi.Pointer<CXTranslationUnitImpl> TU, + ) { + return (_clang_getCXTUResourceUsage ??= _dylib.lookupFunction< + _c_clang_getCXTUResourceUsage, + _dart_clang_getCXTUResourceUsage>('clang_getCXTUResourceUsage'))( + TU, + ); + } + + _dart_clang_getCXTUResourceUsage? _clang_getCXTUResourceUsage; + + void clang_disposeCXTUResourceUsage( + CXTUResourceUsage usage, + ) { + return (_clang_disposeCXTUResourceUsage ??= _dylib.lookupFunction< + _c_clang_disposeCXTUResourceUsage, + _dart_clang_disposeCXTUResourceUsage>( + 'clang_disposeCXTUResourceUsage'))( + usage, + ); + } + + _dart_clang_disposeCXTUResourceUsage? _clang_disposeCXTUResourceUsage; + /// Get target information for this translation unit. /// /// The CXTargetInfo object cannot outlive the CXTranslationUnit object. @@ -1007,6 +1665,21 @@ _dart_clang_TargetInfo_dispose? _clang_TargetInfo_dispose; + /// Get the normalized target triple as a string. + /// + /// Returns the empty string in case of any error. + CXString clang_TargetInfo_getTriple( + ffi.Pointer<CXTargetInfoImpl> Info, + ) { + return (_clang_TargetInfo_getTriple ??= _dylib.lookupFunction< + _c_clang_TargetInfo_getTriple, + _dart_clang_TargetInfo_getTriple>('clang_TargetInfo_getTriple'))( + Info, + ); + } + + _dart_clang_TargetInfo_getTriple? _clang_TargetInfo_getTriple; + /// Get the pointer width of the target in bits. /// /// Returns -1 in case of error. @@ -1023,6 +1696,86 @@ _dart_clang_TargetInfo_getPointerWidth? _clang_TargetInfo_getPointerWidth; + /// Retrieve the NULL cursor, which represents no entity. + CXCursor clang_getNullCursor() { + return (_clang_getNullCursor ??= _dylib.lookupFunction< + _c_clang_getNullCursor, + _dart_clang_getNullCursor>('clang_getNullCursor'))(); + } + + _dart_clang_getNullCursor? _clang_getNullCursor; + + /// Retrieve the cursor that represents the given translation unit. + /// + /// The translation unit cursor can be used to start traversing the + /// various declarations within the given translation unit. + CXCursor clang_getTranslationUnitCursor( + ffi.Pointer<CXTranslationUnitImpl> arg0, + ) { + return (_clang_getTranslationUnitCursor ??= _dylib.lookupFunction< + _c_clang_getTranslationUnitCursor, + _dart_clang_getTranslationUnitCursor>( + 'clang_getTranslationUnitCursor'))( + arg0, + ); + } + + _dart_clang_getTranslationUnitCursor? _clang_getTranslationUnitCursor; + + /// Determine whether two cursors are equivalent. + int clang_equalCursors( + CXCursor arg0, + CXCursor arg1, + ) { + return (_clang_equalCursors ??= + _dylib.lookupFunction<_c_clang_equalCursors, _dart_clang_equalCursors>( + 'clang_equalCursors'))( + arg0, + arg1, + ); + } + + _dart_clang_equalCursors? _clang_equalCursors; + + /// Returns non-zero if \p cursor is null. + int clang_Cursor_isNull( + CXCursor cursor, + ) { + return (_clang_Cursor_isNull ??= _dylib.lookupFunction< + _c_clang_Cursor_isNull, + _dart_clang_Cursor_isNull>('clang_Cursor_isNull'))( + cursor, + ); + } + + _dart_clang_Cursor_isNull? _clang_Cursor_isNull; + + /// Compute a hash value for the given cursor. + int clang_hashCursor( + CXCursor arg0, + ) { + return (_clang_hashCursor ??= + _dylib.lookupFunction<_c_clang_hashCursor, _dart_clang_hashCursor>( + 'clang_hashCursor'))( + arg0, + ); + } + + _dart_clang_hashCursor? _clang_hashCursor; + + /// Retrieve the kind of the given cursor. + int clang_getCursorKind( + CXCursor arg0, + ) { + return (_clang_getCursorKind ??= _dylib.lookupFunction< + _c_clang_getCursorKind, + _dart_clang_getCursorKind>('clang_getCursorKind'))( + arg0, + ); + } + + _dart_clang_getCursorKind? _clang_getCursorKind; + /// Determine whether the given cursor kind represents a declaration. int clang_isDeclaration( int arg0, @@ -1036,6 +1789,24 @@ _dart_clang_isDeclaration? _clang_isDeclaration; + /// Determine whether the given declaration is invalid. + /// + /// A declaration is invalid if it could not be parsed successfully. + /// + /// \returns non-zero if the cursor represents a declaration and it is + /// invalid, otherwise NULL. + int clang_isInvalidDeclaration( + CXCursor arg0, + ) { + return (_clang_isInvalidDeclaration ??= _dylib.lookupFunction< + _c_clang_isInvalidDeclaration, + _dart_clang_isInvalidDeclaration>('clang_isInvalidDeclaration'))( + arg0, + ); + } + + _dart_clang_isInvalidDeclaration? _clang_isInvalidDeclaration; + /// Determine whether the given cursor kind represents a simple /// reference. /// @@ -1093,6 +1864,19 @@ _dart_clang_isAttribute? _clang_isAttribute; + /// Determine whether the given cursor has any attributes. + int clang_Cursor_hasAttrs( + CXCursor C, + ) { + return (_clang_Cursor_hasAttrs ??= _dylib.lookupFunction< + _c_clang_Cursor_hasAttrs, + _dart_clang_Cursor_hasAttrs>('clang_Cursor_hasAttrs'))( + C, + ); + } + + _dart_clang_Cursor_hasAttrs? _clang_Cursor_hasAttrs; + /// Determine whether the given cursor kind represents an invalid /// cursor. int clang_isInvalid( @@ -1149,6 +1933,118 @@ _dart_clang_isUnexposed? _clang_isUnexposed; + /// Determine the linkage of the entity referred to by a given cursor. + int clang_getCursorLinkage( + CXCursor cursor, + ) { + return (_clang_getCursorLinkage ??= _dylib.lookupFunction< + _c_clang_getCursorLinkage, + _dart_clang_getCursorLinkage>('clang_getCursorLinkage'))( + cursor, + ); + } + + _dart_clang_getCursorLinkage? _clang_getCursorLinkage; + + /// Describe the visibility of the entity referred to by a cursor. + /// + /// This returns the default visibility if not explicitly specified by + /// a visibility attribute. The default visibility may be changed by + /// commandline arguments. + /// + /// \param cursor The cursor to query. + /// + /// \returns The visibility of the cursor. + int clang_getCursorVisibility( + CXCursor cursor, + ) { + return (_clang_getCursorVisibility ??= _dylib.lookupFunction< + _c_clang_getCursorVisibility, + _dart_clang_getCursorVisibility>('clang_getCursorVisibility'))( + cursor, + ); + } + + _dart_clang_getCursorVisibility? _clang_getCursorVisibility; + + /// Determine the availability of the entity that this cursor refers to, + /// taking the current target platform into account. + /// + /// \param cursor The cursor to query. + /// + /// \returns The availability of the cursor. + int clang_getCursorAvailability( + CXCursor cursor, + ) { + return (_clang_getCursorAvailability ??= _dylib.lookupFunction< + _c_clang_getCursorAvailability, + _dart_clang_getCursorAvailability>('clang_getCursorAvailability'))( + cursor, + ); + } + + _dart_clang_getCursorAvailability? _clang_getCursorAvailability; + + /// Determine the availability of the entity that this cursor refers to + /// on any platforms for which availability information is known. + /// + /// \param cursor The cursor to query. + /// + /// \param always_deprecated If non-NULL, will be set to indicate whether the + /// entity is deprecated on all platforms. + /// + /// \param deprecated_message If non-NULL, will be set to the message text + /// provided along with the unconditional deprecation of this entity. The client + /// is responsible for deallocating this string. + /// + /// \param always_unavailable If non-NULL, will be set to indicate whether the + /// entity is unavailable on all platforms. + /// + /// \param unavailable_message If non-NULL, will be set to the message text + /// provided along with the unconditional unavailability of this entity. The + /// client is responsible for deallocating this string. + /// + /// \param availability If non-NULL, an array of CXPlatformAvailability instances + /// that will be populated with platform availability information, up to either + /// the number of platforms for which availability information is available (as + /// returned by this function) or \c availability_size, whichever is smaller. + /// + /// \param availability_size The number of elements available in the + /// \c availability array. + /// + /// \returns The number of platforms (N) for which availability information is + /// available (which is unrelated to \c availability_size). + /// + /// Note that the client is responsible for calling + /// \c clang_disposeCXPlatformAvailability to free each of the + /// platform-availability structures returned. There are + /// \c min(N, availability_size) such structures. + int clang_getCursorPlatformAvailability( + CXCursor cursor, + ffi.Pointer<ffi.Int32> always_deprecated, + ffi.Pointer<CXString> deprecated_message, + ffi.Pointer<ffi.Int32> always_unavailable, + ffi.Pointer<CXString> unavailable_message, + ffi.Pointer<CXPlatformAvailability> availability, + int availability_size, + ) { + return (_clang_getCursorPlatformAvailability ??= _dylib.lookupFunction< + _c_clang_getCursorPlatformAvailability, + _dart_clang_getCursorPlatformAvailability>( + 'clang_getCursorPlatformAvailability'))( + cursor, + always_deprecated, + deprecated_message, + always_unavailable, + unavailable_message, + availability, + availability_size, + ); + } + + _dart_clang_getCursorPlatformAvailability? + _clang_getCursorPlatformAvailability; + /// Free the memory associated with a \c CXPlatformAvailability structure. void clang_disposeCXPlatformAvailability( ffi.Pointer<CXPlatformAvailability> availability, @@ -1164,6 +2060,47 @@ _dart_clang_disposeCXPlatformAvailability? _clang_disposeCXPlatformAvailability; + /// Determine the "language" of the entity referred to by a given cursor. + int clang_getCursorLanguage( + CXCursor cursor, + ) { + return (_clang_getCursorLanguage ??= _dylib.lookupFunction< + _c_clang_getCursorLanguage, + _dart_clang_getCursorLanguage>('clang_getCursorLanguage'))( + cursor, + ); + } + + _dart_clang_getCursorLanguage? _clang_getCursorLanguage; + + /// Determine the "thread-local storage (TLS) kind" of the declaration + /// referred to by a cursor. + int clang_getCursorTLSKind( + CXCursor cursor, + ) { + return (_clang_getCursorTLSKind ??= _dylib.lookupFunction< + _c_clang_getCursorTLSKind, + _dart_clang_getCursorTLSKind>('clang_getCursorTLSKind'))( + cursor, + ); + } + + _dart_clang_getCursorTLSKind? _clang_getCursorTLSKind; + + /// Returns the translation unit that a cursor originated from. + ffi.Pointer<CXTranslationUnitImpl> clang_Cursor_getTranslationUnit( + CXCursor arg0, + ) { + return (_clang_Cursor_getTranslationUnit ??= _dylib.lookupFunction< + _c_clang_Cursor_getTranslationUnit, + _dart_clang_Cursor_getTranslationUnit>( + 'clang_Cursor_getTranslationUnit'))( + arg0, + ); + } + + _dart_clang_Cursor_getTranslationUnit? _clang_Cursor_getTranslationUnit; + /// Creates an empty CXCursorSet. ffi.Pointer<CXCursorSetImpl> clang_createCXCursorSet() { return (_clang_createCXCursorSet ??= _dylib.lookupFunction< @@ -1186,6 +2123,184 @@ _dart_clang_disposeCXCursorSet? _clang_disposeCXCursorSet; + /// Queries a CXCursorSet to see if it contains a specific CXCursor. + /// + /// \returns non-zero if the set contains the specified cursor. + int clang_CXCursorSet_contains( + ffi.Pointer<CXCursorSetImpl> cset, + CXCursor cursor, + ) { + return (_clang_CXCursorSet_contains ??= _dylib.lookupFunction< + _c_clang_CXCursorSet_contains, + _dart_clang_CXCursorSet_contains>('clang_CXCursorSet_contains'))( + cset, + cursor, + ); + } + + _dart_clang_CXCursorSet_contains? _clang_CXCursorSet_contains; + + /// Inserts a CXCursor into a CXCursorSet. + /// + /// \returns zero if the CXCursor was already in the set, and non-zero otherwise. + int clang_CXCursorSet_insert( + ffi.Pointer<CXCursorSetImpl> cset, + CXCursor cursor, + ) { + return (_clang_CXCursorSet_insert ??= _dylib.lookupFunction< + _c_clang_CXCursorSet_insert, + _dart_clang_CXCursorSet_insert>('clang_CXCursorSet_insert'))( + cset, + cursor, + ); + } + + _dart_clang_CXCursorSet_insert? _clang_CXCursorSet_insert; + + /// Determine the semantic parent of the given cursor. + /// + /// The semantic parent of a cursor is the cursor that semantically contains + /// the given \p cursor. For many declarations, the lexical and semantic parents + /// are equivalent (the lexical parent is returned by + /// \c clang_getCursorLexicalParent()). They diverge when declarations or + /// definitions are provided out-of-line. For example: + /// + /// \code + /// class C { + /// void f(); + /// }; + /// + /// void C::f() { } + /// \endcode + /// + /// In the out-of-line definition of \c C::f, the semantic parent is + /// the class \c C, of which this function is a member. The lexical parent is + /// the place where the declaration actually occurs in the source code; in this + /// case, the definition occurs in the translation unit. In general, the + /// lexical parent for a given entity can change without affecting the semantics + /// of the program, and the lexical parent of different declarations of the + /// same entity may be different. Changing the semantic parent of a declaration, + /// on the other hand, can have a major impact on semantics, and redeclarations + /// of a particular entity should all have the same semantic context. + /// + /// In the example above, both declarations of \c C::f have \c C as their + /// semantic context, while the lexical context of the first \c C::f is \c C + /// and the lexical context of the second \c C::f is the translation unit. + /// + /// For global declarations, the semantic parent is the translation unit. + CXCursor clang_getCursorSemanticParent( + CXCursor cursor, + ) { + return (_clang_getCursorSemanticParent ??= _dylib.lookupFunction< + _c_clang_getCursorSemanticParent, + _dart_clang_getCursorSemanticParent>('clang_getCursorSemanticParent'))( + cursor, + ); + } + + _dart_clang_getCursorSemanticParent? _clang_getCursorSemanticParent; + + /// Determine the lexical parent of the given cursor. + /// + /// The lexical parent of a cursor is the cursor in which the given \p cursor + /// was actually written. For many declarations, the lexical and semantic parents + /// are equivalent (the semantic parent is returned by + /// \c clang_getCursorSemanticParent()). They diverge when declarations or + /// definitions are provided out-of-line. For example: + /// + /// \code + /// class C { + /// void f(); + /// }; + /// + /// void C::f() { } + /// \endcode + /// + /// In the out-of-line definition of \c C::f, the semantic parent is + /// the class \c C, of which this function is a member. The lexical parent is + /// the place where the declaration actually occurs in the source code; in this + /// case, the definition occurs in the translation unit. In general, the + /// lexical parent for a given entity can change without affecting the semantics + /// of the program, and the lexical parent of different declarations of the + /// same entity may be different. Changing the semantic parent of a declaration, + /// on the other hand, can have a major impact on semantics, and redeclarations + /// of a particular entity should all have the same semantic context. + /// + /// In the example above, both declarations of \c C::f have \c C as their + /// semantic context, while the lexical context of the first \c C::f is \c C + /// and the lexical context of the second \c C::f is the translation unit. + /// + /// For declarations written in the global scope, the lexical parent is + /// the translation unit. + CXCursor clang_getCursorLexicalParent( + CXCursor cursor, + ) { + return (_clang_getCursorLexicalParent ??= _dylib.lookupFunction< + _c_clang_getCursorLexicalParent, + _dart_clang_getCursorLexicalParent>('clang_getCursorLexicalParent'))( + cursor, + ); + } + + _dart_clang_getCursorLexicalParent? _clang_getCursorLexicalParent; + + /// Determine the set of methods that are overridden by the given + /// method. + /// + /// In both Objective-C and C++, a method (aka virtual member function, + /// in C++) can override a virtual method in a base class. For + /// Objective-C, a method is said to override any method in the class's + /// base class, its protocols, or its categories' protocols, that has the same + /// selector and is of the same kind (class or instance). + /// If no such method exists, the search continues to the class's superclass, + /// its protocols, and its categories, and so on. A method from an Objective-C + /// implementation is considered to override the same methods as its + /// corresponding method in the interface. + /// + /// For C++, a virtual member function overrides any virtual member + /// function with the same signature that occurs in its base + /// classes. With multiple inheritance, a virtual member function can + /// override several virtual member functions coming from different + /// base classes. + /// + /// In all cases, this function determines the immediate overridden + /// method, rather than all of the overridden methods. For example, if + /// a method is originally declared in a class A, then overridden in B + /// (which in inherits from A) and also in C (which inherited from B), + /// then the only overridden method returned from this function when + /// invoked on C's method will be B's method. The client may then + /// invoke this function again, given the previously-found overridden + /// methods, to map out the complete method-override set. + /// + /// \param cursor A cursor representing an Objective-C or C++ + /// method. This routine will compute the set of methods that this + /// method overrides. + /// + /// \param overridden A pointer whose pointee will be replaced with a + /// pointer to an array of cursors, representing the set of overridden + /// methods. If there are no overridden methods, the pointee will be + /// set to NULL. The pointee must be freed via a call to + /// \c clang_disposeOverriddenCursors(). + /// + /// \param num_overridden A pointer to the number of overridden + /// functions, will be set to the number of overridden functions in the + /// array pointed to by \p overridden. + void clang_getOverriddenCursors( + CXCursor cursor, + ffi.Pointer<ffi.Pointer<CXCursor>> overridden, + ffi.Pointer<ffi.Uint32> num_overridden, + ) { + return (_clang_getOverriddenCursors ??= _dylib.lookupFunction< + _c_clang_getOverriddenCursors, + _dart_clang_getOverriddenCursors>('clang_getOverriddenCursors'))( + cursor, + overridden, + num_overridden, + ); + } + + _dart_clang_getOverriddenCursors? _clang_getOverriddenCursors; + /// Free the set of overridden cursors returned by \c /// clang_getOverriddenCursors(). void clang_disposeOverriddenCursors( @@ -1201,6 +2316,1468 @@ _dart_clang_disposeOverriddenCursors? _clang_disposeOverriddenCursors; + /// Retrieve the file that is included by the given inclusion directive + /// cursor. + ffi.Pointer<ffi.Void> clang_getIncludedFile( + CXCursor cursor, + ) { + return (_clang_getIncludedFile ??= _dylib.lookupFunction< + _c_clang_getIncludedFile, + _dart_clang_getIncludedFile>('clang_getIncludedFile'))( + cursor, + ); + } + + _dart_clang_getIncludedFile? _clang_getIncludedFile; + + /// Map a source location to the cursor that describes the entity at that + /// location in the source code. + /// + /// clang_getCursor() maps an arbitrary source location within a translation + /// unit down to the most specific cursor that describes the entity at that + /// location. For example, given an expression \c x + y, invoking + /// clang_getCursor() with a source location pointing to "x" will return the + /// cursor for "x"; similarly for "y". If the cursor points anywhere between + /// "x" or "y" (e.g., on the + or the whitespace around it), clang_getCursor() + /// will return a cursor referring to the "+" expression. + /// + /// \returns a cursor representing the entity at the given source location, or + /// a NULL cursor if no such entity can be found. + CXCursor clang_getCursor( + ffi.Pointer<CXTranslationUnitImpl> arg0, + CXSourceLocation arg1, + ) { + return (_clang_getCursor ??= + _dylib.lookupFunction<_c_clang_getCursor, _dart_clang_getCursor>( + 'clang_getCursor'))( + arg0, + arg1, + ); + } + + _dart_clang_getCursor? _clang_getCursor; + + /// Retrieve the physical location of the source constructor referenced + /// by the given cursor. + /// + /// The location of a declaration is typically the location of the name of that + /// declaration, where the name of that declaration would occur if it is + /// unnamed, or some keyword that introduces that particular declaration. + /// The location of a reference is where that reference occurs within the + /// source code. + CXSourceLocation clang_getCursorLocation( + CXCursor arg0, + ) { + return (_clang_getCursorLocation ??= _dylib.lookupFunction< + _c_clang_getCursorLocation, + _dart_clang_getCursorLocation>('clang_getCursorLocation'))( + arg0, + ); + } + + _dart_clang_getCursorLocation? _clang_getCursorLocation; + + /// Retrieve the physical extent of the source construct referenced by + /// the given cursor. + /// + /// The extent of a cursor starts with the file/line/column pointing at the + /// first character within the source construct that the cursor refers to and + /// ends with the last character within that source construct. For a + /// declaration, the extent covers the declaration itself. For a reference, + /// the extent covers the location of the reference (e.g., where the referenced + /// entity was actually used). + CXSourceRange clang_getCursorExtent( + CXCursor arg0, + ) { + return (_clang_getCursorExtent ??= _dylib.lookupFunction< + _c_clang_getCursorExtent, + _dart_clang_getCursorExtent>('clang_getCursorExtent'))( + arg0, + ); + } + + _dart_clang_getCursorExtent? _clang_getCursorExtent; + + /// Retrieve the type of a CXCursor (if any). + CXType clang_getCursorType( + CXCursor C, + ) { + return (_clang_getCursorType ??= _dylib.lookupFunction< + _c_clang_getCursorType, + _dart_clang_getCursorType>('clang_getCursorType'))( + C, + ); + } + + _dart_clang_getCursorType? _clang_getCursorType; + + /// Pretty-print the underlying type using the rules of the + /// language of the translation unit from which it came. + /// + /// If the type is invalid, an empty string is returned. + CXString clang_getTypeSpelling( + CXType CT, + ) { + return (_clang_getTypeSpelling ??= _dylib.lookupFunction< + _c_clang_getTypeSpelling, + _dart_clang_getTypeSpelling>('clang_getTypeSpelling'))( + CT, + ); + } + + _dart_clang_getTypeSpelling? _clang_getTypeSpelling; + + /// Retrieve the underlying type of a typedef declaration. + /// + /// If the cursor does not reference a typedef declaration, an invalid type is + /// returned. + CXType clang_getTypedefDeclUnderlyingType( + CXCursor C, + ) { + return (_clang_getTypedefDeclUnderlyingType ??= _dylib.lookupFunction< + _c_clang_getTypedefDeclUnderlyingType, + _dart_clang_getTypedefDeclUnderlyingType>( + 'clang_getTypedefDeclUnderlyingType'))( + C, + ); + } + + _dart_clang_getTypedefDeclUnderlyingType? _clang_getTypedefDeclUnderlyingType; + + /// Retrieve the integer type of an enum declaration. + /// + /// If the cursor does not reference an enum declaration, an invalid type is + /// returned. + CXType clang_getEnumDeclIntegerType( + CXCursor C, + ) { + return (_clang_getEnumDeclIntegerType ??= _dylib.lookupFunction< + _c_clang_getEnumDeclIntegerType, + _dart_clang_getEnumDeclIntegerType>('clang_getEnumDeclIntegerType'))( + C, + ); + } + + _dart_clang_getEnumDeclIntegerType? _clang_getEnumDeclIntegerType; + + /// Retrieve the integer value of an enum constant declaration as a signed + /// long long. + /// + /// If the cursor does not reference an enum constant declaration, LLONG_MIN is returned. + /// Since this is also potentially a valid constant value, the kind of the cursor + /// must be verified before calling this function. + int clang_getEnumConstantDeclValue( + CXCursor C, + ) { + return (_clang_getEnumConstantDeclValue ??= _dylib.lookupFunction< + _c_clang_getEnumConstantDeclValue, + _dart_clang_getEnumConstantDeclValue>( + 'clang_getEnumConstantDeclValue'))( + C, + ); + } + + _dart_clang_getEnumConstantDeclValue? _clang_getEnumConstantDeclValue; + + /// Retrieve the integer value of an enum constant declaration as an unsigned + /// long long. + /// + /// If the cursor does not reference an enum constant declaration, ULLONG_MAX is returned. + /// Since this is also potentially a valid constant value, the kind of the cursor + /// must be verified before calling this function. + int clang_getEnumConstantDeclUnsignedValue( + CXCursor C, + ) { + return (_clang_getEnumConstantDeclUnsignedValue ??= _dylib.lookupFunction< + _c_clang_getEnumConstantDeclUnsignedValue, + _dart_clang_getEnumConstantDeclUnsignedValue>( + 'clang_getEnumConstantDeclUnsignedValue'))( + C, + ); + } + + _dart_clang_getEnumConstantDeclUnsignedValue? + _clang_getEnumConstantDeclUnsignedValue; + + /// Retrieve the bit width of a bit field declaration as an integer. + /// + /// If a cursor that is not a bit field declaration is passed in, -1 is returned. + int clang_getFieldDeclBitWidth( + CXCursor C, + ) { + return (_clang_getFieldDeclBitWidth ??= _dylib.lookupFunction< + _c_clang_getFieldDeclBitWidth, + _dart_clang_getFieldDeclBitWidth>('clang_getFieldDeclBitWidth'))( + C, + ); + } + + _dart_clang_getFieldDeclBitWidth? _clang_getFieldDeclBitWidth; + + /// Retrieve the number of non-variadic arguments associated with a given + /// cursor. + /// + /// The number of arguments can be determined for calls as well as for + /// declarations of functions or methods. For other cursors -1 is returned. + int clang_Cursor_getNumArguments( + CXCursor C, + ) { + return (_clang_Cursor_getNumArguments ??= _dylib.lookupFunction< + _c_clang_Cursor_getNumArguments, + _dart_clang_Cursor_getNumArguments>('clang_Cursor_getNumArguments'))( + C, + ); + } + + _dart_clang_Cursor_getNumArguments? _clang_Cursor_getNumArguments; + + /// Retrieve the argument cursor of a function or method. + /// + /// The argument cursor can be determined for calls as well as for declarations + /// of functions or methods. For other cursors and for invalid indices, an + /// invalid cursor is returned. + CXCursor clang_Cursor_getArgument( + CXCursor C, + int i, + ) { + return (_clang_Cursor_getArgument ??= _dylib.lookupFunction< + _c_clang_Cursor_getArgument, + _dart_clang_Cursor_getArgument>('clang_Cursor_getArgument'))( + C, + i, + ); + } + + _dart_clang_Cursor_getArgument? _clang_Cursor_getArgument; + + /// Returns the number of template args of a function decl representing a + /// template specialization. + /// + /// If the argument cursor cannot be converted into a template function + /// declaration, -1 is returned. + /// + /// For example, for the following declaration and specialization: + /// template <typename T, int kInt, bool kBool> + /// void foo() { ... } + /// + /// template <> + /// void foo<float, -7, true>(); + /// + /// The value 3 would be returned from this call. + int clang_Cursor_getNumTemplateArguments( + CXCursor C, + ) { + return (_clang_Cursor_getNumTemplateArguments ??= _dylib.lookupFunction< + _c_clang_Cursor_getNumTemplateArguments, + _dart_clang_Cursor_getNumTemplateArguments>( + 'clang_Cursor_getNumTemplateArguments'))( + C, + ); + } + + _dart_clang_Cursor_getNumTemplateArguments? + _clang_Cursor_getNumTemplateArguments; + + /// Retrieve the kind of the I'th template argument of the CXCursor C. + /// + /// If the argument CXCursor does not represent a FunctionDecl, an invalid + /// template argument kind is returned. + /// + /// For example, for the following declaration and specialization: + /// template <typename T, int kInt, bool kBool> + /// void foo() { ... } + /// + /// template <> + /// void foo<float, -7, true>(); + /// + /// For I = 0, 1, and 2, Type, Integral, and Integral will be returned, + /// respectively. + int clang_Cursor_getTemplateArgumentKind( + CXCursor C, + int I, + ) { + return (_clang_Cursor_getTemplateArgumentKind ??= _dylib.lookupFunction< + _c_clang_Cursor_getTemplateArgumentKind, + _dart_clang_Cursor_getTemplateArgumentKind>( + 'clang_Cursor_getTemplateArgumentKind'))( + C, + I, + ); + } + + _dart_clang_Cursor_getTemplateArgumentKind? + _clang_Cursor_getTemplateArgumentKind; + + /// Retrieve a CXType representing the type of a TemplateArgument of a + /// function decl representing a template specialization. + /// + /// If the argument CXCursor does not represent a FunctionDecl whose I'th + /// template argument has a kind of CXTemplateArgKind_Integral, an invalid type + /// is returned. + /// + /// For example, for the following declaration and specialization: + /// template <typename T, int kInt, bool kBool> + /// void foo() { ... } + /// + /// template <> + /// void foo<float, -7, true>(); + /// + /// If called with I = 0, "float", will be returned. + /// Invalid types will be returned for I == 1 or 2. + CXType clang_Cursor_getTemplateArgumentType( + CXCursor C, + int I, + ) { + return (_clang_Cursor_getTemplateArgumentType ??= _dylib.lookupFunction< + _c_clang_Cursor_getTemplateArgumentType, + _dart_clang_Cursor_getTemplateArgumentType>( + 'clang_Cursor_getTemplateArgumentType'))( + C, + I, + ); + } + + _dart_clang_Cursor_getTemplateArgumentType? + _clang_Cursor_getTemplateArgumentType; + + /// Retrieve the value of an Integral TemplateArgument (of a function + /// decl representing a template specialization) as a signed long long. + /// + /// It is undefined to call this function on a CXCursor that does not represent a + /// FunctionDecl or whose I'th template argument is not an integral value. + /// + /// For example, for the following declaration and specialization: + /// template <typename T, int kInt, bool kBool> + /// void foo() { ... } + /// + /// template <> + /// void foo<float, -7, true>(); + /// + /// If called with I = 1 or 2, -7 or true will be returned, respectively. + /// For I == 0, this function's behavior is undefined. + int clang_Cursor_getTemplateArgumentValue( + CXCursor C, + int I, + ) { + return (_clang_Cursor_getTemplateArgumentValue ??= _dylib.lookupFunction< + _c_clang_Cursor_getTemplateArgumentValue, + _dart_clang_Cursor_getTemplateArgumentValue>( + 'clang_Cursor_getTemplateArgumentValue'))( + C, + I, + ); + } + + _dart_clang_Cursor_getTemplateArgumentValue? + _clang_Cursor_getTemplateArgumentValue; + + /// Retrieve the value of an Integral TemplateArgument (of a function + /// decl representing a template specialization) as an unsigned long long. + /// + /// It is undefined to call this function on a CXCursor that does not represent a + /// FunctionDecl or whose I'th template argument is not an integral value. + /// + /// For example, for the following declaration and specialization: + /// template <typename T, int kInt, bool kBool> + /// void foo() { ... } + /// + /// template <> + /// void foo<float, 2147483649, true>(); + /// + /// If called with I = 1 or 2, 2147483649 or true will be returned, respectively. + /// For I == 0, this function's behavior is undefined. + int clang_Cursor_getTemplateArgumentUnsignedValue( + CXCursor C, + int I, + ) { + return (_clang_Cursor_getTemplateArgumentUnsignedValue ??= + _dylib.lookupFunction<_c_clang_Cursor_getTemplateArgumentUnsignedValue, + _dart_clang_Cursor_getTemplateArgumentUnsignedValue>( + 'clang_Cursor_getTemplateArgumentUnsignedValue'))( + C, + I, + ); + } + + _dart_clang_Cursor_getTemplateArgumentUnsignedValue? + _clang_Cursor_getTemplateArgumentUnsignedValue; + + /// Determine whether two CXTypes represent the same type. + /// + /// \returns non-zero if the CXTypes represent the same type and + /// zero otherwise. + int clang_equalTypes( + CXType A, + CXType B, + ) { + return (_clang_equalTypes ??= + _dylib.lookupFunction<_c_clang_equalTypes, _dart_clang_equalTypes>( + 'clang_equalTypes'))( + A, + B, + ); + } + + _dart_clang_equalTypes? _clang_equalTypes; + + /// Return the canonical type for a CXType. + /// + /// Clang's type system explicitly models typedefs and all the ways + /// a specific type can be represented. The canonical type is the underlying + /// type with all the "sugar" removed. For example, if 'T' is a typedef + /// for 'int', the canonical type for 'T' would be 'int'. + CXType clang_getCanonicalType( + CXType T, + ) { + return (_clang_getCanonicalType ??= _dylib.lookupFunction< + _c_clang_getCanonicalType, + _dart_clang_getCanonicalType>('clang_getCanonicalType'))( + T, + ); + } + + _dart_clang_getCanonicalType? _clang_getCanonicalType; + + /// 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 ??= _dylib.lookupFunction< + _c_clang_isConstQualifiedType, + _dart_clang_isConstQualifiedType>('clang_isConstQualifiedType'))( + T, + ); + } + + _dart_clang_isConstQualifiedType? _clang_isConstQualifiedType; + + /// Determine whether a CXCursor that is a macro, is + /// function like. + int clang_Cursor_isMacroFunctionLike( + CXCursor C, + ) { + return (_clang_Cursor_isMacroFunctionLike ??= _dylib.lookupFunction< + _c_clang_Cursor_isMacroFunctionLike, + _dart_clang_Cursor_isMacroFunctionLike>( + 'clang_Cursor_isMacroFunctionLike'))( + C, + ); + } + + _dart_clang_Cursor_isMacroFunctionLike? _clang_Cursor_isMacroFunctionLike; + + /// Determine whether a CXCursor that is a macro, is a + /// builtin one. + int clang_Cursor_isMacroBuiltin( + CXCursor C, + ) { + return (_clang_Cursor_isMacroBuiltin ??= _dylib.lookupFunction< + _c_clang_Cursor_isMacroBuiltin, + _dart_clang_Cursor_isMacroBuiltin>('clang_Cursor_isMacroBuiltin'))( + C, + ); + } + + _dart_clang_Cursor_isMacroBuiltin? _clang_Cursor_isMacroBuiltin; + + /// Determine whether a CXCursor that is a function declaration, is an + /// inline declaration. + int clang_Cursor_isFunctionInlined( + CXCursor C, + ) { + return (_clang_Cursor_isFunctionInlined ??= _dylib.lookupFunction< + _c_clang_Cursor_isFunctionInlined, + _dart_clang_Cursor_isFunctionInlined>( + 'clang_Cursor_isFunctionInlined'))( + C, + ); + } + + _dart_clang_Cursor_isFunctionInlined? _clang_Cursor_isFunctionInlined; + + /// 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 ??= _dylib.lookupFunction< + _c_clang_isVolatileQualifiedType, + _dart_clang_isVolatileQualifiedType>('clang_isVolatileQualifiedType'))( + T, + ); + } + + _dart_clang_isVolatileQualifiedType? _clang_isVolatileQualifiedType; + + /// 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 ??= _dylib.lookupFunction< + _c_clang_isRestrictQualifiedType, + _dart_clang_isRestrictQualifiedType>('clang_isRestrictQualifiedType'))( + T, + ); + } + + _dart_clang_isRestrictQualifiedType? _clang_isRestrictQualifiedType; + + /// Returns the address space of the given type. + int clang_getAddressSpace( + CXType T, + ) { + return (_clang_getAddressSpace ??= _dylib.lookupFunction< + _c_clang_getAddressSpace, + _dart_clang_getAddressSpace>('clang_getAddressSpace'))( + T, + ); + } + + _dart_clang_getAddressSpace? _clang_getAddressSpace; + + /// Returns the typedef name of the given type. + CXString clang_getTypedefName( + CXType CT, + ) { + return (_clang_getTypedefName ??= _dylib.lookupFunction< + _c_clang_getTypedefName, + _dart_clang_getTypedefName>('clang_getTypedefName'))( + CT, + ); + } + + _dart_clang_getTypedefName? _clang_getTypedefName; + + /// For pointer types, returns the type of the pointee. + CXType clang_getPointeeType( + CXType T, + ) { + return (_clang_getPointeeType ??= _dylib.lookupFunction< + _c_clang_getPointeeType, + _dart_clang_getPointeeType>('clang_getPointeeType'))( + T, + ); + } + + _dart_clang_getPointeeType? _clang_getPointeeType; + + /// Return the cursor for the declaration of the given type. + CXCursor clang_getTypeDeclaration( + CXType T, + ) { + return (_clang_getTypeDeclaration ??= _dylib.lookupFunction< + _c_clang_getTypeDeclaration, + _dart_clang_getTypeDeclaration>('clang_getTypeDeclaration'))( + T, + ); + } + + _dart_clang_getTypeDeclaration? _clang_getTypeDeclaration; + + /// Returns the Objective-C type encoding for the specified declaration. + CXString clang_getDeclObjCTypeEncoding( + CXCursor C, + ) { + return (_clang_getDeclObjCTypeEncoding ??= _dylib.lookupFunction< + _c_clang_getDeclObjCTypeEncoding, + _dart_clang_getDeclObjCTypeEncoding>('clang_getDeclObjCTypeEncoding'))( + C, + ); + } + + _dart_clang_getDeclObjCTypeEncoding? _clang_getDeclObjCTypeEncoding; + + /// Returns the Objective-C type encoding for the specified CXType. + CXString clang_Type_getObjCEncoding( + CXType type, + ) { + return (_clang_Type_getObjCEncoding ??= _dylib.lookupFunction< + _c_clang_Type_getObjCEncoding, + _dart_clang_Type_getObjCEncoding>('clang_Type_getObjCEncoding'))( + type, + ); + } + + _dart_clang_Type_getObjCEncoding? _clang_Type_getObjCEncoding; + + /// Retrieve the spelling of a given CXTypeKind. + CXString clang_getTypeKindSpelling( + int K, + ) { + return (_clang_getTypeKindSpelling ??= _dylib.lookupFunction< + _c_clang_getTypeKindSpelling, + _dart_clang_getTypeKindSpelling>('clang_getTypeKindSpelling'))( + K, + ); + } + + _dart_clang_getTypeKindSpelling? _clang_getTypeKindSpelling; + + /// Retrieve the calling convention associated with a function type. + /// + /// If a non-function type is passed in, CXCallingConv_Invalid is returned. + int clang_getFunctionTypeCallingConv( + CXType T, + ) { + return (_clang_getFunctionTypeCallingConv ??= _dylib.lookupFunction< + _c_clang_getFunctionTypeCallingConv, + _dart_clang_getFunctionTypeCallingConv>( + 'clang_getFunctionTypeCallingConv'))( + T, + ); + } + + _dart_clang_getFunctionTypeCallingConv? _clang_getFunctionTypeCallingConv; + + /// Retrieve the return type associated with a function type. + /// + /// If a non-function type is passed in, an invalid type is returned. + CXType clang_getResultType( + CXType T, + ) { + return (_clang_getResultType ??= _dylib.lookupFunction< + _c_clang_getResultType, + _dart_clang_getResultType>('clang_getResultType'))( + T, + ); + } + + _dart_clang_getResultType? _clang_getResultType; + + /// Retrieve the exception specification type associated with a function type. + /// This is a value of type CXCursor_ExceptionSpecificationKind. + /// + /// If a non-function type is passed in, an error code of -1 is returned. + int clang_getExceptionSpecificationType( + CXType T, + ) { + return (_clang_getExceptionSpecificationType ??= _dylib.lookupFunction< + _c_clang_getExceptionSpecificationType, + _dart_clang_getExceptionSpecificationType>( + 'clang_getExceptionSpecificationType'))( + T, + ); + } + + _dart_clang_getExceptionSpecificationType? + _clang_getExceptionSpecificationType; + + /// Retrieve the number of non-variadic parameters associated with a + /// function type. + /// + /// If a non-function type is passed in, -1 is returned. + int clang_getNumArgTypes( + CXType T, + ) { + return (_clang_getNumArgTypes ??= _dylib.lookupFunction< + _c_clang_getNumArgTypes, + _dart_clang_getNumArgTypes>('clang_getNumArgTypes'))( + T, + ); + } + + _dart_clang_getNumArgTypes? _clang_getNumArgTypes; + + /// Retrieve the type of a parameter of a function type. + /// + /// If a non-function type is passed in or the function does not have enough + /// parameters, an invalid type is returned. + CXType clang_getArgType( + CXType T, + int i, + ) { + return (_clang_getArgType ??= + _dylib.lookupFunction<_c_clang_getArgType, _dart_clang_getArgType>( + 'clang_getArgType'))( + T, + i, + ); + } + + _dart_clang_getArgType? _clang_getArgType; + + /// Retrieves the base type of the ObjCObjectType. + /// + /// If the type is not an ObjC object, an invalid type is returned. + CXType clang_Type_getObjCObjectBaseType( + CXType T, + ) { + return (_clang_Type_getObjCObjectBaseType ??= _dylib.lookupFunction< + _c_clang_Type_getObjCObjectBaseType, + _dart_clang_Type_getObjCObjectBaseType>( + 'clang_Type_getObjCObjectBaseType'))( + T, + ); + } + + _dart_clang_Type_getObjCObjectBaseType? _clang_Type_getObjCObjectBaseType; + + /// Retrieve the number of protocol references associated with an ObjC object/id. + /// + /// If the type is not an ObjC object, 0 is returned. + int clang_Type_getNumObjCProtocolRefs( + CXType T, + ) { + return (_clang_Type_getNumObjCProtocolRefs ??= _dylib.lookupFunction< + _c_clang_Type_getNumObjCProtocolRefs, + _dart_clang_Type_getNumObjCProtocolRefs>( + 'clang_Type_getNumObjCProtocolRefs'))( + T, + ); + } + + _dart_clang_Type_getNumObjCProtocolRefs? _clang_Type_getNumObjCProtocolRefs; + + /// Retrieve the decl for a protocol reference for an ObjC object/id. + /// + /// If the type is not an ObjC object or there are not enough protocol + /// references, an invalid cursor is returned. + CXCursor clang_Type_getObjCProtocolDecl( + CXType T, + int i, + ) { + return (_clang_Type_getObjCProtocolDecl ??= _dylib.lookupFunction< + _c_clang_Type_getObjCProtocolDecl, + _dart_clang_Type_getObjCProtocolDecl>( + 'clang_Type_getObjCProtocolDecl'))( + T, + i, + ); + } + + _dart_clang_Type_getObjCProtocolDecl? _clang_Type_getObjCProtocolDecl; + + /// Retreive the number of type arguments associated with an ObjC object. + /// + /// If the type is not an ObjC object, 0 is returned. + int clang_Type_getNumObjCTypeArgs( + CXType T, + ) { + return (_clang_Type_getNumObjCTypeArgs ??= _dylib.lookupFunction< + _c_clang_Type_getNumObjCTypeArgs, + _dart_clang_Type_getNumObjCTypeArgs>('clang_Type_getNumObjCTypeArgs'))( + T, + ); + } + + _dart_clang_Type_getNumObjCTypeArgs? _clang_Type_getNumObjCTypeArgs; + + /// Retrieve a type argument associated with an ObjC object. + /// + /// If the type is not an ObjC or the index is not valid, + /// an invalid type is returned. + CXType clang_Type_getObjCTypeArg( + CXType T, + int i, + ) { + return (_clang_Type_getObjCTypeArg ??= _dylib.lookupFunction< + _c_clang_Type_getObjCTypeArg, + _dart_clang_Type_getObjCTypeArg>('clang_Type_getObjCTypeArg'))( + T, + i, + ); + } + + _dart_clang_Type_getObjCTypeArg? _clang_Type_getObjCTypeArg; + + /// Return 1 if the CXType is a variadic function type, and 0 otherwise. + int clang_isFunctionTypeVariadic( + CXType T, + ) { + return (_clang_isFunctionTypeVariadic ??= _dylib.lookupFunction< + _c_clang_isFunctionTypeVariadic, + _dart_clang_isFunctionTypeVariadic>('clang_isFunctionTypeVariadic'))( + T, + ); + } + + _dart_clang_isFunctionTypeVariadic? _clang_isFunctionTypeVariadic; + + /// Retrieve the return type associated with a given cursor. + /// + /// This only returns a valid type if the cursor refers to a function or method. + CXType clang_getCursorResultType( + CXCursor C, + ) { + return (_clang_getCursorResultType ??= _dylib.lookupFunction< + _c_clang_getCursorResultType, + _dart_clang_getCursorResultType>('clang_getCursorResultType'))( + C, + ); + } + + _dart_clang_getCursorResultType? _clang_getCursorResultType; + + /// Retrieve the exception specification type associated with a given cursor. + /// This is a value of type CXCursor_ExceptionSpecificationKind. + /// + /// This only returns a valid result if the cursor refers to a function or method. + int clang_getCursorExceptionSpecificationType( + CXCursor C, + ) { + return (_clang_getCursorExceptionSpecificationType ??= + _dylib.lookupFunction<_c_clang_getCursorExceptionSpecificationType, + _dart_clang_getCursorExceptionSpecificationType>( + 'clang_getCursorExceptionSpecificationType'))( + C, + ); + } + + _dart_clang_getCursorExceptionSpecificationType? + _clang_getCursorExceptionSpecificationType; + + /// Return 1 if the CXType is a POD (plain old data) type, and 0 + /// otherwise. + int clang_isPODType( + CXType T, + ) { + return (_clang_isPODType ??= + _dylib.lookupFunction<_c_clang_isPODType, _dart_clang_isPODType>( + 'clang_isPODType'))( + T, + ); + } + + _dart_clang_isPODType? _clang_isPODType; + + /// Return the element type of an array, complex, or vector type. + /// + /// If a type is passed in that is not an array, complex, or vector type, + /// an invalid type is returned. + CXType clang_getElementType( + CXType T, + ) { + return (_clang_getElementType ??= _dylib.lookupFunction< + _c_clang_getElementType, + _dart_clang_getElementType>('clang_getElementType'))( + T, + ); + } + + _dart_clang_getElementType? _clang_getElementType; + + /// Return the number of elements of an array or vector type. + /// + /// If a type is passed in that is not an array or vector type, + /// -1 is returned. + int clang_getNumElements( + CXType T, + ) { + return (_clang_getNumElements ??= _dylib.lookupFunction< + _c_clang_getNumElements, + _dart_clang_getNumElements>('clang_getNumElements'))( + T, + ); + } + + _dart_clang_getNumElements? _clang_getNumElements; + + /// Return the element type of an array type. + /// + /// If a non-array type is passed in, an invalid type is returned. + CXType clang_getArrayElementType( + CXType T, + ) { + return (_clang_getArrayElementType ??= _dylib.lookupFunction< + _c_clang_getArrayElementType, + _dart_clang_getArrayElementType>('clang_getArrayElementType'))( + T, + ); + } + + _dart_clang_getArrayElementType? _clang_getArrayElementType; + + /// Return the array size of a constant array. + /// + /// If a non-array type is passed in, -1 is returned. + int clang_getArraySize( + CXType T, + ) { + return (_clang_getArraySize ??= + _dylib.lookupFunction<_c_clang_getArraySize, _dart_clang_getArraySize>( + 'clang_getArraySize'))( + T, + ); + } + + _dart_clang_getArraySize? _clang_getArraySize; + + /// Retrieve the type named by the qualified-id. + /// + /// If a non-elaborated type is passed in, an invalid type is returned. + CXType clang_Type_getNamedType( + CXType T, + ) { + return (_clang_Type_getNamedType ??= _dylib.lookupFunction< + _c_clang_Type_getNamedType, + _dart_clang_Type_getNamedType>('clang_Type_getNamedType'))( + T, + ); + } + + _dart_clang_Type_getNamedType? _clang_Type_getNamedType; + + /// Determine if a typedef is 'transparent' tag. + /// + /// A typedef is considered 'transparent' if it shares a name and spelling + /// location with its underlying tag type, as is the case with the NS_ENUM macro. + /// + /// \returns non-zero if transparent and zero otherwise. + int clang_Type_isTransparentTagTypedef( + CXType T, + ) { + return (_clang_Type_isTransparentTagTypedef ??= _dylib.lookupFunction< + _c_clang_Type_isTransparentTagTypedef, + _dart_clang_Type_isTransparentTagTypedef>( + 'clang_Type_isTransparentTagTypedef'))( + T, + ); + } + + _dart_clang_Type_isTransparentTagTypedef? _clang_Type_isTransparentTagTypedef; + + /// Retrieve the nullability kind of a pointer type. + int clang_Type_getNullability( + CXType T, + ) { + return (_clang_Type_getNullability ??= _dylib.lookupFunction< + _c_clang_Type_getNullability, + _dart_clang_Type_getNullability>('clang_Type_getNullability'))( + T, + ); + } + + _dart_clang_Type_getNullability? _clang_Type_getNullability; + + /// Return the alignment of a type in bytes as per C++[expr.alignof] + /// standard. + /// + /// If the type declaration is invalid, CXTypeLayoutError_Invalid is returned. + /// If the type declaration is an incomplete type, CXTypeLayoutError_Incomplete + /// is returned. + /// If the type declaration is a dependent type, CXTypeLayoutError_Dependent is + /// returned. + /// If the type declaration is not a constant size type, + /// CXTypeLayoutError_NotConstantSize is returned. + int clang_Type_getAlignOf( + CXType T, + ) { + return (_clang_Type_getAlignOf ??= _dylib.lookupFunction< + _c_clang_Type_getAlignOf, + _dart_clang_Type_getAlignOf>('clang_Type_getAlignOf'))( + T, + ); + } + + _dart_clang_Type_getAlignOf? _clang_Type_getAlignOf; + + /// Return the class type of an member pointer type. + /// + /// If a non-member-pointer type is passed in, an invalid type is returned. + CXType clang_Type_getClassType( + CXType T, + ) { + return (_clang_Type_getClassType ??= _dylib.lookupFunction< + _c_clang_Type_getClassType, + _dart_clang_Type_getClassType>('clang_Type_getClassType'))( + T, + ); + } + + _dart_clang_Type_getClassType? _clang_Type_getClassType; + + /// Return the size of a type in bytes as per C++[expr.sizeof] standard. + /// + /// If the type declaration is invalid, CXTypeLayoutError_Invalid is returned. + /// If the type declaration is an incomplete type, CXTypeLayoutError_Incomplete + /// is returned. + /// If the type declaration is a dependent type, CXTypeLayoutError_Dependent is + /// returned. + int clang_Type_getSizeOf( + CXType T, + ) { + return (_clang_Type_getSizeOf ??= _dylib.lookupFunction< + _c_clang_Type_getSizeOf, + _dart_clang_Type_getSizeOf>('clang_Type_getSizeOf'))( + T, + ); + } + + _dart_clang_Type_getSizeOf? _clang_Type_getSizeOf; + + /// 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] + /// + /// If the cursor is not a record field declaration, CXTypeLayoutError_Invalid + /// is returned. + /// If the field's type declaration is an incomplete type, + /// CXTypeLayoutError_Incomplete is returned. + /// If the field's type declaration is a dependent type, + /// CXTypeLayoutError_Dependent is returned. + /// If the field's name S is not found, + /// CXTypeLayoutError_InvalidFieldName is returned. + int clang_Type_getOffsetOf( + CXType T, + ffi.Pointer<ffi.Int8> S, + ) { + return (_clang_Type_getOffsetOf ??= _dylib.lookupFunction< + _c_clang_Type_getOffsetOf, + _dart_clang_Type_getOffsetOf>('clang_Type_getOffsetOf'))( + T, + S, + ); + } + + _dart_clang_Type_getOffsetOf? _clang_Type_getOffsetOf; + + /// Return the type that was modified by this attributed type. + /// + /// If the type is not an attributed type, an invalid type is returned. + CXType clang_Type_getModifiedType( + CXType T, + ) { + return (_clang_Type_getModifiedType ??= _dylib.lookupFunction< + _c_clang_Type_getModifiedType, + _dart_clang_Type_getModifiedType>('clang_Type_getModifiedType'))( + T, + ); + } + + _dart_clang_Type_getModifiedType? _clang_Type_getModifiedType; + + /// Return the offset of the field represented by the Cursor. + /// + /// If the cursor is not a field declaration, -1 is returned. + /// If the cursor semantic parent is not a record field declaration, + /// CXTypeLayoutError_Invalid is returned. + /// If the field's type declaration is an incomplete type, + /// CXTypeLayoutError_Incomplete is returned. + /// If the field's type declaration is a dependent type, + /// CXTypeLayoutError_Dependent is returned. + /// If the field's name S is not found, + /// CXTypeLayoutError_InvalidFieldName is returned. + int clang_Cursor_getOffsetOfField( + CXCursor C, + ) { + return (_clang_Cursor_getOffsetOfField ??= _dylib.lookupFunction< + _c_clang_Cursor_getOffsetOfField, + _dart_clang_Cursor_getOffsetOfField>('clang_Cursor_getOffsetOfField'))( + C, + ); + } + + _dart_clang_Cursor_getOffsetOfField? _clang_Cursor_getOffsetOfField; + + /// Determine whether the given cursor represents an anonymous + /// tag or namespace + int clang_Cursor_isAnonymous( + CXCursor C, + ) { + return (_clang_Cursor_isAnonymous ??= _dylib.lookupFunction< + _c_clang_Cursor_isAnonymous, + _dart_clang_Cursor_isAnonymous>('clang_Cursor_isAnonymous'))( + C, + ); + } + + _dart_clang_Cursor_isAnonymous? _clang_Cursor_isAnonymous; + + /// Determine whether the given cursor represents an anonymous record + /// declaration. + int clang_Cursor_isAnonymousRecordDecl( + CXCursor C, + ) { + return (_clang_Cursor_isAnonymousRecordDecl ??= _dylib.lookupFunction< + _c_clang_Cursor_isAnonymousRecordDecl, + _dart_clang_Cursor_isAnonymousRecordDecl>( + 'clang_Cursor_isAnonymousRecordDecl'))( + C, + ); + } + + _dart_clang_Cursor_isAnonymousRecordDecl? _clang_Cursor_isAnonymousRecordDecl; + + /// Determine whether the given cursor represents an inline namespace + /// declaration. + int clang_Cursor_isInlineNamespace( + CXCursor C, + ) { + return (_clang_Cursor_isInlineNamespace ??= _dylib.lookupFunction< + _c_clang_Cursor_isInlineNamespace, + _dart_clang_Cursor_isInlineNamespace>( + 'clang_Cursor_isInlineNamespace'))( + C, + ); + } + + _dart_clang_Cursor_isInlineNamespace? _clang_Cursor_isInlineNamespace; + + /// Returns the number of template arguments for given template + /// specialization, or -1 if type \c T is not a template specialization. + int clang_Type_getNumTemplateArguments( + CXType T, + ) { + return (_clang_Type_getNumTemplateArguments ??= _dylib.lookupFunction< + _c_clang_Type_getNumTemplateArguments, + _dart_clang_Type_getNumTemplateArguments>( + 'clang_Type_getNumTemplateArguments'))( + T, + ); + } + + _dart_clang_Type_getNumTemplateArguments? _clang_Type_getNumTemplateArguments; + + /// Returns the type template argument of a template class specialization + /// at given index. + /// + /// This function only returns template type arguments and does not handle + /// template template arguments or variadic packs. + CXType clang_Type_getTemplateArgumentAsType( + CXType T, + int i, + ) { + return (_clang_Type_getTemplateArgumentAsType ??= _dylib.lookupFunction< + _c_clang_Type_getTemplateArgumentAsType, + _dart_clang_Type_getTemplateArgumentAsType>( + 'clang_Type_getTemplateArgumentAsType'))( + T, + i, + ); + } + + _dart_clang_Type_getTemplateArgumentAsType? + _clang_Type_getTemplateArgumentAsType; + + /// Retrieve the ref-qualifier kind of a function or method. + /// + /// The ref-qualifier is returned for C++ functions or methods. For other types + /// or non-C++ declarations, CXRefQualifier_None is returned. + int clang_Type_getCXXRefQualifier( + CXType T, + ) { + return (_clang_Type_getCXXRefQualifier ??= _dylib.lookupFunction< + _c_clang_Type_getCXXRefQualifier, + _dart_clang_Type_getCXXRefQualifier>('clang_Type_getCXXRefQualifier'))( + T, + ); + } + + _dart_clang_Type_getCXXRefQualifier? _clang_Type_getCXXRefQualifier; + + /// Returns non-zero if the cursor specifies a Record member that is a + /// bitfield. + int clang_Cursor_isBitField( + CXCursor C, + ) { + return (_clang_Cursor_isBitField ??= _dylib.lookupFunction< + _c_clang_Cursor_isBitField, + _dart_clang_Cursor_isBitField>('clang_Cursor_isBitField'))( + C, + ); + } + + _dart_clang_Cursor_isBitField? _clang_Cursor_isBitField; + + /// Returns 1 if the base class specified by the cursor with kind + /// CX_CXXBaseSpecifier is virtual. + int clang_isVirtualBase( + CXCursor arg0, + ) { + return (_clang_isVirtualBase ??= _dylib.lookupFunction< + _c_clang_isVirtualBase, + _dart_clang_isVirtualBase>('clang_isVirtualBase'))( + arg0, + ); + } + + _dart_clang_isVirtualBase? _clang_isVirtualBase; + + /// Returns the access control level for the referenced object. + /// + /// If the cursor refers to a C++ declaration, its access control level within its + /// parent scope is returned. Otherwise, if the cursor refers to a base specifier or + /// access specifier, the specifier itself is returned. + int clang_getCXXAccessSpecifier( + CXCursor arg0, + ) { + return (_clang_getCXXAccessSpecifier ??= _dylib.lookupFunction< + _c_clang_getCXXAccessSpecifier, + _dart_clang_getCXXAccessSpecifier>('clang_getCXXAccessSpecifier'))( + arg0, + ); + } + + _dart_clang_getCXXAccessSpecifier? _clang_getCXXAccessSpecifier; + + /// Returns the storage class for a function or variable declaration. + /// + /// If the passed in Cursor is not a function or variable declaration, + /// CX_SC_Invalid is returned else the storage class. + int clang_Cursor_getStorageClass( + CXCursor arg0, + ) { + return (_clang_Cursor_getStorageClass ??= _dylib.lookupFunction< + _c_clang_Cursor_getStorageClass, + _dart_clang_Cursor_getStorageClass>('clang_Cursor_getStorageClass'))( + arg0, + ); + } + + _dart_clang_Cursor_getStorageClass? _clang_Cursor_getStorageClass; + + /// Determine the number of overloaded declarations referenced by a + /// \c CXCursor_OverloadedDeclRef cursor. + /// + /// \param cursor The cursor whose overloaded declarations are being queried. + /// + /// \returns The number of overloaded declarations referenced by \c cursor. If it + /// is not a \c CXCursor_OverloadedDeclRef cursor, returns 0. + int clang_getNumOverloadedDecls( + CXCursor cursor, + ) { + return (_clang_getNumOverloadedDecls ??= _dylib.lookupFunction< + _c_clang_getNumOverloadedDecls, + _dart_clang_getNumOverloadedDecls>('clang_getNumOverloadedDecls'))( + cursor, + ); + } + + _dart_clang_getNumOverloadedDecls? _clang_getNumOverloadedDecls; + + /// Retrieve a cursor for one of the overloaded declarations referenced + /// by a \c CXCursor_OverloadedDeclRef cursor. + /// + /// \param cursor The cursor whose overloaded declarations are being queried. + /// + /// \param index The zero-based index into the set of overloaded declarations in + /// the cursor. + /// + /// \returns A cursor representing the declaration referenced by the given + /// \c cursor at the specified \c index. If the cursor does not have an + /// associated set of overloaded declarations, or if the index is out of bounds, + /// returns \c clang_getNullCursor(); + CXCursor clang_getOverloadedDecl( + CXCursor cursor, + int index, + ) { + return (_clang_getOverloadedDecl ??= _dylib.lookupFunction< + _c_clang_getOverloadedDecl, + _dart_clang_getOverloadedDecl>('clang_getOverloadedDecl'))( + cursor, + index, + ); + } + + _dart_clang_getOverloadedDecl? _clang_getOverloadedDecl; + + /// For cursors representing an iboutletcollection attribute, + /// this function returns the collection element type. + CXType clang_getIBOutletCollectionType( + CXCursor arg0, + ) { + return (_clang_getIBOutletCollectionType ??= _dylib.lookupFunction< + _c_clang_getIBOutletCollectionType, + _dart_clang_getIBOutletCollectionType>( + 'clang_getIBOutletCollectionType'))( + arg0, + ); + } + + _dart_clang_getIBOutletCollectionType? _clang_getIBOutletCollectionType; + + /// Visit the children of a particular cursor. + /// + /// This function visits all the direct children of the given cursor, + /// invoking the given \p visitor function with the cursors of each + /// visited child. The traversal may be recursive, if the visitor returns + /// \c CXChildVisit_Recurse. The traversal may also be ended prematurely, if + /// the visitor returns \c CXChildVisit_Break. + /// + /// \param parent the cursor whose child may be visited. All kinds of + /// cursors can be visited, including invalid cursors (which, by + /// definition, have no children). + /// + /// \param visitor the visitor function that will be invoked for each + /// child of \p parent. + /// + /// \param client_data pointer data supplied by the client, which will + /// be passed to the visitor each time it is invoked. + /// + /// \returns a non-zero value if the traversal was terminated + /// prematurely by the visitor returning \c CXChildVisit_Break. + int clang_visitChildren( + CXCursor parent, + ffi.Pointer<ffi.NativeFunction<CXCursorVisitor>> visitor, + ffi.Pointer<ffi.Void> client_data, + ) { + return (_clang_visitChildren ??= _dylib.lookupFunction< + _c_clang_visitChildren, + _dart_clang_visitChildren>('clang_visitChildren'))( + parent, + visitor, + client_data, + ); + } + + _dart_clang_visitChildren? _clang_visitChildren; + + /// Retrieve a Unified Symbol Resolution (USR) for the entity referenced + /// by the given cursor. + /// + /// A Unified Symbol Resolution (USR) is a string that identifies a particular + /// entity (function, class, variable, etc.) within a program. USRs can be + /// compared across translation units to determine, e.g., when references in + /// one translation refer to an entity defined in another translation unit. + CXString clang_getCursorUSR( + CXCursor arg0, + ) { + return (_clang_getCursorUSR ??= + _dylib.lookupFunction<_c_clang_getCursorUSR, _dart_clang_getCursorUSR>( + 'clang_getCursorUSR'))( + arg0, + ); + } + + _dart_clang_getCursorUSR? _clang_getCursorUSR; + + /// Construct a USR for a specified Objective-C class. + CXString clang_constructUSR_ObjCClass( + ffi.Pointer<ffi.Int8> class_name, + ) { + return (_clang_constructUSR_ObjCClass ??= _dylib.lookupFunction< + _c_clang_constructUSR_ObjCClass, + _dart_clang_constructUSR_ObjCClass>('clang_constructUSR_ObjCClass'))( + class_name, + ); + } + + _dart_clang_constructUSR_ObjCClass? _clang_constructUSR_ObjCClass; + + /// Construct a USR for a specified Objective-C category. + CXString clang_constructUSR_ObjCCategory( + ffi.Pointer<ffi.Int8> class_name, + ffi.Pointer<ffi.Int8> category_name, + ) { + return (_clang_constructUSR_ObjCCategory ??= _dylib.lookupFunction< + _c_clang_constructUSR_ObjCCategory, + _dart_clang_constructUSR_ObjCCategory>( + 'clang_constructUSR_ObjCCategory'))( + class_name, + category_name, + ); + } + + _dart_clang_constructUSR_ObjCCategory? _clang_constructUSR_ObjCCategory; + + /// Construct a USR for a specified Objective-C protocol. + CXString clang_constructUSR_ObjCProtocol( + ffi.Pointer<ffi.Int8> protocol_name, + ) { + return (_clang_constructUSR_ObjCProtocol ??= _dylib.lookupFunction< + _c_clang_constructUSR_ObjCProtocol, + _dart_clang_constructUSR_ObjCProtocol>( + 'clang_constructUSR_ObjCProtocol'))( + protocol_name, + ); + } + + _dart_clang_constructUSR_ObjCProtocol? _clang_constructUSR_ObjCProtocol; + + /// Construct a USR for a specified Objective-C instance variable and + /// the USR for its containing class. + CXString clang_constructUSR_ObjCIvar( + ffi.Pointer<ffi.Int8> name, + CXString classUSR, + ) { + return (_clang_constructUSR_ObjCIvar ??= _dylib.lookupFunction< + _c_clang_constructUSR_ObjCIvar, + _dart_clang_constructUSR_ObjCIvar>('clang_constructUSR_ObjCIvar'))( + name, + classUSR, + ); + } + + _dart_clang_constructUSR_ObjCIvar? _clang_constructUSR_ObjCIvar; + + /// Construct a USR for a specified Objective-C method and + /// the USR for its containing class. + CXString clang_constructUSR_ObjCMethod( + ffi.Pointer<ffi.Int8> name, + int isInstanceMethod, + CXString classUSR, + ) { + return (_clang_constructUSR_ObjCMethod ??= _dylib.lookupFunction< + _c_clang_constructUSR_ObjCMethod, + _dart_clang_constructUSR_ObjCMethod>('clang_constructUSR_ObjCMethod'))( + name, + isInstanceMethod, + classUSR, + ); + } + + _dart_clang_constructUSR_ObjCMethod? _clang_constructUSR_ObjCMethod; + + /// Construct a USR for a specified Objective-C property and the USR + /// for its containing class. + CXString clang_constructUSR_ObjCProperty( + ffi.Pointer<ffi.Int8> property, + CXString classUSR, + ) { + return (_clang_constructUSR_ObjCProperty ??= _dylib.lookupFunction< + _c_clang_constructUSR_ObjCProperty, + _dart_clang_constructUSR_ObjCProperty>( + 'clang_constructUSR_ObjCProperty'))( + property, + classUSR, + ); + } + + _dart_clang_constructUSR_ObjCProperty? _clang_constructUSR_ObjCProperty; + + /// Retrieve a name for the entity referenced by this cursor. + CXString clang_getCursorSpelling( + CXCursor arg0, + ) { + return (_clang_getCursorSpelling ??= _dylib.lookupFunction< + _c_clang_getCursorSpelling, + _dart_clang_getCursorSpelling>('clang_getCursorSpelling'))( + arg0, + ); + } + + _dart_clang_getCursorSpelling? _clang_getCursorSpelling; + + /// Retrieve a range for a piece that forms the cursors spelling name. + /// Most of the times there is only one range for the complete spelling but for + /// Objective-C methods and Objective-C message expressions, there are multiple + /// pieces for each selector identifier. + /// + /// \param pieceIndex the index of the spelling name piece. If this is greater + /// than the actual number of pieces, it will return a NULL (invalid) range. + /// + /// \param options Reserved. + CXSourceRange clang_Cursor_getSpellingNameRange( + CXCursor arg0, + int pieceIndex, + int options, + ) { + return (_clang_Cursor_getSpellingNameRange ??= _dylib.lookupFunction< + _c_clang_Cursor_getSpellingNameRange, + _dart_clang_Cursor_getSpellingNameRange>( + 'clang_Cursor_getSpellingNameRange'))( + arg0, + pieceIndex, + options, + ); + } + + _dart_clang_Cursor_getSpellingNameRange? _clang_Cursor_getSpellingNameRange; + /// Get a property value for the given printing policy. int clang_PrintingPolicy_getProperty( ffi.Pointer<ffi.Void> Policy, @@ -1235,6 +3812,22 @@ _dart_clang_PrintingPolicy_setProperty? _clang_PrintingPolicy_setProperty; + /// Retrieve the default policy for the cursor. + /// + /// The policy should be released after use with \c + /// clang_PrintingPolicy_dispose. + ffi.Pointer<ffi.Void> clang_getCursorPrintingPolicy( + CXCursor arg0, + ) { + return (_clang_getCursorPrintingPolicy ??= _dylib.lookupFunction< + _c_clang_getCursorPrintingPolicy, + _dart_clang_getCursorPrintingPolicy>('clang_getCursorPrintingPolicy'))( + arg0, + ); + } + + _dart_clang_getCursorPrintingPolicy? _clang_getCursorPrintingPolicy; + /// Release a printing policy. void clang_PrintingPolicy_dispose( ffi.Pointer<ffi.Void> Policy, @@ -1248,6 +3841,437 @@ _dart_clang_PrintingPolicy_dispose? _clang_PrintingPolicy_dispose; + /// Pretty print declarations. + /// + /// \param Cursor The cursor representing a declaration. + /// + /// \param Policy The policy to control the entities being printed. If + /// NULL, a default policy is used. + /// + /// \returns The pretty printed declaration or the empty string for + /// other cursors. + CXString clang_getCursorPrettyPrinted( + CXCursor Cursor, + ffi.Pointer<ffi.Void> Policy, + ) { + return (_clang_getCursorPrettyPrinted ??= _dylib.lookupFunction< + _c_clang_getCursorPrettyPrinted, + _dart_clang_getCursorPrettyPrinted>('clang_getCursorPrettyPrinted'))( + Cursor, + Policy, + ); + } + + _dart_clang_getCursorPrettyPrinted? _clang_getCursorPrettyPrinted; + + /// Retrieve the display name for the entity referenced by this cursor. + /// + /// The display name contains extra information that helps identify the cursor, + /// such as the parameters of a function or template or the arguments of a + /// class template specialization. + CXString clang_getCursorDisplayName( + CXCursor arg0, + ) { + return (_clang_getCursorDisplayName ??= _dylib.lookupFunction< + _c_clang_getCursorDisplayName, + _dart_clang_getCursorDisplayName>('clang_getCursorDisplayName'))( + arg0, + ); + } + + _dart_clang_getCursorDisplayName? _clang_getCursorDisplayName; + + /// For a cursor that is a reference, retrieve a cursor representing the + /// entity that it references. + /// + /// Reference cursors refer to other entities in the AST. For example, an + /// Objective-C superclass reference cursor refers to an Objective-C class. + /// This function produces the cursor for the Objective-C class from the + /// cursor for the superclass reference. If the input cursor is a declaration or + /// definition, it returns that declaration or definition unchanged. + /// Otherwise, returns the NULL cursor. + CXCursor clang_getCursorReferenced( + CXCursor arg0, + ) { + return (_clang_getCursorReferenced ??= _dylib.lookupFunction< + _c_clang_getCursorReferenced, + _dart_clang_getCursorReferenced>('clang_getCursorReferenced'))( + arg0, + ); + } + + _dart_clang_getCursorReferenced? _clang_getCursorReferenced; + + /// For a cursor that is either a reference to or a declaration + /// of some entity, retrieve a cursor that describes the definition of + /// that entity. + /// + /// Some entities can be declared multiple times within a translation + /// unit, but only one of those declarations can also be a + /// definition. For example, given: + /// + /// \code + /// int f(int, int); + /// int g(int x, int y) { return f(x, y); } + /// int f(int a, int b) { return a + b; } + /// int f(int, int); + /// \endcode + /// + /// there are three declarations of the function "f", but only the + /// second one is a definition. The clang_getCursorDefinition() + /// function will take any cursor pointing to a declaration of "f" + /// (the first or fourth lines of the example) or a cursor referenced + /// that uses "f" (the call to "f' inside "g") and will return a + /// declaration cursor pointing to the definition (the second "f" + /// declaration). + /// + /// If given a cursor for which there is no corresponding definition, + /// e.g., because there is no definition of that entity within this + /// translation unit, returns a NULL cursor. + CXCursor clang_getCursorDefinition( + CXCursor arg0, + ) { + return (_clang_getCursorDefinition ??= _dylib.lookupFunction< + _c_clang_getCursorDefinition, + _dart_clang_getCursorDefinition>('clang_getCursorDefinition'))( + arg0, + ); + } + + _dart_clang_getCursorDefinition? _clang_getCursorDefinition; + + /// Determine whether the declaration pointed to by this cursor + /// is also a definition of that entity. + int clang_isCursorDefinition( + CXCursor arg0, + ) { + return (_clang_isCursorDefinition ??= _dylib.lookupFunction< + _c_clang_isCursorDefinition, + _dart_clang_isCursorDefinition>('clang_isCursorDefinition'))( + arg0, + ); + } + + _dart_clang_isCursorDefinition? _clang_isCursorDefinition; + + /// Retrieve the canonical cursor corresponding to the given cursor. + /// + /// In the C family of languages, many kinds of entities can be declared several + /// times within a single translation unit. For example, a structure type can + /// be forward-declared (possibly multiple times) and later defined: + /// + /// \code + /// struct X; + /// struct X; + /// struct X { + /// int member; + /// }; + /// \endcode + /// + /// The declarations and the definition of \c X are represented by three + /// different cursors, all of which are declarations of the same underlying + /// entity. One of these cursor is considered the "canonical" cursor, which + /// is effectively the representative for the underlying entity. One can + /// determine if two cursors are declarations of the same underlying entity by + /// comparing their canonical cursors. + /// + /// \returns The canonical cursor for the entity referred to by the given cursor. + CXCursor clang_getCanonicalCursor( + CXCursor arg0, + ) { + return (_clang_getCanonicalCursor ??= _dylib.lookupFunction< + _c_clang_getCanonicalCursor, + _dart_clang_getCanonicalCursor>('clang_getCanonicalCursor'))( + arg0, + ); + } + + _dart_clang_getCanonicalCursor? _clang_getCanonicalCursor; + + /// If the cursor points to a selector identifier in an Objective-C + /// method or message expression, this returns the selector index. + /// + /// After getting a cursor with #clang_getCursor, this can be called to + /// determine if the location points to a selector identifier. + /// + /// \returns The selector index if the cursor is an Objective-C method or message + /// expression and the cursor is pointing to a selector identifier, or -1 + /// otherwise. + int clang_Cursor_getObjCSelectorIndex( + CXCursor arg0, + ) { + return (_clang_Cursor_getObjCSelectorIndex ??= _dylib.lookupFunction< + _c_clang_Cursor_getObjCSelectorIndex, + _dart_clang_Cursor_getObjCSelectorIndex>( + 'clang_Cursor_getObjCSelectorIndex'))( + arg0, + ); + } + + _dart_clang_Cursor_getObjCSelectorIndex? _clang_Cursor_getObjCSelectorIndex; + + /// Given a cursor pointing to a C++ method call or an Objective-C + /// message, returns non-zero if the method/message is "dynamic", meaning: + /// + /// For a C++ method: the call is virtual. + /// For an Objective-C message: the receiver is an object instance, not 'super' + /// or a specific class. + /// + /// If the method/message is "static" or the cursor does not point to a + /// method/message, it will return zero. + int clang_Cursor_isDynamicCall( + CXCursor C, + ) { + return (_clang_Cursor_isDynamicCall ??= _dylib.lookupFunction< + _c_clang_Cursor_isDynamicCall, + _dart_clang_Cursor_isDynamicCall>('clang_Cursor_isDynamicCall'))( + C, + ); + } + + _dart_clang_Cursor_isDynamicCall? _clang_Cursor_isDynamicCall; + + /// Given a cursor pointing to an Objective-C message or property + /// reference, or C++ method call, returns the CXType of the receiver. + CXType clang_Cursor_getReceiverType( + CXCursor C, + ) { + return (_clang_Cursor_getReceiverType ??= _dylib.lookupFunction< + _c_clang_Cursor_getReceiverType, + _dart_clang_Cursor_getReceiverType>('clang_Cursor_getReceiverType'))( + C, + ); + } + + _dart_clang_Cursor_getReceiverType? _clang_Cursor_getReceiverType; + + /// Given a cursor that represents a property declaration, return the + /// associated property attributes. The bits are formed from + /// \c CXObjCPropertyAttrKind. + /// + /// \param reserved Reserved for future use, pass 0. + int clang_Cursor_getObjCPropertyAttributes( + CXCursor C, + int reserved, + ) { + return (_clang_Cursor_getObjCPropertyAttributes ??= _dylib.lookupFunction< + _c_clang_Cursor_getObjCPropertyAttributes, + _dart_clang_Cursor_getObjCPropertyAttributes>( + 'clang_Cursor_getObjCPropertyAttributes'))( + C, + reserved, + ); + } + + _dart_clang_Cursor_getObjCPropertyAttributes? + _clang_Cursor_getObjCPropertyAttributes; + + /// Given a cursor that represents a property declaration, return the + /// name of the method that implements the getter. + CXString clang_Cursor_getObjCPropertyGetterName( + CXCursor C, + ) { + return (_clang_Cursor_getObjCPropertyGetterName ??= _dylib.lookupFunction< + _c_clang_Cursor_getObjCPropertyGetterName, + _dart_clang_Cursor_getObjCPropertyGetterName>( + 'clang_Cursor_getObjCPropertyGetterName'))( + C, + ); + } + + _dart_clang_Cursor_getObjCPropertyGetterName? + _clang_Cursor_getObjCPropertyGetterName; + + /// Given a cursor that represents a property declaration, return the + /// name of the method that implements the setter, if any. + CXString clang_Cursor_getObjCPropertySetterName( + CXCursor C, + ) { + return (_clang_Cursor_getObjCPropertySetterName ??= _dylib.lookupFunction< + _c_clang_Cursor_getObjCPropertySetterName, + _dart_clang_Cursor_getObjCPropertySetterName>( + 'clang_Cursor_getObjCPropertySetterName'))( + C, + ); + } + + _dart_clang_Cursor_getObjCPropertySetterName? + _clang_Cursor_getObjCPropertySetterName; + + /// Given a cursor that represents an Objective-C method or parameter + /// declaration, return the associated Objective-C qualifiers for the return + /// type or the parameter respectively. The bits are formed from + /// CXObjCDeclQualifierKind. + int clang_Cursor_getObjCDeclQualifiers( + CXCursor C, + ) { + return (_clang_Cursor_getObjCDeclQualifiers ??= _dylib.lookupFunction< + _c_clang_Cursor_getObjCDeclQualifiers, + _dart_clang_Cursor_getObjCDeclQualifiers>( + 'clang_Cursor_getObjCDeclQualifiers'))( + C, + ); + } + + _dart_clang_Cursor_getObjCDeclQualifiers? _clang_Cursor_getObjCDeclQualifiers; + + /// Given a cursor that represents an Objective-C method or property + /// declaration, return non-zero if the declaration was affected by "\@optional". + /// Returns zero if the cursor is not such a declaration or it is "\@required". + int clang_Cursor_isObjCOptional( + CXCursor C, + ) { + return (_clang_Cursor_isObjCOptional ??= _dylib.lookupFunction< + _c_clang_Cursor_isObjCOptional, + _dart_clang_Cursor_isObjCOptional>('clang_Cursor_isObjCOptional'))( + C, + ); + } + + _dart_clang_Cursor_isObjCOptional? _clang_Cursor_isObjCOptional; + + /// Returns non-zero if the given cursor is a variadic function or method. + int clang_Cursor_isVariadic( + CXCursor C, + ) { + return (_clang_Cursor_isVariadic ??= _dylib.lookupFunction< + _c_clang_Cursor_isVariadic, + _dart_clang_Cursor_isVariadic>('clang_Cursor_isVariadic'))( + C, + ); + } + + _dart_clang_Cursor_isVariadic? _clang_Cursor_isVariadic; + + /// Returns non-zero if the given cursor points to a symbol marked with + /// external_source_symbol attribute. + /// + /// \param language If non-NULL, and the attribute is present, will be set to + /// the 'language' string from the attribute. + /// + /// \param definedIn If non-NULL, and the attribute is present, will be set to + /// the 'definedIn' string from the attribute. + /// + /// \param isGenerated If non-NULL, and the attribute is present, will be set to + /// non-zero if the 'generated_declaration' is set in the attribute. + int clang_Cursor_isExternalSymbol( + CXCursor C, + ffi.Pointer<CXString> language, + ffi.Pointer<CXString> definedIn, + ffi.Pointer<ffi.Uint32> isGenerated, + ) { + return (_clang_Cursor_isExternalSymbol ??= _dylib.lookupFunction< + _c_clang_Cursor_isExternalSymbol, + _dart_clang_Cursor_isExternalSymbol>('clang_Cursor_isExternalSymbol'))( + C, + language, + definedIn, + isGenerated, + ); + } + + _dart_clang_Cursor_isExternalSymbol? _clang_Cursor_isExternalSymbol; + + /// Given a cursor that represents a declaration, return the associated + /// comment's source range. The range may include multiple consecutive comments + /// with whitespace in between. + CXSourceRange clang_Cursor_getCommentRange( + CXCursor C, + ) { + return (_clang_Cursor_getCommentRange ??= _dylib.lookupFunction< + _c_clang_Cursor_getCommentRange, + _dart_clang_Cursor_getCommentRange>('clang_Cursor_getCommentRange'))( + C, + ); + } + + _dart_clang_Cursor_getCommentRange? _clang_Cursor_getCommentRange; + + /// Given a cursor that represents a declaration, return the associated + /// comment text, including comment markers. + CXString clang_Cursor_getRawCommentText( + CXCursor C, + ) { + return (_clang_Cursor_getRawCommentText ??= _dylib.lookupFunction< + _c_clang_Cursor_getRawCommentText, + _dart_clang_Cursor_getRawCommentText>( + 'clang_Cursor_getRawCommentText'))( + C, + ); + } + + _dart_clang_Cursor_getRawCommentText? _clang_Cursor_getRawCommentText; + + /// Given a cursor that represents a documentable entity (e.g., + /// declaration), return the associated \paragraph; otherwise return the + /// first paragraph. + CXString clang_Cursor_getBriefCommentText( + CXCursor C, + ) { + return (_clang_Cursor_getBriefCommentText ??= _dylib.lookupFunction< + _c_clang_Cursor_getBriefCommentText, + _dart_clang_Cursor_getBriefCommentText>( + 'clang_Cursor_getBriefCommentText'))( + C, + ); + } + + _dart_clang_Cursor_getBriefCommentText? _clang_Cursor_getBriefCommentText; + + /// Retrieve the CXString representing the mangled name of the cursor. + CXString clang_Cursor_getMangling( + CXCursor arg0, + ) { + return (_clang_Cursor_getMangling ??= _dylib.lookupFunction< + _c_clang_Cursor_getMangling, + _dart_clang_Cursor_getMangling>('clang_Cursor_getMangling'))( + arg0, + ); + } + + _dart_clang_Cursor_getMangling? _clang_Cursor_getMangling; + + /// Retrieve the CXStrings representing the mangled symbols of the C++ + /// constructor or destructor at the cursor. + ffi.Pointer<CXStringSet> clang_Cursor_getCXXManglings( + CXCursor arg0, + ) { + return (_clang_Cursor_getCXXManglings ??= _dylib.lookupFunction< + _c_clang_Cursor_getCXXManglings, + _dart_clang_Cursor_getCXXManglings>('clang_Cursor_getCXXManglings'))( + arg0, + ); + } + + _dart_clang_Cursor_getCXXManglings? _clang_Cursor_getCXXManglings; + + /// Retrieve the CXStrings representing the mangled symbols of the ObjC + /// class interface or implementation at the cursor. + ffi.Pointer<CXStringSet> clang_Cursor_getObjCManglings( + CXCursor arg0, + ) { + return (_clang_Cursor_getObjCManglings ??= _dylib.lookupFunction< + _c_clang_Cursor_getObjCManglings, + _dart_clang_Cursor_getObjCManglings>('clang_Cursor_getObjCManglings'))( + arg0, + ); + } + + _dart_clang_Cursor_getObjCManglings? _clang_Cursor_getObjCManglings; + + /// Given a CXCursor_ModuleImportDecl cursor, return the associated module. + ffi.Pointer<ffi.Void> clang_Cursor_getModule( + CXCursor C, + ) { + return (_clang_Cursor_getModule ??= _dylib.lookupFunction< + _c_clang_Cursor_getModule, + _dart_clang_Cursor_getModule>('clang_Cursor_getModule'))( + C, + ); + } + + _dart_clang_Cursor_getModule? _clang_Cursor_getModule; + /// Given a CXFile header file, return the module that contains it, if one /// exists. ffi.Pointer<ffi.Void> clang_getModuleForFile( @@ -1297,6 +4321,37 @@ /// \param Module a module object. /// + /// \returns the name of the module, e.g. for the 'std.vector' sub-module it + /// will return "vector". + CXString clang_Module_getName( + ffi.Pointer<ffi.Void> Module, + ) { + return (_clang_Module_getName ??= _dylib.lookupFunction< + _c_clang_Module_getName, + _dart_clang_Module_getName>('clang_Module_getName'))( + Module, + ); + } + + _dart_clang_Module_getName? _clang_Module_getName; + + /// \param Module a module object. + /// + /// \returns the full name of the module, e.g. "std.vector". + CXString clang_Module_getFullName( + ffi.Pointer<ffi.Void> Module, + ) { + return (_clang_Module_getFullName ??= _dylib.lookupFunction< + _c_clang_Module_getFullName, + _dart_clang_Module_getFullName>('clang_Module_getFullName'))( + Module, + ); + } + + _dart_clang_Module_getFullName? _clang_Module_getFullName; + + /// \param Module a module object. + /// /// \returns non-zero if the module is a system one. int clang_Module_isSystem( ffi.Pointer<ffi.Void> Module, @@ -1350,6 +4405,391 @@ _dart_clang_Module_getTopLevelHeader? _clang_Module_getTopLevelHeader; + /// Determine if a C++ constructor is a converting constructor. + int clang_CXXConstructor_isConvertingConstructor( + CXCursor C, + ) { + return (_clang_CXXConstructor_isConvertingConstructor ??= + _dylib.lookupFunction<_c_clang_CXXConstructor_isConvertingConstructor, + _dart_clang_CXXConstructor_isConvertingConstructor>( + 'clang_CXXConstructor_isConvertingConstructor'))( + C, + ); + } + + _dart_clang_CXXConstructor_isConvertingConstructor? + _clang_CXXConstructor_isConvertingConstructor; + + /// Determine if a C++ constructor is a copy constructor. + int clang_CXXConstructor_isCopyConstructor( + CXCursor C, + ) { + return (_clang_CXXConstructor_isCopyConstructor ??= _dylib.lookupFunction< + _c_clang_CXXConstructor_isCopyConstructor, + _dart_clang_CXXConstructor_isCopyConstructor>( + 'clang_CXXConstructor_isCopyConstructor'))( + C, + ); + } + + _dart_clang_CXXConstructor_isCopyConstructor? + _clang_CXXConstructor_isCopyConstructor; + + /// Determine if a C++ constructor is the default constructor. + int clang_CXXConstructor_isDefaultConstructor( + CXCursor C, + ) { + return (_clang_CXXConstructor_isDefaultConstructor ??= + _dylib.lookupFunction<_c_clang_CXXConstructor_isDefaultConstructor, + _dart_clang_CXXConstructor_isDefaultConstructor>( + 'clang_CXXConstructor_isDefaultConstructor'))( + C, + ); + } + + _dart_clang_CXXConstructor_isDefaultConstructor? + _clang_CXXConstructor_isDefaultConstructor; + + /// Determine if a C++ constructor is a move constructor. + int clang_CXXConstructor_isMoveConstructor( + CXCursor C, + ) { + return (_clang_CXXConstructor_isMoveConstructor ??= _dylib.lookupFunction< + _c_clang_CXXConstructor_isMoveConstructor, + _dart_clang_CXXConstructor_isMoveConstructor>( + 'clang_CXXConstructor_isMoveConstructor'))( + C, + ); + } + + _dart_clang_CXXConstructor_isMoveConstructor? + _clang_CXXConstructor_isMoveConstructor; + + /// Determine if a C++ field is declared 'mutable'. + int clang_CXXField_isMutable( + CXCursor C, + ) { + return (_clang_CXXField_isMutable ??= _dylib.lookupFunction< + _c_clang_CXXField_isMutable, + _dart_clang_CXXField_isMutable>('clang_CXXField_isMutable'))( + C, + ); + } + + _dart_clang_CXXField_isMutable? _clang_CXXField_isMutable; + + /// Determine if a C++ method is declared '= default'. + int clang_CXXMethod_isDefaulted( + CXCursor C, + ) { + return (_clang_CXXMethod_isDefaulted ??= _dylib.lookupFunction< + _c_clang_CXXMethod_isDefaulted, + _dart_clang_CXXMethod_isDefaulted>('clang_CXXMethod_isDefaulted'))( + C, + ); + } + + _dart_clang_CXXMethod_isDefaulted? _clang_CXXMethod_isDefaulted; + + /// Determine if a C++ member function or member function template is + /// pure virtual. + int clang_CXXMethod_isPureVirtual( + CXCursor C, + ) { + return (_clang_CXXMethod_isPureVirtual ??= _dylib.lookupFunction< + _c_clang_CXXMethod_isPureVirtual, + _dart_clang_CXXMethod_isPureVirtual>('clang_CXXMethod_isPureVirtual'))( + C, + ); + } + + _dart_clang_CXXMethod_isPureVirtual? _clang_CXXMethod_isPureVirtual; + + /// Determine if a C++ member function or member function template is + /// declared 'static'. + int clang_CXXMethod_isStatic( + CXCursor C, + ) { + return (_clang_CXXMethod_isStatic ??= _dylib.lookupFunction< + _c_clang_CXXMethod_isStatic, + _dart_clang_CXXMethod_isStatic>('clang_CXXMethod_isStatic'))( + C, + ); + } + + _dart_clang_CXXMethod_isStatic? _clang_CXXMethod_isStatic; + + /// Determine if a C++ member function or member function template is + /// explicitly declared 'virtual' or if it overrides a virtual method from + /// one of the base classes. + int clang_CXXMethod_isVirtual( + CXCursor C, + ) { + return (_clang_CXXMethod_isVirtual ??= _dylib.lookupFunction< + _c_clang_CXXMethod_isVirtual, + _dart_clang_CXXMethod_isVirtual>('clang_CXXMethod_isVirtual'))( + C, + ); + } + + _dart_clang_CXXMethod_isVirtual? _clang_CXXMethod_isVirtual; + + /// Determine if a C++ record is abstract, i.e. whether a class or struct + /// has a pure virtual member function. + int clang_CXXRecord_isAbstract( + CXCursor C, + ) { + return (_clang_CXXRecord_isAbstract ??= _dylib.lookupFunction< + _c_clang_CXXRecord_isAbstract, + _dart_clang_CXXRecord_isAbstract>('clang_CXXRecord_isAbstract'))( + C, + ); + } + + _dart_clang_CXXRecord_isAbstract? _clang_CXXRecord_isAbstract; + + /// Determine if an enum declaration refers to a scoped enum. + int clang_EnumDecl_isScoped( + CXCursor C, + ) { + return (_clang_EnumDecl_isScoped ??= _dylib.lookupFunction< + _c_clang_EnumDecl_isScoped, + _dart_clang_EnumDecl_isScoped>('clang_EnumDecl_isScoped'))( + C, + ); + } + + _dart_clang_EnumDecl_isScoped? _clang_EnumDecl_isScoped; + + /// Determine if a C++ member function or member function template is + /// declared 'const'. + int clang_CXXMethod_isConst( + CXCursor C, + ) { + return (_clang_CXXMethod_isConst ??= _dylib.lookupFunction< + _c_clang_CXXMethod_isConst, + _dart_clang_CXXMethod_isConst>('clang_CXXMethod_isConst'))( + C, + ); + } + + _dart_clang_CXXMethod_isConst? _clang_CXXMethod_isConst; + + /// Given a cursor that represents a template, determine + /// the cursor kind of the specializations would be generated by instantiating + /// the template. + /// + /// This routine can be used to determine what flavor of function template, + /// class template, or class template partial specialization is stored in the + /// cursor. For example, it can describe whether a class template cursor is + /// declared with "struct", "class" or "union". + /// + /// \param C The cursor to query. This cursor should represent a template + /// declaration. + /// + /// \returns The cursor kind of the specializations that would be generated + /// by instantiating the template \p C. If \p C is not a template, returns + /// \c CXCursor_NoDeclFound. + int clang_getTemplateCursorKind( + CXCursor C, + ) { + return (_clang_getTemplateCursorKind ??= _dylib.lookupFunction< + _c_clang_getTemplateCursorKind, + _dart_clang_getTemplateCursorKind>('clang_getTemplateCursorKind'))( + C, + ); + } + + _dart_clang_getTemplateCursorKind? _clang_getTemplateCursorKind; + + /// Given a cursor that may represent a specialization or instantiation + /// of a template, retrieve the cursor that represents the template that it + /// specializes or from which it was instantiated. + /// + /// This routine determines the template involved both for explicit + /// specializations of templates and for implicit instantiations of the template, + /// both of which are referred to as "specializations". For a class template + /// specialization (e.g., \c std::vector<bool>), this routine will return + /// either the primary template (\c std::vector) or, if the specialization was + /// instantiated from a class template partial specialization, the class template + /// partial specialization. For a class template partial specialization and a + /// function template specialization (including instantiations), this + /// this routine will return the specialized template. + /// + /// For members of a class template (e.g., member functions, member classes, or + /// static data members), returns the specialized or instantiated member. + /// Although not strictly "templates" in the C++ language, members of class + /// templates have the same notions of specializations and instantiations that + /// templates do, so this routine treats them similarly. + /// + /// \param C A cursor that may be a specialization of a template or a member + /// of a template. + /// + /// \returns If the given cursor is a specialization or instantiation of a + /// template or a member thereof, the template or member that it specializes or + /// from which it was instantiated. Otherwise, returns a NULL cursor. + CXCursor clang_getSpecializedCursorTemplate( + CXCursor C, + ) { + return (_clang_getSpecializedCursorTemplate ??= _dylib.lookupFunction< + _c_clang_getSpecializedCursorTemplate, + _dart_clang_getSpecializedCursorTemplate>( + 'clang_getSpecializedCursorTemplate'))( + C, + ); + } + + _dart_clang_getSpecializedCursorTemplate? _clang_getSpecializedCursorTemplate; + + /// Given a cursor that references something else, return the source range + /// covering that reference. + /// + /// \param C A cursor pointing to a member reference, a declaration reference, or + /// an operator call. + /// \param NameFlags A bitset with three independent flags: + /// CXNameRange_WantQualifier, CXNameRange_WantTemplateArgs, and + /// CXNameRange_WantSinglePiece. + /// \param PieceIndex For contiguous names or when passing the flag + /// CXNameRange_WantSinglePiece, only one piece with index 0 is + /// available. When the CXNameRange_WantSinglePiece flag is not passed for a + /// non-contiguous names, this index can be used to retrieve the individual + /// pieces of the name. See also CXNameRange_WantSinglePiece. + /// + /// \returns The piece of the name pointed to by the given cursor. If there is no + /// name, or if the PieceIndex is out-of-range, a null-cursor will be returned. + CXSourceRange clang_getCursorReferenceNameRange( + CXCursor C, + int NameFlags, + int PieceIndex, + ) { + return (_clang_getCursorReferenceNameRange ??= _dylib.lookupFunction< + _c_clang_getCursorReferenceNameRange, + _dart_clang_getCursorReferenceNameRange>( + 'clang_getCursorReferenceNameRange'))( + C, + NameFlags, + PieceIndex, + ); + } + + _dart_clang_getCursorReferenceNameRange? _clang_getCursorReferenceNameRange; + + /// Get the raw lexical token starting with the given location. + /// + /// \param TU the translation unit whose text is being tokenized. + /// + /// \param Location the source location with which the token starts. + /// + /// \returns The token starting with the given location or NULL if no such token + /// exist. The returned pointer must be freed with clang_disposeTokens before the + /// translation unit is destroyed. + ffi.Pointer<CXToken> clang_getToken( + ffi.Pointer<CXTranslationUnitImpl> TU, + CXSourceLocation Location, + ) { + return (_clang_getToken ??= + _dylib.lookupFunction<_c_clang_getToken, _dart_clang_getToken>( + 'clang_getToken'))( + TU, + Location, + ); + } + + _dart_clang_getToken? _clang_getToken; + + /// Determine the kind of the given token. + int clang_getTokenKind( + CXToken arg0, + ) { + return (_clang_getTokenKind ??= + _dylib.lookupFunction<_c_clang_getTokenKind, _dart_clang_getTokenKind>( + 'clang_getTokenKind'))( + arg0, + ); + } + + _dart_clang_getTokenKind? _clang_getTokenKind; + + /// Determine the spelling of the given token. + /// + /// The spelling of a token is the textual representation of that token, e.g., + /// the text of an identifier or keyword. + CXString clang_getTokenSpelling( + ffi.Pointer<CXTranslationUnitImpl> arg0, + CXToken arg1, + ) { + return (_clang_getTokenSpelling ??= _dylib.lookupFunction< + _c_clang_getTokenSpelling, + _dart_clang_getTokenSpelling>('clang_getTokenSpelling'))( + arg0, + arg1, + ); + } + + _dart_clang_getTokenSpelling? _clang_getTokenSpelling; + + /// Retrieve the source location of the given token. + CXSourceLocation clang_getTokenLocation( + ffi.Pointer<CXTranslationUnitImpl> arg0, + CXToken arg1, + ) { + return (_clang_getTokenLocation ??= _dylib.lookupFunction< + _c_clang_getTokenLocation, + _dart_clang_getTokenLocation>('clang_getTokenLocation'))( + arg0, + arg1, + ); + } + + _dart_clang_getTokenLocation? _clang_getTokenLocation; + + /// Retrieve a source range that covers the given token. + CXSourceRange clang_getTokenExtent( + ffi.Pointer<CXTranslationUnitImpl> arg0, + CXToken arg1, + ) { + return (_clang_getTokenExtent ??= _dylib.lookupFunction< + _c_clang_getTokenExtent, + _dart_clang_getTokenExtent>('clang_getTokenExtent'))( + arg0, + arg1, + ); + } + + _dart_clang_getTokenExtent? _clang_getTokenExtent; + + /// Tokenize the source code described by the given range into raw + /// lexical tokens. + /// + /// \param TU the translation unit whose text is being tokenized. + /// + /// \param Range the source range in which text should be tokenized. All of the + /// tokens produced by tokenization will fall within this source range, + /// + /// \param Tokens this pointer will be set to point to the array of tokens + /// that occur within the given source range. The returned pointer must be + /// freed with clang_disposeTokens() before the translation unit is destroyed. + /// + /// \param NumTokens will be set to the number of tokens in the \c *Tokens + /// array. + void clang_tokenize( + ffi.Pointer<CXTranslationUnitImpl> TU, + CXSourceRange Range, + ffi.Pointer<ffi.Pointer<CXToken>> Tokens, + ffi.Pointer<ffi.Uint32> NumTokens, + ) { + return (_clang_tokenize ??= + _dylib.lookupFunction<_c_clang_tokenize, _dart_clang_tokenize>( + 'clang_tokenize'))( + TU, + Range, + Tokens, + NumTokens, + ); + } + + _dart_clang_tokenize? _clang_tokenize; + /// Annotate the given set of tokens by providing cursors for each token /// that can be mapped to a specific entity within the abstract syntax tree. /// @@ -1413,6 +4853,50 @@ _dart_clang_disposeTokens? _clang_disposeTokens; + /// \defgroup CINDEX_DEBUG Debugging facilities + /// + /// These routines are used for testing and debugging, only, and should not + /// be relied upon. + /// + /// @{ + CXString clang_getCursorKindSpelling( + int Kind, + ) { + return (_clang_getCursorKindSpelling ??= _dylib.lookupFunction< + _c_clang_getCursorKindSpelling, + _dart_clang_getCursorKindSpelling>('clang_getCursorKindSpelling'))( + Kind, + ); + } + + _dart_clang_getCursorKindSpelling? _clang_getCursorKindSpelling; + + void clang_getDefinitionSpellingAndExtent( + CXCursor arg0, + ffi.Pointer<ffi.Pointer<ffi.Int8>> startBuf, + ffi.Pointer<ffi.Pointer<ffi.Int8>> endBuf, + ffi.Pointer<ffi.Uint32> startLine, + ffi.Pointer<ffi.Uint32> startColumn, + ffi.Pointer<ffi.Uint32> endLine, + ffi.Pointer<ffi.Uint32> endColumn, + ) { + return (_clang_getDefinitionSpellingAndExtent ??= _dylib.lookupFunction< + _c_clang_getDefinitionSpellingAndExtent, + _dart_clang_getDefinitionSpellingAndExtent>( + 'clang_getDefinitionSpellingAndExtent'))( + arg0, + startBuf, + endBuf, + startLine, + startColumn, + endLine, + endColumn, + ); + } + + _dart_clang_getDefinitionSpellingAndExtent? + _clang_getDefinitionSpellingAndExtent; + void clang_enableStackTraces() { return (_clang_enableStackTraces ??= _dylib.lookupFunction< _c_clang_enableStackTraces, @@ -1458,6 +4942,28 @@ _dart_clang_getCompletionChunkKind? _clang_getCompletionChunkKind; + /// Retrieve the text associated with a particular chunk within a + /// completion string. + /// + /// \param completion_string the completion string to query. + /// + /// \param chunk_number the 0-based index of the chunk in the completion string. + /// + /// \returns the text associated with the chunk at index \c chunk_number. + CXString clang_getCompletionChunkText( + ffi.Pointer<ffi.Void> completion_string, + int chunk_number, + ) { + return (_clang_getCompletionChunkText ??= _dylib.lookupFunction< + _c_clang_getCompletionChunkText, + _dart_clang_getCompletionChunkText>('clang_getCompletionChunkText'))( + completion_string, + chunk_number, + ); + } + + _dart_clang_getCompletionChunkText? _clang_getCompletionChunkText; + /// Retrieve the completion string associated with a particular chunk /// within a completion string. /// @@ -1557,6 +5063,92 @@ _dart_clang_getCompletionNumAnnotations? _clang_getCompletionNumAnnotations; + /// Retrieve the annotation associated with the given completion string. + /// + /// \param completion_string the completion string to query. + /// + /// \param annotation_number the 0-based index of the annotation of the + /// completion string. + /// + /// \returns annotation string associated with the completion at index + /// \c annotation_number, or a NULL string if that annotation is not available. + CXString clang_getCompletionAnnotation( + ffi.Pointer<ffi.Void> completion_string, + int annotation_number, + ) { + return (_clang_getCompletionAnnotation ??= _dylib.lookupFunction< + _c_clang_getCompletionAnnotation, + _dart_clang_getCompletionAnnotation>('clang_getCompletionAnnotation'))( + completion_string, + annotation_number, + ); + } + + _dart_clang_getCompletionAnnotation? _clang_getCompletionAnnotation; + + /// Retrieve the parent context of the given completion string. + /// + /// The parent context of a completion string is the semantic parent of + /// the declaration (if any) that the code completion represents. For example, + /// a code completion for an Objective-C method would have the method's class + /// or protocol as its context. + /// + /// \param completion_string The code completion string whose parent is + /// being queried. + /// + /// \param kind DEPRECATED: always set to CXCursor_NotImplemented if non-NULL. + /// + /// \returns The name of the completion parent, e.g., "NSObject" if + /// the completion string represents a method in the NSObject class. + CXString clang_getCompletionParent( + ffi.Pointer<ffi.Void> completion_string, + ffi.Pointer<ffi.Int32> kind, + ) { + return (_clang_getCompletionParent ??= _dylib.lookupFunction< + _c_clang_getCompletionParent, + _dart_clang_getCompletionParent>('clang_getCompletionParent'))( + completion_string, + kind, + ); + } + + _dart_clang_getCompletionParent? _clang_getCompletionParent; + + /// Retrieve the brief documentation comment attached to the declaration + /// that corresponds to the given completion string. + CXString clang_getCompletionBriefComment( + ffi.Pointer<ffi.Void> completion_string, + ) { + return (_clang_getCompletionBriefComment ??= _dylib.lookupFunction< + _c_clang_getCompletionBriefComment, + _dart_clang_getCompletionBriefComment>( + 'clang_getCompletionBriefComment'))( + completion_string, + ); + } + + _dart_clang_getCompletionBriefComment? _clang_getCompletionBriefComment; + + /// Retrieve a completion string for an arbitrary declaration or macro + /// definition cursor. + /// + /// \param cursor The cursor to query. + /// + /// \returns A non-context-sensitive completion string for declaration and macro + /// definition cursors, or NULL for other kinds of cursors. + ffi.Pointer<ffi.Void> clang_getCursorCompletionString( + CXCursor cursor, + ) { + return (_clang_getCursorCompletionString ??= _dylib.lookupFunction< + _c_clang_getCursorCompletionString, + _dart_clang_getCursorCompletionString>( + 'clang_getCursorCompletionString'))( + cursor, + ); + } + + _dart_clang_getCursorCompletionString? _clang_getCursorCompletionString; + /// Retrieve the number of fix-its for the given completion index. /// /// Calling this makes sense only if CXCodeComplete_IncludeCompletionsWithFixIts @@ -1582,6 +5174,65 @@ _dart_clang_getCompletionNumFixIts? _clang_getCompletionNumFixIts; + /// Fix-its that *must* be applied before inserting the text for the + /// corresponding completion. + /// + /// By default, clang_codeCompleteAt() only returns completions with empty + /// fix-its. Extra completions with non-empty fix-its should be explicitly + /// requested by setting CXCodeComplete_IncludeCompletionsWithFixIts. + /// + /// For the clients to be able to compute position of the cursor after applying + /// fix-its, the following conditions are guaranteed to hold for + /// replacement_range of the stored fix-its: + /// - Ranges in the fix-its are guaranteed to never contain the completion + /// point (or identifier under completion point, if any) inside them, except + /// at the start or at the end of the range. + /// - If a fix-it range starts or ends with completion point (or starts or + /// ends after the identifier under completion point), it will contain at + /// least one character. It allows to unambiguously recompute completion + /// point after applying the fix-it. + /// + /// The intuition is that provided fix-its change code around the identifier we + /// complete, but are not allowed to touch the identifier itself or the + /// completion point. One example of completions with corrections are the ones + /// replacing '.' with '->' and vice versa: + /// + /// std::unique_ptr<std::vector<int>> vec_ptr; + /// In 'vec_ptr.^', one of the completions is 'push_back', it requires + /// replacing '.' with '->'. + /// In 'vec_ptr->^', one of the completions is 'release', it requires + /// replacing '->' with '.'. + /// + /// \param results The structure keeping all completion results + /// + /// \param completion_index The index of the completion + /// + /// \param fixit_index The index of the fix-it for the completion at + /// completion_index + /// + /// \param replacement_range The fix-it range that must be replaced before the + /// completion at completion_index can be applied + /// + /// \returns The fix-it string that must replace the code at replacement_range + /// before the completion at completion_index can be applied + CXString clang_getCompletionFixIt( + ffi.Pointer<CXCodeCompleteResults> results, + int completion_index, + int fixit_index, + ffi.Pointer<CXSourceRange> replacement_range, + ) { + return (_clang_getCompletionFixIt ??= _dylib.lookupFunction< + _c_clang_getCompletionFixIt, + _dart_clang_getCompletionFixIt>('clang_getCompletionFixIt'))( + results, + completion_index, + fixit_index, + replacement_range, + ); + } + + _dart_clang_getCompletionFixIt? _clang_getCompletionFixIt; + /// Returns a default set of code-completion options that can be /// passed to\c clang_codeCompleteAt(). int clang_defaultCodeCompleteOptions() { @@ -1803,6 +5454,58 @@ _dart_clang_codeCompleteGetContainerKind? _clang_codeCompleteGetContainerKind; + /// Returns the USR for the container for the current code completion + /// context. If there is not a container for the current context, this + /// function will return the empty string. + /// + /// \param Results the code completion results to query + /// + /// \returns the USR for the container + CXString clang_codeCompleteGetContainerUSR( + ffi.Pointer<CXCodeCompleteResults> Results, + ) { + return (_clang_codeCompleteGetContainerUSR ??= _dylib.lookupFunction< + _c_clang_codeCompleteGetContainerUSR, + _dart_clang_codeCompleteGetContainerUSR>( + 'clang_codeCompleteGetContainerUSR'))( + Results, + ); + } + + _dart_clang_codeCompleteGetContainerUSR? _clang_codeCompleteGetContainerUSR; + + /// Returns the currently-entered selector for an Objective-C message + /// send, formatted like "initWithFoo:bar:". Only guaranteed to return a + /// non-empty string for CXCompletionContext_ObjCInstanceMessage and + /// CXCompletionContext_ObjCClassMessage. + /// + /// \param Results the code completion results to query + /// + /// \returns the selector (or partial selector) that has been entered thus far + /// for an Objective-C message send. + CXString clang_codeCompleteGetObjCSelector( + ffi.Pointer<CXCodeCompleteResults> Results, + ) { + return (_clang_codeCompleteGetObjCSelector ??= _dylib.lookupFunction< + _c_clang_codeCompleteGetObjCSelector, + _dart_clang_codeCompleteGetObjCSelector>( + 'clang_codeCompleteGetObjCSelector'))( + Results, + ); + } + + _dart_clang_codeCompleteGetObjCSelector? _clang_codeCompleteGetObjCSelector; + + /// Return a version string, suitable for showing to a user, but not + /// intended to be parsed (the format is not guaranteed to be stable). + CXString clang_getClangVersion() { + return (_clang_getClangVersion ??= _dylib.lookupFunction< + _c_clang_getClangVersion, + _dart_clang_getClangVersion>('clang_getClangVersion'))(); + } + + _dart_clang_getClangVersion? _clang_getClangVersion; + /// Enable/disable crash recovery. /// /// \param isEnabled Flag to indicate if crash recovery is enabled. A non-zero @@ -1839,6 +5542,21 @@ _dart_clang_getInclusions? _clang_getInclusions; + /// If cursor is a statement declaration tries to evaluate the + /// statement and if its variable, tries to evaluate its initializer, + /// into its corresponding type. + ffi.Pointer<ffi.Void> clang_Cursor_Evaluate( + CXCursor C, + ) { + return (_clang_Cursor_Evaluate ??= _dylib.lookupFunction< + _c_clang_Cursor_Evaluate, + _dart_clang_Cursor_Evaluate>('clang_Cursor_Evaluate'))( + C, + ); + } + + _dart_clang_Cursor_Evaluate? _clang_Cursor_Evaluate; + /// Returns the kind of the evaluated result. int clang_EvalResult_getKind( ffi.Pointer<ffi.Void> E, @@ -2046,6 +5764,60 @@ _dart_clang_remap_dispose? _clang_remap_dispose; + /// Find references of a declaration in a specific file. + /// + /// \param cursor pointing to a declaration or a reference of one. + /// + /// \param file to search for references. + /// + /// \param visitor callback that will receive pairs of CXCursor/CXSourceRange for + /// each reference found. + /// The CXSourceRange will point inside the file; if the reference is inside + /// a macro (and not a macro argument) the CXSourceRange will be invalid. + /// + /// \returns one of the CXResult enumerators. + int clang_findReferencesInFile( + CXCursor cursor, + ffi.Pointer<ffi.Void> file, + CXCursorAndRangeVisitor visitor, + ) { + return (_clang_findReferencesInFile ??= _dylib.lookupFunction< + _c_clang_findReferencesInFile, + _dart_clang_findReferencesInFile>('clang_findReferencesInFile'))( + cursor, + file, + visitor, + ); + } + + _dart_clang_findReferencesInFile? _clang_findReferencesInFile; + + /// Find #import/#include directives in a specific file. + /// + /// \param TU translation unit containing the file to query. + /// + /// \param file to search for #import/#include directives. + /// + /// \param visitor callback that will receive pairs of CXCursor/CXSourceRange for + /// each directive found. + /// + /// \returns one of the CXResult enumerators. + int clang_findIncludesInFile( + ffi.Pointer<CXTranslationUnitImpl> TU, + ffi.Pointer<ffi.Void> file, + CXCursorAndRangeVisitor visitor, + ) { + return (_clang_findIncludesInFile ??= _dylib.lookupFunction< + _c_clang_findIncludesInFile, + _dart_clang_findIncludesInFile>('clang_findIncludesInFile'))( + TU, + file, + visitor, + ); + } + + _dart_clang_findIncludesInFile? _clang_findIncludesInFile; + int clang_index_isEntityObjCContainerKind( int arg0, ) { @@ -2380,6 +6152,82 @@ } _dart_clang_indexTranslationUnit? _clang_indexTranslationUnit; + + /// Retrieve the CXIdxFile, file, line, column, and offset represented by + /// the given CXIdxLoc. + /// + /// If the location refers into a macro expansion, retrieves the + /// location of the macro expansion and if it refers into a macro argument + /// retrieves the location of the argument. + void clang_indexLoc_getFileLocation( + CXIdxLoc loc, + ffi.Pointer<ffi.Pointer<ffi.Void>> indexFile, + ffi.Pointer<ffi.Pointer<ffi.Void>> file, + ffi.Pointer<ffi.Uint32> line, + ffi.Pointer<ffi.Uint32> column, + ffi.Pointer<ffi.Uint32> offset, + ) { + return (_clang_indexLoc_getFileLocation ??= _dylib.lookupFunction< + _c_clang_indexLoc_getFileLocation, + _dart_clang_indexLoc_getFileLocation>( + 'clang_indexLoc_getFileLocation'))( + loc, + indexFile, + file, + line, + column, + offset, + ); + } + + _dart_clang_indexLoc_getFileLocation? _clang_indexLoc_getFileLocation; + + /// Retrieve the CXSourceLocation represented by the given CXIdxLoc. + CXSourceLocation clang_indexLoc_getCXSourceLocation( + CXIdxLoc loc, + ) { + return (_clang_indexLoc_getCXSourceLocation ??= _dylib.lookupFunction< + _c_clang_indexLoc_getCXSourceLocation, + _dart_clang_indexLoc_getCXSourceLocation>( + 'clang_indexLoc_getCXSourceLocation'))( + loc, + ); + } + + _dart_clang_indexLoc_getCXSourceLocation? _clang_indexLoc_getCXSourceLocation; + + /// Visit the fields of a particular type. + /// + /// This function visits all the direct fields of the given cursor, + /// invoking the given \p visitor function with the cursors of each + /// visited field. The traversal may be ended prematurely, if + /// the visitor returns \c CXFieldVisit_Break. + /// + /// \param T the record type whose field may be visited. + /// + /// \param visitor the visitor function that will be invoked for each + /// field of \p T. + /// + /// \param client_data pointer data supplied by the client, which will + /// be passed to the visitor each time it is invoked. + /// + /// \returns a non-zero value if the traversal was terminated + /// prematurely by the visitor returning \c CXFieldVisit_Break. + int clang_Type_visitFields( + CXType T, + ffi.Pointer<ffi.NativeFunction<CXFieldVisitor>> visitor, + ffi.Pointer<ffi.Void> client_data, + ) { + return (_clang_Type_visitFields ??= _dylib.lookupFunction< + _c_clang_Type_visitFields, + _dart_clang_Type_visitFields>('clang_Type_visitFields'))( + T, + visitor, + client_data, + ); + } + + _dart_clang_Type_visitFields? _clang_Type_visitFields; } /// A character string. @@ -3079,7 +6927,11 @@ external int NumResults; } -class CXCursorAndRangeVisitor extends ffi.Struct {} +class CXCursorAndRangeVisitor extends ffi.Struct { + external ffi.Pointer<ffi.Void> context; + + external ffi.Pointer<ffi.NativeFunction<_typedefC_2>> visit; +} /// Source location passed to index callbacks. class CXIdxLoc extends ffi.Struct { @@ -3363,15 +7215,15 @@ class IndexerCallbacks extends ffi.Struct { /// Called periodically to check whether indexing should be aborted. /// Should return 0 to continue, and non-zero to abort. - external ffi.Pointer<ffi.NativeFunction<_typedefC_2>> abortQuery; + external ffi.Pointer<ffi.NativeFunction<_typedefC_3>> abortQuery; /// Called at the end of indexing; passes the complete diagnostic set. - external ffi.Pointer<ffi.NativeFunction<_typedefC_3>> diagnostic; + external ffi.Pointer<ffi.NativeFunction<_typedefC_4>> diagnostic; - external ffi.Pointer<ffi.NativeFunction<_typedefC_4>> enteredMainFile; + external ffi.Pointer<ffi.NativeFunction<_typedefC_5>> enteredMainFile; /// Called when a file gets \#included/\#imported. - external ffi.Pointer<ffi.NativeFunction<_typedefC_5>> ppIncludedFile; + external ffi.Pointer<ffi.NativeFunction<_typedefC_6>> ppIncludedFile; /// Called when a AST file (PCH or module) gets imported. /// @@ -3379,15 +7231,15 @@ /// the entities in an AST file). The recommended action is that, if the AST /// file is not already indexed, to initiate a new indexing job specific to /// the AST file. - external ffi.Pointer<ffi.NativeFunction<_typedefC_6>> importedASTFile; + external ffi.Pointer<ffi.NativeFunction<_typedefC_7>> importedASTFile; /// Called at the beginning of indexing a translation unit. - external ffi.Pointer<ffi.NativeFunction<_typedefC_7>> startedTranslationUnit; + external ffi.Pointer<ffi.NativeFunction<_typedefC_8>> startedTranslationUnit; - external ffi.Pointer<ffi.NativeFunction<_typedefC_8>> indexDeclaration; + external ffi.Pointer<ffi.NativeFunction<_typedefC_9>> indexDeclaration; /// Called to index a reference of an entity. - external ffi.Pointer<ffi.NativeFunction<_typedefC_9>> indexEntityReference; + external ffi.Pointer<ffi.NativeFunction<_typedefC_10>> indexEntityReference; } const int CINDEX_VERSION_MAJOR = 0; @@ -3398,6 +7250,22 @@ const String CINDEX_VERSION_STRING = '0.59'; +typedef _c_clang_getCString = ffi.Pointer<ffi.Int8> Function( + CXString string, +); + +typedef _dart_clang_getCString = ffi.Pointer<ffi.Int8> Function( + CXString string, +); + +typedef _c_clang_disposeString = ffi.Void Function( + CXString string, +); + +typedef _dart_clang_disposeString = void Function( + CXString string, +); + typedef _c_clang_disposeStringSet = ffi.Void Function( ffi.Pointer<CXStringSet> set_1, ); @@ -3452,6 +7320,14 @@ ffi.Pointer<ffi.Int8> Path, ); +typedef _c_clang_getFileName = CXString Function( + ffi.Pointer<ffi.Void> SFile, +); + +typedef _dart_clang_getFileName = CXString Function( + ffi.Pointer<ffi.Void> SFile, +); + typedef _c_clang_getFileTime = ffi.Int64 Function( ffi.Pointer<ffi.Void> SFile, ); @@ -3512,6 +7388,196 @@ ffi.Pointer<ffi.Void> file2, ); +typedef _c_clang_File_tryGetRealPathName = CXString Function( + ffi.Pointer<ffi.Void> file, +); + +typedef _dart_clang_File_tryGetRealPathName = CXString Function( + ffi.Pointer<ffi.Void> file, +); + +typedef _c_clang_getNullLocation = CXSourceLocation Function(); + +typedef _dart_clang_getNullLocation = CXSourceLocation Function(); + +typedef _c_clang_equalLocations = ffi.Uint32 Function( + CXSourceLocation loc1, + CXSourceLocation loc2, +); + +typedef _dart_clang_equalLocations = int Function( + CXSourceLocation loc1, + CXSourceLocation loc2, +); + +typedef _c_clang_getLocation = CXSourceLocation Function( + ffi.Pointer<CXTranslationUnitImpl> tu, + ffi.Pointer<ffi.Void> file, + ffi.Uint32 line, + ffi.Uint32 column, +); + +typedef _dart_clang_getLocation = CXSourceLocation Function( + ffi.Pointer<CXTranslationUnitImpl> tu, + ffi.Pointer<ffi.Void> file, + int line, + int column, +); + +typedef _c_clang_getLocationForOffset = CXSourceLocation Function( + ffi.Pointer<CXTranslationUnitImpl> tu, + ffi.Pointer<ffi.Void> file, + ffi.Uint32 offset, +); + +typedef _dart_clang_getLocationForOffset = CXSourceLocation Function( + ffi.Pointer<CXTranslationUnitImpl> tu, + ffi.Pointer<ffi.Void> file, + int offset, +); + +typedef _c_clang_Location_isInSystemHeader = ffi.Int32 Function( + CXSourceLocation location, +); + +typedef _dart_clang_Location_isInSystemHeader = int Function( + CXSourceLocation location, +); + +typedef _c_clang_Location_isFromMainFile = ffi.Int32 Function( + CXSourceLocation location, +); + +typedef _dart_clang_Location_isFromMainFile = int Function( + CXSourceLocation location, +); + +typedef _c_clang_getNullRange = CXSourceRange Function(); + +typedef _dart_clang_getNullRange = CXSourceRange Function(); + +typedef _c_clang_getRange = CXSourceRange Function( + CXSourceLocation begin, + CXSourceLocation end, +); + +typedef _dart_clang_getRange = CXSourceRange Function( + CXSourceLocation begin, + CXSourceLocation end, +); + +typedef _c_clang_equalRanges = ffi.Uint32 Function( + CXSourceRange range1, + CXSourceRange range2, +); + +typedef _dart_clang_equalRanges = int Function( + CXSourceRange range1, + CXSourceRange range2, +); + +typedef _c_clang_Range_isNull = ffi.Int32 Function( + CXSourceRange range, +); + +typedef _dart_clang_Range_isNull = int Function( + CXSourceRange range, +); + +typedef _c_clang_getExpansionLocation = ffi.Void Function( + CXSourceLocation location, + ffi.Pointer<ffi.Pointer<ffi.Void>> file, + ffi.Pointer<ffi.Uint32> line, + ffi.Pointer<ffi.Uint32> column, + ffi.Pointer<ffi.Uint32> offset, +); + +typedef _dart_clang_getExpansionLocation = void Function( + CXSourceLocation location, + ffi.Pointer<ffi.Pointer<ffi.Void>> file, + ffi.Pointer<ffi.Uint32> line, + ffi.Pointer<ffi.Uint32> column, + ffi.Pointer<ffi.Uint32> offset, +); + +typedef _c_clang_getPresumedLocation = ffi.Void Function( + CXSourceLocation location, + ffi.Pointer<CXString> filename, + ffi.Pointer<ffi.Uint32> line, + ffi.Pointer<ffi.Uint32> column, +); + +typedef _dart_clang_getPresumedLocation = void Function( + CXSourceLocation location, + ffi.Pointer<CXString> filename, + ffi.Pointer<ffi.Uint32> line, + ffi.Pointer<ffi.Uint32> column, +); + +typedef _c_clang_getInstantiationLocation = ffi.Void Function( + CXSourceLocation location, + ffi.Pointer<ffi.Pointer<ffi.Void>> file, + ffi.Pointer<ffi.Uint32> line, + ffi.Pointer<ffi.Uint32> column, + ffi.Pointer<ffi.Uint32> offset, +); + +typedef _dart_clang_getInstantiationLocation = void Function( + CXSourceLocation location, + ffi.Pointer<ffi.Pointer<ffi.Void>> file, + ffi.Pointer<ffi.Uint32> line, + ffi.Pointer<ffi.Uint32> column, + ffi.Pointer<ffi.Uint32> offset, +); + +typedef _c_clang_getSpellingLocation = ffi.Void Function( + CXSourceLocation location, + ffi.Pointer<ffi.Pointer<ffi.Void>> file, + ffi.Pointer<ffi.Uint32> line, + ffi.Pointer<ffi.Uint32> column, + ffi.Pointer<ffi.Uint32> offset, +); + +typedef _dart_clang_getSpellingLocation = void Function( + CXSourceLocation location, + ffi.Pointer<ffi.Pointer<ffi.Void>> file, + ffi.Pointer<ffi.Uint32> line, + ffi.Pointer<ffi.Uint32> column, + ffi.Pointer<ffi.Uint32> offset, +); + +typedef _c_clang_getFileLocation = ffi.Void Function( + CXSourceLocation location, + ffi.Pointer<ffi.Pointer<ffi.Void>> file, + ffi.Pointer<ffi.Uint32> line, + ffi.Pointer<ffi.Uint32> column, + ffi.Pointer<ffi.Uint32> offset, +); + +typedef _dart_clang_getFileLocation = void Function( + CXSourceLocation location, + ffi.Pointer<ffi.Pointer<ffi.Void>> file, + ffi.Pointer<ffi.Uint32> line, + ffi.Pointer<ffi.Uint32> column, + ffi.Pointer<ffi.Uint32> offset, +); + +typedef _c_clang_getRangeStart = CXSourceLocation Function( + CXSourceRange range, +); + +typedef _dart_clang_getRangeStart = CXSourceLocation Function( + CXSourceRange range, +); + +typedef _c_clang_getRangeEnd = CXSourceLocation Function( + CXSourceRange range, +); + +typedef _dart_clang_getRangeEnd = CXSourceLocation Function( + CXSourceRange range, +); + typedef _c_clang_getSkippedRanges = ffi.Pointer<CXSourceRangeList> Function( ffi.Pointer<CXTranslationUnitImpl> tu, ffi.Pointer<ffi.Void> file, @@ -3619,6 +7685,16 @@ ffi.Pointer<ffi.Void> Diagnostic, ); +typedef _c_clang_formatDiagnostic = CXString Function( + ffi.Pointer<ffi.Void> Diagnostic, + ffi.Uint32 Options, +); + +typedef _dart_clang_formatDiagnostic = CXString Function( + ffi.Pointer<ffi.Void> Diagnostic, + int Options, +); + typedef _c_clang_defaultDiagnosticDisplayOptions = ffi.Uint32 Function(); typedef _dart_clang_defaultDiagnosticDisplayOptions = int Function(); @@ -3631,6 +7707,32 @@ ffi.Pointer<ffi.Void> arg0, ); +typedef _c_clang_getDiagnosticLocation = CXSourceLocation Function( + ffi.Pointer<ffi.Void> arg0, +); + +typedef _dart_clang_getDiagnosticLocation = CXSourceLocation Function( + ffi.Pointer<ffi.Void> arg0, +); + +typedef _c_clang_getDiagnosticSpelling = CXString Function( + ffi.Pointer<ffi.Void> arg0, +); + +typedef _dart_clang_getDiagnosticSpelling = CXString Function( + ffi.Pointer<ffi.Void> arg0, +); + +typedef _c_clang_getDiagnosticOption = CXString Function( + ffi.Pointer<ffi.Void> Diag, + ffi.Pointer<CXString> Disable, +); + +typedef _dart_clang_getDiagnosticOption = CXString Function( + ffi.Pointer<ffi.Void> Diag, + ffi.Pointer<CXString> Disable, +); + typedef _c_clang_getDiagnosticCategory = ffi.Uint32 Function( ffi.Pointer<ffi.Void> arg0, ); @@ -3639,6 +7741,22 @@ ffi.Pointer<ffi.Void> arg0, ); +typedef _c_clang_getDiagnosticCategoryName = CXString Function( + ffi.Uint32 Category, +); + +typedef _dart_clang_getDiagnosticCategoryName = CXString Function( + int Category, +); + +typedef _c_clang_getDiagnosticCategoryText = CXString Function( + ffi.Pointer<ffi.Void> arg0, +); + +typedef _dart_clang_getDiagnosticCategoryText = CXString Function( + ffi.Pointer<ffi.Void> arg0, +); + typedef _c_clang_getDiagnosticNumRanges = ffi.Uint32 Function( ffi.Pointer<ffi.Void> arg0, ); @@ -3647,6 +7765,16 @@ ffi.Pointer<ffi.Void> arg0, ); +typedef _c_clang_getDiagnosticRange = CXSourceRange Function( + ffi.Pointer<ffi.Void> Diagnostic, + ffi.Uint32 Range, +); + +typedef _dart_clang_getDiagnosticRange = CXSourceRange Function( + ffi.Pointer<ffi.Void> Diagnostic, + int Range, +); + typedef _c_clang_getDiagnosticNumFixIts = ffi.Uint32 Function( ffi.Pointer<ffi.Void> Diagnostic, ); @@ -3655,6 +7783,26 @@ ffi.Pointer<ffi.Void> Diagnostic, ); +typedef _c_clang_getDiagnosticFixIt = CXString Function( + ffi.Pointer<ffi.Void> Diagnostic, + ffi.Uint32 FixIt, + ffi.Pointer<CXSourceRange> ReplacementRange, +); + +typedef _dart_clang_getDiagnosticFixIt = CXString Function( + ffi.Pointer<ffi.Void> Diagnostic, + int FixIt, + ffi.Pointer<CXSourceRange> ReplacementRange, +); + +typedef _c_clang_getTranslationUnitSpelling = CXString Function( + ffi.Pointer<CXTranslationUnitImpl> CTUnit, +); + +typedef _dart_clang_getTranslationUnitSpelling = CXString Function( + ffi.Pointer<CXTranslationUnitImpl> CTUnit, +); + typedef _c_clang_createTranslationUnitFromSourceFile = ffi.Pointer<CXTranslationUnitImpl> Function( ffi.Pointer<ffi.Void> CIdx, @@ -3835,6 +7983,22 @@ int kind, ); +typedef _c_clang_getCXTUResourceUsage = CXTUResourceUsage Function( + ffi.Pointer<CXTranslationUnitImpl> TU, +); + +typedef _dart_clang_getCXTUResourceUsage = CXTUResourceUsage Function( + ffi.Pointer<CXTranslationUnitImpl> TU, +); + +typedef _c_clang_disposeCXTUResourceUsage = ffi.Void Function( + CXTUResourceUsage usage, +); + +typedef _dart_clang_disposeCXTUResourceUsage = void Function( + CXTUResourceUsage usage, +); + typedef _c_clang_getTranslationUnitTargetInfo = ffi.Pointer<CXTargetInfoImpl> Function( ffi.Pointer<CXTranslationUnitImpl> CTUnit, @@ -3853,6 +8017,14 @@ ffi.Pointer<CXTargetInfoImpl> Info, ); +typedef _c_clang_TargetInfo_getTriple = CXString Function( + ffi.Pointer<CXTargetInfoImpl> Info, +); + +typedef _dart_clang_TargetInfo_getTriple = CXString Function( + ffi.Pointer<CXTargetInfoImpl> Info, +); + typedef _c_clang_TargetInfo_getPointerWidth = ffi.Int32 Function( ffi.Pointer<CXTargetInfoImpl> Info, ); @@ -3861,6 +8033,52 @@ ffi.Pointer<CXTargetInfoImpl> Info, ); +typedef _c_clang_getNullCursor = CXCursor Function(); + +typedef _dart_clang_getNullCursor = CXCursor Function(); + +typedef _c_clang_getTranslationUnitCursor = CXCursor Function( + ffi.Pointer<CXTranslationUnitImpl> arg0, +); + +typedef _dart_clang_getTranslationUnitCursor = CXCursor Function( + ffi.Pointer<CXTranslationUnitImpl> arg0, +); + +typedef _c_clang_equalCursors = ffi.Uint32 Function( + CXCursor arg0, + CXCursor arg1, +); + +typedef _dart_clang_equalCursors = int Function( + CXCursor arg0, + CXCursor arg1, +); + +typedef _c_clang_Cursor_isNull = ffi.Int32 Function( + CXCursor cursor, +); + +typedef _dart_clang_Cursor_isNull = int Function( + CXCursor cursor, +); + +typedef _c_clang_hashCursor = ffi.Uint32 Function( + CXCursor arg0, +); + +typedef _dart_clang_hashCursor = int Function( + CXCursor arg0, +); + +typedef _c_clang_getCursorKind = ffi.Int32 Function( + CXCursor arg0, +); + +typedef _dart_clang_getCursorKind = int Function( + CXCursor arg0, +); + typedef _c_clang_isDeclaration = ffi.Uint32 Function( ffi.Int32 arg0, ); @@ -3869,6 +8087,14 @@ int arg0, ); +typedef _c_clang_isInvalidDeclaration = ffi.Uint32 Function( + CXCursor arg0, +); + +typedef _dart_clang_isInvalidDeclaration = int Function( + CXCursor arg0, +); + typedef _c_clang_isReference = ffi.Uint32 Function( ffi.Int32 arg0, ); @@ -3901,6 +8127,14 @@ int arg0, ); +typedef _c_clang_Cursor_hasAttrs = ffi.Uint32 Function( + CXCursor C, +); + +typedef _dart_clang_Cursor_hasAttrs = int Function( + CXCursor C, +); + typedef _c_clang_isInvalid = ffi.Uint32 Function( ffi.Int32 arg0, ); @@ -3933,6 +8167,50 @@ int arg0, ); +typedef _c_clang_getCursorLinkage = ffi.Int32 Function( + CXCursor cursor, +); + +typedef _dart_clang_getCursorLinkage = int Function( + CXCursor cursor, +); + +typedef _c_clang_getCursorVisibility = ffi.Int32 Function( + CXCursor cursor, +); + +typedef _dart_clang_getCursorVisibility = int Function( + CXCursor cursor, +); + +typedef _c_clang_getCursorAvailability = ffi.Int32 Function( + CXCursor cursor, +); + +typedef _dart_clang_getCursorAvailability = int Function( + CXCursor cursor, +); + +typedef _c_clang_getCursorPlatformAvailability = ffi.Int32 Function( + CXCursor cursor, + ffi.Pointer<ffi.Int32> always_deprecated, + ffi.Pointer<CXString> deprecated_message, + ffi.Pointer<ffi.Int32> always_unavailable, + ffi.Pointer<CXString> unavailable_message, + ffi.Pointer<CXPlatformAvailability> availability, + ffi.Int32 availability_size, +); + +typedef _dart_clang_getCursorPlatformAvailability = int Function( + CXCursor cursor, + ffi.Pointer<ffi.Int32> always_deprecated, + ffi.Pointer<CXString> deprecated_message, + ffi.Pointer<ffi.Int32> always_unavailable, + ffi.Pointer<CXString> unavailable_message, + ffi.Pointer<CXPlatformAvailability> availability, + int availability_size, +); + typedef _c_clang_disposeCXPlatformAvailability = ffi.Void Function( ffi.Pointer<CXPlatformAvailability> availability, ); @@ -3941,6 +8219,32 @@ ffi.Pointer<CXPlatformAvailability> availability, ); +typedef _c_clang_getCursorLanguage = ffi.Int32 Function( + CXCursor cursor, +); + +typedef _dart_clang_getCursorLanguage = int Function( + CXCursor cursor, +); + +typedef _c_clang_getCursorTLSKind = ffi.Int32 Function( + CXCursor cursor, +); + +typedef _dart_clang_getCursorTLSKind = int Function( + CXCursor cursor, +); + +typedef _c_clang_Cursor_getTranslationUnit = ffi.Pointer<CXTranslationUnitImpl> + Function( + CXCursor arg0, +); + +typedef _dart_clang_Cursor_getTranslationUnit + = ffi.Pointer<CXTranslationUnitImpl> Function( + CXCursor arg0, +); + typedef _c_clang_createCXCursorSet = ffi.Pointer<CXCursorSetImpl> Function(); typedef _dart_clang_createCXCursorSet = ffi.Pointer<CXCursorSetImpl> Function(); @@ -3953,6 +8257,54 @@ ffi.Pointer<CXCursorSetImpl> cset, ); +typedef _c_clang_CXCursorSet_contains = ffi.Uint32 Function( + ffi.Pointer<CXCursorSetImpl> cset, + CXCursor cursor, +); + +typedef _dart_clang_CXCursorSet_contains = int Function( + ffi.Pointer<CXCursorSetImpl> cset, + CXCursor cursor, +); + +typedef _c_clang_CXCursorSet_insert = ffi.Uint32 Function( + ffi.Pointer<CXCursorSetImpl> cset, + CXCursor cursor, +); + +typedef _dart_clang_CXCursorSet_insert = int Function( + ffi.Pointer<CXCursorSetImpl> cset, + CXCursor cursor, +); + +typedef _c_clang_getCursorSemanticParent = CXCursor Function( + CXCursor cursor, +); + +typedef _dart_clang_getCursorSemanticParent = CXCursor Function( + CXCursor cursor, +); + +typedef _c_clang_getCursorLexicalParent = CXCursor Function( + CXCursor cursor, +); + +typedef _dart_clang_getCursorLexicalParent = CXCursor Function( + CXCursor cursor, +); + +typedef _c_clang_getOverriddenCursors = ffi.Void Function( + CXCursor cursor, + ffi.Pointer<ffi.Pointer<CXCursor>> overridden, + ffi.Pointer<ffi.Uint32> num_overridden, +); + +typedef _dart_clang_getOverriddenCursors = void Function( + CXCursor cursor, + ffi.Pointer<ffi.Pointer<CXCursor>> overridden, + ffi.Pointer<ffi.Uint32> num_overridden, +); + typedef _c_clang_disposeOverriddenCursors = ffi.Void Function( ffi.Pointer<CXCursor> overridden, ); @@ -3961,6 +8313,720 @@ ffi.Pointer<CXCursor> overridden, ); +typedef _c_clang_getIncludedFile = ffi.Pointer<ffi.Void> Function( + CXCursor cursor, +); + +typedef _dart_clang_getIncludedFile = ffi.Pointer<ffi.Void> Function( + CXCursor cursor, +); + +typedef _c_clang_getCursor = CXCursor Function( + ffi.Pointer<CXTranslationUnitImpl> arg0, + CXSourceLocation arg1, +); + +typedef _dart_clang_getCursor = CXCursor Function( + ffi.Pointer<CXTranslationUnitImpl> arg0, + CXSourceLocation arg1, +); + +typedef _c_clang_getCursorLocation = CXSourceLocation Function( + CXCursor arg0, +); + +typedef _dart_clang_getCursorLocation = CXSourceLocation Function( + CXCursor arg0, +); + +typedef _c_clang_getCursorExtent = CXSourceRange Function( + CXCursor arg0, +); + +typedef _dart_clang_getCursorExtent = CXSourceRange Function( + CXCursor arg0, +); + +typedef _c_clang_getCursorType = CXType Function( + CXCursor C, +); + +typedef _dart_clang_getCursorType = CXType Function( + CXCursor C, +); + +typedef _c_clang_getTypeSpelling = CXString Function( + CXType CT, +); + +typedef _dart_clang_getTypeSpelling = CXString Function( + CXType CT, +); + +typedef _c_clang_getTypedefDeclUnderlyingType = CXType Function( + CXCursor C, +); + +typedef _dart_clang_getTypedefDeclUnderlyingType = CXType Function( + CXCursor C, +); + +typedef _c_clang_getEnumDeclIntegerType = CXType Function( + CXCursor C, +); + +typedef _dart_clang_getEnumDeclIntegerType = CXType Function( + CXCursor C, +); + +typedef _c_clang_getEnumConstantDeclValue = ffi.Int64 Function( + CXCursor C, +); + +typedef _dart_clang_getEnumConstantDeclValue = int Function( + CXCursor C, +); + +typedef _c_clang_getEnumConstantDeclUnsignedValue = ffi.Uint64 Function( + CXCursor C, +); + +typedef _dart_clang_getEnumConstantDeclUnsignedValue = int Function( + CXCursor C, +); + +typedef _c_clang_getFieldDeclBitWidth = ffi.Int32 Function( + CXCursor C, +); + +typedef _dart_clang_getFieldDeclBitWidth = int Function( + CXCursor C, +); + +typedef _c_clang_Cursor_getNumArguments = ffi.Int32 Function( + CXCursor C, +); + +typedef _dart_clang_Cursor_getNumArguments = int Function( + CXCursor C, +); + +typedef _c_clang_Cursor_getArgument = CXCursor Function( + CXCursor C, + ffi.Uint32 i, +); + +typedef _dart_clang_Cursor_getArgument = CXCursor Function( + CXCursor C, + int i, +); + +typedef _c_clang_Cursor_getNumTemplateArguments = ffi.Int32 Function( + CXCursor C, +); + +typedef _dart_clang_Cursor_getNumTemplateArguments = int Function( + CXCursor C, +); + +typedef _c_clang_Cursor_getTemplateArgumentKind = ffi.Int32 Function( + CXCursor C, + ffi.Uint32 I, +); + +typedef _dart_clang_Cursor_getTemplateArgumentKind = int Function( + CXCursor C, + int I, +); + +typedef _c_clang_Cursor_getTemplateArgumentType = CXType Function( + CXCursor C, + ffi.Uint32 I, +); + +typedef _dart_clang_Cursor_getTemplateArgumentType = CXType Function( + CXCursor C, + int I, +); + +typedef _c_clang_Cursor_getTemplateArgumentValue = ffi.Int64 Function( + CXCursor C, + ffi.Uint32 I, +); + +typedef _dart_clang_Cursor_getTemplateArgumentValue = int Function( + CXCursor C, + int I, +); + +typedef _c_clang_Cursor_getTemplateArgumentUnsignedValue = ffi.Uint64 Function( + CXCursor C, + ffi.Uint32 I, +); + +typedef _dart_clang_Cursor_getTemplateArgumentUnsignedValue = int Function( + CXCursor C, + int I, +); + +typedef _c_clang_equalTypes = ffi.Uint32 Function( + CXType A, + CXType B, +); + +typedef _dart_clang_equalTypes = int Function( + CXType A, + CXType B, +); + +typedef _c_clang_getCanonicalType = CXType Function( + CXType T, +); + +typedef _dart_clang_getCanonicalType = CXType Function( + CXType T, +); + +typedef _c_clang_isConstQualifiedType = ffi.Uint32 Function( + CXType T, +); + +typedef _dart_clang_isConstQualifiedType = int Function( + CXType T, +); + +typedef _c_clang_Cursor_isMacroFunctionLike = ffi.Uint32 Function( + CXCursor C, +); + +typedef _dart_clang_Cursor_isMacroFunctionLike = int Function( + CXCursor C, +); + +typedef _c_clang_Cursor_isMacroBuiltin = ffi.Uint32 Function( + CXCursor C, +); + +typedef _dart_clang_Cursor_isMacroBuiltin = int Function( + CXCursor C, +); + +typedef _c_clang_Cursor_isFunctionInlined = ffi.Uint32 Function( + CXCursor C, +); + +typedef _dart_clang_Cursor_isFunctionInlined = int Function( + CXCursor C, +); + +typedef _c_clang_isVolatileQualifiedType = ffi.Uint32 Function( + CXType T, +); + +typedef _dart_clang_isVolatileQualifiedType = int Function( + CXType T, +); + +typedef _c_clang_isRestrictQualifiedType = ffi.Uint32 Function( + CXType T, +); + +typedef _dart_clang_isRestrictQualifiedType = int Function( + CXType T, +); + +typedef _c_clang_getAddressSpace = ffi.Uint32 Function( + CXType T, +); + +typedef _dart_clang_getAddressSpace = int Function( + CXType T, +); + +typedef _c_clang_getTypedefName = CXString Function( + CXType CT, +); + +typedef _dart_clang_getTypedefName = CXString Function( + CXType CT, +); + +typedef _c_clang_getPointeeType = CXType Function( + CXType T, +); + +typedef _dart_clang_getPointeeType = CXType Function( + CXType T, +); + +typedef _c_clang_getTypeDeclaration = CXCursor Function( + CXType T, +); + +typedef _dart_clang_getTypeDeclaration = CXCursor Function( + CXType T, +); + +typedef _c_clang_getDeclObjCTypeEncoding = CXString Function( + CXCursor C, +); + +typedef _dart_clang_getDeclObjCTypeEncoding = CXString Function( + CXCursor C, +); + +typedef _c_clang_Type_getObjCEncoding = CXString Function( + CXType type, +); + +typedef _dart_clang_Type_getObjCEncoding = CXString Function( + CXType type, +); + +typedef _c_clang_getTypeKindSpelling = CXString Function( + ffi.Int32 K, +); + +typedef _dart_clang_getTypeKindSpelling = CXString Function( + int K, +); + +typedef _c_clang_getFunctionTypeCallingConv = ffi.Int32 Function( + CXType T, +); + +typedef _dart_clang_getFunctionTypeCallingConv = int Function( + CXType T, +); + +typedef _c_clang_getResultType = CXType Function( + CXType T, +); + +typedef _dart_clang_getResultType = CXType Function( + CXType T, +); + +typedef _c_clang_getExceptionSpecificationType = ffi.Int32 Function( + CXType T, +); + +typedef _dart_clang_getExceptionSpecificationType = int Function( + CXType T, +); + +typedef _c_clang_getNumArgTypes = ffi.Int32 Function( + CXType T, +); + +typedef _dart_clang_getNumArgTypes = int Function( + CXType T, +); + +typedef _c_clang_getArgType = CXType Function( + CXType T, + ffi.Uint32 i, +); + +typedef _dart_clang_getArgType = CXType Function( + CXType T, + int i, +); + +typedef _c_clang_Type_getObjCObjectBaseType = CXType Function( + CXType T, +); + +typedef _dart_clang_Type_getObjCObjectBaseType = CXType Function( + CXType T, +); + +typedef _c_clang_Type_getNumObjCProtocolRefs = ffi.Uint32 Function( + CXType T, +); + +typedef _dart_clang_Type_getNumObjCProtocolRefs = int Function( + CXType T, +); + +typedef _c_clang_Type_getObjCProtocolDecl = CXCursor Function( + CXType T, + ffi.Uint32 i, +); + +typedef _dart_clang_Type_getObjCProtocolDecl = CXCursor Function( + CXType T, + int i, +); + +typedef _c_clang_Type_getNumObjCTypeArgs = ffi.Uint32 Function( + CXType T, +); + +typedef _dart_clang_Type_getNumObjCTypeArgs = int Function( + CXType T, +); + +typedef _c_clang_Type_getObjCTypeArg = CXType Function( + CXType T, + ffi.Uint32 i, +); + +typedef _dart_clang_Type_getObjCTypeArg = CXType Function( + CXType T, + int i, +); + +typedef _c_clang_isFunctionTypeVariadic = ffi.Uint32 Function( + CXType T, +); + +typedef _dart_clang_isFunctionTypeVariadic = int Function( + CXType T, +); + +typedef _c_clang_getCursorResultType = CXType Function( + CXCursor C, +); + +typedef _dart_clang_getCursorResultType = CXType Function( + CXCursor C, +); + +typedef _c_clang_getCursorExceptionSpecificationType = ffi.Int32 Function( + CXCursor C, +); + +typedef _dart_clang_getCursorExceptionSpecificationType = int Function( + CXCursor C, +); + +typedef _c_clang_isPODType = ffi.Uint32 Function( + CXType T, +); + +typedef _dart_clang_isPODType = int Function( + CXType T, +); + +typedef _c_clang_getElementType = CXType Function( + CXType T, +); + +typedef _dart_clang_getElementType = CXType Function( + CXType T, +); + +typedef _c_clang_getNumElements = ffi.Int64 Function( + CXType T, +); + +typedef _dart_clang_getNumElements = int Function( + CXType T, +); + +typedef _c_clang_getArrayElementType = CXType Function( + CXType T, +); + +typedef _dart_clang_getArrayElementType = CXType Function( + CXType T, +); + +typedef _c_clang_getArraySize = ffi.Int64 Function( + CXType T, +); + +typedef _dart_clang_getArraySize = int Function( + CXType T, +); + +typedef _c_clang_Type_getNamedType = CXType Function( + CXType T, +); + +typedef _dart_clang_Type_getNamedType = CXType Function( + CXType T, +); + +typedef _c_clang_Type_isTransparentTagTypedef = ffi.Uint32 Function( + CXType T, +); + +typedef _dart_clang_Type_isTransparentTagTypedef = int Function( + CXType T, +); + +typedef _c_clang_Type_getNullability = ffi.Int32 Function( + CXType T, +); + +typedef _dart_clang_Type_getNullability = int Function( + CXType T, +); + +typedef _c_clang_Type_getAlignOf = ffi.Int64 Function( + CXType T, +); + +typedef _dart_clang_Type_getAlignOf = int Function( + CXType T, +); + +typedef _c_clang_Type_getClassType = CXType Function( + CXType T, +); + +typedef _dart_clang_Type_getClassType = CXType Function( + CXType T, +); + +typedef _c_clang_Type_getSizeOf = ffi.Int64 Function( + CXType T, +); + +typedef _dart_clang_Type_getSizeOf = int Function( + CXType T, +); + +typedef _c_clang_Type_getOffsetOf = ffi.Int64 Function( + CXType T, + ffi.Pointer<ffi.Int8> S, +); + +typedef _dart_clang_Type_getOffsetOf = int Function( + CXType T, + ffi.Pointer<ffi.Int8> S, +); + +typedef _c_clang_Type_getModifiedType = CXType Function( + CXType T, +); + +typedef _dart_clang_Type_getModifiedType = CXType Function( + CXType T, +); + +typedef _c_clang_Cursor_getOffsetOfField = ffi.Int64 Function( + CXCursor C, +); + +typedef _dart_clang_Cursor_getOffsetOfField = int Function( + CXCursor C, +); + +typedef _c_clang_Cursor_isAnonymous = ffi.Uint32 Function( + CXCursor C, +); + +typedef _dart_clang_Cursor_isAnonymous = int Function( + CXCursor C, +); + +typedef _c_clang_Cursor_isAnonymousRecordDecl = ffi.Uint32 Function( + CXCursor C, +); + +typedef _dart_clang_Cursor_isAnonymousRecordDecl = int Function( + CXCursor C, +); + +typedef _c_clang_Cursor_isInlineNamespace = ffi.Uint32 Function( + CXCursor C, +); + +typedef _dart_clang_Cursor_isInlineNamespace = int Function( + CXCursor C, +); + +typedef _c_clang_Type_getNumTemplateArguments = ffi.Int32 Function( + CXType T, +); + +typedef _dart_clang_Type_getNumTemplateArguments = int Function( + CXType T, +); + +typedef _c_clang_Type_getTemplateArgumentAsType = CXType Function( + CXType T, + ffi.Uint32 i, +); + +typedef _dart_clang_Type_getTemplateArgumentAsType = CXType Function( + CXType T, + int i, +); + +typedef _c_clang_Type_getCXXRefQualifier = ffi.Int32 Function( + CXType T, +); + +typedef _dart_clang_Type_getCXXRefQualifier = int Function( + CXType T, +); + +typedef _c_clang_Cursor_isBitField = ffi.Uint32 Function( + CXCursor C, +); + +typedef _dart_clang_Cursor_isBitField = int Function( + CXCursor C, +); + +typedef _c_clang_isVirtualBase = ffi.Uint32 Function( + CXCursor arg0, +); + +typedef _dart_clang_isVirtualBase = int Function( + CXCursor arg0, +); + +typedef _c_clang_getCXXAccessSpecifier = ffi.Int32 Function( + CXCursor arg0, +); + +typedef _dart_clang_getCXXAccessSpecifier = int Function( + CXCursor arg0, +); + +typedef _c_clang_Cursor_getStorageClass = ffi.Int32 Function( + CXCursor arg0, +); + +typedef _dart_clang_Cursor_getStorageClass = int Function( + CXCursor arg0, +); + +typedef _c_clang_getNumOverloadedDecls = ffi.Uint32 Function( + CXCursor cursor, +); + +typedef _dart_clang_getNumOverloadedDecls = int Function( + CXCursor cursor, +); + +typedef _c_clang_getOverloadedDecl = CXCursor Function( + CXCursor cursor, + ffi.Uint32 index, +); + +typedef _dart_clang_getOverloadedDecl = CXCursor Function( + CXCursor cursor, + int index, +); + +typedef _c_clang_getIBOutletCollectionType = CXType Function( + CXCursor arg0, +); + +typedef _dart_clang_getIBOutletCollectionType = CXType Function( + CXCursor arg0, +); + +typedef CXCursorVisitor = ffi.Int32 Function( + CXCursor, + CXCursor, + ffi.Pointer<ffi.Void>, +); + +typedef _c_clang_visitChildren = ffi.Uint32 Function( + CXCursor parent, + ffi.Pointer<ffi.NativeFunction<CXCursorVisitor>> visitor, + ffi.Pointer<ffi.Void> client_data, +); + +typedef _dart_clang_visitChildren = int Function( + CXCursor parent, + ffi.Pointer<ffi.NativeFunction<CXCursorVisitor>> visitor, + ffi.Pointer<ffi.Void> client_data, +); + +typedef _c_clang_getCursorUSR = CXString Function( + CXCursor arg0, +); + +typedef _dart_clang_getCursorUSR = CXString Function( + CXCursor arg0, +); + +typedef _c_clang_constructUSR_ObjCClass = CXString Function( + ffi.Pointer<ffi.Int8> class_name, +); + +typedef _dart_clang_constructUSR_ObjCClass = CXString Function( + ffi.Pointer<ffi.Int8> class_name, +); + +typedef _c_clang_constructUSR_ObjCCategory = CXString Function( + ffi.Pointer<ffi.Int8> class_name, + ffi.Pointer<ffi.Int8> category_name, +); + +typedef _dart_clang_constructUSR_ObjCCategory = CXString Function( + ffi.Pointer<ffi.Int8> class_name, + ffi.Pointer<ffi.Int8> category_name, +); + +typedef _c_clang_constructUSR_ObjCProtocol = CXString Function( + ffi.Pointer<ffi.Int8> protocol_name, +); + +typedef _dart_clang_constructUSR_ObjCProtocol = CXString Function( + ffi.Pointer<ffi.Int8> protocol_name, +); + +typedef _c_clang_constructUSR_ObjCIvar = CXString Function( + ffi.Pointer<ffi.Int8> name, + CXString classUSR, +); + +typedef _dart_clang_constructUSR_ObjCIvar = CXString Function( + ffi.Pointer<ffi.Int8> name, + CXString classUSR, +); + +typedef _c_clang_constructUSR_ObjCMethod = CXString Function( + ffi.Pointer<ffi.Int8> name, + ffi.Uint32 isInstanceMethod, + CXString classUSR, +); + +typedef _dart_clang_constructUSR_ObjCMethod = CXString Function( + ffi.Pointer<ffi.Int8> name, + int isInstanceMethod, + CXString classUSR, +); + +typedef _c_clang_constructUSR_ObjCProperty = CXString Function( + ffi.Pointer<ffi.Int8> property, + CXString classUSR, +); + +typedef _dart_clang_constructUSR_ObjCProperty = CXString Function( + ffi.Pointer<ffi.Int8> property, + CXString classUSR, +); + +typedef _c_clang_getCursorSpelling = CXString Function( + CXCursor arg0, +); + +typedef _dart_clang_getCursorSpelling = CXString Function( + CXCursor arg0, +); + +typedef _c_clang_Cursor_getSpellingNameRange = CXSourceRange Function( + CXCursor arg0, + ffi.Uint32 pieceIndex, + ffi.Uint32 options, +); + +typedef _dart_clang_Cursor_getSpellingNameRange = CXSourceRange Function( + CXCursor arg0, + int pieceIndex, + int options, +); + typedef _c_clang_PrintingPolicy_getProperty = ffi.Uint32 Function( ffi.Pointer<ffi.Void> Policy, ffi.Int32 Property, @@ -3983,6 +9049,14 @@ int Value, ); +typedef _c_clang_getCursorPrintingPolicy = ffi.Pointer<ffi.Void> Function( + CXCursor arg0, +); + +typedef _dart_clang_getCursorPrintingPolicy = ffi.Pointer<ffi.Void> Function( + CXCursor arg0, +); + typedef _c_clang_PrintingPolicy_dispose = ffi.Void Function( ffi.Pointer<ffi.Void> Policy, ); @@ -3991,6 +9065,200 @@ ffi.Pointer<ffi.Void> Policy, ); +typedef _c_clang_getCursorPrettyPrinted = CXString Function( + CXCursor Cursor, + ffi.Pointer<ffi.Void> Policy, +); + +typedef _dart_clang_getCursorPrettyPrinted = CXString Function( + CXCursor Cursor, + ffi.Pointer<ffi.Void> Policy, +); + +typedef _c_clang_getCursorDisplayName = CXString Function( + CXCursor arg0, +); + +typedef _dart_clang_getCursorDisplayName = CXString Function( + CXCursor arg0, +); + +typedef _c_clang_getCursorReferenced = CXCursor Function( + CXCursor arg0, +); + +typedef _dart_clang_getCursorReferenced = CXCursor Function( + CXCursor arg0, +); + +typedef _c_clang_getCursorDefinition = CXCursor Function( + CXCursor arg0, +); + +typedef _dart_clang_getCursorDefinition = CXCursor Function( + CXCursor arg0, +); + +typedef _c_clang_isCursorDefinition = ffi.Uint32 Function( + CXCursor arg0, +); + +typedef _dart_clang_isCursorDefinition = int Function( + CXCursor arg0, +); + +typedef _c_clang_getCanonicalCursor = CXCursor Function( + CXCursor arg0, +); + +typedef _dart_clang_getCanonicalCursor = CXCursor Function( + CXCursor arg0, +); + +typedef _c_clang_Cursor_getObjCSelectorIndex = ffi.Int32 Function( + CXCursor arg0, +); + +typedef _dart_clang_Cursor_getObjCSelectorIndex = int Function( + CXCursor arg0, +); + +typedef _c_clang_Cursor_isDynamicCall = ffi.Int32 Function( + CXCursor C, +); + +typedef _dart_clang_Cursor_isDynamicCall = int Function( + CXCursor C, +); + +typedef _c_clang_Cursor_getReceiverType = CXType Function( + CXCursor C, +); + +typedef _dart_clang_Cursor_getReceiverType = CXType Function( + CXCursor C, +); + +typedef _c_clang_Cursor_getObjCPropertyAttributes = ffi.Uint32 Function( + CXCursor C, + ffi.Uint32 reserved, +); + +typedef _dart_clang_Cursor_getObjCPropertyAttributes = int Function( + CXCursor C, + int reserved, +); + +typedef _c_clang_Cursor_getObjCPropertyGetterName = CXString Function( + CXCursor C, +); + +typedef _dart_clang_Cursor_getObjCPropertyGetterName = CXString Function( + CXCursor C, +); + +typedef _c_clang_Cursor_getObjCPropertySetterName = CXString Function( + CXCursor C, +); + +typedef _dart_clang_Cursor_getObjCPropertySetterName = CXString Function( + CXCursor C, +); + +typedef _c_clang_Cursor_getObjCDeclQualifiers = ffi.Uint32 Function( + CXCursor C, +); + +typedef _dart_clang_Cursor_getObjCDeclQualifiers = int Function( + CXCursor C, +); + +typedef _c_clang_Cursor_isObjCOptional = ffi.Uint32 Function( + CXCursor C, +); + +typedef _dart_clang_Cursor_isObjCOptional = int Function( + CXCursor C, +); + +typedef _c_clang_Cursor_isVariadic = ffi.Uint32 Function( + CXCursor C, +); + +typedef _dart_clang_Cursor_isVariadic = int Function( + CXCursor C, +); + +typedef _c_clang_Cursor_isExternalSymbol = ffi.Uint32 Function( + CXCursor C, + ffi.Pointer<CXString> language, + ffi.Pointer<CXString> definedIn, + ffi.Pointer<ffi.Uint32> isGenerated, +); + +typedef _dart_clang_Cursor_isExternalSymbol = int Function( + CXCursor C, + ffi.Pointer<CXString> language, + ffi.Pointer<CXString> definedIn, + ffi.Pointer<ffi.Uint32> isGenerated, +); + +typedef _c_clang_Cursor_getCommentRange = CXSourceRange Function( + CXCursor C, +); + +typedef _dart_clang_Cursor_getCommentRange = CXSourceRange Function( + CXCursor C, +); + +typedef _c_clang_Cursor_getRawCommentText = CXString Function( + CXCursor C, +); + +typedef _dart_clang_Cursor_getRawCommentText = CXString Function( + CXCursor C, +); + +typedef _c_clang_Cursor_getBriefCommentText = CXString Function( + CXCursor C, +); + +typedef _dart_clang_Cursor_getBriefCommentText = CXString Function( + CXCursor C, +); + +typedef _c_clang_Cursor_getMangling = CXString Function( + CXCursor arg0, +); + +typedef _dart_clang_Cursor_getMangling = CXString Function( + CXCursor arg0, +); + +typedef _c_clang_Cursor_getCXXManglings = ffi.Pointer<CXStringSet> Function( + CXCursor arg0, +); + +typedef _dart_clang_Cursor_getCXXManglings = ffi.Pointer<CXStringSet> Function( + CXCursor arg0, +); + +typedef _c_clang_Cursor_getObjCManglings = ffi.Pointer<CXStringSet> Function( + CXCursor arg0, +); + +typedef _dart_clang_Cursor_getObjCManglings = ffi.Pointer<CXStringSet> Function( + CXCursor arg0, +); + +typedef _c_clang_Cursor_getModule = ffi.Pointer<ffi.Void> Function( + CXCursor C, +); + +typedef _dart_clang_Cursor_getModule = ffi.Pointer<ffi.Void> Function( + CXCursor C, +); + typedef _c_clang_getModuleForFile = ffi.Pointer<ffi.Void> Function( ffi.Pointer<CXTranslationUnitImpl> arg0, ffi.Pointer<ffi.Void> arg1, @@ -4017,6 +9285,22 @@ ffi.Pointer<ffi.Void> Module, ); +typedef _c_clang_Module_getName = CXString Function( + ffi.Pointer<ffi.Void> Module, +); + +typedef _dart_clang_Module_getName = CXString Function( + ffi.Pointer<ffi.Void> Module, +); + +typedef _c_clang_Module_getFullName = CXString Function( + ffi.Pointer<ffi.Void> Module, +); + +typedef _dart_clang_Module_getFullName = CXString Function( + ffi.Pointer<ffi.Void> Module, +); + typedef _c_clang_Module_isSystem = ffi.Int32 Function( ffi.Pointer<ffi.Void> Module, ); @@ -4047,6 +9331,192 @@ int Index, ); +typedef _c_clang_CXXConstructor_isConvertingConstructor = ffi.Uint32 Function( + CXCursor C, +); + +typedef _dart_clang_CXXConstructor_isConvertingConstructor = int Function( + CXCursor C, +); + +typedef _c_clang_CXXConstructor_isCopyConstructor = ffi.Uint32 Function( + CXCursor C, +); + +typedef _dart_clang_CXXConstructor_isCopyConstructor = int Function( + CXCursor C, +); + +typedef _c_clang_CXXConstructor_isDefaultConstructor = ffi.Uint32 Function( + CXCursor C, +); + +typedef _dart_clang_CXXConstructor_isDefaultConstructor = int Function( + CXCursor C, +); + +typedef _c_clang_CXXConstructor_isMoveConstructor = ffi.Uint32 Function( + CXCursor C, +); + +typedef _dart_clang_CXXConstructor_isMoveConstructor = int Function( + CXCursor C, +); + +typedef _c_clang_CXXField_isMutable = ffi.Uint32 Function( + CXCursor C, +); + +typedef _dart_clang_CXXField_isMutable = int Function( + CXCursor C, +); + +typedef _c_clang_CXXMethod_isDefaulted = ffi.Uint32 Function( + CXCursor C, +); + +typedef _dart_clang_CXXMethod_isDefaulted = int Function( + CXCursor C, +); + +typedef _c_clang_CXXMethod_isPureVirtual = ffi.Uint32 Function( + CXCursor C, +); + +typedef _dart_clang_CXXMethod_isPureVirtual = int Function( + CXCursor C, +); + +typedef _c_clang_CXXMethod_isStatic = ffi.Uint32 Function( + CXCursor C, +); + +typedef _dart_clang_CXXMethod_isStatic = int Function( + CXCursor C, +); + +typedef _c_clang_CXXMethod_isVirtual = ffi.Uint32 Function( + CXCursor C, +); + +typedef _dart_clang_CXXMethod_isVirtual = int Function( + CXCursor C, +); + +typedef _c_clang_CXXRecord_isAbstract = ffi.Uint32 Function( + CXCursor C, +); + +typedef _dart_clang_CXXRecord_isAbstract = int Function( + CXCursor C, +); + +typedef _c_clang_EnumDecl_isScoped = ffi.Uint32 Function( + CXCursor C, +); + +typedef _dart_clang_EnumDecl_isScoped = int Function( + CXCursor C, +); + +typedef _c_clang_CXXMethod_isConst = ffi.Uint32 Function( + CXCursor C, +); + +typedef _dart_clang_CXXMethod_isConst = int Function( + CXCursor C, +); + +typedef _c_clang_getTemplateCursorKind = ffi.Int32 Function( + CXCursor C, +); + +typedef _dart_clang_getTemplateCursorKind = int Function( + CXCursor C, +); + +typedef _c_clang_getSpecializedCursorTemplate = CXCursor Function( + CXCursor C, +); + +typedef _dart_clang_getSpecializedCursorTemplate = CXCursor Function( + CXCursor C, +); + +typedef _c_clang_getCursorReferenceNameRange = CXSourceRange Function( + CXCursor C, + ffi.Uint32 NameFlags, + ffi.Uint32 PieceIndex, +); + +typedef _dart_clang_getCursorReferenceNameRange = CXSourceRange Function( + CXCursor C, + int NameFlags, + int PieceIndex, +); + +typedef _c_clang_getToken = ffi.Pointer<CXToken> Function( + ffi.Pointer<CXTranslationUnitImpl> TU, + CXSourceLocation Location, +); + +typedef _dart_clang_getToken = ffi.Pointer<CXToken> Function( + ffi.Pointer<CXTranslationUnitImpl> TU, + CXSourceLocation Location, +); + +typedef _c_clang_getTokenKind = ffi.Int32 Function( + CXToken arg0, +); + +typedef _dart_clang_getTokenKind = int Function( + CXToken arg0, +); + +typedef _c_clang_getTokenSpelling = CXString Function( + ffi.Pointer<CXTranslationUnitImpl> arg0, + CXToken arg1, +); + +typedef _dart_clang_getTokenSpelling = CXString Function( + ffi.Pointer<CXTranslationUnitImpl> arg0, + CXToken arg1, +); + +typedef _c_clang_getTokenLocation = CXSourceLocation Function( + ffi.Pointer<CXTranslationUnitImpl> arg0, + CXToken arg1, +); + +typedef _dart_clang_getTokenLocation = CXSourceLocation Function( + ffi.Pointer<CXTranslationUnitImpl> arg0, + CXToken arg1, +); + +typedef _c_clang_getTokenExtent = CXSourceRange Function( + ffi.Pointer<CXTranslationUnitImpl> arg0, + CXToken arg1, +); + +typedef _dart_clang_getTokenExtent = CXSourceRange Function( + ffi.Pointer<CXTranslationUnitImpl> arg0, + CXToken arg1, +); + +typedef _c_clang_tokenize = ffi.Void Function( + ffi.Pointer<CXTranslationUnitImpl> TU, + CXSourceRange Range, + ffi.Pointer<ffi.Pointer<CXToken>> Tokens, + ffi.Pointer<ffi.Uint32> NumTokens, +); + +typedef _dart_clang_tokenize = void Function( + ffi.Pointer<CXTranslationUnitImpl> TU, + CXSourceRange Range, + ffi.Pointer<ffi.Pointer<CXToken>> Tokens, + ffi.Pointer<ffi.Uint32> NumTokens, +); + typedef _c_clang_annotateTokens = ffi.Void Function( ffi.Pointer<CXTranslationUnitImpl> TU, ffi.Pointer<CXToken> Tokens, @@ -4073,6 +9543,34 @@ int NumTokens, ); +typedef _c_clang_getCursorKindSpelling = CXString Function( + ffi.Int32 Kind, +); + +typedef _dart_clang_getCursorKindSpelling = CXString Function( + int Kind, +); + +typedef _c_clang_getDefinitionSpellingAndExtent = ffi.Void Function( + CXCursor arg0, + ffi.Pointer<ffi.Pointer<ffi.Int8>> startBuf, + ffi.Pointer<ffi.Pointer<ffi.Int8>> endBuf, + ffi.Pointer<ffi.Uint32> startLine, + ffi.Pointer<ffi.Uint32> startColumn, + ffi.Pointer<ffi.Uint32> endLine, + ffi.Pointer<ffi.Uint32> endColumn, +); + +typedef _dart_clang_getDefinitionSpellingAndExtent = void Function( + CXCursor arg0, + ffi.Pointer<ffi.Pointer<ffi.Int8>> startBuf, + ffi.Pointer<ffi.Pointer<ffi.Int8>> endBuf, + ffi.Pointer<ffi.Uint32> startLine, + ffi.Pointer<ffi.Uint32> startColumn, + ffi.Pointer<ffi.Uint32> endLine, + ffi.Pointer<ffi.Uint32> endColumn, +); + typedef _c_clang_enableStackTraces = ffi.Void Function(); typedef _dart_clang_enableStackTraces = void Function(); @@ -4103,6 +9601,16 @@ int chunk_number, ); +typedef _c_clang_getCompletionChunkText = CXString Function( + ffi.Pointer<ffi.Void> completion_string, + ffi.Uint32 chunk_number, +); + +typedef _dart_clang_getCompletionChunkText = CXString Function( + ffi.Pointer<ffi.Void> completion_string, + int chunk_number, +); + typedef _c_clang_getCompletionChunkCompletionString = ffi.Pointer<ffi.Void> Function( ffi.Pointer<ffi.Void> completion_string, @@ -4147,6 +9655,42 @@ ffi.Pointer<ffi.Void> completion_string, ); +typedef _c_clang_getCompletionAnnotation = CXString Function( + ffi.Pointer<ffi.Void> completion_string, + ffi.Uint32 annotation_number, +); + +typedef _dart_clang_getCompletionAnnotation = CXString Function( + ffi.Pointer<ffi.Void> completion_string, + int annotation_number, +); + +typedef _c_clang_getCompletionParent = CXString Function( + ffi.Pointer<ffi.Void> completion_string, + ffi.Pointer<ffi.Int32> kind, +); + +typedef _dart_clang_getCompletionParent = CXString Function( + ffi.Pointer<ffi.Void> completion_string, + ffi.Pointer<ffi.Int32> kind, +); + +typedef _c_clang_getCompletionBriefComment = CXString Function( + ffi.Pointer<ffi.Void> completion_string, +); + +typedef _dart_clang_getCompletionBriefComment = CXString Function( + ffi.Pointer<ffi.Void> completion_string, +); + +typedef _c_clang_getCursorCompletionString = ffi.Pointer<ffi.Void> Function( + CXCursor cursor, +); + +typedef _dart_clang_getCursorCompletionString = ffi.Pointer<ffi.Void> Function( + CXCursor cursor, +); + typedef _c_clang_getCompletionNumFixIts = ffi.Uint32 Function( ffi.Pointer<CXCodeCompleteResults> results, ffi.Uint32 completion_index, @@ -4157,6 +9701,20 @@ int completion_index, ); +typedef _c_clang_getCompletionFixIt = CXString Function( + ffi.Pointer<CXCodeCompleteResults> results, + ffi.Uint32 completion_index, + ffi.Uint32 fixit_index, + ffi.Pointer<CXSourceRange> replacement_range, +); + +typedef _dart_clang_getCompletionFixIt = CXString Function( + ffi.Pointer<CXCodeCompleteResults> results, + int completion_index, + int fixit_index, + ffi.Pointer<CXSourceRange> replacement_range, +); + typedef _c_clang_defaultCodeCompleteOptions = ffi.Uint32 Function(); typedef _dart_clang_defaultCodeCompleteOptions = int Function(); @@ -4236,6 +9794,26 @@ ffi.Pointer<ffi.Uint32> IsIncomplete, ); +typedef _c_clang_codeCompleteGetContainerUSR = CXString Function( + ffi.Pointer<CXCodeCompleteResults> Results, +); + +typedef _dart_clang_codeCompleteGetContainerUSR = CXString Function( + ffi.Pointer<CXCodeCompleteResults> Results, +); + +typedef _c_clang_codeCompleteGetObjCSelector = CXString Function( + ffi.Pointer<CXCodeCompleteResults> Results, +); + +typedef _dart_clang_codeCompleteGetObjCSelector = CXString Function( + ffi.Pointer<CXCodeCompleteResults> Results, +); + +typedef _c_clang_getClangVersion = CXString Function(); + +typedef _dart_clang_getClangVersion = CXString Function(); + typedef _c_clang_toggleCrashRecovery = ffi.Void Function( ffi.Uint32 isEnabled, ); @@ -4263,6 +9841,14 @@ ffi.Pointer<ffi.Void> client_data, ); +typedef _c_clang_Cursor_Evaluate = ffi.Pointer<ffi.Void> Function( + CXCursor C, +); + +typedef _dart_clang_Cursor_Evaluate = ffi.Pointer<ffi.Void> Function( + CXCursor C, +); + typedef _c_clang_EvalResult_getKind = ffi.Int32 Function( ffi.Pointer<ffi.Void> E, ); @@ -4375,6 +9961,30 @@ ffi.Pointer<ffi.Void> arg0, ); +typedef _c_clang_findReferencesInFile = ffi.Int32 Function( + CXCursor cursor, + ffi.Pointer<ffi.Void> file, + CXCursorAndRangeVisitor visitor, +); + +typedef _dart_clang_findReferencesInFile = int Function( + CXCursor cursor, + ffi.Pointer<ffi.Void> file, + CXCursorAndRangeVisitor visitor, +); + +typedef _c_clang_findIncludesInFile = ffi.Int32 Function( + ffi.Pointer<CXTranslationUnitImpl> TU, + ffi.Pointer<ffi.Void> file, + CXCursorAndRangeVisitor visitor, +); + +typedef _dart_clang_findIncludesInFile = int Function( + ffi.Pointer<CXTranslationUnitImpl> TU, + ffi.Pointer<ffi.Void> file, + CXCursorAndRangeVisitor visitor, +); + typedef _c_clang_index_isEntityObjCContainerKind = ffi.Int32 Function( ffi.Int32 arg0, ); @@ -4583,18 +10193,61 @@ ffi.Pointer<CXTranslationUnitImpl> arg5, ); +typedef _c_clang_indexLoc_getFileLocation = ffi.Void Function( + CXIdxLoc loc, + ffi.Pointer<ffi.Pointer<ffi.Void>> indexFile, + ffi.Pointer<ffi.Pointer<ffi.Void>> file, + ffi.Pointer<ffi.Uint32> line, + ffi.Pointer<ffi.Uint32> column, + ffi.Pointer<ffi.Uint32> offset, +); + +typedef _dart_clang_indexLoc_getFileLocation = void Function( + CXIdxLoc loc, + ffi.Pointer<ffi.Pointer<ffi.Void>> indexFile, + ffi.Pointer<ffi.Pointer<ffi.Void>> file, + ffi.Pointer<ffi.Uint32> line, + ffi.Pointer<ffi.Uint32> column, + ffi.Pointer<ffi.Uint32> offset, +); + +typedef _c_clang_indexLoc_getCXSourceLocation = CXSourceLocation Function( + CXIdxLoc loc, +); + +typedef _dart_clang_indexLoc_getCXSourceLocation = CXSourceLocation Function( + CXIdxLoc loc, +); + +typedef CXFieldVisitor = ffi.Int32 Function( + CXCursor, + ffi.Pointer<ffi.Void>, +); + +typedef _c_clang_Type_visitFields = ffi.Uint32 Function( + CXType T, + ffi.Pointer<ffi.NativeFunction<CXFieldVisitor>> visitor, + ffi.Pointer<ffi.Void> client_data, +); + +typedef _dart_clang_Type_visitFields = int Function( + CXType T, + ffi.Pointer<ffi.NativeFunction<CXFieldVisitor>> visitor, + ffi.Pointer<ffi.Void> client_data, +); + typedef _typedefC_2 = ffi.Int32 Function( ffi.Pointer<ffi.Void>, - ffi.Pointer<ffi.Void>, + CXCursor, + CXSourceRange, ); -typedef _typedefC_3 = ffi.Void Function( - ffi.Pointer<ffi.Void>, +typedef _typedefC_3 = ffi.Int32 Function( ffi.Pointer<ffi.Void>, ffi.Pointer<ffi.Void>, ); -typedef _typedefC_4 = ffi.Pointer<ffi.Void> Function( +typedef _typedefC_4 = ffi.Void Function( ffi.Pointer<ffi.Void>, ffi.Pointer<ffi.Void>, ffi.Pointer<ffi.Void>, @@ -4602,25 +10255,31 @@ typedef _typedefC_5 = ffi.Pointer<ffi.Void> Function( ffi.Pointer<ffi.Void>, - ffi.Pointer<CXIdxIncludedFileInfo>, + ffi.Pointer<ffi.Void>, + ffi.Pointer<ffi.Void>, ); typedef _typedefC_6 = ffi.Pointer<ffi.Void> Function( ffi.Pointer<ffi.Void>, - ffi.Pointer<CXIdxImportedASTFileInfo>, + ffi.Pointer<CXIdxIncludedFileInfo>, ); typedef _typedefC_7 = ffi.Pointer<ffi.Void> Function( ffi.Pointer<ffi.Void>, + ffi.Pointer<CXIdxImportedASTFileInfo>, +); + +typedef _typedefC_8 = ffi.Pointer<ffi.Void> Function( + ffi.Pointer<ffi.Void>, ffi.Pointer<ffi.Void>, ); -typedef _typedefC_8 = ffi.Void Function( +typedef _typedefC_9 = ffi.Void Function( ffi.Pointer<ffi.Void>, ffi.Pointer<CXIdxDeclInfo>, ); -typedef _typedefC_9 = ffi.Void Function( +typedef _typedefC_10 = ffi.Void Function( ffi.Pointer<ffi.Void>, ffi.Pointer<CXIdxEntityRefInfo>, );
diff --git a/pkgs/ffigen/lib/src/code_generator/struc.dart b/pkgs/ffigen/lib/src/code_generator/struc.dart index ee8a523..8958139 100644 --- a/pkgs/ffigen/lib/src/code_generator/struc.dart +++ b/pkgs/ffigen/lib/src/code_generator/struc.dart
@@ -35,12 +35,18 @@ /// } /// ``` class Struc extends NoLookUpBinding { + /// Marker for if a struct definition is complete. + /// + /// A function can be safely pass this struct by value if it's complete. + bool isInComplete; + List<Member> members; Struc({ String? usr, String? originalName, required String name, + this.isInComplete = false, String? dartDoc, List<Member>? members, }) : members = members ?? [],
diff --git a/pkgs/ffigen/lib/src/code_generator/type.dart b/pkgs/ffigen/lib/src/code_generator/type.dart index 014413a..f6e5001 100644 --- a/pkgs/ffigen/lib/src/code_generator/type.dart +++ b/pkgs/ffigen/lib/src/code_generator/type.dart
@@ -162,6 +162,10 @@ bool get isPrimitive => (broadType == BroadType.NativeType || broadType == BroadType.Boolean); + /// Returns true if the type is a [Struc] and is incomplete. + bool get isIncompleteStruct => + broadType == BroadType.Struct && struc!.isInComplete; + String getCType(Writer w) { switch (broadType) { case BroadType.NativeType:
diff --git a/pkgs/ffigen/lib/src/header_parser/sub_parsers/functiondecl_parser.dart b/pkgs/ffigen/lib/src/header_parser/sub_parsers/functiondecl_parser.dart index 2b005d8..acb223a 100644 --- a/pkgs/ffigen/lib/src/header_parser/sub_parsers/functiondecl_parser.dart +++ b/pkgs/ffigen/lib/src/header_parser/sub_parsers/functiondecl_parser.dart
@@ -18,7 +18,7 @@ /// Holds temporary information regarding [Func] while parsing. class _ParserFunc { Func? func; - bool structByValueParameter = false; + bool incompleteStructParameter = false; bool unimplementedParameterType = false; _ParserFunc(); } @@ -28,8 +28,6 @@ /// Parses a function declaration. Func? parseFunctionDeclaration(Pointer<clang_types.CXCursor> cursor) { _stack.push(_ParserFunc()); - _stack.top.structByValueParameter = false; - _stack.top.unimplementedParameterType = false; final funcUsr = cursor.usr(); final funcName = cursor.spelling(); @@ -39,12 +37,11 @@ final rt = _getFunctionReturnType(cursor); final parameters = _getParameters(cursor, funcName); - //TODO(3): Remove this when support for Structs by value arrives. - if (rt.broadType == BroadType.Struct || _stack.top.structByValueParameter) { + if (rt.isIncompleteStruct || _stack.top.incompleteStructParameter) { _logger.fine( - '---- Removed Function, reason: struct pass/return by value: ${cursor.completeStringRepr()}'); + '---- Removed Function, reason: Incomplete struct pass/return by value: ${cursor.completeStringRepr()}'); _logger.warning( - "Skipped Function '$funcName', struct pass/return by value not supported."); + "Skipped Function '$funcName', Incomplete struct pass/return by value not supported."); return _stack .pop() .func; // Returning null so that [addToBindings] function excludes this. @@ -95,10 +92,11 @@ _logger.finer('===== parameter: ${paramCursor.completeStringRepr()}'); final pt = _getParameterType(paramCursor); - //TODO(3): Remove this when support for Structs by value arrives. - if (pt.broadType == BroadType.Struct) { - _stack.top.structByValueParameter = true; + if (pt.isIncompleteStruct) { + _stack.top.incompleteStructParameter = true; } else if (pt.getBaseType().broadType == BroadType.Unimplemented) { + _logger + .finer('Unimplemented type: ${pt.getBaseType().unimplementedReason}'); _stack.top.unimplementedParameterType = true; }
diff --git a/pkgs/ffigen/lib/src/header_parser/sub_parsers/structdecl_parser.dart b/pkgs/ffigen/lib/src/header_parser/sub_parsers/structdecl_parser.dart index 0c014d7..ffa4109 100644 --- a/pkgs/ffigen/lib/src/header_parser/sub_parsers/structdecl_parser.dart +++ b/pkgs/ffigen/lib/src/header_parser/sub_parsers/structdecl_parser.dart
@@ -5,6 +5,7 @@ import 'dart:ffi'; import 'package:ffigen/src/code_generator.dart'; +import 'package:ffigen/src/strings.dart'; import 'package:logging/logging.dart'; import '../clang_bindings/clang_bindings.dart' as clang_types; @@ -22,6 +23,16 @@ bool arrayMember = false; bool bitFieldMember = false; bool dartHandleMember = false; + bool incompleteStructMember = false; + + bool get isInComplete => + unimplementedMemberType || + flexibleArrayMember || + (arrayMember && !config.arrayWorkaround) || + bitFieldMember || + (dartHandleMember && config.useDartHandle) || + incompleteStructMember; + _ParsedStruc(); } @@ -83,38 +94,44 @@ visitChildrenResultChecker(resultCode); - // Returning null to exclude the struct members as it has a struct by value field. if (_stack.top.arrayMember && !config.arrayWorkaround) { _logger.fine( '---- Removed Struct members, reason: struct has array members ${cursor.completeStringRepr()}'); _logger.warning( 'Removed All Struct Members from: ${_stack.top.struc!.name}(${_stack.top.struc!.originalName}), Array members not supported'); - return _stack.top.struc!.members.clear(); } else if (_stack.top.unimplementedMemberType) { _logger.fine( '---- Removed Struct members, reason: member with unimplementedtype ${cursor.completeStringRepr()}'); _logger.warning( 'Removed All Struct Members from ${_stack.top.struc!.name}(${_stack.top.struc!.originalName}), struct member has an unsupported type.'); - return _stack.top.struc!.members.clear(); } else if (_stack.top.flexibleArrayMember) { _logger.fine( '---- Removed Struct members, reason: incomplete array member ${cursor.completeStringRepr()}'); _logger.warning( 'Removed All Struct Members from ${_stack.top.struc!.name}(${_stack.top.struc!.originalName}), Flexible array members not supported.'); - return _stack.top.struc!.members.clear(); } else if (_stack.top.bitFieldMember) { _logger.fine( '---- Removed Struct members, reason: bitfield members ${cursor.completeStringRepr()}'); _logger.warning( 'Removed All Struct Members from ${_stack.top.struc!.name}(${_stack.top.struc!.originalName}), Bit Field members not supported.'); - return _stack.top.struc!.members.clear(); - } else if (_stack.top.dartHandleMember) { + } else if (_stack.top.dartHandleMember && config.useDartHandle) { _logger.fine( '---- Removed Struct members, reason: Dart_Handle member. ${cursor.completeStringRepr()}'); _logger.warning( 'Removed All Struct Members from ${_stack.top.struc!.name}(${_stack.top.struc!.originalName}), Dart_Handle member not supported.'); - return _stack.top.struc!.members.clear(); + } else if (_stack.top.incompleteStructMember) { + _logger.fine( + '---- Removed Struct members, reason: Incomplete Nested Struct member. ${cursor.completeStringRepr()}'); + _logger.warning( + 'Removed All Struct Members from ${_stack.top.struc!.name}(${_stack.top.struc!.originalName}), Incomplete Nested Struct member not supported.'); } + + // Clear all struct members if struct is incomplete. + if (_stack.top.isInComplete) { + _stack.top.struc!.members.clear(); + } + + _stack.top.struc!.isInComplete = _stack.top.isInComplete; } /// Visitor for the struct cursor [CXCursorKind.CXCursor_StructDecl]. @@ -137,6 +154,8 @@ _stack.top.bitFieldMember = true; } else if (mt.broadType == BroadType.Handle) { _stack.top.dartHandleMember = true; + } else if (mt.isIncompleteStruct) { + _stack.top.incompleteStructMember = true; } if (mt.getBaseType().broadType == BroadType.Unimplemented) {
diff --git a/pkgs/ffigen/lib/src/header_parser/type_extractor/extractor.dart b/pkgs/ffigen/lib/src/header_parser/type_extractor/extractor.dart index defa1d3..d1a7883 100644 --- a/pkgs/ffigen/lib/src/header_parser/type_extractor/extractor.dart +++ b/pkgs/ffigen/lib/src/header_parser/type_extractor/extractor.dart
@@ -158,8 +158,9 @@ final t = clang.clang_getArgType_wrap(cxtype, i); final pt = t.toCodeGenTypeAndDispose(); - if (pt.broadType == BroadType.Struct) { - return Type.unimplemented('Struct by value in function parameter.'); + if (pt.isIncompleteStruct) { + return Type.unimplemented( + 'Incomplete Struct by value in function parameter.'); } else if (pt.getBaseType().broadType == BroadType.Unimplemented) { return Type.unimplemented('Function parameter has an unsupported type.'); }
diff --git a/pkgs/ffigen/pubspec.yaml b/pkgs/ffigen/pubspec.yaml index 44f1f1c..d3c8da0 100644 --- a/pkgs/ffigen/pubspec.yaml +++ b/pkgs/ffigen/pubspec.yaml
@@ -3,7 +3,7 @@ # BSD-style license that can be found in the LICENSE file. name: ffigen -version: 2.0.0-dev.0 +version: 2.0.0-dev.1 homepage: https://github.com/dart-lang/ffigen description: Experimental generator for FFI bindings, using LibClang to parse C header files.
diff --git a/pkgs/ffigen/test/header_parser_tests/function_n_struct.h b/pkgs/ffigen/test/header_parser_tests/function_n_struct.h index 629c0ba..bae5f40 100644 --- a/pkgs/ffigen/test/header_parser_tests/function_n_struct.h +++ b/pkgs/ffigen/test/header_parser_tests/function_n_struct.h
@@ -12,6 +12,7 @@ struct Struct1 a; }; +// All members should be removed, Flexible array members are not supported. struct Struct3 { int a; @@ -21,8 +22,15 @@ // All members should be removed, Bit fields are not supported. struct Struct4 { - int a:3; - int :2; // Unnamed bit field. + int a : 3; + int : 2; // Unnamed bit field. +}; + +// All members should be removed, Incomplete struct members are not supported. +struct Struct5 +{ + int a; + struct Struct3 s; // Incomplete nested struct. }; void func1(struct Struct2 *s);
diff --git a/pkgs/ffigen/test/header_parser_tests/function_n_struct_test.dart b/pkgs/ffigen/test/header_parser_tests/function_n_struct_test.dart index f8852d5..aec4502 100644 --- a/pkgs/ffigen/test/header_parser_tests/function_n_struct_test.dart +++ b/pkgs/ffigen/test/header_parser_tests/function_n_struct_test.dart
@@ -32,6 +32,9 @@ ); }); + test('Total bindings count', () { + expect(actual.bindings.length, expected.bindings.length); + }); test('func1 struct pointer parameter', () { expect(actual.getBindingAsString('func1'), expected.getBindingAsString('func1')); @@ -50,6 +53,9 @@ test('Struct4 bit field member', () { expect((actual.getBinding('Struct4') as Struc).members.isEmpty, true); }); + test('Struct5 incompleted struct member', () { + expect((actual.getBinding('Struct5') as Struc).members.isEmpty, true); + }); }); } @@ -97,6 +103,7 @@ type: Type.struct(struc1), ), ]), + Struc(name: 'Struct5'), ], ); }
diff --git a/pkgs/ffigen/test/large_integration_tests/_expected_libclang_bindings.dart b/pkgs/ffigen/test/large_integration_tests/_expected_libclang_bindings.dart index 60698fc..e0abce7 100644 --- a/pkgs/ffigen/test/large_integration_tests/_expected_libclang_bindings.dart +++ b/pkgs/ffigen/test/large_integration_tests/_expected_libclang_bindings.dart
@@ -11,6 +11,32 @@ /// The symbols are looked up in [dynamicLibrary]. LibClang(ffi.DynamicLibrary dynamicLibrary) : _dylib = dynamicLibrary; + /// Retrieve the character data associated with the given string. + ffi.Pointer<ffi.Int8> clang_getCString( + CXString string, + ) { + return (_clang_getCString ??= + _dylib.lookupFunction<_c_clang_getCString, _dart_clang_getCString>( + 'clang_getCString'))( + string, + ); + } + + _dart_clang_getCString? _clang_getCString; + + /// Free the given string. + void clang_disposeString( + CXString string, + ) { + return (_clang_disposeString ??= _dylib.lookupFunction< + _c_clang_disposeString, + _dart_clang_disposeString>('clang_disposeString'))( + string, + ); + } + + _dart_clang_disposeString? _clang_disposeString; + /// Free the given string set. void clang_disposeStringSet( ffi.Pointer<CXStringSet> set_1, @@ -297,6 +323,19 @@ _dart_clang_CXIndex_setInvocationEmissionPathOption? _clang_CXIndex_setInvocationEmissionPathOption; + /// Retrieve the complete file and path name of the given file. + CXString clang_getFileName( + ffi.Pointer<ffi.Void> SFile, + ) { + return (_clang_getFileName ??= + _dylib.lookupFunction<_c_clang_getFileName, _dart_clang_getFileName>( + 'clang_getFileName'))( + SFile, + ); + } + + _dart_clang_getFileName? _clang_getFileName; + /// Retrieve the last modification time of the given file. int clang_getFileTime( ffi.Pointer<ffi.Void> SFile, @@ -391,6 +430,299 @@ _dart_clang_File_isEqual? _clang_File_isEqual; + /// Returns the real path name of file. + CXString clang_File_tryGetRealPathName( + ffi.Pointer<ffi.Void> file, + ) { + return (_clang_File_tryGetRealPathName ??= _dylib.lookupFunction< + _c_clang_File_tryGetRealPathName, + _dart_clang_File_tryGetRealPathName>('clang_File_tryGetRealPathName'))( + file, + ); + } + + _dart_clang_File_tryGetRealPathName? _clang_File_tryGetRealPathName; + + /// Retrieve a NULL (invalid) source location. + CXSourceLocation clang_getNullLocation() { + return (_clang_getNullLocation ??= _dylib.lookupFunction< + _c_clang_getNullLocation, + _dart_clang_getNullLocation>('clang_getNullLocation'))(); + } + + _dart_clang_getNullLocation? _clang_getNullLocation; + + /// 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 ??= _dylib.lookupFunction< + _c_clang_equalLocations, + _dart_clang_equalLocations>('clang_equalLocations'))( + loc1, + loc2, + ); + } + + _dart_clang_equalLocations? _clang_equalLocations; + + /// Retrieves the source location associated with a given file/line/column in + /// a particular translation unit. + CXSourceLocation clang_getLocation( + ffi.Pointer<CXTranslationUnitImpl> tu, + ffi.Pointer<ffi.Void> file, + int line, + int column, + ) { + return (_clang_getLocation ??= + _dylib.lookupFunction<_c_clang_getLocation, _dart_clang_getLocation>( + 'clang_getLocation'))( + tu, + file, + line, + column, + ); + } + + _dart_clang_getLocation? _clang_getLocation; + + /// Retrieves the source location associated with a given character offset in + /// a particular translation unit. + CXSourceLocation clang_getLocationForOffset( + ffi.Pointer<CXTranslationUnitImpl> tu, + ffi.Pointer<ffi.Void> file, + int offset, + ) { + return (_clang_getLocationForOffset ??= _dylib.lookupFunction< + _c_clang_getLocationForOffset, + _dart_clang_getLocationForOffset>('clang_getLocationForOffset'))( + tu, + file, + offset, + ); + } + + _dart_clang_getLocationForOffset? _clang_getLocationForOffset; + + /// Returns non-zero if the given source location is in a system header. + int clang_Location_isInSystemHeader( + CXSourceLocation location, + ) { + return (_clang_Location_isInSystemHeader ??= _dylib.lookupFunction< + _c_clang_Location_isInSystemHeader, + _dart_clang_Location_isInSystemHeader>( + 'clang_Location_isInSystemHeader'))( + location, + ); + } + + _dart_clang_Location_isInSystemHeader? _clang_Location_isInSystemHeader; + + /// 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 ??= _dylib.lookupFunction< + _c_clang_Location_isFromMainFile, + _dart_clang_Location_isFromMainFile>('clang_Location_isFromMainFile'))( + location, + ); + } + + _dart_clang_Location_isFromMainFile? _clang_Location_isFromMainFile; + + /// Retrieve a NULL (invalid) source range. + CXSourceRange clang_getNullRange() { + return (_clang_getNullRange ??= + _dylib.lookupFunction<_c_clang_getNullRange, _dart_clang_getNullRange>( + 'clang_getNullRange'))(); + } + + _dart_clang_getNullRange? _clang_getNullRange; + + /// Retrieve a source range given the beginning and ending source locations. + CXSourceRange clang_getRange( + CXSourceLocation begin, + CXSourceLocation end, + ) { + return (_clang_getRange ??= + _dylib.lookupFunction<_c_clang_getRange, _dart_clang_getRange>( + 'clang_getRange'))( + begin, + end, + ); + } + + _dart_clang_getRange? _clang_getRange; + + /// Determine whether two ranges are equivalent. + int clang_equalRanges( + CXSourceRange range1, + CXSourceRange range2, + ) { + return (_clang_equalRanges ??= + _dylib.lookupFunction<_c_clang_equalRanges, _dart_clang_equalRanges>( + 'clang_equalRanges'))( + range1, + range2, + ); + } + + _dart_clang_equalRanges? _clang_equalRanges; + + /// Returns non-zero if range is null. + int clang_Range_isNull( + CXSourceRange range, + ) { + return (_clang_Range_isNull ??= + _dylib.lookupFunction<_c_clang_Range_isNull, _dart_clang_Range_isNull>( + 'clang_Range_isNull'))( + range, + ); + } + + _dart_clang_Range_isNull? _clang_Range_isNull; + + /// Retrieve the file, line, column, and offset represented by the given + /// source location. + void clang_getExpansionLocation( + CXSourceLocation location, + ffi.Pointer<ffi.Pointer<ffi.Void>> file, + ffi.Pointer<ffi.Uint32> line, + ffi.Pointer<ffi.Uint32> column, + ffi.Pointer<ffi.Uint32> offset, + ) { + return (_clang_getExpansionLocation ??= _dylib.lookupFunction< + _c_clang_getExpansionLocation, + _dart_clang_getExpansionLocation>('clang_getExpansionLocation'))( + location, + file, + line, + column, + offset, + ); + } + + _dart_clang_getExpansionLocation? _clang_getExpansionLocation; + + /// 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.Uint32> line, + ffi.Pointer<ffi.Uint32> column, + ) { + return (_clang_getPresumedLocation ??= _dylib.lookupFunction< + _c_clang_getPresumedLocation, + _dart_clang_getPresumedLocation>('clang_getPresumedLocation'))( + location, + filename, + line, + column, + ); + } + + _dart_clang_getPresumedLocation? _clang_getPresumedLocation; + + /// Legacy API to retrieve the file, line, column, and offset represented by + /// the given source location. + void clang_getInstantiationLocation( + CXSourceLocation location, + ffi.Pointer<ffi.Pointer<ffi.Void>> file, + ffi.Pointer<ffi.Uint32> line, + ffi.Pointer<ffi.Uint32> column, + ffi.Pointer<ffi.Uint32> offset, + ) { + return (_clang_getInstantiationLocation ??= _dylib.lookupFunction< + _c_clang_getInstantiationLocation, + _dart_clang_getInstantiationLocation>( + 'clang_getInstantiationLocation'))( + location, + file, + line, + column, + offset, + ); + } + + _dart_clang_getInstantiationLocation? _clang_getInstantiationLocation; + + /// Retrieve the file, line, column, and offset represented by the given + /// source location. + void clang_getSpellingLocation( + CXSourceLocation location, + ffi.Pointer<ffi.Pointer<ffi.Void>> file, + ffi.Pointer<ffi.Uint32> line, + ffi.Pointer<ffi.Uint32> column, + ffi.Pointer<ffi.Uint32> offset, + ) { + return (_clang_getSpellingLocation ??= _dylib.lookupFunction< + _c_clang_getSpellingLocation, + _dart_clang_getSpellingLocation>('clang_getSpellingLocation'))( + location, + file, + line, + column, + offset, + ); + } + + _dart_clang_getSpellingLocation? _clang_getSpellingLocation; + + /// Retrieve the file, line, column, and offset represented by the given + /// source location. + void clang_getFileLocation( + CXSourceLocation location, + ffi.Pointer<ffi.Pointer<ffi.Void>> file, + ffi.Pointer<ffi.Uint32> line, + ffi.Pointer<ffi.Uint32> column, + ffi.Pointer<ffi.Uint32> offset, + ) { + return (_clang_getFileLocation ??= _dylib.lookupFunction< + _c_clang_getFileLocation, + _dart_clang_getFileLocation>('clang_getFileLocation'))( + location, + file, + line, + column, + offset, + ); + } + + _dart_clang_getFileLocation? _clang_getFileLocation; + + /// Retrieve a source location representing the first character within a + /// source range. + CXSourceLocation clang_getRangeStart( + CXSourceRange range, + ) { + return (_clang_getRangeStart ??= _dylib.lookupFunction< + _c_clang_getRangeStart, + _dart_clang_getRangeStart>('clang_getRangeStart'))( + range, + ); + } + + _dart_clang_getRangeStart? _clang_getRangeStart; + + /// Retrieve a source location representing the last character within a source + /// range. + CXSourceLocation clang_getRangeEnd( + CXSourceRange range, + ) { + return (_clang_getRangeEnd ??= + _dylib.lookupFunction<_c_clang_getRangeEnd, _dart_clang_getRangeEnd>( + 'clang_getRangeEnd'))( + range, + ); + } + + _dart_clang_getRangeEnd? _clang_getRangeEnd; + /// Retrieve all ranges that were skipped by the preprocessor. ffi.Pointer<CXSourceRangeList> clang_getSkippedRanges( ffi.Pointer<CXTranslationUnitImpl> tu, @@ -559,6 +891,21 @@ _dart_clang_disposeDiagnostic? _clang_disposeDiagnostic; + /// Format the given diagnostic in a manner that is suitable for display. + CXString clang_formatDiagnostic( + ffi.Pointer<ffi.Void> Diagnostic, + int Options, + ) { + return (_clang_formatDiagnostic ??= _dylib.lookupFunction< + _c_clang_formatDiagnostic, + _dart_clang_formatDiagnostic>('clang_formatDiagnostic'))( + Diagnostic, + Options, + ); + } + + _dart_clang_formatDiagnostic? _clang_formatDiagnostic; + /// Retrieve the set of display options most similar to the default behavior /// of the clang compiler. int clang_defaultDiagnosticDisplayOptions() { @@ -584,6 +931,47 @@ _dart_clang_getDiagnosticSeverity? _clang_getDiagnosticSeverity; + /// Retrieve the source location of the given diagnostic. + CXSourceLocation clang_getDiagnosticLocation( + ffi.Pointer<ffi.Void> arg0, + ) { + return (_clang_getDiagnosticLocation ??= _dylib.lookupFunction< + _c_clang_getDiagnosticLocation, + _dart_clang_getDiagnosticLocation>('clang_getDiagnosticLocation'))( + arg0, + ); + } + + _dart_clang_getDiagnosticLocation? _clang_getDiagnosticLocation; + + /// Retrieve the text of the given diagnostic. + CXString clang_getDiagnosticSpelling( + ffi.Pointer<ffi.Void> arg0, + ) { + return (_clang_getDiagnosticSpelling ??= _dylib.lookupFunction< + _c_clang_getDiagnosticSpelling, + _dart_clang_getDiagnosticSpelling>('clang_getDiagnosticSpelling'))( + arg0, + ); + } + + _dart_clang_getDiagnosticSpelling? _clang_getDiagnosticSpelling; + + /// Retrieve the name of the command-line option that enabled this diagnostic. + CXString clang_getDiagnosticOption( + ffi.Pointer<ffi.Void> Diag, + ffi.Pointer<CXString> Disable, + ) { + return (_clang_getDiagnosticOption ??= _dylib.lookupFunction< + _c_clang_getDiagnosticOption, + _dart_clang_getDiagnosticOption>('clang_getDiagnosticOption'))( + Diag, + Disable, + ); + } + + _dart_clang_getDiagnosticOption? _clang_getDiagnosticOption; + /// Retrieve the category number for this diagnostic. int clang_getDiagnosticCategory( ffi.Pointer<ffi.Void> arg0, @@ -597,6 +985,35 @@ _dart_clang_getDiagnosticCategory? _clang_getDiagnosticCategory; + /// Retrieve the name of a particular diagnostic category. This is now + /// deprecated. Use clang_getDiagnosticCategoryText() instead. + CXString clang_getDiagnosticCategoryName( + int Category, + ) { + return (_clang_getDiagnosticCategoryName ??= _dylib.lookupFunction< + _c_clang_getDiagnosticCategoryName, + _dart_clang_getDiagnosticCategoryName>( + 'clang_getDiagnosticCategoryName'))( + Category, + ); + } + + _dart_clang_getDiagnosticCategoryName? _clang_getDiagnosticCategoryName; + + /// Retrieve the diagnostic category text for a given diagnostic. + CXString clang_getDiagnosticCategoryText( + ffi.Pointer<ffi.Void> arg0, + ) { + return (_clang_getDiagnosticCategoryText ??= _dylib.lookupFunction< + _c_clang_getDiagnosticCategoryText, + _dart_clang_getDiagnosticCategoryText>( + 'clang_getDiagnosticCategoryText'))( + arg0, + ); + } + + _dart_clang_getDiagnosticCategoryText? _clang_getDiagnosticCategoryText; + /// Determine the number of source ranges associated with the given /// diagnostic. int clang_getDiagnosticNumRanges( @@ -611,6 +1028,21 @@ _dart_clang_getDiagnosticNumRanges? _clang_getDiagnosticNumRanges; + /// Retrieve a source range associated with the diagnostic. + CXSourceRange clang_getDiagnosticRange( + ffi.Pointer<ffi.Void> Diagnostic, + int Range, + ) { + return (_clang_getDiagnosticRange ??= _dylib.lookupFunction< + _c_clang_getDiagnosticRange, + _dart_clang_getDiagnosticRange>('clang_getDiagnosticRange'))( + Diagnostic, + Range, + ); + } + + _dart_clang_getDiagnosticRange? _clang_getDiagnosticRange; + /// Determine the number of fix-it hints associated with the given diagnostic. int clang_getDiagnosticNumFixIts( ffi.Pointer<ffi.Void> Diagnostic, @@ -624,6 +1056,37 @@ _dart_clang_getDiagnosticNumFixIts? _clang_getDiagnosticNumFixIts; + /// Retrieve the replacement information for a given fix-it. + CXString clang_getDiagnosticFixIt( + ffi.Pointer<ffi.Void> Diagnostic, + int FixIt, + ffi.Pointer<CXSourceRange> ReplacementRange, + ) { + return (_clang_getDiagnosticFixIt ??= _dylib.lookupFunction< + _c_clang_getDiagnosticFixIt, + _dart_clang_getDiagnosticFixIt>('clang_getDiagnosticFixIt'))( + Diagnostic, + FixIt, + ReplacementRange, + ); + } + + _dart_clang_getDiagnosticFixIt? _clang_getDiagnosticFixIt; + + /// Get the original translation unit source file name. + CXString clang_getTranslationUnitSpelling( + ffi.Pointer<CXTranslationUnitImpl> CTUnit, + ) { + return (_clang_getTranslationUnitSpelling ??= _dylib.lookupFunction< + _c_clang_getTranslationUnitSpelling, + _dart_clang_getTranslationUnitSpelling>( + 'clang_getTranslationUnitSpelling'))( + CTUnit, + ); + } + + _dart_clang_getTranslationUnitSpelling? _clang_getTranslationUnitSpelling; + /// Return the CXTranslationUnit for a given source file and the provided /// command line arguments one would pass to the compiler. ffi.Pointer<CXTranslationUnitImpl> clang_createTranslationUnitFromSourceFile( @@ -886,6 +1349,33 @@ _dart_clang_getTUResourceUsageName? _clang_getTUResourceUsageName; + /// Return the memory usage of a translation unit. This object should be + /// released with clang_disposeCXTUResourceUsage(). + CXTUResourceUsage clang_getCXTUResourceUsage( + ffi.Pointer<CXTranslationUnitImpl> TU, + ) { + return (_clang_getCXTUResourceUsage ??= _dylib.lookupFunction< + _c_clang_getCXTUResourceUsage, + _dart_clang_getCXTUResourceUsage>('clang_getCXTUResourceUsage'))( + TU, + ); + } + + _dart_clang_getCXTUResourceUsage? _clang_getCXTUResourceUsage; + + void clang_disposeCXTUResourceUsage( + CXTUResourceUsage usage, + ) { + return (_clang_disposeCXTUResourceUsage ??= _dylib.lookupFunction< + _c_clang_disposeCXTUResourceUsage, + _dart_clang_disposeCXTUResourceUsage>( + 'clang_disposeCXTUResourceUsage'))( + usage, + ); + } + + _dart_clang_disposeCXTUResourceUsage? _clang_disposeCXTUResourceUsage; + /// Get target information for this translation unit. ffi.Pointer<CXTargetInfoImpl> clang_getTranslationUnitTargetInfo( ffi.Pointer<CXTranslationUnitImpl> CTUnit, @@ -913,6 +1403,19 @@ _dart_clang_TargetInfo_dispose? _clang_TargetInfo_dispose; + /// Get the normalized target triple as a string. + CXString clang_TargetInfo_getTriple( + ffi.Pointer<CXTargetInfoImpl> Info, + ) { + return (_clang_TargetInfo_getTriple ??= _dylib.lookupFunction< + _c_clang_TargetInfo_getTriple, + _dart_clang_TargetInfo_getTriple>('clang_TargetInfo_getTriple'))( + Info, + ); + } + + _dart_clang_TargetInfo_getTriple? _clang_TargetInfo_getTriple; + /// Get the pointer width of the target in bits. int clang_TargetInfo_getPointerWidth( ffi.Pointer<CXTargetInfoImpl> Info, @@ -927,6 +1430,83 @@ _dart_clang_TargetInfo_getPointerWidth? _clang_TargetInfo_getPointerWidth; + /// Retrieve the NULL cursor, which represents no entity. + CXCursor clang_getNullCursor() { + return (_clang_getNullCursor ??= _dylib.lookupFunction< + _c_clang_getNullCursor, + _dart_clang_getNullCursor>('clang_getNullCursor'))(); + } + + _dart_clang_getNullCursor? _clang_getNullCursor; + + /// Retrieve the cursor that represents the given translation unit. + CXCursor clang_getTranslationUnitCursor( + ffi.Pointer<CXTranslationUnitImpl> arg0, + ) { + return (_clang_getTranslationUnitCursor ??= _dylib.lookupFunction< + _c_clang_getTranslationUnitCursor, + _dart_clang_getTranslationUnitCursor>( + 'clang_getTranslationUnitCursor'))( + arg0, + ); + } + + _dart_clang_getTranslationUnitCursor? _clang_getTranslationUnitCursor; + + /// Determine whether two cursors are equivalent. + int clang_equalCursors( + CXCursor arg0, + CXCursor arg1, + ) { + return (_clang_equalCursors ??= + _dylib.lookupFunction<_c_clang_equalCursors, _dart_clang_equalCursors>( + 'clang_equalCursors'))( + arg0, + arg1, + ); + } + + _dart_clang_equalCursors? _clang_equalCursors; + + /// Returns non-zero if cursor is null. + int clang_Cursor_isNull( + CXCursor cursor, + ) { + return (_clang_Cursor_isNull ??= _dylib.lookupFunction< + _c_clang_Cursor_isNull, + _dart_clang_Cursor_isNull>('clang_Cursor_isNull'))( + cursor, + ); + } + + _dart_clang_Cursor_isNull? _clang_Cursor_isNull; + + /// Compute a hash value for the given cursor. + int clang_hashCursor( + CXCursor arg0, + ) { + return (_clang_hashCursor ??= + _dylib.lookupFunction<_c_clang_hashCursor, _dart_clang_hashCursor>( + 'clang_hashCursor'))( + arg0, + ); + } + + _dart_clang_hashCursor? _clang_hashCursor; + + /// Retrieve the kind of the given cursor. + int clang_getCursorKind( + CXCursor arg0, + ) { + return (_clang_getCursorKind ??= _dylib.lookupFunction< + _c_clang_getCursorKind, + _dart_clang_getCursorKind>('clang_getCursorKind'))( + arg0, + ); + } + + _dart_clang_getCursorKind? _clang_getCursorKind; + /// Determine whether the given cursor kind represents a declaration. int clang_isDeclaration( int arg0, @@ -940,6 +1520,19 @@ _dart_clang_isDeclaration? _clang_isDeclaration; + /// Determine whether the given declaration is invalid. + int clang_isInvalidDeclaration( + CXCursor arg0, + ) { + return (_clang_isInvalidDeclaration ??= _dylib.lookupFunction< + _c_clang_isInvalidDeclaration, + _dart_clang_isInvalidDeclaration>('clang_isInvalidDeclaration'))( + arg0, + ); + } + + _dart_clang_isInvalidDeclaration? _clang_isInvalidDeclaration; + /// Determine whether the given cursor kind represents a simple reference. int clang_isReference( int arg0, @@ -992,6 +1585,19 @@ _dart_clang_isAttribute? _clang_isAttribute; + /// Determine whether the given cursor has any attributes. + int clang_Cursor_hasAttrs( + CXCursor C, + ) { + return (_clang_Cursor_hasAttrs ??= _dylib.lookupFunction< + _c_clang_Cursor_hasAttrs, + _dart_clang_Cursor_hasAttrs>('clang_Cursor_hasAttrs'))( + C, + ); + } + + _dart_clang_Cursor_hasAttrs? _clang_Cursor_hasAttrs; + /// Determine whether the given cursor kind represents an invalid cursor. int clang_isInvalid( int arg0, @@ -1046,6 +1652,74 @@ _dart_clang_isUnexposed? _clang_isUnexposed; + /// Determine the linkage of the entity referred to by a given cursor. + int clang_getCursorLinkage( + CXCursor cursor, + ) { + return (_clang_getCursorLinkage ??= _dylib.lookupFunction< + _c_clang_getCursorLinkage, + _dart_clang_getCursorLinkage>('clang_getCursorLinkage'))( + cursor, + ); + } + + _dart_clang_getCursorLinkage? _clang_getCursorLinkage; + + /// Describe the visibility of the entity referred to by a cursor. + int clang_getCursorVisibility( + CXCursor cursor, + ) { + return (_clang_getCursorVisibility ??= _dylib.lookupFunction< + _c_clang_getCursorVisibility, + _dart_clang_getCursorVisibility>('clang_getCursorVisibility'))( + cursor, + ); + } + + _dart_clang_getCursorVisibility? _clang_getCursorVisibility; + + /// 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 ??= _dylib.lookupFunction< + _c_clang_getCursorAvailability, + _dart_clang_getCursorAvailability>('clang_getCursorAvailability'))( + cursor, + ); + } + + _dart_clang_getCursorAvailability? _clang_getCursorAvailability; + + /// 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.Int32> always_deprecated, + ffi.Pointer<CXString> deprecated_message, + ffi.Pointer<ffi.Int32> always_unavailable, + ffi.Pointer<CXString> unavailable_message, + ffi.Pointer<CXPlatformAvailability> availability, + int availability_size, + ) { + return (_clang_getCursorPlatformAvailability ??= _dylib.lookupFunction< + _c_clang_getCursorPlatformAvailability, + _dart_clang_getCursorPlatformAvailability>( + 'clang_getCursorPlatformAvailability'))( + cursor, + always_deprecated, + deprecated_message, + always_unavailable, + unavailable_message, + availability, + availability_size, + ); + } + + _dart_clang_getCursorPlatformAvailability? + _clang_getCursorPlatformAvailability; + /// Free the memory associated with a CXPlatformAvailability structure. void clang_disposeCXPlatformAvailability( ffi.Pointer<CXPlatformAvailability> availability, @@ -1061,6 +1735,47 @@ _dart_clang_disposeCXPlatformAvailability? _clang_disposeCXPlatformAvailability; + /// Determine the "language" of the entity referred to by a given cursor. + int clang_getCursorLanguage( + CXCursor cursor, + ) { + return (_clang_getCursorLanguage ??= _dylib.lookupFunction< + _c_clang_getCursorLanguage, + _dart_clang_getCursorLanguage>('clang_getCursorLanguage'))( + cursor, + ); + } + + _dart_clang_getCursorLanguage? _clang_getCursorLanguage; + + /// Determine the "thread-local storage (TLS) kind" of the declaration + /// referred to by a cursor. + int clang_getCursorTLSKind( + CXCursor cursor, + ) { + return (_clang_getCursorTLSKind ??= _dylib.lookupFunction< + _c_clang_getCursorTLSKind, + _dart_clang_getCursorTLSKind>('clang_getCursorTLSKind'))( + cursor, + ); + } + + _dart_clang_getCursorTLSKind? _clang_getCursorTLSKind; + + /// Returns the translation unit that a cursor originated from. + ffi.Pointer<CXTranslationUnitImpl> clang_Cursor_getTranslationUnit( + CXCursor arg0, + ) { + return (_clang_Cursor_getTranslationUnit ??= _dylib.lookupFunction< + _c_clang_Cursor_getTranslationUnit, + _dart_clang_Cursor_getTranslationUnit>( + 'clang_Cursor_getTranslationUnit'))( + arg0, + ); + } + + _dart_clang_Cursor_getTranslationUnit? _clang_Cursor_getTranslationUnit; + /// Creates an empty CXCursorSet. ffi.Pointer<CXCursorSetImpl> clang_createCXCursorSet() { return (_clang_createCXCursorSet ??= _dylib.lookupFunction< @@ -1083,6 +1798,79 @@ _dart_clang_disposeCXCursorSet? _clang_disposeCXCursorSet; + /// Queries a CXCursorSet to see if it contains a specific CXCursor. + int clang_CXCursorSet_contains( + ffi.Pointer<CXCursorSetImpl> cset, + CXCursor cursor, + ) { + return (_clang_CXCursorSet_contains ??= _dylib.lookupFunction< + _c_clang_CXCursorSet_contains, + _dart_clang_CXCursorSet_contains>('clang_CXCursorSet_contains'))( + cset, + cursor, + ); + } + + _dart_clang_CXCursorSet_contains? _clang_CXCursorSet_contains; + + /// Inserts a CXCursor into a CXCursorSet. + int clang_CXCursorSet_insert( + ffi.Pointer<CXCursorSetImpl> cset, + CXCursor cursor, + ) { + return (_clang_CXCursorSet_insert ??= _dylib.lookupFunction< + _c_clang_CXCursorSet_insert, + _dart_clang_CXCursorSet_insert>('clang_CXCursorSet_insert'))( + cset, + cursor, + ); + } + + _dart_clang_CXCursorSet_insert? _clang_CXCursorSet_insert; + + /// Determine the semantic parent of the given cursor. + CXCursor clang_getCursorSemanticParent( + CXCursor cursor, + ) { + return (_clang_getCursorSemanticParent ??= _dylib.lookupFunction< + _c_clang_getCursorSemanticParent, + _dart_clang_getCursorSemanticParent>('clang_getCursorSemanticParent'))( + cursor, + ); + } + + _dart_clang_getCursorSemanticParent? _clang_getCursorSemanticParent; + + /// Determine the lexical parent of the given cursor. + CXCursor clang_getCursorLexicalParent( + CXCursor cursor, + ) { + return (_clang_getCursorLexicalParent ??= _dylib.lookupFunction< + _c_clang_getCursorLexicalParent, + _dart_clang_getCursorLexicalParent>('clang_getCursorLexicalParent'))( + cursor, + ); + } + + _dart_clang_getCursorLexicalParent? _clang_getCursorLexicalParent; + + /// 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.Uint32> num_overridden, + ) { + return (_clang_getOverriddenCursors ??= _dylib.lookupFunction< + _c_clang_getOverriddenCursors, + _dart_clang_getOverriddenCursors>('clang_getOverriddenCursors'))( + cursor, + overridden, + num_overridden, + ); + } + + _dart_clang_getOverriddenCursors? _clang_getOverriddenCursors; + /// Free the set of overridden cursors returned by /// clang_getOverriddenCursors(). void clang_disposeOverriddenCursors( @@ -1098,6 +1886,1204 @@ _dart_clang_disposeOverriddenCursors? _clang_disposeOverriddenCursors; + /// Retrieve the file that is included by the given inclusion directive + /// cursor. + ffi.Pointer<ffi.Void> clang_getIncludedFile( + CXCursor cursor, + ) { + return (_clang_getIncludedFile ??= _dylib.lookupFunction< + _c_clang_getIncludedFile, + _dart_clang_getIncludedFile>('clang_getIncludedFile'))( + cursor, + ); + } + + _dart_clang_getIncludedFile? _clang_getIncludedFile; + + /// Map a source location to the cursor that describes the entity at that + /// location in the source code. + CXCursor clang_getCursor( + ffi.Pointer<CXTranslationUnitImpl> arg0, + CXSourceLocation arg1, + ) { + return (_clang_getCursor ??= + _dylib.lookupFunction<_c_clang_getCursor, _dart_clang_getCursor>( + 'clang_getCursor'))( + arg0, + arg1, + ); + } + + _dart_clang_getCursor? _clang_getCursor; + + /// Retrieve the physical location of the source constructor referenced by the + /// given cursor. + CXSourceLocation clang_getCursorLocation( + CXCursor arg0, + ) { + return (_clang_getCursorLocation ??= _dylib.lookupFunction< + _c_clang_getCursorLocation, + _dart_clang_getCursorLocation>('clang_getCursorLocation'))( + arg0, + ); + } + + _dart_clang_getCursorLocation? _clang_getCursorLocation; + + /// Retrieve the physical extent of the source construct referenced by the + /// given cursor. + CXSourceRange clang_getCursorExtent( + CXCursor arg0, + ) { + return (_clang_getCursorExtent ??= _dylib.lookupFunction< + _c_clang_getCursorExtent, + _dart_clang_getCursorExtent>('clang_getCursorExtent'))( + arg0, + ); + } + + _dart_clang_getCursorExtent? _clang_getCursorExtent; + + /// Retrieve the type of a CXCursor (if any). + CXType clang_getCursorType( + CXCursor C, + ) { + return (_clang_getCursorType ??= _dylib.lookupFunction< + _c_clang_getCursorType, + _dart_clang_getCursorType>('clang_getCursorType'))( + C, + ); + } + + _dart_clang_getCursorType? _clang_getCursorType; + + /// 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 ??= _dylib.lookupFunction< + _c_clang_getTypeSpelling, + _dart_clang_getTypeSpelling>('clang_getTypeSpelling'))( + CT, + ); + } + + _dart_clang_getTypeSpelling? _clang_getTypeSpelling; + + /// Retrieve the underlying type of a typedef declaration. + CXType clang_getTypedefDeclUnderlyingType( + CXCursor C, + ) { + return (_clang_getTypedefDeclUnderlyingType ??= _dylib.lookupFunction< + _c_clang_getTypedefDeclUnderlyingType, + _dart_clang_getTypedefDeclUnderlyingType>( + 'clang_getTypedefDeclUnderlyingType'))( + C, + ); + } + + _dart_clang_getTypedefDeclUnderlyingType? _clang_getTypedefDeclUnderlyingType; + + /// Retrieve the integer type of an enum declaration. + CXType clang_getEnumDeclIntegerType( + CXCursor C, + ) { + return (_clang_getEnumDeclIntegerType ??= _dylib.lookupFunction< + _c_clang_getEnumDeclIntegerType, + _dart_clang_getEnumDeclIntegerType>('clang_getEnumDeclIntegerType'))( + C, + ); + } + + _dart_clang_getEnumDeclIntegerType? _clang_getEnumDeclIntegerType; + + /// Retrieve the integer value of an enum constant declaration as a signed + /// long long. + int clang_getEnumConstantDeclValue( + CXCursor C, + ) { + return (_clang_getEnumConstantDeclValue ??= _dylib.lookupFunction< + _c_clang_getEnumConstantDeclValue, + _dart_clang_getEnumConstantDeclValue>( + 'clang_getEnumConstantDeclValue'))( + C, + ); + } + + _dart_clang_getEnumConstantDeclValue? _clang_getEnumConstantDeclValue; + + /// Retrieve the integer value of an enum constant declaration as an unsigned + /// long long. + int clang_getEnumConstantDeclUnsignedValue( + CXCursor C, + ) { + return (_clang_getEnumConstantDeclUnsignedValue ??= _dylib.lookupFunction< + _c_clang_getEnumConstantDeclUnsignedValue, + _dart_clang_getEnumConstantDeclUnsignedValue>( + 'clang_getEnumConstantDeclUnsignedValue'))( + C, + ); + } + + _dart_clang_getEnumConstantDeclUnsignedValue? + _clang_getEnumConstantDeclUnsignedValue; + + /// Retrieve the bit width of a bit field declaration as an integer. + int clang_getFieldDeclBitWidth( + CXCursor C, + ) { + return (_clang_getFieldDeclBitWidth ??= _dylib.lookupFunction< + _c_clang_getFieldDeclBitWidth, + _dart_clang_getFieldDeclBitWidth>('clang_getFieldDeclBitWidth'))( + C, + ); + } + + _dart_clang_getFieldDeclBitWidth? _clang_getFieldDeclBitWidth; + + /// Retrieve the number of non-variadic arguments associated with a given + /// cursor. + int clang_Cursor_getNumArguments( + CXCursor C, + ) { + return (_clang_Cursor_getNumArguments ??= _dylib.lookupFunction< + _c_clang_Cursor_getNumArguments, + _dart_clang_Cursor_getNumArguments>('clang_Cursor_getNumArguments'))( + C, + ); + } + + _dart_clang_Cursor_getNumArguments? _clang_Cursor_getNumArguments; + + /// Retrieve the argument cursor of a function or method. + CXCursor clang_Cursor_getArgument( + CXCursor C, + int i, + ) { + return (_clang_Cursor_getArgument ??= _dylib.lookupFunction< + _c_clang_Cursor_getArgument, + _dart_clang_Cursor_getArgument>('clang_Cursor_getArgument'))( + C, + i, + ); + } + + _dart_clang_Cursor_getArgument? _clang_Cursor_getArgument; + + /// Returns the number of template args of a function decl representing a + /// template specialization. + int clang_Cursor_getNumTemplateArguments( + CXCursor C, + ) { + return (_clang_Cursor_getNumTemplateArguments ??= _dylib.lookupFunction< + _c_clang_Cursor_getNumTemplateArguments, + _dart_clang_Cursor_getNumTemplateArguments>( + 'clang_Cursor_getNumTemplateArguments'))( + C, + ); + } + + _dart_clang_Cursor_getNumTemplateArguments? + _clang_Cursor_getNumTemplateArguments; + + /// 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 ??= _dylib.lookupFunction< + _c_clang_Cursor_getTemplateArgumentKind, + _dart_clang_Cursor_getTemplateArgumentKind>( + 'clang_Cursor_getTemplateArgumentKind'))( + C, + I, + ); + } + + _dart_clang_Cursor_getTemplateArgumentKind? + _clang_Cursor_getTemplateArgumentKind; + + /// 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 ??= _dylib.lookupFunction< + _c_clang_Cursor_getTemplateArgumentType, + _dart_clang_Cursor_getTemplateArgumentType>( + 'clang_Cursor_getTemplateArgumentType'))( + C, + I, + ); + } + + _dart_clang_Cursor_getTemplateArgumentType? + _clang_Cursor_getTemplateArgumentType; + + /// 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 ??= _dylib.lookupFunction< + _c_clang_Cursor_getTemplateArgumentValue, + _dart_clang_Cursor_getTemplateArgumentValue>( + 'clang_Cursor_getTemplateArgumentValue'))( + C, + I, + ); + } + + _dart_clang_Cursor_getTemplateArgumentValue? + _clang_Cursor_getTemplateArgumentValue; + + /// 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 ??= + _dylib.lookupFunction<_c_clang_Cursor_getTemplateArgumentUnsignedValue, + _dart_clang_Cursor_getTemplateArgumentUnsignedValue>( + 'clang_Cursor_getTemplateArgumentUnsignedValue'))( + C, + I, + ); + } + + _dart_clang_Cursor_getTemplateArgumentUnsignedValue? + _clang_Cursor_getTemplateArgumentUnsignedValue; + + /// Determine whether two CXTypes represent the same type. + int clang_equalTypes( + CXType A, + CXType B, + ) { + return (_clang_equalTypes ??= + _dylib.lookupFunction<_c_clang_equalTypes, _dart_clang_equalTypes>( + 'clang_equalTypes'))( + A, + B, + ); + } + + _dart_clang_equalTypes? _clang_equalTypes; + + /// Return the canonical type for a CXType. + CXType clang_getCanonicalType( + CXType T, + ) { + return (_clang_getCanonicalType ??= _dylib.lookupFunction< + _c_clang_getCanonicalType, + _dart_clang_getCanonicalType>('clang_getCanonicalType'))( + T, + ); + } + + _dart_clang_getCanonicalType? _clang_getCanonicalType; + + /// 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 ??= _dylib.lookupFunction< + _c_clang_isConstQualifiedType, + _dart_clang_isConstQualifiedType>('clang_isConstQualifiedType'))( + T, + ); + } + + _dart_clang_isConstQualifiedType? _clang_isConstQualifiedType; + + /// Determine whether a CXCursor that is a macro, is function like. + int clang_Cursor_isMacroFunctionLike( + CXCursor C, + ) { + return (_clang_Cursor_isMacroFunctionLike ??= _dylib.lookupFunction< + _c_clang_Cursor_isMacroFunctionLike, + _dart_clang_Cursor_isMacroFunctionLike>( + 'clang_Cursor_isMacroFunctionLike'))( + C, + ); + } + + _dart_clang_Cursor_isMacroFunctionLike? _clang_Cursor_isMacroFunctionLike; + + /// Determine whether a CXCursor that is a macro, is a builtin one. + int clang_Cursor_isMacroBuiltin( + CXCursor C, + ) { + return (_clang_Cursor_isMacroBuiltin ??= _dylib.lookupFunction< + _c_clang_Cursor_isMacroBuiltin, + _dart_clang_Cursor_isMacroBuiltin>('clang_Cursor_isMacroBuiltin'))( + C, + ); + } + + _dart_clang_Cursor_isMacroBuiltin? _clang_Cursor_isMacroBuiltin; + + /// Determine whether a CXCursor that is a function declaration, is an inline + /// declaration. + int clang_Cursor_isFunctionInlined( + CXCursor C, + ) { + return (_clang_Cursor_isFunctionInlined ??= _dylib.lookupFunction< + _c_clang_Cursor_isFunctionInlined, + _dart_clang_Cursor_isFunctionInlined>( + 'clang_Cursor_isFunctionInlined'))( + C, + ); + } + + _dart_clang_Cursor_isFunctionInlined? _clang_Cursor_isFunctionInlined; + + /// 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 ??= _dylib.lookupFunction< + _c_clang_isVolatileQualifiedType, + _dart_clang_isVolatileQualifiedType>('clang_isVolatileQualifiedType'))( + T, + ); + } + + _dart_clang_isVolatileQualifiedType? _clang_isVolatileQualifiedType; + + /// 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 ??= _dylib.lookupFunction< + _c_clang_isRestrictQualifiedType, + _dart_clang_isRestrictQualifiedType>('clang_isRestrictQualifiedType'))( + T, + ); + } + + _dart_clang_isRestrictQualifiedType? _clang_isRestrictQualifiedType; + + /// Returns the address space of the given type. + int clang_getAddressSpace( + CXType T, + ) { + return (_clang_getAddressSpace ??= _dylib.lookupFunction< + _c_clang_getAddressSpace, + _dart_clang_getAddressSpace>('clang_getAddressSpace'))( + T, + ); + } + + _dart_clang_getAddressSpace? _clang_getAddressSpace; + + /// Returns the typedef name of the given type. + CXString clang_getTypedefName( + CXType CT, + ) { + return (_clang_getTypedefName ??= _dylib.lookupFunction< + _c_clang_getTypedefName, + _dart_clang_getTypedefName>('clang_getTypedefName'))( + CT, + ); + } + + _dart_clang_getTypedefName? _clang_getTypedefName; + + /// For pointer types, returns the type of the pointee. + CXType clang_getPointeeType( + CXType T, + ) { + return (_clang_getPointeeType ??= _dylib.lookupFunction< + _c_clang_getPointeeType, + _dart_clang_getPointeeType>('clang_getPointeeType'))( + T, + ); + } + + _dart_clang_getPointeeType? _clang_getPointeeType; + + /// Return the cursor for the declaration of the given type. + CXCursor clang_getTypeDeclaration( + CXType T, + ) { + return (_clang_getTypeDeclaration ??= _dylib.lookupFunction< + _c_clang_getTypeDeclaration, + _dart_clang_getTypeDeclaration>('clang_getTypeDeclaration'))( + T, + ); + } + + _dart_clang_getTypeDeclaration? _clang_getTypeDeclaration; + + /// Returns the Objective-C type encoding for the specified declaration. + CXString clang_getDeclObjCTypeEncoding( + CXCursor C, + ) { + return (_clang_getDeclObjCTypeEncoding ??= _dylib.lookupFunction< + _c_clang_getDeclObjCTypeEncoding, + _dart_clang_getDeclObjCTypeEncoding>('clang_getDeclObjCTypeEncoding'))( + C, + ); + } + + _dart_clang_getDeclObjCTypeEncoding? _clang_getDeclObjCTypeEncoding; + + /// Returns the Objective-C type encoding for the specified CXType. + CXString clang_Type_getObjCEncoding( + CXType type, + ) { + return (_clang_Type_getObjCEncoding ??= _dylib.lookupFunction< + _c_clang_Type_getObjCEncoding, + _dart_clang_Type_getObjCEncoding>('clang_Type_getObjCEncoding'))( + type, + ); + } + + _dart_clang_Type_getObjCEncoding? _clang_Type_getObjCEncoding; + + /// Retrieve the spelling of a given CXTypeKind. + CXString clang_getTypeKindSpelling( + int K, + ) { + return (_clang_getTypeKindSpelling ??= _dylib.lookupFunction< + _c_clang_getTypeKindSpelling, + _dart_clang_getTypeKindSpelling>('clang_getTypeKindSpelling'))( + K, + ); + } + + _dart_clang_getTypeKindSpelling? _clang_getTypeKindSpelling; + + /// Retrieve the calling convention associated with a function type. + int clang_getFunctionTypeCallingConv( + CXType T, + ) { + return (_clang_getFunctionTypeCallingConv ??= _dylib.lookupFunction< + _c_clang_getFunctionTypeCallingConv, + _dart_clang_getFunctionTypeCallingConv>( + 'clang_getFunctionTypeCallingConv'))( + T, + ); + } + + _dart_clang_getFunctionTypeCallingConv? _clang_getFunctionTypeCallingConv; + + /// Retrieve the return type associated with a function type. + CXType clang_getResultType( + CXType T, + ) { + return (_clang_getResultType ??= _dylib.lookupFunction< + _c_clang_getResultType, + _dart_clang_getResultType>('clang_getResultType'))( + T, + ); + } + + _dart_clang_getResultType? _clang_getResultType; + + /// 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 ??= _dylib.lookupFunction< + _c_clang_getExceptionSpecificationType, + _dart_clang_getExceptionSpecificationType>( + 'clang_getExceptionSpecificationType'))( + T, + ); + } + + _dart_clang_getExceptionSpecificationType? + _clang_getExceptionSpecificationType; + + /// Retrieve the number of non-variadic parameters associated with a function + /// type. + int clang_getNumArgTypes( + CXType T, + ) { + return (_clang_getNumArgTypes ??= _dylib.lookupFunction< + _c_clang_getNumArgTypes, + _dart_clang_getNumArgTypes>('clang_getNumArgTypes'))( + T, + ); + } + + _dart_clang_getNumArgTypes? _clang_getNumArgTypes; + + /// Retrieve the type of a parameter of a function type. + CXType clang_getArgType( + CXType T, + int i, + ) { + return (_clang_getArgType ??= + _dylib.lookupFunction<_c_clang_getArgType, _dart_clang_getArgType>( + 'clang_getArgType'))( + T, + i, + ); + } + + _dart_clang_getArgType? _clang_getArgType; + + /// Retrieves the base type of the ObjCObjectType. + CXType clang_Type_getObjCObjectBaseType( + CXType T, + ) { + return (_clang_Type_getObjCObjectBaseType ??= _dylib.lookupFunction< + _c_clang_Type_getObjCObjectBaseType, + _dart_clang_Type_getObjCObjectBaseType>( + 'clang_Type_getObjCObjectBaseType'))( + T, + ); + } + + _dart_clang_Type_getObjCObjectBaseType? _clang_Type_getObjCObjectBaseType; + + /// Retrieve the number of protocol references associated with an ObjC + /// object/id. + int clang_Type_getNumObjCProtocolRefs( + CXType T, + ) { + return (_clang_Type_getNumObjCProtocolRefs ??= _dylib.lookupFunction< + _c_clang_Type_getNumObjCProtocolRefs, + _dart_clang_Type_getNumObjCProtocolRefs>( + 'clang_Type_getNumObjCProtocolRefs'))( + T, + ); + } + + _dart_clang_Type_getNumObjCProtocolRefs? _clang_Type_getNumObjCProtocolRefs; + + /// Retrieve the decl for a protocol reference for an ObjC object/id. + CXCursor clang_Type_getObjCProtocolDecl( + CXType T, + int i, + ) { + return (_clang_Type_getObjCProtocolDecl ??= _dylib.lookupFunction< + _c_clang_Type_getObjCProtocolDecl, + _dart_clang_Type_getObjCProtocolDecl>( + 'clang_Type_getObjCProtocolDecl'))( + T, + i, + ); + } + + _dart_clang_Type_getObjCProtocolDecl? _clang_Type_getObjCProtocolDecl; + + /// Retreive the number of type arguments associated with an ObjC object. + int clang_Type_getNumObjCTypeArgs( + CXType T, + ) { + return (_clang_Type_getNumObjCTypeArgs ??= _dylib.lookupFunction< + _c_clang_Type_getNumObjCTypeArgs, + _dart_clang_Type_getNumObjCTypeArgs>('clang_Type_getNumObjCTypeArgs'))( + T, + ); + } + + _dart_clang_Type_getNumObjCTypeArgs? _clang_Type_getNumObjCTypeArgs; + + /// Retrieve a type argument associated with an ObjC object. + CXType clang_Type_getObjCTypeArg( + CXType T, + int i, + ) { + return (_clang_Type_getObjCTypeArg ??= _dylib.lookupFunction< + _c_clang_Type_getObjCTypeArg, + _dart_clang_Type_getObjCTypeArg>('clang_Type_getObjCTypeArg'))( + T, + i, + ); + } + + _dart_clang_Type_getObjCTypeArg? _clang_Type_getObjCTypeArg; + + /// Return 1 if the CXType is a variadic function type, and 0 otherwise. + int clang_isFunctionTypeVariadic( + CXType T, + ) { + return (_clang_isFunctionTypeVariadic ??= _dylib.lookupFunction< + _c_clang_isFunctionTypeVariadic, + _dart_clang_isFunctionTypeVariadic>('clang_isFunctionTypeVariadic'))( + T, + ); + } + + _dart_clang_isFunctionTypeVariadic? _clang_isFunctionTypeVariadic; + + /// Retrieve the return type associated with a given cursor. + CXType clang_getCursorResultType( + CXCursor C, + ) { + return (_clang_getCursorResultType ??= _dylib.lookupFunction< + _c_clang_getCursorResultType, + _dart_clang_getCursorResultType>('clang_getCursorResultType'))( + C, + ); + } + + _dart_clang_getCursorResultType? _clang_getCursorResultType; + + /// 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 ??= + _dylib.lookupFunction<_c_clang_getCursorExceptionSpecificationType, + _dart_clang_getCursorExceptionSpecificationType>( + 'clang_getCursorExceptionSpecificationType'))( + C, + ); + } + + _dart_clang_getCursorExceptionSpecificationType? + _clang_getCursorExceptionSpecificationType; + + /// Return 1 if the CXType is a POD (plain old data) type, and 0 otherwise. + int clang_isPODType( + CXType T, + ) { + return (_clang_isPODType ??= + _dylib.lookupFunction<_c_clang_isPODType, _dart_clang_isPODType>( + 'clang_isPODType'))( + T, + ); + } + + _dart_clang_isPODType? _clang_isPODType; + + /// Return the element type of an array, complex, or vector type. + CXType clang_getElementType( + CXType T, + ) { + return (_clang_getElementType ??= _dylib.lookupFunction< + _c_clang_getElementType, + _dart_clang_getElementType>('clang_getElementType'))( + T, + ); + } + + _dart_clang_getElementType? _clang_getElementType; + + /// Return the number of elements of an array or vector type. + int clang_getNumElements( + CXType T, + ) { + return (_clang_getNumElements ??= _dylib.lookupFunction< + _c_clang_getNumElements, + _dart_clang_getNumElements>('clang_getNumElements'))( + T, + ); + } + + _dart_clang_getNumElements? _clang_getNumElements; + + /// Return the element type of an array type. + CXType clang_getArrayElementType( + CXType T, + ) { + return (_clang_getArrayElementType ??= _dylib.lookupFunction< + _c_clang_getArrayElementType, + _dart_clang_getArrayElementType>('clang_getArrayElementType'))( + T, + ); + } + + _dart_clang_getArrayElementType? _clang_getArrayElementType; + + /// Return the array size of a constant array. + int clang_getArraySize( + CXType T, + ) { + return (_clang_getArraySize ??= + _dylib.lookupFunction<_c_clang_getArraySize, _dart_clang_getArraySize>( + 'clang_getArraySize'))( + T, + ); + } + + _dart_clang_getArraySize? _clang_getArraySize; + + /// Retrieve the type named by the qualified-id. + CXType clang_Type_getNamedType( + CXType T, + ) { + return (_clang_Type_getNamedType ??= _dylib.lookupFunction< + _c_clang_Type_getNamedType, + _dart_clang_Type_getNamedType>('clang_Type_getNamedType'))( + T, + ); + } + + _dart_clang_Type_getNamedType? _clang_Type_getNamedType; + + /// Determine if a typedef is 'transparent' tag. + int clang_Type_isTransparentTagTypedef( + CXType T, + ) { + return (_clang_Type_isTransparentTagTypedef ??= _dylib.lookupFunction< + _c_clang_Type_isTransparentTagTypedef, + _dart_clang_Type_isTransparentTagTypedef>( + 'clang_Type_isTransparentTagTypedef'))( + T, + ); + } + + _dart_clang_Type_isTransparentTagTypedef? _clang_Type_isTransparentTagTypedef; + + /// Retrieve the nullability kind of a pointer type. + int clang_Type_getNullability( + CXType T, + ) { + return (_clang_Type_getNullability ??= _dylib.lookupFunction< + _c_clang_Type_getNullability, + _dart_clang_Type_getNullability>('clang_Type_getNullability'))( + T, + ); + } + + _dart_clang_Type_getNullability? _clang_Type_getNullability; + + /// Return the alignment of a type in bytes as per C++[expr.alignof] standard. + int clang_Type_getAlignOf( + CXType T, + ) { + return (_clang_Type_getAlignOf ??= _dylib.lookupFunction< + _c_clang_Type_getAlignOf, + _dart_clang_Type_getAlignOf>('clang_Type_getAlignOf'))( + T, + ); + } + + _dart_clang_Type_getAlignOf? _clang_Type_getAlignOf; + + /// Return the class type of an member pointer type. + CXType clang_Type_getClassType( + CXType T, + ) { + return (_clang_Type_getClassType ??= _dylib.lookupFunction< + _c_clang_Type_getClassType, + _dart_clang_Type_getClassType>('clang_Type_getClassType'))( + T, + ); + } + + _dart_clang_Type_getClassType? _clang_Type_getClassType; + + /// Return the size of a type in bytes as per C++[expr.sizeof] standard. + int clang_Type_getSizeOf( + CXType T, + ) { + return (_clang_Type_getSizeOf ??= _dylib.lookupFunction< + _c_clang_Type_getSizeOf, + _dart_clang_Type_getSizeOf>('clang_Type_getSizeOf'))( + T, + ); + } + + _dart_clang_Type_getSizeOf? _clang_Type_getSizeOf; + + /// 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.Int8> S, + ) { + return (_clang_Type_getOffsetOf ??= _dylib.lookupFunction< + _c_clang_Type_getOffsetOf, + _dart_clang_Type_getOffsetOf>('clang_Type_getOffsetOf'))( + T, + S, + ); + } + + _dart_clang_Type_getOffsetOf? _clang_Type_getOffsetOf; + + /// Return the type that was modified by this attributed type. + CXType clang_Type_getModifiedType( + CXType T, + ) { + return (_clang_Type_getModifiedType ??= _dylib.lookupFunction< + _c_clang_Type_getModifiedType, + _dart_clang_Type_getModifiedType>('clang_Type_getModifiedType'))( + T, + ); + } + + _dart_clang_Type_getModifiedType? _clang_Type_getModifiedType; + + /// Return the offset of the field represented by the Cursor. + int clang_Cursor_getOffsetOfField( + CXCursor C, + ) { + return (_clang_Cursor_getOffsetOfField ??= _dylib.lookupFunction< + _c_clang_Cursor_getOffsetOfField, + _dart_clang_Cursor_getOffsetOfField>('clang_Cursor_getOffsetOfField'))( + C, + ); + } + + _dart_clang_Cursor_getOffsetOfField? _clang_Cursor_getOffsetOfField; + + /// Determine whether the given cursor represents an anonymous tag or + /// namespace + int clang_Cursor_isAnonymous( + CXCursor C, + ) { + return (_clang_Cursor_isAnonymous ??= _dylib.lookupFunction< + _c_clang_Cursor_isAnonymous, + _dart_clang_Cursor_isAnonymous>('clang_Cursor_isAnonymous'))( + C, + ); + } + + _dart_clang_Cursor_isAnonymous? _clang_Cursor_isAnonymous; + + /// Determine whether the given cursor represents an anonymous record + /// declaration. + int clang_Cursor_isAnonymousRecordDecl( + CXCursor C, + ) { + return (_clang_Cursor_isAnonymousRecordDecl ??= _dylib.lookupFunction< + _c_clang_Cursor_isAnonymousRecordDecl, + _dart_clang_Cursor_isAnonymousRecordDecl>( + 'clang_Cursor_isAnonymousRecordDecl'))( + C, + ); + } + + _dart_clang_Cursor_isAnonymousRecordDecl? _clang_Cursor_isAnonymousRecordDecl; + + /// Determine whether the given cursor represents an inline namespace + /// declaration. + int clang_Cursor_isInlineNamespace( + CXCursor C, + ) { + return (_clang_Cursor_isInlineNamespace ??= _dylib.lookupFunction< + _c_clang_Cursor_isInlineNamespace, + _dart_clang_Cursor_isInlineNamespace>( + 'clang_Cursor_isInlineNamespace'))( + C, + ); + } + + _dart_clang_Cursor_isInlineNamespace? _clang_Cursor_isInlineNamespace; + + /// Returns the number of template arguments for given template + /// specialization, or -1 if type T is not a template specialization. + int clang_Type_getNumTemplateArguments( + CXType T, + ) { + return (_clang_Type_getNumTemplateArguments ??= _dylib.lookupFunction< + _c_clang_Type_getNumTemplateArguments, + _dart_clang_Type_getNumTemplateArguments>( + 'clang_Type_getNumTemplateArguments'))( + T, + ); + } + + _dart_clang_Type_getNumTemplateArguments? _clang_Type_getNumTemplateArguments; + + /// Returns the type template argument of a template class specialization at + /// given index. + CXType clang_Type_getTemplateArgumentAsType( + CXType T, + int i, + ) { + return (_clang_Type_getTemplateArgumentAsType ??= _dylib.lookupFunction< + _c_clang_Type_getTemplateArgumentAsType, + _dart_clang_Type_getTemplateArgumentAsType>( + 'clang_Type_getTemplateArgumentAsType'))( + T, + i, + ); + } + + _dart_clang_Type_getTemplateArgumentAsType? + _clang_Type_getTemplateArgumentAsType; + + /// Retrieve the ref-qualifier kind of a function or method. + int clang_Type_getCXXRefQualifier( + CXType T, + ) { + return (_clang_Type_getCXXRefQualifier ??= _dylib.lookupFunction< + _c_clang_Type_getCXXRefQualifier, + _dart_clang_Type_getCXXRefQualifier>('clang_Type_getCXXRefQualifier'))( + T, + ); + } + + _dart_clang_Type_getCXXRefQualifier? _clang_Type_getCXXRefQualifier; + + /// Returns non-zero if the cursor specifies a Record member that is a + /// bitfield. + int clang_Cursor_isBitField( + CXCursor C, + ) { + return (_clang_Cursor_isBitField ??= _dylib.lookupFunction< + _c_clang_Cursor_isBitField, + _dart_clang_Cursor_isBitField>('clang_Cursor_isBitField'))( + C, + ); + } + + _dart_clang_Cursor_isBitField? _clang_Cursor_isBitField; + + /// Returns 1 if the base class specified by the cursor with kind + /// CX_CXXBaseSpecifier is virtual. + int clang_isVirtualBase( + CXCursor arg0, + ) { + return (_clang_isVirtualBase ??= _dylib.lookupFunction< + _c_clang_isVirtualBase, + _dart_clang_isVirtualBase>('clang_isVirtualBase'))( + arg0, + ); + } + + _dart_clang_isVirtualBase? _clang_isVirtualBase; + + /// Returns the access control level for the referenced object. + int clang_getCXXAccessSpecifier( + CXCursor arg0, + ) { + return (_clang_getCXXAccessSpecifier ??= _dylib.lookupFunction< + _c_clang_getCXXAccessSpecifier, + _dart_clang_getCXXAccessSpecifier>('clang_getCXXAccessSpecifier'))( + arg0, + ); + } + + _dart_clang_getCXXAccessSpecifier? _clang_getCXXAccessSpecifier; + + /// Returns the storage class for a function or variable declaration. + int clang_Cursor_getStorageClass( + CXCursor arg0, + ) { + return (_clang_Cursor_getStorageClass ??= _dylib.lookupFunction< + _c_clang_Cursor_getStorageClass, + _dart_clang_Cursor_getStorageClass>('clang_Cursor_getStorageClass'))( + arg0, + ); + } + + _dart_clang_Cursor_getStorageClass? _clang_Cursor_getStorageClass; + + /// Determine the number of overloaded declarations referenced by a + /// CXCursor_OverloadedDeclRef cursor. + int clang_getNumOverloadedDecls( + CXCursor cursor, + ) { + return (_clang_getNumOverloadedDecls ??= _dylib.lookupFunction< + _c_clang_getNumOverloadedDecls, + _dart_clang_getNumOverloadedDecls>('clang_getNumOverloadedDecls'))( + cursor, + ); + } + + _dart_clang_getNumOverloadedDecls? _clang_getNumOverloadedDecls; + + /// Retrieve a cursor for one of the overloaded declarations referenced by a + /// CXCursor_OverloadedDeclRef cursor. + CXCursor clang_getOverloadedDecl( + CXCursor cursor, + int index, + ) { + return (_clang_getOverloadedDecl ??= _dylib.lookupFunction< + _c_clang_getOverloadedDecl, + _dart_clang_getOverloadedDecl>('clang_getOverloadedDecl'))( + cursor, + index, + ); + } + + _dart_clang_getOverloadedDecl? _clang_getOverloadedDecl; + + /// For cursors representing an iboutletcollection attribute, this function + /// returns the collection element type. + CXType clang_getIBOutletCollectionType( + CXCursor arg0, + ) { + return (_clang_getIBOutletCollectionType ??= _dylib.lookupFunction< + _c_clang_getIBOutletCollectionType, + _dart_clang_getIBOutletCollectionType>( + 'clang_getIBOutletCollectionType'))( + arg0, + ); + } + + _dart_clang_getIBOutletCollectionType? _clang_getIBOutletCollectionType; + + /// Visit the children of a particular cursor. + int clang_visitChildren( + CXCursor parent, + ffi.Pointer<ffi.NativeFunction<CXCursorVisitor>> visitor, + ffi.Pointer<ffi.Void> client_data, + ) { + return (_clang_visitChildren ??= _dylib.lookupFunction< + _c_clang_visitChildren, + _dart_clang_visitChildren>('clang_visitChildren'))( + parent, + visitor, + client_data, + ); + } + + _dart_clang_visitChildren? _clang_visitChildren; + + /// Retrieve a Unified Symbol Resolution (USR) for the entity referenced by + /// the given cursor. + CXString clang_getCursorUSR( + CXCursor arg0, + ) { + return (_clang_getCursorUSR ??= + _dylib.lookupFunction<_c_clang_getCursorUSR, _dart_clang_getCursorUSR>( + 'clang_getCursorUSR'))( + arg0, + ); + } + + _dart_clang_getCursorUSR? _clang_getCursorUSR; + + /// Construct a USR for a specified Objective-C class. + CXString clang_constructUSR_ObjCClass( + ffi.Pointer<ffi.Int8> class_name, + ) { + return (_clang_constructUSR_ObjCClass ??= _dylib.lookupFunction< + _c_clang_constructUSR_ObjCClass, + _dart_clang_constructUSR_ObjCClass>('clang_constructUSR_ObjCClass'))( + class_name, + ); + } + + _dart_clang_constructUSR_ObjCClass? _clang_constructUSR_ObjCClass; + + /// Construct a USR for a specified Objective-C category. + CXString clang_constructUSR_ObjCCategory( + ffi.Pointer<ffi.Int8> class_name, + ffi.Pointer<ffi.Int8> category_name, + ) { + return (_clang_constructUSR_ObjCCategory ??= _dylib.lookupFunction< + _c_clang_constructUSR_ObjCCategory, + _dart_clang_constructUSR_ObjCCategory>( + 'clang_constructUSR_ObjCCategory'))( + class_name, + category_name, + ); + } + + _dart_clang_constructUSR_ObjCCategory? _clang_constructUSR_ObjCCategory; + + /// Construct a USR for a specified Objective-C protocol. + CXString clang_constructUSR_ObjCProtocol( + ffi.Pointer<ffi.Int8> protocol_name, + ) { + return (_clang_constructUSR_ObjCProtocol ??= _dylib.lookupFunction< + _c_clang_constructUSR_ObjCProtocol, + _dart_clang_constructUSR_ObjCProtocol>( + 'clang_constructUSR_ObjCProtocol'))( + protocol_name, + ); + } + + _dart_clang_constructUSR_ObjCProtocol? _clang_constructUSR_ObjCProtocol; + + /// Construct a USR for a specified Objective-C instance variable and the USR + /// for its containing class. + CXString clang_constructUSR_ObjCIvar( + ffi.Pointer<ffi.Int8> name, + CXString classUSR, + ) { + return (_clang_constructUSR_ObjCIvar ??= _dylib.lookupFunction< + _c_clang_constructUSR_ObjCIvar, + _dart_clang_constructUSR_ObjCIvar>('clang_constructUSR_ObjCIvar'))( + name, + classUSR, + ); + } + + _dart_clang_constructUSR_ObjCIvar? _clang_constructUSR_ObjCIvar; + + /// Construct a USR for a specified Objective-C method and the USR for its + /// containing class. + CXString clang_constructUSR_ObjCMethod( + ffi.Pointer<ffi.Int8> name, + int isInstanceMethod, + CXString classUSR, + ) { + return (_clang_constructUSR_ObjCMethod ??= _dylib.lookupFunction< + _c_clang_constructUSR_ObjCMethod, + _dart_clang_constructUSR_ObjCMethod>('clang_constructUSR_ObjCMethod'))( + name, + isInstanceMethod, + classUSR, + ); + } + + _dart_clang_constructUSR_ObjCMethod? _clang_constructUSR_ObjCMethod; + + /// Construct a USR for a specified Objective-C property and the USR for its + /// containing class. + CXString clang_constructUSR_ObjCProperty( + ffi.Pointer<ffi.Int8> property, + CXString classUSR, + ) { + return (_clang_constructUSR_ObjCProperty ??= _dylib.lookupFunction< + _c_clang_constructUSR_ObjCProperty, + _dart_clang_constructUSR_ObjCProperty>( + 'clang_constructUSR_ObjCProperty'))( + property, + classUSR, + ); + } + + _dart_clang_constructUSR_ObjCProperty? _clang_constructUSR_ObjCProperty; + + /// Retrieve a name for the entity referenced by this cursor. + CXString clang_getCursorSpelling( + CXCursor arg0, + ) { + return (_clang_getCursorSpelling ??= _dylib.lookupFunction< + _c_clang_getCursorSpelling, + _dart_clang_getCursorSpelling>('clang_getCursorSpelling'))( + arg0, + ); + } + + _dart_clang_getCursorSpelling? _clang_getCursorSpelling; + + /// Retrieve a range for a piece that forms the cursors spelling name. Most of + /// the times there is only one range for the complete spelling but for + /// Objective-C methods and Objective-C message expressions, there are + /// multiple pieces for each selector identifier. + CXSourceRange clang_Cursor_getSpellingNameRange( + CXCursor arg0, + int pieceIndex, + int options, + ) { + return (_clang_Cursor_getSpellingNameRange ??= _dylib.lookupFunction< + _c_clang_Cursor_getSpellingNameRange, + _dart_clang_Cursor_getSpellingNameRange>( + 'clang_Cursor_getSpellingNameRange'))( + arg0, + pieceIndex, + options, + ); + } + + _dart_clang_Cursor_getSpellingNameRange? _clang_Cursor_getSpellingNameRange; + /// Get a property value for the given printing policy. int clang_PrintingPolicy_getProperty( ffi.Pointer<ffi.Void> Policy, @@ -1132,6 +3118,19 @@ _dart_clang_PrintingPolicy_setProperty? _clang_PrintingPolicy_setProperty; + /// Retrieve the default policy for the cursor. + ffi.Pointer<ffi.Void> clang_getCursorPrintingPolicy( + CXCursor arg0, + ) { + return (_clang_getCursorPrintingPolicy ??= _dylib.lookupFunction< + _c_clang_getCursorPrintingPolicy, + _dart_clang_getCursorPrintingPolicy>('clang_getCursorPrintingPolicy'))( + arg0, + ); + } + + _dart_clang_getCursorPrintingPolicy? _clang_getCursorPrintingPolicy; + /// Release a printing policy. void clang_PrintingPolicy_dispose( ffi.Pointer<ffi.Void> Policy, @@ -1145,6 +3144,348 @@ _dart_clang_PrintingPolicy_dispose? _clang_PrintingPolicy_dispose; + /// Pretty print declarations. + CXString clang_getCursorPrettyPrinted( + CXCursor Cursor, + ffi.Pointer<ffi.Void> Policy, + ) { + return (_clang_getCursorPrettyPrinted ??= _dylib.lookupFunction< + _c_clang_getCursorPrettyPrinted, + _dart_clang_getCursorPrettyPrinted>('clang_getCursorPrettyPrinted'))( + Cursor, + Policy, + ); + } + + _dart_clang_getCursorPrettyPrinted? _clang_getCursorPrettyPrinted; + + /// Retrieve the display name for the entity referenced by this cursor. + CXString clang_getCursorDisplayName( + CXCursor arg0, + ) { + return (_clang_getCursorDisplayName ??= _dylib.lookupFunction< + _c_clang_getCursorDisplayName, + _dart_clang_getCursorDisplayName>('clang_getCursorDisplayName'))( + arg0, + ); + } + + _dart_clang_getCursorDisplayName? _clang_getCursorDisplayName; + + /// For a cursor that is a reference, retrieve a cursor representing the + /// entity that it references. + CXCursor clang_getCursorReferenced( + CXCursor arg0, + ) { + return (_clang_getCursorReferenced ??= _dylib.lookupFunction< + _c_clang_getCursorReferenced, + _dart_clang_getCursorReferenced>('clang_getCursorReferenced'))( + arg0, + ); + } + + _dart_clang_getCursorReferenced? _clang_getCursorReferenced; + + /// For a cursor that is either a reference to or a declaration of some + /// entity, retrieve a cursor that describes the definition of that entity. + CXCursor clang_getCursorDefinition( + CXCursor arg0, + ) { + return (_clang_getCursorDefinition ??= _dylib.lookupFunction< + _c_clang_getCursorDefinition, + _dart_clang_getCursorDefinition>('clang_getCursorDefinition'))( + arg0, + ); + } + + _dart_clang_getCursorDefinition? _clang_getCursorDefinition; + + /// Determine whether the declaration pointed to by this cursor is also a + /// definition of that entity. + int clang_isCursorDefinition( + CXCursor arg0, + ) { + return (_clang_isCursorDefinition ??= _dylib.lookupFunction< + _c_clang_isCursorDefinition, + _dart_clang_isCursorDefinition>('clang_isCursorDefinition'))( + arg0, + ); + } + + _dart_clang_isCursorDefinition? _clang_isCursorDefinition; + + /// Retrieve the canonical cursor corresponding to the given cursor. + CXCursor clang_getCanonicalCursor( + CXCursor arg0, + ) { + return (_clang_getCanonicalCursor ??= _dylib.lookupFunction< + _c_clang_getCanonicalCursor, + _dart_clang_getCanonicalCursor>('clang_getCanonicalCursor'))( + arg0, + ); + } + + _dart_clang_getCanonicalCursor? _clang_getCanonicalCursor; + + /// If the cursor points to a selector identifier in an Objective-C method or + /// message expression, this returns the selector index. + int clang_Cursor_getObjCSelectorIndex( + CXCursor arg0, + ) { + return (_clang_Cursor_getObjCSelectorIndex ??= _dylib.lookupFunction< + _c_clang_Cursor_getObjCSelectorIndex, + _dart_clang_Cursor_getObjCSelectorIndex>( + 'clang_Cursor_getObjCSelectorIndex'))( + arg0, + ); + } + + _dart_clang_Cursor_getObjCSelectorIndex? _clang_Cursor_getObjCSelectorIndex; + + /// Given a cursor pointing to a C++ method call or an Objective-C message, + /// returns non-zero if the method/message is "dynamic", meaning: + int clang_Cursor_isDynamicCall( + CXCursor C, + ) { + return (_clang_Cursor_isDynamicCall ??= _dylib.lookupFunction< + _c_clang_Cursor_isDynamicCall, + _dart_clang_Cursor_isDynamicCall>('clang_Cursor_isDynamicCall'))( + C, + ); + } + + _dart_clang_Cursor_isDynamicCall? _clang_Cursor_isDynamicCall; + + /// Given a cursor pointing to an Objective-C message or property reference, + /// or C++ method call, returns the CXType of the receiver. + CXType clang_Cursor_getReceiverType( + CXCursor C, + ) { + return (_clang_Cursor_getReceiverType ??= _dylib.lookupFunction< + _c_clang_Cursor_getReceiverType, + _dart_clang_Cursor_getReceiverType>('clang_Cursor_getReceiverType'))( + C, + ); + } + + _dart_clang_Cursor_getReceiverType? _clang_Cursor_getReceiverType; + + /// Given a cursor that represents a property declaration, return the + /// associated property attributes. The bits are formed from + /// CXObjCPropertyAttrKind. + int clang_Cursor_getObjCPropertyAttributes( + CXCursor C, + int reserved, + ) { + return (_clang_Cursor_getObjCPropertyAttributes ??= _dylib.lookupFunction< + _c_clang_Cursor_getObjCPropertyAttributes, + _dart_clang_Cursor_getObjCPropertyAttributes>( + 'clang_Cursor_getObjCPropertyAttributes'))( + C, + reserved, + ); + } + + _dart_clang_Cursor_getObjCPropertyAttributes? + _clang_Cursor_getObjCPropertyAttributes; + + /// Given a cursor that represents a property declaration, return the name of + /// the method that implements the getter. + CXString clang_Cursor_getObjCPropertyGetterName( + CXCursor C, + ) { + return (_clang_Cursor_getObjCPropertyGetterName ??= _dylib.lookupFunction< + _c_clang_Cursor_getObjCPropertyGetterName, + _dart_clang_Cursor_getObjCPropertyGetterName>( + 'clang_Cursor_getObjCPropertyGetterName'))( + C, + ); + } + + _dart_clang_Cursor_getObjCPropertyGetterName? + _clang_Cursor_getObjCPropertyGetterName; + + /// Given a cursor that represents a property declaration, return the name of + /// the method that implements the setter, if any. + CXString clang_Cursor_getObjCPropertySetterName( + CXCursor C, + ) { + return (_clang_Cursor_getObjCPropertySetterName ??= _dylib.lookupFunction< + _c_clang_Cursor_getObjCPropertySetterName, + _dart_clang_Cursor_getObjCPropertySetterName>( + 'clang_Cursor_getObjCPropertySetterName'))( + C, + ); + } + + _dart_clang_Cursor_getObjCPropertySetterName? + _clang_Cursor_getObjCPropertySetterName; + + /// Given a cursor that represents an Objective-C method or parameter + /// declaration, return the associated Objective-C qualifiers for the return + /// type or the parameter respectively. The bits are formed from + /// CXObjCDeclQualifierKind. + int clang_Cursor_getObjCDeclQualifiers( + CXCursor C, + ) { + return (_clang_Cursor_getObjCDeclQualifiers ??= _dylib.lookupFunction< + _c_clang_Cursor_getObjCDeclQualifiers, + _dart_clang_Cursor_getObjCDeclQualifiers>( + 'clang_Cursor_getObjCDeclQualifiers'))( + C, + ); + } + + _dart_clang_Cursor_getObjCDeclQualifiers? _clang_Cursor_getObjCDeclQualifiers; + + /// Given a cursor that represents an Objective-C method or property + /// declaration, return non-zero if the declaration was affected by + /// "@optional". Returns zero if the cursor is not such a declaration or it is + /// "@required". + int clang_Cursor_isObjCOptional( + CXCursor C, + ) { + return (_clang_Cursor_isObjCOptional ??= _dylib.lookupFunction< + _c_clang_Cursor_isObjCOptional, + _dart_clang_Cursor_isObjCOptional>('clang_Cursor_isObjCOptional'))( + C, + ); + } + + _dart_clang_Cursor_isObjCOptional? _clang_Cursor_isObjCOptional; + + /// Returns non-zero if the given cursor is a variadic function or method. + int clang_Cursor_isVariadic( + CXCursor C, + ) { + return (_clang_Cursor_isVariadic ??= _dylib.lookupFunction< + _c_clang_Cursor_isVariadic, + _dart_clang_Cursor_isVariadic>('clang_Cursor_isVariadic'))( + C, + ); + } + + _dart_clang_Cursor_isVariadic? _clang_Cursor_isVariadic; + + /// Returns non-zero if the given cursor points to a symbol marked with + /// external_source_symbol attribute. + int clang_Cursor_isExternalSymbol( + CXCursor C, + ffi.Pointer<CXString> language, + ffi.Pointer<CXString> definedIn, + ffi.Pointer<ffi.Uint32> isGenerated, + ) { + return (_clang_Cursor_isExternalSymbol ??= _dylib.lookupFunction< + _c_clang_Cursor_isExternalSymbol, + _dart_clang_Cursor_isExternalSymbol>('clang_Cursor_isExternalSymbol'))( + C, + language, + definedIn, + isGenerated, + ); + } + + _dart_clang_Cursor_isExternalSymbol? _clang_Cursor_isExternalSymbol; + + /// Given a cursor that represents a declaration, return the associated + /// comment's source range. The range may include multiple consecutive + /// comments with whitespace in between. + CXSourceRange clang_Cursor_getCommentRange( + CXCursor C, + ) { + return (_clang_Cursor_getCommentRange ??= _dylib.lookupFunction< + _c_clang_Cursor_getCommentRange, + _dart_clang_Cursor_getCommentRange>('clang_Cursor_getCommentRange'))( + C, + ); + } + + _dart_clang_Cursor_getCommentRange? _clang_Cursor_getCommentRange; + + /// Given a cursor that represents a declaration, return the associated + /// comment text, including comment markers. + CXString clang_Cursor_getRawCommentText( + CXCursor C, + ) { + return (_clang_Cursor_getRawCommentText ??= _dylib.lookupFunction< + _c_clang_Cursor_getRawCommentText, + _dart_clang_Cursor_getRawCommentText>( + 'clang_Cursor_getRawCommentText'))( + C, + ); + } + + _dart_clang_Cursor_getRawCommentText? _clang_Cursor_getRawCommentText; + + /// Given a cursor that represents a documentable entity (e.g., declaration), + /// return the associated first paragraph. + CXString clang_Cursor_getBriefCommentText( + CXCursor C, + ) { + return (_clang_Cursor_getBriefCommentText ??= _dylib.lookupFunction< + _c_clang_Cursor_getBriefCommentText, + _dart_clang_Cursor_getBriefCommentText>( + 'clang_Cursor_getBriefCommentText'))( + C, + ); + } + + _dart_clang_Cursor_getBriefCommentText? _clang_Cursor_getBriefCommentText; + + /// Retrieve the CXString representing the mangled name of the cursor. + CXString clang_Cursor_getMangling( + CXCursor arg0, + ) { + return (_clang_Cursor_getMangling ??= _dylib.lookupFunction< + _c_clang_Cursor_getMangling, + _dart_clang_Cursor_getMangling>('clang_Cursor_getMangling'))( + arg0, + ); + } + + _dart_clang_Cursor_getMangling? _clang_Cursor_getMangling; + + /// Retrieve the CXStrings representing the mangled symbols of the C++ + /// constructor or destructor at the cursor. + ffi.Pointer<CXStringSet> clang_Cursor_getCXXManglings( + CXCursor arg0, + ) { + return (_clang_Cursor_getCXXManglings ??= _dylib.lookupFunction< + _c_clang_Cursor_getCXXManglings, + _dart_clang_Cursor_getCXXManglings>('clang_Cursor_getCXXManglings'))( + arg0, + ); + } + + _dart_clang_Cursor_getCXXManglings? _clang_Cursor_getCXXManglings; + + /// Retrieve the CXStrings representing the mangled symbols of the ObjC class + /// interface or implementation at the cursor. + ffi.Pointer<CXStringSet> clang_Cursor_getObjCManglings( + CXCursor arg0, + ) { + return (_clang_Cursor_getObjCManglings ??= _dylib.lookupFunction< + _c_clang_Cursor_getObjCManglings, + _dart_clang_Cursor_getObjCManglings>('clang_Cursor_getObjCManglings'))( + arg0, + ); + } + + _dart_clang_Cursor_getObjCManglings? _clang_Cursor_getObjCManglings; + + /// Given a CXCursor_ModuleImportDecl cursor, return the associated module. + ffi.Pointer<ffi.Void> clang_Cursor_getModule( + CXCursor C, + ) { + return (_clang_Cursor_getModule ??= _dylib.lookupFunction< + _c_clang_Cursor_getModule, + _dart_clang_Cursor_getModule>('clang_Cursor_getModule'))( + C, + ); + } + + _dart_clang_Cursor_getModule? _clang_Cursor_getModule; + /// Given a CXFile header file, return the module that contains it, if one /// exists. ffi.Pointer<ffi.Void> clang_getModuleForFile( @@ -1188,6 +3529,33 @@ _dart_clang_Module_getParent? _clang_Module_getParent; + /// Returns the name of the module, e.g. for the 'std.vector' sub-module it + /// will return "vector". + CXString clang_Module_getName( + ffi.Pointer<ffi.Void> Module, + ) { + return (_clang_Module_getName ??= _dylib.lookupFunction< + _c_clang_Module_getName, + _dart_clang_Module_getName>('clang_Module_getName'))( + Module, + ); + } + + _dart_clang_Module_getName? _clang_Module_getName; + + /// Returns the full name of the module, e.g. "std.vector". + CXString clang_Module_getFullName( + ffi.Pointer<ffi.Void> Module, + ) { + return (_clang_Module_getFullName ??= _dylib.lookupFunction< + _c_clang_Module_getFullName, + _dart_clang_Module_getFullName>('clang_Module_getFullName'))( + Module, + ); + } + + _dart_clang_Module_getFullName? _clang_Module_getFullName; + /// Returns non-zero if the module is a system one. int clang_Module_isSystem( ffi.Pointer<ffi.Void> Module, @@ -1235,6 +3603,318 @@ _dart_clang_Module_getTopLevelHeader? _clang_Module_getTopLevelHeader; + /// Determine if a C++ constructor is a converting constructor. + int clang_CXXConstructor_isConvertingConstructor( + CXCursor C, + ) { + return (_clang_CXXConstructor_isConvertingConstructor ??= + _dylib.lookupFunction<_c_clang_CXXConstructor_isConvertingConstructor, + _dart_clang_CXXConstructor_isConvertingConstructor>( + 'clang_CXXConstructor_isConvertingConstructor'))( + C, + ); + } + + _dart_clang_CXXConstructor_isConvertingConstructor? + _clang_CXXConstructor_isConvertingConstructor; + + /// Determine if a C++ constructor is a copy constructor. + int clang_CXXConstructor_isCopyConstructor( + CXCursor C, + ) { + return (_clang_CXXConstructor_isCopyConstructor ??= _dylib.lookupFunction< + _c_clang_CXXConstructor_isCopyConstructor, + _dart_clang_CXXConstructor_isCopyConstructor>( + 'clang_CXXConstructor_isCopyConstructor'))( + C, + ); + } + + _dart_clang_CXXConstructor_isCopyConstructor? + _clang_CXXConstructor_isCopyConstructor; + + /// Determine if a C++ constructor is the default constructor. + int clang_CXXConstructor_isDefaultConstructor( + CXCursor C, + ) { + return (_clang_CXXConstructor_isDefaultConstructor ??= + _dylib.lookupFunction<_c_clang_CXXConstructor_isDefaultConstructor, + _dart_clang_CXXConstructor_isDefaultConstructor>( + 'clang_CXXConstructor_isDefaultConstructor'))( + C, + ); + } + + _dart_clang_CXXConstructor_isDefaultConstructor? + _clang_CXXConstructor_isDefaultConstructor; + + /// Determine if a C++ constructor is a move constructor. + int clang_CXXConstructor_isMoveConstructor( + CXCursor C, + ) { + return (_clang_CXXConstructor_isMoveConstructor ??= _dylib.lookupFunction< + _c_clang_CXXConstructor_isMoveConstructor, + _dart_clang_CXXConstructor_isMoveConstructor>( + 'clang_CXXConstructor_isMoveConstructor'))( + C, + ); + } + + _dart_clang_CXXConstructor_isMoveConstructor? + _clang_CXXConstructor_isMoveConstructor; + + /// Determine if a C++ field is declared 'mutable'. + int clang_CXXField_isMutable( + CXCursor C, + ) { + return (_clang_CXXField_isMutable ??= _dylib.lookupFunction< + _c_clang_CXXField_isMutable, + _dart_clang_CXXField_isMutable>('clang_CXXField_isMutable'))( + C, + ); + } + + _dart_clang_CXXField_isMutable? _clang_CXXField_isMutable; + + /// Determine if a C++ method is declared '= default'. + int clang_CXXMethod_isDefaulted( + CXCursor C, + ) { + return (_clang_CXXMethod_isDefaulted ??= _dylib.lookupFunction< + _c_clang_CXXMethod_isDefaulted, + _dart_clang_CXXMethod_isDefaulted>('clang_CXXMethod_isDefaulted'))( + C, + ); + } + + _dart_clang_CXXMethod_isDefaulted? _clang_CXXMethod_isDefaulted; + + /// Determine if a C++ member function or member function template is pure + /// virtual. + int clang_CXXMethod_isPureVirtual( + CXCursor C, + ) { + return (_clang_CXXMethod_isPureVirtual ??= _dylib.lookupFunction< + _c_clang_CXXMethod_isPureVirtual, + _dart_clang_CXXMethod_isPureVirtual>('clang_CXXMethod_isPureVirtual'))( + C, + ); + } + + _dart_clang_CXXMethod_isPureVirtual? _clang_CXXMethod_isPureVirtual; + + /// Determine if a C++ member function or member function template is declared + /// 'static'. + int clang_CXXMethod_isStatic( + CXCursor C, + ) { + return (_clang_CXXMethod_isStatic ??= _dylib.lookupFunction< + _c_clang_CXXMethod_isStatic, + _dart_clang_CXXMethod_isStatic>('clang_CXXMethod_isStatic'))( + C, + ); + } + + _dart_clang_CXXMethod_isStatic? _clang_CXXMethod_isStatic; + + /// Determine if a C++ member function or member function template is + /// explicitly declared 'virtual' or if it overrides a virtual method from one + /// of the base classes. + int clang_CXXMethod_isVirtual( + CXCursor C, + ) { + return (_clang_CXXMethod_isVirtual ??= _dylib.lookupFunction< + _c_clang_CXXMethod_isVirtual, + _dart_clang_CXXMethod_isVirtual>('clang_CXXMethod_isVirtual'))( + C, + ); + } + + _dart_clang_CXXMethod_isVirtual? _clang_CXXMethod_isVirtual; + + /// Determine if a C++ record is abstract, i.e. whether a class or struct has + /// a pure virtual member function. + int clang_CXXRecord_isAbstract( + CXCursor C, + ) { + return (_clang_CXXRecord_isAbstract ??= _dylib.lookupFunction< + _c_clang_CXXRecord_isAbstract, + _dart_clang_CXXRecord_isAbstract>('clang_CXXRecord_isAbstract'))( + C, + ); + } + + _dart_clang_CXXRecord_isAbstract? _clang_CXXRecord_isAbstract; + + /// Determine if an enum declaration refers to a scoped enum. + int clang_EnumDecl_isScoped( + CXCursor C, + ) { + return (_clang_EnumDecl_isScoped ??= _dylib.lookupFunction< + _c_clang_EnumDecl_isScoped, + _dart_clang_EnumDecl_isScoped>('clang_EnumDecl_isScoped'))( + C, + ); + } + + _dart_clang_EnumDecl_isScoped? _clang_EnumDecl_isScoped; + + /// Determine if a C++ member function or member function template is declared + /// 'const'. + int clang_CXXMethod_isConst( + CXCursor C, + ) { + return (_clang_CXXMethod_isConst ??= _dylib.lookupFunction< + _c_clang_CXXMethod_isConst, + _dart_clang_CXXMethod_isConst>('clang_CXXMethod_isConst'))( + C, + ); + } + + _dart_clang_CXXMethod_isConst? _clang_CXXMethod_isConst; + + /// Given a cursor that represents a template, determine the cursor kind of + /// the specializations would be generated by instantiating the template. + int clang_getTemplateCursorKind( + CXCursor C, + ) { + return (_clang_getTemplateCursorKind ??= _dylib.lookupFunction< + _c_clang_getTemplateCursorKind, + _dart_clang_getTemplateCursorKind>('clang_getTemplateCursorKind'))( + C, + ); + } + + _dart_clang_getTemplateCursorKind? _clang_getTemplateCursorKind; + + /// Given a cursor that may represent a specialization or instantiation of a + /// template, retrieve the cursor that represents the template that it + /// specializes or from which it was instantiated. + CXCursor clang_getSpecializedCursorTemplate( + CXCursor C, + ) { + return (_clang_getSpecializedCursorTemplate ??= _dylib.lookupFunction< + _c_clang_getSpecializedCursorTemplate, + _dart_clang_getSpecializedCursorTemplate>( + 'clang_getSpecializedCursorTemplate'))( + C, + ); + } + + _dart_clang_getSpecializedCursorTemplate? _clang_getSpecializedCursorTemplate; + + /// Given a cursor that references something else, return the source range + /// covering that reference. + CXSourceRange clang_getCursorReferenceNameRange( + CXCursor C, + int NameFlags, + int PieceIndex, + ) { + return (_clang_getCursorReferenceNameRange ??= _dylib.lookupFunction< + _c_clang_getCursorReferenceNameRange, + _dart_clang_getCursorReferenceNameRange>( + 'clang_getCursorReferenceNameRange'))( + C, + NameFlags, + PieceIndex, + ); + } + + _dart_clang_getCursorReferenceNameRange? _clang_getCursorReferenceNameRange; + + /// Get the raw lexical token starting with the given location. + ffi.Pointer<CXToken> clang_getToken( + ffi.Pointer<CXTranslationUnitImpl> TU, + CXSourceLocation Location, + ) { + return (_clang_getToken ??= + _dylib.lookupFunction<_c_clang_getToken, _dart_clang_getToken>( + 'clang_getToken'))( + TU, + Location, + ); + } + + _dart_clang_getToken? _clang_getToken; + + /// Determine the kind of the given token. + int clang_getTokenKind( + CXToken arg0, + ) { + return (_clang_getTokenKind ??= + _dylib.lookupFunction<_c_clang_getTokenKind, _dart_clang_getTokenKind>( + 'clang_getTokenKind'))( + arg0, + ); + } + + _dart_clang_getTokenKind? _clang_getTokenKind; + + /// Determine the spelling of the given token. + CXString clang_getTokenSpelling( + ffi.Pointer<CXTranslationUnitImpl> arg0, + CXToken arg1, + ) { + return (_clang_getTokenSpelling ??= _dylib.lookupFunction< + _c_clang_getTokenSpelling, + _dart_clang_getTokenSpelling>('clang_getTokenSpelling'))( + arg0, + arg1, + ); + } + + _dart_clang_getTokenSpelling? _clang_getTokenSpelling; + + /// Retrieve the source location of the given token. + CXSourceLocation clang_getTokenLocation( + ffi.Pointer<CXTranslationUnitImpl> arg0, + CXToken arg1, + ) { + return (_clang_getTokenLocation ??= _dylib.lookupFunction< + _c_clang_getTokenLocation, + _dart_clang_getTokenLocation>('clang_getTokenLocation'))( + arg0, + arg1, + ); + } + + _dart_clang_getTokenLocation? _clang_getTokenLocation; + + /// Retrieve a source range that covers the given token. + CXSourceRange clang_getTokenExtent( + ffi.Pointer<CXTranslationUnitImpl> arg0, + CXToken arg1, + ) { + return (_clang_getTokenExtent ??= _dylib.lookupFunction< + _c_clang_getTokenExtent, + _dart_clang_getTokenExtent>('clang_getTokenExtent'))( + arg0, + arg1, + ); + } + + _dart_clang_getTokenExtent? _clang_getTokenExtent; + + /// Tokenize the source code described by the given range into raw lexical + /// tokens. + void clang_tokenize( + ffi.Pointer<CXTranslationUnitImpl> TU, + CXSourceRange Range, + ffi.Pointer<ffi.Pointer<CXToken>> Tokens, + ffi.Pointer<ffi.Uint32> NumTokens, + ) { + return (_clang_tokenize ??= + _dylib.lookupFunction<_c_clang_tokenize, _dart_clang_tokenize>( + 'clang_tokenize'))( + TU, + Range, + Tokens, + NumTokens, + ); + } + + _dart_clang_tokenize? _clang_tokenize; + /// Annotate the given set of tokens by providing cursors for each token that /// can be mapped to a specific entity within the abstract syntax tree. void clang_annotateTokens( @@ -1272,6 +3952,46 @@ _dart_clang_disposeTokens? _clang_disposeTokens; + /// These routines are used for testing and debugging, only, and should not be + /// relied upon. + CXString clang_getCursorKindSpelling( + int Kind, + ) { + return (_clang_getCursorKindSpelling ??= _dylib.lookupFunction< + _c_clang_getCursorKindSpelling, + _dart_clang_getCursorKindSpelling>('clang_getCursorKindSpelling'))( + Kind, + ); + } + + _dart_clang_getCursorKindSpelling? _clang_getCursorKindSpelling; + + void clang_getDefinitionSpellingAndExtent( + CXCursor arg0, + ffi.Pointer<ffi.Pointer<ffi.Int8>> startBuf, + ffi.Pointer<ffi.Pointer<ffi.Int8>> endBuf, + ffi.Pointer<ffi.Uint32> startLine, + ffi.Pointer<ffi.Uint32> startColumn, + ffi.Pointer<ffi.Uint32> endLine, + ffi.Pointer<ffi.Uint32> endColumn, + ) { + return (_clang_getDefinitionSpellingAndExtent ??= _dylib.lookupFunction< + _c_clang_getDefinitionSpellingAndExtent, + _dart_clang_getDefinitionSpellingAndExtent>( + 'clang_getDefinitionSpellingAndExtent'))( + arg0, + startBuf, + endBuf, + startLine, + startColumn, + endLine, + endColumn, + ); + } + + _dart_clang_getDefinitionSpellingAndExtent? + _clang_getDefinitionSpellingAndExtent; + void clang_enableStackTraces() { return (_clang_enableStackTraces ??= _dylib.lookupFunction< _c_clang_enableStackTraces, @@ -1311,6 +4031,22 @@ _dart_clang_getCompletionChunkKind? _clang_getCompletionChunkKind; + /// Retrieve the text associated with a particular chunk within a completion + /// string. + CXString clang_getCompletionChunkText( + ffi.Pointer<ffi.Void> completion_string, + int chunk_number, + ) { + return (_clang_getCompletionChunkText ??= _dylib.lookupFunction< + _c_clang_getCompletionChunkText, + _dart_clang_getCompletionChunkText>('clang_getCompletionChunkText'))( + completion_string, + chunk_number, + ); + } + + _dart_clang_getCompletionChunkText? _clang_getCompletionChunkText; + /// Retrieve the completion string associated with a particular chunk within a /// completion string. ffi.Pointer<ffi.Void> clang_getCompletionChunkCompletionString( @@ -1385,6 +4121,66 @@ _dart_clang_getCompletionNumAnnotations? _clang_getCompletionNumAnnotations; + /// Retrieve the annotation associated with the given completion string. + CXString clang_getCompletionAnnotation( + ffi.Pointer<ffi.Void> completion_string, + int annotation_number, + ) { + return (_clang_getCompletionAnnotation ??= _dylib.lookupFunction< + _c_clang_getCompletionAnnotation, + _dart_clang_getCompletionAnnotation>('clang_getCompletionAnnotation'))( + completion_string, + annotation_number, + ); + } + + _dart_clang_getCompletionAnnotation? _clang_getCompletionAnnotation; + + /// Retrieve the parent context of the given completion string. + CXString clang_getCompletionParent( + ffi.Pointer<ffi.Void> completion_string, + ffi.Pointer<ffi.Int32> kind, + ) { + return (_clang_getCompletionParent ??= _dylib.lookupFunction< + _c_clang_getCompletionParent, + _dart_clang_getCompletionParent>('clang_getCompletionParent'))( + completion_string, + kind, + ); + } + + _dart_clang_getCompletionParent? _clang_getCompletionParent; + + /// Retrieve the brief documentation comment attached to the declaration that + /// corresponds to the given completion string. + CXString clang_getCompletionBriefComment( + ffi.Pointer<ffi.Void> completion_string, + ) { + return (_clang_getCompletionBriefComment ??= _dylib.lookupFunction< + _c_clang_getCompletionBriefComment, + _dart_clang_getCompletionBriefComment>( + 'clang_getCompletionBriefComment'))( + completion_string, + ); + } + + _dart_clang_getCompletionBriefComment? _clang_getCompletionBriefComment; + + /// Retrieve a completion string for an arbitrary declaration or macro + /// definition cursor. + ffi.Pointer<ffi.Void> clang_getCursorCompletionString( + CXCursor cursor, + ) { + return (_clang_getCursorCompletionString ??= _dylib.lookupFunction< + _c_clang_getCursorCompletionString, + _dart_clang_getCursorCompletionString>( + 'clang_getCursorCompletionString'))( + cursor, + ); + } + + _dart_clang_getCursorCompletionString? _clang_getCursorCompletionString; + /// Retrieve the number of fix-its for the given completion index. int clang_getCompletionNumFixIts( ffi.Pointer<CXCodeCompleteResults> results, @@ -1400,6 +4196,26 @@ _dart_clang_getCompletionNumFixIts? _clang_getCompletionNumFixIts; + /// Fix-its that *must* be applied before inserting the text for the + /// corresponding completion. + CXString clang_getCompletionFixIt( + ffi.Pointer<CXCodeCompleteResults> results, + int completion_index, + int fixit_index, + ffi.Pointer<CXSourceRange> replacement_range, + ) { + return (_clang_getCompletionFixIt ??= _dylib.lookupFunction< + _c_clang_getCompletionFixIt, + _dart_clang_getCompletionFixIt>('clang_getCompletionFixIt'))( + results, + completion_index, + fixit_index, + replacement_range, + ); + } + + _dart_clang_getCompletionFixIt? _clang_getCompletionFixIt; + /// Returns a default set of code-completion options that can be passed to /// clang_codeCompleteAt(). int clang_defaultCodeCompleteOptions() { @@ -1531,6 +4347,49 @@ _dart_clang_codeCompleteGetContainerKind? _clang_codeCompleteGetContainerKind; + /// Returns the USR for the container for the current code completion context. + /// If there is not a container for the current context, this function will + /// return the empty string. + CXString clang_codeCompleteGetContainerUSR( + ffi.Pointer<CXCodeCompleteResults> Results, + ) { + return (_clang_codeCompleteGetContainerUSR ??= _dylib.lookupFunction< + _c_clang_codeCompleteGetContainerUSR, + _dart_clang_codeCompleteGetContainerUSR>( + 'clang_codeCompleteGetContainerUSR'))( + Results, + ); + } + + _dart_clang_codeCompleteGetContainerUSR? _clang_codeCompleteGetContainerUSR; + + /// Returns the currently-entered selector for an Objective-C message send, + /// formatted like "initWithFoo:bar:". Only guaranteed to return a non-empty + /// string for CXCompletionContext_ObjCInstanceMessage and + /// CXCompletionContext_ObjCClassMessage. + CXString clang_codeCompleteGetObjCSelector( + ffi.Pointer<CXCodeCompleteResults> Results, + ) { + return (_clang_codeCompleteGetObjCSelector ??= _dylib.lookupFunction< + _c_clang_codeCompleteGetObjCSelector, + _dart_clang_codeCompleteGetObjCSelector>( + 'clang_codeCompleteGetObjCSelector'))( + Results, + ); + } + + _dart_clang_codeCompleteGetObjCSelector? _clang_codeCompleteGetObjCSelector; + + /// Return a version string, suitable for showing to a user, but not intended + /// to be parsed (the format is not guaranteed to be stable). + CXString clang_getClangVersion() { + return (_clang_getClangVersion ??= _dylib.lookupFunction< + _c_clang_getClangVersion, + _dart_clang_getClangVersion>('clang_getClangVersion'))(); + } + + _dart_clang_getClangVersion? _clang_getClangVersion; + /// Enable/disable crash recovery. void clang_toggleCrashRecovery( int isEnabled, @@ -1564,6 +4423,21 @@ _dart_clang_getInclusions? _clang_getInclusions; + /// If cursor is a statement declaration tries to evaluate the statement and + /// if its variable, tries to evaluate its initializer, into its corresponding + /// type. + ffi.Pointer<ffi.Void> clang_Cursor_Evaluate( + CXCursor C, + ) { + return (_clang_Cursor_Evaluate ??= _dylib.lookupFunction< + _c_clang_Cursor_Evaluate, + _dart_clang_Cursor_Evaluate>('clang_Cursor_Evaluate'))( + C, + ); + } + + _dart_clang_Cursor_Evaluate? _clang_Cursor_Evaluate; + /// Returns the kind of the evaluated result. int clang_EvalResult_getKind( ffi.Pointer<ffi.Void> E, @@ -1752,6 +4626,40 @@ _dart_clang_remap_dispose? _clang_remap_dispose; + /// Find references of a declaration in a specific file. + int clang_findReferencesInFile( + CXCursor cursor, + ffi.Pointer<ffi.Void> file, + CXCursorAndRangeVisitor visitor, + ) { + return (_clang_findReferencesInFile ??= _dylib.lookupFunction< + _c_clang_findReferencesInFile, + _dart_clang_findReferencesInFile>('clang_findReferencesInFile'))( + cursor, + file, + visitor, + ); + } + + _dart_clang_findReferencesInFile? _clang_findReferencesInFile; + + /// Find #import/#include directives in a specific file. + int clang_findIncludesInFile( + ffi.Pointer<CXTranslationUnitImpl> TU, + ffi.Pointer<ffi.Void> file, + CXCursorAndRangeVisitor visitor, + ) { + return (_clang_findIncludesInFile ??= _dylib.lookupFunction< + _c_clang_findIncludesInFile, + _dart_clang_findIncludesInFile>('clang_findIncludesInFile'))( + TU, + file, + visitor, + ); + } + + _dart_clang_findIncludesInFile? _clang_findIncludesInFile; + int clang_index_isEntityObjCContainerKind( int arg0, ) { @@ -2046,6 +4954,62 @@ } _dart_clang_indexTranslationUnit? _clang_indexTranslationUnit; + + /// Retrieve the CXIdxFile, file, line, column, and offset represented by the + /// given CXIdxLoc. + void clang_indexLoc_getFileLocation( + CXIdxLoc loc, + ffi.Pointer<ffi.Pointer<ffi.Void>> indexFile, + ffi.Pointer<ffi.Pointer<ffi.Void>> file, + ffi.Pointer<ffi.Uint32> line, + ffi.Pointer<ffi.Uint32> column, + ffi.Pointer<ffi.Uint32> offset, + ) { + return (_clang_indexLoc_getFileLocation ??= _dylib.lookupFunction< + _c_clang_indexLoc_getFileLocation, + _dart_clang_indexLoc_getFileLocation>( + 'clang_indexLoc_getFileLocation'))( + loc, + indexFile, + file, + line, + column, + offset, + ); + } + + _dart_clang_indexLoc_getFileLocation? _clang_indexLoc_getFileLocation; + + /// Retrieve the CXSourceLocation represented by the given CXIdxLoc. + CXSourceLocation clang_indexLoc_getCXSourceLocation( + CXIdxLoc loc, + ) { + return (_clang_indexLoc_getCXSourceLocation ??= _dylib.lookupFunction< + _c_clang_indexLoc_getCXSourceLocation, + _dart_clang_indexLoc_getCXSourceLocation>( + 'clang_indexLoc_getCXSourceLocation'))( + loc, + ); + } + + _dart_clang_indexLoc_getCXSourceLocation? _clang_indexLoc_getCXSourceLocation; + + /// Visit the fields of a particular type. + int clang_Type_visitFields( + CXType T, + ffi.Pointer<ffi.NativeFunction<CXFieldVisitor>> visitor, + ffi.Pointer<ffi.Void> client_data, + ) { + return (_clang_Type_visitFields ??= _dylib.lookupFunction< + _c_clang_Type_visitFields, + _dart_clang_Type_visitFields>('clang_Type_visitFields'))( + T, + visitor, + client_data, + ); + } + + _dart_clang_Type_visitFields? _clang_Type_visitFields; } /// Error codes returned by libclang routines. @@ -4066,7 +7030,11 @@ static const int CXVisit_Continue = 1; } -class CXCursorAndRangeVisitor extends ffi.Struct {} +class CXCursorAndRangeVisitor extends ffi.Struct { + external ffi.Pointer<ffi.Void> context; + + external ffi.Pointer<ffi.NativeFunction<_typedefC_2>> visit; +} abstract class CXResult { /// Function returned successfully. @@ -4442,26 +7410,26 @@ class IndexerCallbacks extends ffi.Struct { /// Called periodically to check whether indexing should be aborted. Should /// return 0 to continue, and non-zero to abort. - external ffi.Pointer<ffi.NativeFunction<_typedefC_2>> abortQuery; + external ffi.Pointer<ffi.NativeFunction<_typedefC_3>> abortQuery; /// Called at the end of indexing; passes the complete diagnostic set. - external ffi.Pointer<ffi.NativeFunction<_typedefC_3>> diagnostic; + external ffi.Pointer<ffi.NativeFunction<_typedefC_4>> diagnostic; - external ffi.Pointer<ffi.NativeFunction<_typedefC_4>> enteredMainFile; + external ffi.Pointer<ffi.NativeFunction<_typedefC_5>> enteredMainFile; /// Called when a file gets #included/#imported. - external ffi.Pointer<ffi.NativeFunction<_typedefC_5>> ppIncludedFile; + external ffi.Pointer<ffi.NativeFunction<_typedefC_6>> ppIncludedFile; /// Called when a AST file (PCH or module) gets imported. - external ffi.Pointer<ffi.NativeFunction<_typedefC_6>> importedASTFile; + external ffi.Pointer<ffi.NativeFunction<_typedefC_7>> importedASTFile; /// Called at the beginning of indexing a translation unit. - external ffi.Pointer<ffi.NativeFunction<_typedefC_7>> startedTranslationUnit; + external ffi.Pointer<ffi.NativeFunction<_typedefC_8>> startedTranslationUnit; - external ffi.Pointer<ffi.NativeFunction<_typedefC_8>> indexDeclaration; + external ffi.Pointer<ffi.NativeFunction<_typedefC_9>> indexDeclaration; /// Called to index a reference of an entity. - external ffi.Pointer<ffi.NativeFunction<_typedefC_9>> indexEntityReference; + external ffi.Pointer<ffi.NativeFunction<_typedefC_10>> indexEntityReference; } abstract class CXIndexOptFlags { @@ -4498,6 +7466,22 @@ const String CINDEX_VERSION_STRING = '0.59'; +typedef _c_clang_getCString = ffi.Pointer<ffi.Int8> Function( + CXString string, +); + +typedef _dart_clang_getCString = ffi.Pointer<ffi.Int8> Function( + CXString string, +); + +typedef _c_clang_disposeString = ffi.Void Function( + CXString string, +); + +typedef _dart_clang_disposeString = void Function( + CXString string, +); + typedef _c_clang_disposeStringSet = ffi.Void Function( ffi.Pointer<CXStringSet> set_1, ); @@ -4671,6 +7655,14 @@ ffi.Pointer<ffi.Int8> Path, ); +typedef _c_clang_getFileName = CXString Function( + ffi.Pointer<ffi.Void> SFile, +); + +typedef _dart_clang_getFileName = CXString Function( + ffi.Pointer<ffi.Void> SFile, +); + typedef _c_clang_getFileTime = ffi.Int64 Function( ffi.Pointer<ffi.Void> SFile, ); @@ -4731,6 +7723,196 @@ ffi.Pointer<ffi.Void> file2, ); +typedef _c_clang_File_tryGetRealPathName = CXString Function( + ffi.Pointer<ffi.Void> file, +); + +typedef _dart_clang_File_tryGetRealPathName = CXString Function( + ffi.Pointer<ffi.Void> file, +); + +typedef _c_clang_getNullLocation = CXSourceLocation Function(); + +typedef _dart_clang_getNullLocation = CXSourceLocation Function(); + +typedef _c_clang_equalLocations = ffi.Uint32 Function( + CXSourceLocation loc1, + CXSourceLocation loc2, +); + +typedef _dart_clang_equalLocations = int Function( + CXSourceLocation loc1, + CXSourceLocation loc2, +); + +typedef _c_clang_getLocation = CXSourceLocation Function( + ffi.Pointer<CXTranslationUnitImpl> tu, + ffi.Pointer<ffi.Void> file, + ffi.Uint32 line, + ffi.Uint32 column, +); + +typedef _dart_clang_getLocation = CXSourceLocation Function( + ffi.Pointer<CXTranslationUnitImpl> tu, + ffi.Pointer<ffi.Void> file, + int line, + int column, +); + +typedef _c_clang_getLocationForOffset = CXSourceLocation Function( + ffi.Pointer<CXTranslationUnitImpl> tu, + ffi.Pointer<ffi.Void> file, + ffi.Uint32 offset, +); + +typedef _dart_clang_getLocationForOffset = CXSourceLocation Function( + ffi.Pointer<CXTranslationUnitImpl> tu, + ffi.Pointer<ffi.Void> file, + int offset, +); + +typedef _c_clang_Location_isInSystemHeader = ffi.Int32 Function( + CXSourceLocation location, +); + +typedef _dart_clang_Location_isInSystemHeader = int Function( + CXSourceLocation location, +); + +typedef _c_clang_Location_isFromMainFile = ffi.Int32 Function( + CXSourceLocation location, +); + +typedef _dart_clang_Location_isFromMainFile = int Function( + CXSourceLocation location, +); + +typedef _c_clang_getNullRange = CXSourceRange Function(); + +typedef _dart_clang_getNullRange = CXSourceRange Function(); + +typedef _c_clang_getRange = CXSourceRange Function( + CXSourceLocation begin, + CXSourceLocation end, +); + +typedef _dart_clang_getRange = CXSourceRange Function( + CXSourceLocation begin, + CXSourceLocation end, +); + +typedef _c_clang_equalRanges = ffi.Uint32 Function( + CXSourceRange range1, + CXSourceRange range2, +); + +typedef _dart_clang_equalRanges = int Function( + CXSourceRange range1, + CXSourceRange range2, +); + +typedef _c_clang_Range_isNull = ffi.Int32 Function( + CXSourceRange range, +); + +typedef _dart_clang_Range_isNull = int Function( + CXSourceRange range, +); + +typedef _c_clang_getExpansionLocation = ffi.Void Function( + CXSourceLocation location, + ffi.Pointer<ffi.Pointer<ffi.Void>> file, + ffi.Pointer<ffi.Uint32> line, + ffi.Pointer<ffi.Uint32> column, + ffi.Pointer<ffi.Uint32> offset, +); + +typedef _dart_clang_getExpansionLocation = void Function( + CXSourceLocation location, + ffi.Pointer<ffi.Pointer<ffi.Void>> file, + ffi.Pointer<ffi.Uint32> line, + ffi.Pointer<ffi.Uint32> column, + ffi.Pointer<ffi.Uint32> offset, +); + +typedef _c_clang_getPresumedLocation = ffi.Void Function( + CXSourceLocation location, + ffi.Pointer<CXString> filename, + ffi.Pointer<ffi.Uint32> line, + ffi.Pointer<ffi.Uint32> column, +); + +typedef _dart_clang_getPresumedLocation = void Function( + CXSourceLocation location, + ffi.Pointer<CXString> filename, + ffi.Pointer<ffi.Uint32> line, + ffi.Pointer<ffi.Uint32> column, +); + +typedef _c_clang_getInstantiationLocation = ffi.Void Function( + CXSourceLocation location, + ffi.Pointer<ffi.Pointer<ffi.Void>> file, + ffi.Pointer<ffi.Uint32> line, + ffi.Pointer<ffi.Uint32> column, + ffi.Pointer<ffi.Uint32> offset, +); + +typedef _dart_clang_getInstantiationLocation = void Function( + CXSourceLocation location, + ffi.Pointer<ffi.Pointer<ffi.Void>> file, + ffi.Pointer<ffi.Uint32> line, + ffi.Pointer<ffi.Uint32> column, + ffi.Pointer<ffi.Uint32> offset, +); + +typedef _c_clang_getSpellingLocation = ffi.Void Function( + CXSourceLocation location, + ffi.Pointer<ffi.Pointer<ffi.Void>> file, + ffi.Pointer<ffi.Uint32> line, + ffi.Pointer<ffi.Uint32> column, + ffi.Pointer<ffi.Uint32> offset, +); + +typedef _dart_clang_getSpellingLocation = void Function( + CXSourceLocation location, + ffi.Pointer<ffi.Pointer<ffi.Void>> file, + ffi.Pointer<ffi.Uint32> line, + ffi.Pointer<ffi.Uint32> column, + ffi.Pointer<ffi.Uint32> offset, +); + +typedef _c_clang_getFileLocation = ffi.Void Function( + CXSourceLocation location, + ffi.Pointer<ffi.Pointer<ffi.Void>> file, + ffi.Pointer<ffi.Uint32> line, + ffi.Pointer<ffi.Uint32> column, + ffi.Pointer<ffi.Uint32> offset, +); + +typedef _dart_clang_getFileLocation = void Function( + CXSourceLocation location, + ffi.Pointer<ffi.Pointer<ffi.Void>> file, + ffi.Pointer<ffi.Uint32> line, + ffi.Pointer<ffi.Uint32> column, + ffi.Pointer<ffi.Uint32> offset, +); + +typedef _c_clang_getRangeStart = CXSourceLocation Function( + CXSourceRange range, +); + +typedef _dart_clang_getRangeStart = CXSourceLocation Function( + CXSourceRange range, +); + +typedef _c_clang_getRangeEnd = CXSourceLocation Function( + CXSourceRange range, +); + +typedef _dart_clang_getRangeEnd = CXSourceLocation Function( + CXSourceRange range, +); + typedef _c_clang_getSkippedRanges = ffi.Pointer<CXSourceRangeList> Function( ffi.Pointer<CXTranslationUnitImpl> tu, ffi.Pointer<ffi.Void> file, @@ -4838,6 +8020,16 @@ ffi.Pointer<ffi.Void> Diagnostic, ); +typedef _c_clang_formatDiagnostic = CXString Function( + ffi.Pointer<ffi.Void> Diagnostic, + ffi.Uint32 Options, +); + +typedef _dart_clang_formatDiagnostic = CXString Function( + ffi.Pointer<ffi.Void> Diagnostic, + int Options, +); + typedef _c_clang_defaultDiagnosticDisplayOptions = ffi.Uint32 Function(); typedef _dart_clang_defaultDiagnosticDisplayOptions = int Function(); @@ -4850,6 +8042,32 @@ ffi.Pointer<ffi.Void> arg0, ); +typedef _c_clang_getDiagnosticLocation = CXSourceLocation Function( + ffi.Pointer<ffi.Void> arg0, +); + +typedef _dart_clang_getDiagnosticLocation = CXSourceLocation Function( + ffi.Pointer<ffi.Void> arg0, +); + +typedef _c_clang_getDiagnosticSpelling = CXString Function( + ffi.Pointer<ffi.Void> arg0, +); + +typedef _dart_clang_getDiagnosticSpelling = CXString Function( + ffi.Pointer<ffi.Void> arg0, +); + +typedef _c_clang_getDiagnosticOption = CXString Function( + ffi.Pointer<ffi.Void> Diag, + ffi.Pointer<CXString> Disable, +); + +typedef _dart_clang_getDiagnosticOption = CXString Function( + ffi.Pointer<ffi.Void> Diag, + ffi.Pointer<CXString> Disable, +); + typedef _c_clang_getDiagnosticCategory = ffi.Uint32 Function( ffi.Pointer<ffi.Void> arg0, ); @@ -4858,6 +8076,22 @@ ffi.Pointer<ffi.Void> arg0, ); +typedef _c_clang_getDiagnosticCategoryName = CXString Function( + ffi.Uint32 Category, +); + +typedef _dart_clang_getDiagnosticCategoryName = CXString Function( + int Category, +); + +typedef _c_clang_getDiagnosticCategoryText = CXString Function( + ffi.Pointer<ffi.Void> arg0, +); + +typedef _dart_clang_getDiagnosticCategoryText = CXString Function( + ffi.Pointer<ffi.Void> arg0, +); + typedef _c_clang_getDiagnosticNumRanges = ffi.Uint32 Function( ffi.Pointer<ffi.Void> arg0, ); @@ -4866,6 +8100,16 @@ ffi.Pointer<ffi.Void> arg0, ); +typedef _c_clang_getDiagnosticRange = CXSourceRange Function( + ffi.Pointer<ffi.Void> Diagnostic, + ffi.Uint32 Range, +); + +typedef _dart_clang_getDiagnosticRange = CXSourceRange Function( + ffi.Pointer<ffi.Void> Diagnostic, + int Range, +); + typedef _c_clang_getDiagnosticNumFixIts = ffi.Uint32 Function( ffi.Pointer<ffi.Void> Diagnostic, ); @@ -4874,6 +8118,26 @@ ffi.Pointer<ffi.Void> Diagnostic, ); +typedef _c_clang_getDiagnosticFixIt = CXString Function( + ffi.Pointer<ffi.Void> Diagnostic, + ffi.Uint32 FixIt, + ffi.Pointer<CXSourceRange> ReplacementRange, +); + +typedef _dart_clang_getDiagnosticFixIt = CXString Function( + ffi.Pointer<ffi.Void> Diagnostic, + int FixIt, + ffi.Pointer<CXSourceRange> ReplacementRange, +); + +typedef _c_clang_getTranslationUnitSpelling = CXString Function( + ffi.Pointer<CXTranslationUnitImpl> CTUnit, +); + +typedef _dart_clang_getTranslationUnitSpelling = CXString Function( + ffi.Pointer<CXTranslationUnitImpl> CTUnit, +); + typedef _c_clang_createTranslationUnitFromSourceFile = ffi.Pointer<CXTranslationUnitImpl> Function( ffi.Pointer<ffi.Void> CIdx, @@ -5054,6 +8318,22 @@ int kind, ); +typedef _c_clang_getCXTUResourceUsage = CXTUResourceUsage Function( + ffi.Pointer<CXTranslationUnitImpl> TU, +); + +typedef _dart_clang_getCXTUResourceUsage = CXTUResourceUsage Function( + ffi.Pointer<CXTranslationUnitImpl> TU, +); + +typedef _c_clang_disposeCXTUResourceUsage = ffi.Void Function( + CXTUResourceUsage usage, +); + +typedef _dart_clang_disposeCXTUResourceUsage = void Function( + CXTUResourceUsage usage, +); + typedef _c_clang_getTranslationUnitTargetInfo = ffi.Pointer<CXTargetInfoImpl> Function( ffi.Pointer<CXTranslationUnitImpl> CTUnit, @@ -5072,6 +8352,14 @@ ffi.Pointer<CXTargetInfoImpl> Info, ); +typedef _c_clang_TargetInfo_getTriple = CXString Function( + ffi.Pointer<CXTargetInfoImpl> Info, +); + +typedef _dart_clang_TargetInfo_getTriple = CXString Function( + ffi.Pointer<CXTargetInfoImpl> Info, +); + typedef _c_clang_TargetInfo_getPointerWidth = ffi.Int32 Function( ffi.Pointer<CXTargetInfoImpl> Info, ); @@ -5080,6 +8368,52 @@ ffi.Pointer<CXTargetInfoImpl> Info, ); +typedef _c_clang_getNullCursor = CXCursor Function(); + +typedef _dart_clang_getNullCursor = CXCursor Function(); + +typedef _c_clang_getTranslationUnitCursor = CXCursor Function( + ffi.Pointer<CXTranslationUnitImpl> arg0, +); + +typedef _dart_clang_getTranslationUnitCursor = CXCursor Function( + ffi.Pointer<CXTranslationUnitImpl> arg0, +); + +typedef _c_clang_equalCursors = ffi.Uint32 Function( + CXCursor arg0, + CXCursor arg1, +); + +typedef _dart_clang_equalCursors = int Function( + CXCursor arg0, + CXCursor arg1, +); + +typedef _c_clang_Cursor_isNull = ffi.Int32 Function( + CXCursor cursor, +); + +typedef _dart_clang_Cursor_isNull = int Function( + CXCursor cursor, +); + +typedef _c_clang_hashCursor = ffi.Uint32 Function( + CXCursor arg0, +); + +typedef _dart_clang_hashCursor = int Function( + CXCursor arg0, +); + +typedef _c_clang_getCursorKind = ffi.Int32 Function( + CXCursor arg0, +); + +typedef _dart_clang_getCursorKind = int Function( + CXCursor arg0, +); + typedef _c_clang_isDeclaration = ffi.Uint32 Function( ffi.Int32 arg0, ); @@ -5088,6 +8422,14 @@ int arg0, ); +typedef _c_clang_isInvalidDeclaration = ffi.Uint32 Function( + CXCursor arg0, +); + +typedef _dart_clang_isInvalidDeclaration = int Function( + CXCursor arg0, +); + typedef _c_clang_isReference = ffi.Uint32 Function( ffi.Int32 arg0, ); @@ -5120,6 +8462,14 @@ int arg0, ); +typedef _c_clang_Cursor_hasAttrs = ffi.Uint32 Function( + CXCursor C, +); + +typedef _dart_clang_Cursor_hasAttrs = int Function( + CXCursor C, +); + typedef _c_clang_isInvalid = ffi.Uint32 Function( ffi.Int32 arg0, ); @@ -5152,6 +8502,50 @@ int arg0, ); +typedef _c_clang_getCursorLinkage = ffi.Int32 Function( + CXCursor cursor, +); + +typedef _dart_clang_getCursorLinkage = int Function( + CXCursor cursor, +); + +typedef _c_clang_getCursorVisibility = ffi.Int32 Function( + CXCursor cursor, +); + +typedef _dart_clang_getCursorVisibility = int Function( + CXCursor cursor, +); + +typedef _c_clang_getCursorAvailability = ffi.Int32 Function( + CXCursor cursor, +); + +typedef _dart_clang_getCursorAvailability = int Function( + CXCursor cursor, +); + +typedef _c_clang_getCursorPlatformAvailability = ffi.Int32 Function( + CXCursor cursor, + ffi.Pointer<ffi.Int32> always_deprecated, + ffi.Pointer<CXString> deprecated_message, + ffi.Pointer<ffi.Int32> always_unavailable, + ffi.Pointer<CXString> unavailable_message, + ffi.Pointer<CXPlatformAvailability> availability, + ffi.Int32 availability_size, +); + +typedef _dart_clang_getCursorPlatformAvailability = int Function( + CXCursor cursor, + ffi.Pointer<ffi.Int32> always_deprecated, + ffi.Pointer<CXString> deprecated_message, + ffi.Pointer<ffi.Int32> always_unavailable, + ffi.Pointer<CXString> unavailable_message, + ffi.Pointer<CXPlatformAvailability> availability, + int availability_size, +); + typedef _c_clang_disposeCXPlatformAvailability = ffi.Void Function( ffi.Pointer<CXPlatformAvailability> availability, ); @@ -5160,6 +8554,32 @@ ffi.Pointer<CXPlatformAvailability> availability, ); +typedef _c_clang_getCursorLanguage = ffi.Int32 Function( + CXCursor cursor, +); + +typedef _dart_clang_getCursorLanguage = int Function( + CXCursor cursor, +); + +typedef _c_clang_getCursorTLSKind = ffi.Int32 Function( + CXCursor cursor, +); + +typedef _dart_clang_getCursorTLSKind = int Function( + CXCursor cursor, +); + +typedef _c_clang_Cursor_getTranslationUnit = ffi.Pointer<CXTranslationUnitImpl> + Function( + CXCursor arg0, +); + +typedef _dart_clang_Cursor_getTranslationUnit + = ffi.Pointer<CXTranslationUnitImpl> Function( + CXCursor arg0, +); + typedef _c_clang_createCXCursorSet = ffi.Pointer<CXCursorSetImpl> Function(); typedef _dart_clang_createCXCursorSet = ffi.Pointer<CXCursorSetImpl> Function(); @@ -5172,6 +8592,54 @@ ffi.Pointer<CXCursorSetImpl> cset, ); +typedef _c_clang_CXCursorSet_contains = ffi.Uint32 Function( + ffi.Pointer<CXCursorSetImpl> cset, + CXCursor cursor, +); + +typedef _dart_clang_CXCursorSet_contains = int Function( + ffi.Pointer<CXCursorSetImpl> cset, + CXCursor cursor, +); + +typedef _c_clang_CXCursorSet_insert = ffi.Uint32 Function( + ffi.Pointer<CXCursorSetImpl> cset, + CXCursor cursor, +); + +typedef _dart_clang_CXCursorSet_insert = int Function( + ffi.Pointer<CXCursorSetImpl> cset, + CXCursor cursor, +); + +typedef _c_clang_getCursorSemanticParent = CXCursor Function( + CXCursor cursor, +); + +typedef _dart_clang_getCursorSemanticParent = CXCursor Function( + CXCursor cursor, +); + +typedef _c_clang_getCursorLexicalParent = CXCursor Function( + CXCursor cursor, +); + +typedef _dart_clang_getCursorLexicalParent = CXCursor Function( + CXCursor cursor, +); + +typedef _c_clang_getOverriddenCursors = ffi.Void Function( + CXCursor cursor, + ffi.Pointer<ffi.Pointer<CXCursor>> overridden, + ffi.Pointer<ffi.Uint32> num_overridden, +); + +typedef _dart_clang_getOverriddenCursors = void Function( + CXCursor cursor, + ffi.Pointer<ffi.Pointer<CXCursor>> overridden, + ffi.Pointer<ffi.Uint32> num_overridden, +); + typedef _c_clang_disposeOverriddenCursors = ffi.Void Function( ffi.Pointer<CXCursor> overridden, ); @@ -5180,6 +8648,720 @@ ffi.Pointer<CXCursor> overridden, ); +typedef _c_clang_getIncludedFile = ffi.Pointer<ffi.Void> Function( + CXCursor cursor, +); + +typedef _dart_clang_getIncludedFile = ffi.Pointer<ffi.Void> Function( + CXCursor cursor, +); + +typedef _c_clang_getCursor = CXCursor Function( + ffi.Pointer<CXTranslationUnitImpl> arg0, + CXSourceLocation arg1, +); + +typedef _dart_clang_getCursor = CXCursor Function( + ffi.Pointer<CXTranslationUnitImpl> arg0, + CXSourceLocation arg1, +); + +typedef _c_clang_getCursorLocation = CXSourceLocation Function( + CXCursor arg0, +); + +typedef _dart_clang_getCursorLocation = CXSourceLocation Function( + CXCursor arg0, +); + +typedef _c_clang_getCursorExtent = CXSourceRange Function( + CXCursor arg0, +); + +typedef _dart_clang_getCursorExtent = CXSourceRange Function( + CXCursor arg0, +); + +typedef _c_clang_getCursorType = CXType Function( + CXCursor C, +); + +typedef _dart_clang_getCursorType = CXType Function( + CXCursor C, +); + +typedef _c_clang_getTypeSpelling = CXString Function( + CXType CT, +); + +typedef _dart_clang_getTypeSpelling = CXString Function( + CXType CT, +); + +typedef _c_clang_getTypedefDeclUnderlyingType = CXType Function( + CXCursor C, +); + +typedef _dart_clang_getTypedefDeclUnderlyingType = CXType Function( + CXCursor C, +); + +typedef _c_clang_getEnumDeclIntegerType = CXType Function( + CXCursor C, +); + +typedef _dart_clang_getEnumDeclIntegerType = CXType Function( + CXCursor C, +); + +typedef _c_clang_getEnumConstantDeclValue = ffi.Int64 Function( + CXCursor C, +); + +typedef _dart_clang_getEnumConstantDeclValue = int Function( + CXCursor C, +); + +typedef _c_clang_getEnumConstantDeclUnsignedValue = ffi.Uint64 Function( + CXCursor C, +); + +typedef _dart_clang_getEnumConstantDeclUnsignedValue = int Function( + CXCursor C, +); + +typedef _c_clang_getFieldDeclBitWidth = ffi.Int32 Function( + CXCursor C, +); + +typedef _dart_clang_getFieldDeclBitWidth = int Function( + CXCursor C, +); + +typedef _c_clang_Cursor_getNumArguments = ffi.Int32 Function( + CXCursor C, +); + +typedef _dart_clang_Cursor_getNumArguments = int Function( + CXCursor C, +); + +typedef _c_clang_Cursor_getArgument = CXCursor Function( + CXCursor C, + ffi.Uint32 i, +); + +typedef _dart_clang_Cursor_getArgument = CXCursor Function( + CXCursor C, + int i, +); + +typedef _c_clang_Cursor_getNumTemplateArguments = ffi.Int32 Function( + CXCursor C, +); + +typedef _dart_clang_Cursor_getNumTemplateArguments = int Function( + CXCursor C, +); + +typedef _c_clang_Cursor_getTemplateArgumentKind = ffi.Int32 Function( + CXCursor C, + ffi.Uint32 I, +); + +typedef _dart_clang_Cursor_getTemplateArgumentKind = int Function( + CXCursor C, + int I, +); + +typedef _c_clang_Cursor_getTemplateArgumentType = CXType Function( + CXCursor C, + ffi.Uint32 I, +); + +typedef _dart_clang_Cursor_getTemplateArgumentType = CXType Function( + CXCursor C, + int I, +); + +typedef _c_clang_Cursor_getTemplateArgumentValue = ffi.Int64 Function( + CXCursor C, + ffi.Uint32 I, +); + +typedef _dart_clang_Cursor_getTemplateArgumentValue = int Function( + CXCursor C, + int I, +); + +typedef _c_clang_Cursor_getTemplateArgumentUnsignedValue = ffi.Uint64 Function( + CXCursor C, + ffi.Uint32 I, +); + +typedef _dart_clang_Cursor_getTemplateArgumentUnsignedValue = int Function( + CXCursor C, + int I, +); + +typedef _c_clang_equalTypes = ffi.Uint32 Function( + CXType A, + CXType B, +); + +typedef _dart_clang_equalTypes = int Function( + CXType A, + CXType B, +); + +typedef _c_clang_getCanonicalType = CXType Function( + CXType T, +); + +typedef _dart_clang_getCanonicalType = CXType Function( + CXType T, +); + +typedef _c_clang_isConstQualifiedType = ffi.Uint32 Function( + CXType T, +); + +typedef _dart_clang_isConstQualifiedType = int Function( + CXType T, +); + +typedef _c_clang_Cursor_isMacroFunctionLike = ffi.Uint32 Function( + CXCursor C, +); + +typedef _dart_clang_Cursor_isMacroFunctionLike = int Function( + CXCursor C, +); + +typedef _c_clang_Cursor_isMacroBuiltin = ffi.Uint32 Function( + CXCursor C, +); + +typedef _dart_clang_Cursor_isMacroBuiltin = int Function( + CXCursor C, +); + +typedef _c_clang_Cursor_isFunctionInlined = ffi.Uint32 Function( + CXCursor C, +); + +typedef _dart_clang_Cursor_isFunctionInlined = int Function( + CXCursor C, +); + +typedef _c_clang_isVolatileQualifiedType = ffi.Uint32 Function( + CXType T, +); + +typedef _dart_clang_isVolatileQualifiedType = int Function( + CXType T, +); + +typedef _c_clang_isRestrictQualifiedType = ffi.Uint32 Function( + CXType T, +); + +typedef _dart_clang_isRestrictQualifiedType = int Function( + CXType T, +); + +typedef _c_clang_getAddressSpace = ffi.Uint32 Function( + CXType T, +); + +typedef _dart_clang_getAddressSpace = int Function( + CXType T, +); + +typedef _c_clang_getTypedefName = CXString Function( + CXType CT, +); + +typedef _dart_clang_getTypedefName = CXString Function( + CXType CT, +); + +typedef _c_clang_getPointeeType = CXType Function( + CXType T, +); + +typedef _dart_clang_getPointeeType = CXType Function( + CXType T, +); + +typedef _c_clang_getTypeDeclaration = CXCursor Function( + CXType T, +); + +typedef _dart_clang_getTypeDeclaration = CXCursor Function( + CXType T, +); + +typedef _c_clang_getDeclObjCTypeEncoding = CXString Function( + CXCursor C, +); + +typedef _dart_clang_getDeclObjCTypeEncoding = CXString Function( + CXCursor C, +); + +typedef _c_clang_Type_getObjCEncoding = CXString Function( + CXType type, +); + +typedef _dart_clang_Type_getObjCEncoding = CXString Function( + CXType type, +); + +typedef _c_clang_getTypeKindSpelling = CXString Function( + ffi.Int32 K, +); + +typedef _dart_clang_getTypeKindSpelling = CXString Function( + int K, +); + +typedef _c_clang_getFunctionTypeCallingConv = ffi.Int32 Function( + CXType T, +); + +typedef _dart_clang_getFunctionTypeCallingConv = int Function( + CXType T, +); + +typedef _c_clang_getResultType = CXType Function( + CXType T, +); + +typedef _dart_clang_getResultType = CXType Function( + CXType T, +); + +typedef _c_clang_getExceptionSpecificationType = ffi.Int32 Function( + CXType T, +); + +typedef _dart_clang_getExceptionSpecificationType = int Function( + CXType T, +); + +typedef _c_clang_getNumArgTypes = ffi.Int32 Function( + CXType T, +); + +typedef _dart_clang_getNumArgTypes = int Function( + CXType T, +); + +typedef _c_clang_getArgType = CXType Function( + CXType T, + ffi.Uint32 i, +); + +typedef _dart_clang_getArgType = CXType Function( + CXType T, + int i, +); + +typedef _c_clang_Type_getObjCObjectBaseType = CXType Function( + CXType T, +); + +typedef _dart_clang_Type_getObjCObjectBaseType = CXType Function( + CXType T, +); + +typedef _c_clang_Type_getNumObjCProtocolRefs = ffi.Uint32 Function( + CXType T, +); + +typedef _dart_clang_Type_getNumObjCProtocolRefs = int Function( + CXType T, +); + +typedef _c_clang_Type_getObjCProtocolDecl = CXCursor Function( + CXType T, + ffi.Uint32 i, +); + +typedef _dart_clang_Type_getObjCProtocolDecl = CXCursor Function( + CXType T, + int i, +); + +typedef _c_clang_Type_getNumObjCTypeArgs = ffi.Uint32 Function( + CXType T, +); + +typedef _dart_clang_Type_getNumObjCTypeArgs = int Function( + CXType T, +); + +typedef _c_clang_Type_getObjCTypeArg = CXType Function( + CXType T, + ffi.Uint32 i, +); + +typedef _dart_clang_Type_getObjCTypeArg = CXType Function( + CXType T, + int i, +); + +typedef _c_clang_isFunctionTypeVariadic = ffi.Uint32 Function( + CXType T, +); + +typedef _dart_clang_isFunctionTypeVariadic = int Function( + CXType T, +); + +typedef _c_clang_getCursorResultType = CXType Function( + CXCursor C, +); + +typedef _dart_clang_getCursorResultType = CXType Function( + CXCursor C, +); + +typedef _c_clang_getCursorExceptionSpecificationType = ffi.Int32 Function( + CXCursor C, +); + +typedef _dart_clang_getCursorExceptionSpecificationType = int Function( + CXCursor C, +); + +typedef _c_clang_isPODType = ffi.Uint32 Function( + CXType T, +); + +typedef _dart_clang_isPODType = int Function( + CXType T, +); + +typedef _c_clang_getElementType = CXType Function( + CXType T, +); + +typedef _dart_clang_getElementType = CXType Function( + CXType T, +); + +typedef _c_clang_getNumElements = ffi.Int64 Function( + CXType T, +); + +typedef _dart_clang_getNumElements = int Function( + CXType T, +); + +typedef _c_clang_getArrayElementType = CXType Function( + CXType T, +); + +typedef _dart_clang_getArrayElementType = CXType Function( + CXType T, +); + +typedef _c_clang_getArraySize = ffi.Int64 Function( + CXType T, +); + +typedef _dart_clang_getArraySize = int Function( + CXType T, +); + +typedef _c_clang_Type_getNamedType = CXType Function( + CXType T, +); + +typedef _dart_clang_Type_getNamedType = CXType Function( + CXType T, +); + +typedef _c_clang_Type_isTransparentTagTypedef = ffi.Uint32 Function( + CXType T, +); + +typedef _dart_clang_Type_isTransparentTagTypedef = int Function( + CXType T, +); + +typedef _c_clang_Type_getNullability = ffi.Int32 Function( + CXType T, +); + +typedef _dart_clang_Type_getNullability = int Function( + CXType T, +); + +typedef _c_clang_Type_getAlignOf = ffi.Int64 Function( + CXType T, +); + +typedef _dart_clang_Type_getAlignOf = int Function( + CXType T, +); + +typedef _c_clang_Type_getClassType = CXType Function( + CXType T, +); + +typedef _dart_clang_Type_getClassType = CXType Function( + CXType T, +); + +typedef _c_clang_Type_getSizeOf = ffi.Int64 Function( + CXType T, +); + +typedef _dart_clang_Type_getSizeOf = int Function( + CXType T, +); + +typedef _c_clang_Type_getOffsetOf = ffi.Int64 Function( + CXType T, + ffi.Pointer<ffi.Int8> S, +); + +typedef _dart_clang_Type_getOffsetOf = int Function( + CXType T, + ffi.Pointer<ffi.Int8> S, +); + +typedef _c_clang_Type_getModifiedType = CXType Function( + CXType T, +); + +typedef _dart_clang_Type_getModifiedType = CXType Function( + CXType T, +); + +typedef _c_clang_Cursor_getOffsetOfField = ffi.Int64 Function( + CXCursor C, +); + +typedef _dart_clang_Cursor_getOffsetOfField = int Function( + CXCursor C, +); + +typedef _c_clang_Cursor_isAnonymous = ffi.Uint32 Function( + CXCursor C, +); + +typedef _dart_clang_Cursor_isAnonymous = int Function( + CXCursor C, +); + +typedef _c_clang_Cursor_isAnonymousRecordDecl = ffi.Uint32 Function( + CXCursor C, +); + +typedef _dart_clang_Cursor_isAnonymousRecordDecl = int Function( + CXCursor C, +); + +typedef _c_clang_Cursor_isInlineNamespace = ffi.Uint32 Function( + CXCursor C, +); + +typedef _dart_clang_Cursor_isInlineNamespace = int Function( + CXCursor C, +); + +typedef _c_clang_Type_getNumTemplateArguments = ffi.Int32 Function( + CXType T, +); + +typedef _dart_clang_Type_getNumTemplateArguments = int Function( + CXType T, +); + +typedef _c_clang_Type_getTemplateArgumentAsType = CXType Function( + CXType T, + ffi.Uint32 i, +); + +typedef _dart_clang_Type_getTemplateArgumentAsType = CXType Function( + CXType T, + int i, +); + +typedef _c_clang_Type_getCXXRefQualifier = ffi.Int32 Function( + CXType T, +); + +typedef _dart_clang_Type_getCXXRefQualifier = int Function( + CXType T, +); + +typedef _c_clang_Cursor_isBitField = ffi.Uint32 Function( + CXCursor C, +); + +typedef _dart_clang_Cursor_isBitField = int Function( + CXCursor C, +); + +typedef _c_clang_isVirtualBase = ffi.Uint32 Function( + CXCursor arg0, +); + +typedef _dart_clang_isVirtualBase = int Function( + CXCursor arg0, +); + +typedef _c_clang_getCXXAccessSpecifier = ffi.Int32 Function( + CXCursor arg0, +); + +typedef _dart_clang_getCXXAccessSpecifier = int Function( + CXCursor arg0, +); + +typedef _c_clang_Cursor_getStorageClass = ffi.Int32 Function( + CXCursor arg0, +); + +typedef _dart_clang_Cursor_getStorageClass = int Function( + CXCursor arg0, +); + +typedef _c_clang_getNumOverloadedDecls = ffi.Uint32 Function( + CXCursor cursor, +); + +typedef _dart_clang_getNumOverloadedDecls = int Function( + CXCursor cursor, +); + +typedef _c_clang_getOverloadedDecl = CXCursor Function( + CXCursor cursor, + ffi.Uint32 index, +); + +typedef _dart_clang_getOverloadedDecl = CXCursor Function( + CXCursor cursor, + int index, +); + +typedef _c_clang_getIBOutletCollectionType = CXType Function( + CXCursor arg0, +); + +typedef _dart_clang_getIBOutletCollectionType = CXType Function( + CXCursor arg0, +); + +typedef CXCursorVisitor = ffi.Int32 Function( + CXCursor, + CXCursor, + ffi.Pointer<ffi.Void>, +); + +typedef _c_clang_visitChildren = ffi.Uint32 Function( + CXCursor parent, + ffi.Pointer<ffi.NativeFunction<CXCursorVisitor>> visitor, + ffi.Pointer<ffi.Void> client_data, +); + +typedef _dart_clang_visitChildren = int Function( + CXCursor parent, + ffi.Pointer<ffi.NativeFunction<CXCursorVisitor>> visitor, + ffi.Pointer<ffi.Void> client_data, +); + +typedef _c_clang_getCursorUSR = CXString Function( + CXCursor arg0, +); + +typedef _dart_clang_getCursorUSR = CXString Function( + CXCursor arg0, +); + +typedef _c_clang_constructUSR_ObjCClass = CXString Function( + ffi.Pointer<ffi.Int8> class_name, +); + +typedef _dart_clang_constructUSR_ObjCClass = CXString Function( + ffi.Pointer<ffi.Int8> class_name, +); + +typedef _c_clang_constructUSR_ObjCCategory = CXString Function( + ffi.Pointer<ffi.Int8> class_name, + ffi.Pointer<ffi.Int8> category_name, +); + +typedef _dart_clang_constructUSR_ObjCCategory = CXString Function( + ffi.Pointer<ffi.Int8> class_name, + ffi.Pointer<ffi.Int8> category_name, +); + +typedef _c_clang_constructUSR_ObjCProtocol = CXString Function( + ffi.Pointer<ffi.Int8> protocol_name, +); + +typedef _dart_clang_constructUSR_ObjCProtocol = CXString Function( + ffi.Pointer<ffi.Int8> protocol_name, +); + +typedef _c_clang_constructUSR_ObjCIvar = CXString Function( + ffi.Pointer<ffi.Int8> name, + CXString classUSR, +); + +typedef _dart_clang_constructUSR_ObjCIvar = CXString Function( + ffi.Pointer<ffi.Int8> name, + CXString classUSR, +); + +typedef _c_clang_constructUSR_ObjCMethod = CXString Function( + ffi.Pointer<ffi.Int8> name, + ffi.Uint32 isInstanceMethod, + CXString classUSR, +); + +typedef _dart_clang_constructUSR_ObjCMethod = CXString Function( + ffi.Pointer<ffi.Int8> name, + int isInstanceMethod, + CXString classUSR, +); + +typedef _c_clang_constructUSR_ObjCProperty = CXString Function( + ffi.Pointer<ffi.Int8> property, + CXString classUSR, +); + +typedef _dart_clang_constructUSR_ObjCProperty = CXString Function( + ffi.Pointer<ffi.Int8> property, + CXString classUSR, +); + +typedef _c_clang_getCursorSpelling = CXString Function( + CXCursor arg0, +); + +typedef _dart_clang_getCursorSpelling = CXString Function( + CXCursor arg0, +); + +typedef _c_clang_Cursor_getSpellingNameRange = CXSourceRange Function( + CXCursor arg0, + ffi.Uint32 pieceIndex, + ffi.Uint32 options, +); + +typedef _dart_clang_Cursor_getSpellingNameRange = CXSourceRange Function( + CXCursor arg0, + int pieceIndex, + int options, +); + typedef _c_clang_PrintingPolicy_getProperty = ffi.Uint32 Function( ffi.Pointer<ffi.Void> Policy, ffi.Int32 Property, @@ -5202,6 +9384,14 @@ int Value, ); +typedef _c_clang_getCursorPrintingPolicy = ffi.Pointer<ffi.Void> Function( + CXCursor arg0, +); + +typedef _dart_clang_getCursorPrintingPolicy = ffi.Pointer<ffi.Void> Function( + CXCursor arg0, +); + typedef _c_clang_PrintingPolicy_dispose = ffi.Void Function( ffi.Pointer<ffi.Void> Policy, ); @@ -5210,6 +9400,200 @@ ffi.Pointer<ffi.Void> Policy, ); +typedef _c_clang_getCursorPrettyPrinted = CXString Function( + CXCursor Cursor, + ffi.Pointer<ffi.Void> Policy, +); + +typedef _dart_clang_getCursorPrettyPrinted = CXString Function( + CXCursor Cursor, + ffi.Pointer<ffi.Void> Policy, +); + +typedef _c_clang_getCursorDisplayName = CXString Function( + CXCursor arg0, +); + +typedef _dart_clang_getCursorDisplayName = CXString Function( + CXCursor arg0, +); + +typedef _c_clang_getCursorReferenced = CXCursor Function( + CXCursor arg0, +); + +typedef _dart_clang_getCursorReferenced = CXCursor Function( + CXCursor arg0, +); + +typedef _c_clang_getCursorDefinition = CXCursor Function( + CXCursor arg0, +); + +typedef _dart_clang_getCursorDefinition = CXCursor Function( + CXCursor arg0, +); + +typedef _c_clang_isCursorDefinition = ffi.Uint32 Function( + CXCursor arg0, +); + +typedef _dart_clang_isCursorDefinition = int Function( + CXCursor arg0, +); + +typedef _c_clang_getCanonicalCursor = CXCursor Function( + CXCursor arg0, +); + +typedef _dart_clang_getCanonicalCursor = CXCursor Function( + CXCursor arg0, +); + +typedef _c_clang_Cursor_getObjCSelectorIndex = ffi.Int32 Function( + CXCursor arg0, +); + +typedef _dart_clang_Cursor_getObjCSelectorIndex = int Function( + CXCursor arg0, +); + +typedef _c_clang_Cursor_isDynamicCall = ffi.Int32 Function( + CXCursor C, +); + +typedef _dart_clang_Cursor_isDynamicCall = int Function( + CXCursor C, +); + +typedef _c_clang_Cursor_getReceiverType = CXType Function( + CXCursor C, +); + +typedef _dart_clang_Cursor_getReceiverType = CXType Function( + CXCursor C, +); + +typedef _c_clang_Cursor_getObjCPropertyAttributes = ffi.Uint32 Function( + CXCursor C, + ffi.Uint32 reserved, +); + +typedef _dart_clang_Cursor_getObjCPropertyAttributes = int Function( + CXCursor C, + int reserved, +); + +typedef _c_clang_Cursor_getObjCPropertyGetterName = CXString Function( + CXCursor C, +); + +typedef _dart_clang_Cursor_getObjCPropertyGetterName = CXString Function( + CXCursor C, +); + +typedef _c_clang_Cursor_getObjCPropertySetterName = CXString Function( + CXCursor C, +); + +typedef _dart_clang_Cursor_getObjCPropertySetterName = CXString Function( + CXCursor C, +); + +typedef _c_clang_Cursor_getObjCDeclQualifiers = ffi.Uint32 Function( + CXCursor C, +); + +typedef _dart_clang_Cursor_getObjCDeclQualifiers = int Function( + CXCursor C, +); + +typedef _c_clang_Cursor_isObjCOptional = ffi.Uint32 Function( + CXCursor C, +); + +typedef _dart_clang_Cursor_isObjCOptional = int Function( + CXCursor C, +); + +typedef _c_clang_Cursor_isVariadic = ffi.Uint32 Function( + CXCursor C, +); + +typedef _dart_clang_Cursor_isVariadic = int Function( + CXCursor C, +); + +typedef _c_clang_Cursor_isExternalSymbol = ffi.Uint32 Function( + CXCursor C, + ffi.Pointer<CXString> language, + ffi.Pointer<CXString> definedIn, + ffi.Pointer<ffi.Uint32> isGenerated, +); + +typedef _dart_clang_Cursor_isExternalSymbol = int Function( + CXCursor C, + ffi.Pointer<CXString> language, + ffi.Pointer<CXString> definedIn, + ffi.Pointer<ffi.Uint32> isGenerated, +); + +typedef _c_clang_Cursor_getCommentRange = CXSourceRange Function( + CXCursor C, +); + +typedef _dart_clang_Cursor_getCommentRange = CXSourceRange Function( + CXCursor C, +); + +typedef _c_clang_Cursor_getRawCommentText = CXString Function( + CXCursor C, +); + +typedef _dart_clang_Cursor_getRawCommentText = CXString Function( + CXCursor C, +); + +typedef _c_clang_Cursor_getBriefCommentText = CXString Function( + CXCursor C, +); + +typedef _dart_clang_Cursor_getBriefCommentText = CXString Function( + CXCursor C, +); + +typedef _c_clang_Cursor_getMangling = CXString Function( + CXCursor arg0, +); + +typedef _dart_clang_Cursor_getMangling = CXString Function( + CXCursor arg0, +); + +typedef _c_clang_Cursor_getCXXManglings = ffi.Pointer<CXStringSet> Function( + CXCursor arg0, +); + +typedef _dart_clang_Cursor_getCXXManglings = ffi.Pointer<CXStringSet> Function( + CXCursor arg0, +); + +typedef _c_clang_Cursor_getObjCManglings = ffi.Pointer<CXStringSet> Function( + CXCursor arg0, +); + +typedef _dart_clang_Cursor_getObjCManglings = ffi.Pointer<CXStringSet> Function( + CXCursor arg0, +); + +typedef _c_clang_Cursor_getModule = ffi.Pointer<ffi.Void> Function( + CXCursor C, +); + +typedef _dart_clang_Cursor_getModule = ffi.Pointer<ffi.Void> Function( + CXCursor C, +); + typedef _c_clang_getModuleForFile = ffi.Pointer<ffi.Void> Function( ffi.Pointer<CXTranslationUnitImpl> arg0, ffi.Pointer<ffi.Void> arg1, @@ -5236,6 +9620,22 @@ ffi.Pointer<ffi.Void> Module, ); +typedef _c_clang_Module_getName = CXString Function( + ffi.Pointer<ffi.Void> Module, +); + +typedef _dart_clang_Module_getName = CXString Function( + ffi.Pointer<ffi.Void> Module, +); + +typedef _c_clang_Module_getFullName = CXString Function( + ffi.Pointer<ffi.Void> Module, +); + +typedef _dart_clang_Module_getFullName = CXString Function( + ffi.Pointer<ffi.Void> Module, +); + typedef _c_clang_Module_isSystem = ffi.Int32 Function( ffi.Pointer<ffi.Void> Module, ); @@ -5266,6 +9666,192 @@ int Index, ); +typedef _c_clang_CXXConstructor_isConvertingConstructor = ffi.Uint32 Function( + CXCursor C, +); + +typedef _dart_clang_CXXConstructor_isConvertingConstructor = int Function( + CXCursor C, +); + +typedef _c_clang_CXXConstructor_isCopyConstructor = ffi.Uint32 Function( + CXCursor C, +); + +typedef _dart_clang_CXXConstructor_isCopyConstructor = int Function( + CXCursor C, +); + +typedef _c_clang_CXXConstructor_isDefaultConstructor = ffi.Uint32 Function( + CXCursor C, +); + +typedef _dart_clang_CXXConstructor_isDefaultConstructor = int Function( + CXCursor C, +); + +typedef _c_clang_CXXConstructor_isMoveConstructor = ffi.Uint32 Function( + CXCursor C, +); + +typedef _dart_clang_CXXConstructor_isMoveConstructor = int Function( + CXCursor C, +); + +typedef _c_clang_CXXField_isMutable = ffi.Uint32 Function( + CXCursor C, +); + +typedef _dart_clang_CXXField_isMutable = int Function( + CXCursor C, +); + +typedef _c_clang_CXXMethod_isDefaulted = ffi.Uint32 Function( + CXCursor C, +); + +typedef _dart_clang_CXXMethod_isDefaulted = int Function( + CXCursor C, +); + +typedef _c_clang_CXXMethod_isPureVirtual = ffi.Uint32 Function( + CXCursor C, +); + +typedef _dart_clang_CXXMethod_isPureVirtual = int Function( + CXCursor C, +); + +typedef _c_clang_CXXMethod_isStatic = ffi.Uint32 Function( + CXCursor C, +); + +typedef _dart_clang_CXXMethod_isStatic = int Function( + CXCursor C, +); + +typedef _c_clang_CXXMethod_isVirtual = ffi.Uint32 Function( + CXCursor C, +); + +typedef _dart_clang_CXXMethod_isVirtual = int Function( + CXCursor C, +); + +typedef _c_clang_CXXRecord_isAbstract = ffi.Uint32 Function( + CXCursor C, +); + +typedef _dart_clang_CXXRecord_isAbstract = int Function( + CXCursor C, +); + +typedef _c_clang_EnumDecl_isScoped = ffi.Uint32 Function( + CXCursor C, +); + +typedef _dart_clang_EnumDecl_isScoped = int Function( + CXCursor C, +); + +typedef _c_clang_CXXMethod_isConst = ffi.Uint32 Function( + CXCursor C, +); + +typedef _dart_clang_CXXMethod_isConst = int Function( + CXCursor C, +); + +typedef _c_clang_getTemplateCursorKind = ffi.Int32 Function( + CXCursor C, +); + +typedef _dart_clang_getTemplateCursorKind = int Function( + CXCursor C, +); + +typedef _c_clang_getSpecializedCursorTemplate = CXCursor Function( + CXCursor C, +); + +typedef _dart_clang_getSpecializedCursorTemplate = CXCursor Function( + CXCursor C, +); + +typedef _c_clang_getCursorReferenceNameRange = CXSourceRange Function( + CXCursor C, + ffi.Uint32 NameFlags, + ffi.Uint32 PieceIndex, +); + +typedef _dart_clang_getCursorReferenceNameRange = CXSourceRange Function( + CXCursor C, + int NameFlags, + int PieceIndex, +); + +typedef _c_clang_getToken = ffi.Pointer<CXToken> Function( + ffi.Pointer<CXTranslationUnitImpl> TU, + CXSourceLocation Location, +); + +typedef _dart_clang_getToken = ffi.Pointer<CXToken> Function( + ffi.Pointer<CXTranslationUnitImpl> TU, + CXSourceLocation Location, +); + +typedef _c_clang_getTokenKind = ffi.Int32 Function( + CXToken arg0, +); + +typedef _dart_clang_getTokenKind = int Function( + CXToken arg0, +); + +typedef _c_clang_getTokenSpelling = CXString Function( + ffi.Pointer<CXTranslationUnitImpl> arg0, + CXToken arg1, +); + +typedef _dart_clang_getTokenSpelling = CXString Function( + ffi.Pointer<CXTranslationUnitImpl> arg0, + CXToken arg1, +); + +typedef _c_clang_getTokenLocation = CXSourceLocation Function( + ffi.Pointer<CXTranslationUnitImpl> arg0, + CXToken arg1, +); + +typedef _dart_clang_getTokenLocation = CXSourceLocation Function( + ffi.Pointer<CXTranslationUnitImpl> arg0, + CXToken arg1, +); + +typedef _c_clang_getTokenExtent = CXSourceRange Function( + ffi.Pointer<CXTranslationUnitImpl> arg0, + CXToken arg1, +); + +typedef _dart_clang_getTokenExtent = CXSourceRange Function( + ffi.Pointer<CXTranslationUnitImpl> arg0, + CXToken arg1, +); + +typedef _c_clang_tokenize = ffi.Void Function( + ffi.Pointer<CXTranslationUnitImpl> TU, + CXSourceRange Range, + ffi.Pointer<ffi.Pointer<CXToken>> Tokens, + ffi.Pointer<ffi.Uint32> NumTokens, +); + +typedef _dart_clang_tokenize = void Function( + ffi.Pointer<CXTranslationUnitImpl> TU, + CXSourceRange Range, + ffi.Pointer<ffi.Pointer<CXToken>> Tokens, + ffi.Pointer<ffi.Uint32> NumTokens, +); + typedef _c_clang_annotateTokens = ffi.Void Function( ffi.Pointer<CXTranslationUnitImpl> TU, ffi.Pointer<CXToken> Tokens, @@ -5292,6 +9878,34 @@ int NumTokens, ); +typedef _c_clang_getCursorKindSpelling = CXString Function( + ffi.Int32 Kind, +); + +typedef _dart_clang_getCursorKindSpelling = CXString Function( + int Kind, +); + +typedef _c_clang_getDefinitionSpellingAndExtent = ffi.Void Function( + CXCursor arg0, + ffi.Pointer<ffi.Pointer<ffi.Int8>> startBuf, + ffi.Pointer<ffi.Pointer<ffi.Int8>> endBuf, + ffi.Pointer<ffi.Uint32> startLine, + ffi.Pointer<ffi.Uint32> startColumn, + ffi.Pointer<ffi.Uint32> endLine, + ffi.Pointer<ffi.Uint32> endColumn, +); + +typedef _dart_clang_getDefinitionSpellingAndExtent = void Function( + CXCursor arg0, + ffi.Pointer<ffi.Pointer<ffi.Int8>> startBuf, + ffi.Pointer<ffi.Pointer<ffi.Int8>> endBuf, + ffi.Pointer<ffi.Uint32> startLine, + ffi.Pointer<ffi.Uint32> startColumn, + ffi.Pointer<ffi.Uint32> endLine, + ffi.Pointer<ffi.Uint32> endColumn, +); + typedef _c_clang_enableStackTraces = ffi.Void Function(); typedef _dart_clang_enableStackTraces = void Function(); @@ -5322,6 +9936,16 @@ int chunk_number, ); +typedef _c_clang_getCompletionChunkText = CXString Function( + ffi.Pointer<ffi.Void> completion_string, + ffi.Uint32 chunk_number, +); + +typedef _dart_clang_getCompletionChunkText = CXString Function( + ffi.Pointer<ffi.Void> completion_string, + int chunk_number, +); + typedef _c_clang_getCompletionChunkCompletionString = ffi.Pointer<ffi.Void> Function( ffi.Pointer<ffi.Void> completion_string, @@ -5366,6 +9990,42 @@ ffi.Pointer<ffi.Void> completion_string, ); +typedef _c_clang_getCompletionAnnotation = CXString Function( + ffi.Pointer<ffi.Void> completion_string, + ffi.Uint32 annotation_number, +); + +typedef _dart_clang_getCompletionAnnotation = CXString Function( + ffi.Pointer<ffi.Void> completion_string, + int annotation_number, +); + +typedef _c_clang_getCompletionParent = CXString Function( + ffi.Pointer<ffi.Void> completion_string, + ffi.Pointer<ffi.Int32> kind, +); + +typedef _dart_clang_getCompletionParent = CXString Function( + ffi.Pointer<ffi.Void> completion_string, + ffi.Pointer<ffi.Int32> kind, +); + +typedef _c_clang_getCompletionBriefComment = CXString Function( + ffi.Pointer<ffi.Void> completion_string, +); + +typedef _dart_clang_getCompletionBriefComment = CXString Function( + ffi.Pointer<ffi.Void> completion_string, +); + +typedef _c_clang_getCursorCompletionString = ffi.Pointer<ffi.Void> Function( + CXCursor cursor, +); + +typedef _dart_clang_getCursorCompletionString = ffi.Pointer<ffi.Void> Function( + CXCursor cursor, +); + typedef _c_clang_getCompletionNumFixIts = ffi.Uint32 Function( ffi.Pointer<CXCodeCompleteResults> results, ffi.Uint32 completion_index, @@ -5376,6 +10036,20 @@ int completion_index, ); +typedef _c_clang_getCompletionFixIt = CXString Function( + ffi.Pointer<CXCodeCompleteResults> results, + ffi.Uint32 completion_index, + ffi.Uint32 fixit_index, + ffi.Pointer<CXSourceRange> replacement_range, +); + +typedef _dart_clang_getCompletionFixIt = CXString Function( + ffi.Pointer<CXCodeCompleteResults> results, + int completion_index, + int fixit_index, + ffi.Pointer<CXSourceRange> replacement_range, +); + typedef _c_clang_defaultCodeCompleteOptions = ffi.Uint32 Function(); typedef _dart_clang_defaultCodeCompleteOptions = int Function(); @@ -5455,6 +10129,26 @@ ffi.Pointer<ffi.Uint32> IsIncomplete, ); +typedef _c_clang_codeCompleteGetContainerUSR = CXString Function( + ffi.Pointer<CXCodeCompleteResults> Results, +); + +typedef _dart_clang_codeCompleteGetContainerUSR = CXString Function( + ffi.Pointer<CXCodeCompleteResults> Results, +); + +typedef _c_clang_codeCompleteGetObjCSelector = CXString Function( + ffi.Pointer<CXCodeCompleteResults> Results, +); + +typedef _dart_clang_codeCompleteGetObjCSelector = CXString Function( + ffi.Pointer<CXCodeCompleteResults> Results, +); + +typedef _c_clang_getClangVersion = CXString Function(); + +typedef _dart_clang_getClangVersion = CXString Function(); + typedef _c_clang_toggleCrashRecovery = ffi.Void Function( ffi.Uint32 isEnabled, ); @@ -5482,6 +10176,14 @@ ffi.Pointer<ffi.Void> client_data, ); +typedef _c_clang_Cursor_Evaluate = ffi.Pointer<ffi.Void> Function( + CXCursor C, +); + +typedef _dart_clang_Cursor_Evaluate = ffi.Pointer<ffi.Void> Function( + CXCursor C, +); + typedef _c_clang_EvalResult_getKind = ffi.Int32 Function( ffi.Pointer<ffi.Void> E, ); @@ -5594,6 +10296,30 @@ ffi.Pointer<ffi.Void> arg0, ); +typedef _c_clang_findReferencesInFile = ffi.Int32 Function( + CXCursor cursor, + ffi.Pointer<ffi.Void> file, + CXCursorAndRangeVisitor visitor, +); + +typedef _dart_clang_findReferencesInFile = int Function( + CXCursor cursor, + ffi.Pointer<ffi.Void> file, + CXCursorAndRangeVisitor visitor, +); + +typedef _c_clang_findIncludesInFile = ffi.Int32 Function( + ffi.Pointer<CXTranslationUnitImpl> TU, + ffi.Pointer<ffi.Void> file, + CXCursorAndRangeVisitor visitor, +); + +typedef _dart_clang_findIncludesInFile = int Function( + ffi.Pointer<CXTranslationUnitImpl> TU, + ffi.Pointer<ffi.Void> file, + CXCursorAndRangeVisitor visitor, +); + typedef _c_clang_index_isEntityObjCContainerKind = ffi.Int32 Function( ffi.Int32 arg0, ); @@ -5802,18 +10528,61 @@ ffi.Pointer<CXTranslationUnitImpl> arg5, ); +typedef _c_clang_indexLoc_getFileLocation = ffi.Void Function( + CXIdxLoc loc, + ffi.Pointer<ffi.Pointer<ffi.Void>> indexFile, + ffi.Pointer<ffi.Pointer<ffi.Void>> file, + ffi.Pointer<ffi.Uint32> line, + ffi.Pointer<ffi.Uint32> column, + ffi.Pointer<ffi.Uint32> offset, +); + +typedef _dart_clang_indexLoc_getFileLocation = void Function( + CXIdxLoc loc, + ffi.Pointer<ffi.Pointer<ffi.Void>> indexFile, + ffi.Pointer<ffi.Pointer<ffi.Void>> file, + ffi.Pointer<ffi.Uint32> line, + ffi.Pointer<ffi.Uint32> column, + ffi.Pointer<ffi.Uint32> offset, +); + +typedef _c_clang_indexLoc_getCXSourceLocation = CXSourceLocation Function( + CXIdxLoc loc, +); + +typedef _dart_clang_indexLoc_getCXSourceLocation = CXSourceLocation Function( + CXIdxLoc loc, +); + +typedef CXFieldVisitor = ffi.Int32 Function( + CXCursor, + ffi.Pointer<ffi.Void>, +); + +typedef _c_clang_Type_visitFields = ffi.Uint32 Function( + CXType T, + ffi.Pointer<ffi.NativeFunction<CXFieldVisitor>> visitor, + ffi.Pointer<ffi.Void> client_data, +); + +typedef _dart_clang_Type_visitFields = int Function( + CXType T, + ffi.Pointer<ffi.NativeFunction<CXFieldVisitor>> visitor, + ffi.Pointer<ffi.Void> client_data, +); + typedef _typedefC_2 = ffi.Int32 Function( ffi.Pointer<ffi.Void>, - ffi.Pointer<ffi.Void>, + CXCursor, + CXSourceRange, ); -typedef _typedefC_3 = ffi.Void Function( - ffi.Pointer<ffi.Void>, +typedef _typedefC_3 = ffi.Int32 Function( ffi.Pointer<ffi.Void>, ffi.Pointer<ffi.Void>, ); -typedef _typedefC_4 = ffi.Pointer<ffi.Void> Function( +typedef _typedefC_4 = ffi.Void Function( ffi.Pointer<ffi.Void>, ffi.Pointer<ffi.Void>, ffi.Pointer<ffi.Void>, @@ -5821,25 +10590,31 @@ typedef _typedefC_5 = ffi.Pointer<ffi.Void> Function( ffi.Pointer<ffi.Void>, - ffi.Pointer<CXIdxIncludedFileInfo>, + ffi.Pointer<ffi.Void>, + ffi.Pointer<ffi.Void>, ); typedef _typedefC_6 = ffi.Pointer<ffi.Void> Function( ffi.Pointer<ffi.Void>, - ffi.Pointer<CXIdxImportedASTFileInfo>, + ffi.Pointer<CXIdxIncludedFileInfo>, ); typedef _typedefC_7 = ffi.Pointer<ffi.Void> Function( ffi.Pointer<ffi.Void>, + ffi.Pointer<CXIdxImportedASTFileInfo>, +); + +typedef _typedefC_8 = ffi.Pointer<ffi.Void> Function( + ffi.Pointer<ffi.Void>, ffi.Pointer<ffi.Void>, ); -typedef _typedefC_8 = ffi.Void Function( +typedef _typedefC_9 = ffi.Void Function( ffi.Pointer<ffi.Void>, ffi.Pointer<CXIdxDeclInfo>, ); -typedef _typedefC_9 = ffi.Void Function( +typedef _typedefC_10 = ffi.Void Function( ffi.Pointer<ffi.Void>, ffi.Pointer<CXIdxEntityRefInfo>, );
diff --git a/pkgs/ffigen/test/native_test/native_test.c b/pkgs/ffigen/test/native_test/native_test.c index 57b23c0..037a73b 100644 --- a/pkgs/ffigen/test/native_test/native_test.c +++ b/pkgs/ffigen/test/native_test/native_test.c
@@ -49,3 +49,24 @@ s->data[2][0][1] = 6; return s; } + +struct Struct3 +{ + int a; + int b; + int c; +}; + +struct Struct3 Function1StructReturnByValue(int a, int b, int c) +{ + struct Struct3 s; + s.a = a; + s.b = b; + s.c = c; + return s; +} + +int Function1StructPassByValue(struct Struct3 sum_a_b_c) +{ + return sum_a_b_c.a + sum_a_b_c.b + sum_a_b_c.c; +}
diff --git a/pkgs/ffigen/test/native_test/native_test.dart b/pkgs/ffigen/test/native_test/native_test.dart index 479b910..5e90a0b 100644 --- a/pkgs/ffigen/test/native_test/native_test.dart +++ b/pkgs/ffigen/test/native_test/native_test.dart
@@ -135,5 +135,11 @@ expect(() => struct1.ref.data[0][0][-1] = 0, throwsA(TypeMatcher<RangeError>())); }); + test('Struct By Value', () { + final r = Random(); + final a = r.nextInt(100), b = r.nextInt(100), c = r.nextInt(100); + final s = bindings.Function1StructReturnByValue(a, b, c); + expect(bindings.Function1StructPassByValue(s), a + b + c); + }); }); }
diff --git a/pkgs/ffigen/test/native_test/native_test_bindings.dart b/pkgs/ffigen/test/native_test/native_test_bindings.dart index 60825f1..a4ae36f 100644 --- a/pkgs/ffigen/test/native_test/native_test_bindings.dart +++ b/pkgs/ffigen/test/native_test/native_test_bindings.dart
@@ -162,6 +162,34 @@ } _dart_getStruct1? _getStruct1; + + Struct3 Function1StructReturnByValue( + int a, + int b, + int c, + ) { + return (_Function1StructReturnByValue ??= _dylib.lookupFunction< + _c_Function1StructReturnByValue, + _dart_Function1StructReturnByValue>('Function1StructReturnByValue'))( + a, + b, + c, + ); + } + + _dart_Function1StructReturnByValue? _Function1StructReturnByValue; + + int Function1StructPassByValue( + Struct3 sum_a_b_c, + ) { + return (_Function1StructPassByValue ??= _dylib.lookupFunction< + _c_Function1StructPassByValue, + _dart_Function1StructPassByValue>('Function1StructPassByValue'))( + sum_a_b_c, + ); + } + + _dart_Function1StructPassByValue? _Function1StructPassByValue; } class Struct1 extends ffi.Struct { @@ -303,6 +331,17 @@ } } +class Struct3 extends ffi.Struct { + @ffi.Int32() + external int a; + + @ffi.Int32() + external int b; + + @ffi.Int32() + external int c; +} + typedef _c_Function1Bool = ffi.Uint8 Function( ffi.Uint8 x, ); @@ -402,3 +441,23 @@ typedef _c_getStruct1 = ffi.Pointer<Struct1> Function(); typedef _dart_getStruct1 = ffi.Pointer<Struct1> Function(); + +typedef _c_Function1StructReturnByValue = Struct3 Function( + ffi.Int32 a, + ffi.Int32 b, + ffi.Int32 c, +); + +typedef _dart_Function1StructReturnByValue = Struct3 Function( + int a, + int b, + int c, +); + +typedef _c_Function1StructPassByValue = ffi.Int32 Function( + Struct3 sum_a_b_c, +); + +typedef _dart_Function1StructPassByValue = int Function( + Struct3 sum_a_b_c, +);