libclang-bindings-0.1.0.0: cbits/clang_wrappers_ffi.h

/* this header is autogenerated with cabal run libclang-bootstrap */

#include "clang_config.h"

/* *** Top-level *** */

/* <https://clang.llvm.org/doxygen/group__CINDEX.html> */

/* OMITTED: CXIndex             clang_createIndexWithOptions (const CXIndexOptions * options); */

/* OMITTED: void                clang_CXIndex_setGlobalOptions (CXIndex, unsigned options); */

/* OMITTED: unsigned            clang_CXIndex_getGlobalOptions (CXIndex); */

/* OMITTED: void                clang_CXIndex_setInvocationEmissionPathOption (CXIndex, const char * Path); */

/* OMITTED: unsigned            clang_isFileMultipleIncludeGuarded (CXTranslationUnit tu, CXFile file); */

static inline void wrap_getLocation(CXTranslationUnit tu, CXFile file, unsigned line, unsigned column, CXSourceLocation * result) {
  *result = clang_getLocation(tu, file, line, column);
}

/* OMITTED: CXSourceLocation    clang_getLocationForOffset (CXTranslationUnit tu, CXFile file, unsigned offset); */

/* OMITTED: CXSourceRangeList * clang_getSkippedRanges (CXTranslationUnit tu, CXFile file); */

/* OMITTED: CXSourceRangeList * clang_getAllSkippedRanges (CXTranslationUnit tu); */

/* OMITTED: CXDiagnosticSet     clang_getDiagnosticSetFromTU (CXTranslationUnit Unit); */

/* *** Diagnostic reporting *** */

/* <https://clang.llvm.org/doxygen/group__CINDEX__DIAG.html> */

/* OMITTED: CXDiagnosticSet           clang_loadDiagnostics (const char * file, enum CXLoadDiag_Error * error, CXString * errorString); */

static inline void wrap_formatDiagnostic(CXDiagnostic Diagnostic, unsigned Options, CXString * result) {
  *result = clang_formatDiagnostic(Diagnostic, Options);
}

static inline void wrap_getDiagnosticLocation(CXDiagnostic Diag, CXSourceLocation * result) {
  *result = clang_getDiagnosticLocation(Diag);
}

static inline void wrap_getDiagnosticSpelling(CXDiagnostic Diag, CXString * result) {
  *result = clang_getDiagnosticSpelling(Diag);
}

static inline void wrap_getDiagnosticOption(CXDiagnostic Diag, CXString * Disable, CXString * result) {
  *result = clang_getDiagnosticOption(Diag, Disable);
}

static inline void wrap_getDiagnosticCategoryText(CXDiagnostic Diag, CXString * result) {
  *result = clang_getDiagnosticCategoryText(Diag);
}

static inline void wrap_getDiagnosticRange(CXDiagnostic Diagnostic, unsigned Range, CXSourceRange * result) {
  *result = clang_getDiagnosticRange(Diagnostic, Range);
}

static inline void wrap_getDiagnosticFixIt(CXDiagnostic Diagnostic, unsigned FixIt, CXSourceRange * ReplacementRange, CXString * result) {
  *result = clang_getDiagnosticFixIt(Diagnostic, FixIt, ReplacementRange);
}

/* *** File manipulation routines *** */

/* <https://clang.llvm.org/doxygen/group__CINDEX__FILES.html> */

static inline void wrap_getFileName(CXFile SFile, CXString * result) {
  *result = clang_getFileName(SFile);
}

/* OMITTED: time_t   clang_getFileTime (CXFile SFile); */

/* OMITTED: int      clang_getFileUniqueID (CXFile file, CXFileUniqueID * outID); */

/* OMITTED: int      clang_File_isEqual (CXFile file1, CXFile file2); */

/* OMITTED: CXString clang_File_tryGetRealPathName (CXFile file); */

/* *** Physical source locations *** */

/* <https://clang.llvm.org/doxygen/group__CINDEX__LOCATIONS.html> */

/* OMITTED: CXSourceLocation clang_getNullLocation (void); */

/* OMITTED: unsigned         clang_equalLocations (CXSourceLocation loc1, CXSourceLocation loc2); */

#ifdef HAVE_CLANG_ISBEFOREINTRANSLATIONUNIT

static inline unsigned wrap_isBeforeInTranslationUnit(const CXSourceLocation * loc1, const CXSourceLocation * loc2) {
  return clang_isBeforeInTranslationUnit(*loc1, *loc2);
}

#endif

/* OMITTED: int              clang_Location_isInSystemHeader (CXSourceLocation location); */

static inline int wrap_Location_isFromMainFile(const CXSourceLocation * location) {
  return clang_Location_isFromMainFile(*location);
}

/* OMITTED: CXSourceRange    clang_getNullRange (void); */

static inline void wrap_getRange(const CXSourceLocation * begin, const CXSourceLocation * end, CXSourceRange * result) {
  *result = clang_getRange(*begin, *end);
}

/* OMITTED: unsigned         clang_equalRanges (CXSourceRange range1, CXSourceRange range2); */

static inline int wrap_Range_isNull(const CXSourceRange * range) {
  return clang_Range_isNull(*range);
}

static inline void wrap_getExpansionLocation(const CXSourceLocation * location, CXFile * file, unsigned * line, unsigned * column, unsigned * offset) {
  return clang_getExpansionLocation(*location, file, line, column, offset);
}

static inline void wrap_getPresumedLocation(const CXSourceLocation * location, CXString * filename, unsigned * line, unsigned * column) {
  return clang_getPresumedLocation(*location, filename, line, column);
}

/* OMITTED: void             clang_getInstantiationLocation (CXSourceLocation location, CXFile * file, unsigned * line, unsigned * column, unsigned * offset); */

static inline void wrap_getSpellingLocation(const CXSourceLocation * location, CXFile * file, unsigned * line, unsigned * column, unsigned * offset) {
  return clang_getSpellingLocation(*location, file, line, column, offset);
}

static inline void wrap_getFileLocation(const CXSourceLocation * location, CXFile * file, unsigned * line, unsigned * column, unsigned * offset) {
  return clang_getFileLocation(*location, file, line, column, offset);
}

static inline void wrap_getRangeStart(const CXSourceRange * range, CXSourceLocation * result) {
  *result = clang_getRangeStart(*range);
}

static inline void wrap_getRangeEnd(const CXSourceRange * range, CXSourceLocation * result) {
  *result = clang_getRangeEnd(*range);
}

/* OMITTED: void             clang_disposeSourceRangeList (CXSourceRangeList * ranges); */

/* *** String manipulation routines *** */

/* <https://clang.llvm.org/doxygen/group__CINDEX__STRING.html> */

static inline const char * wrap_getCString(const CXString * string) {
  return clang_getCString(*string);
}

static inline void wrap_disposeString(const CXString * string) {
  return clang_disposeString(*string);
}

/* OMITTED: void         clang_disposeStringSet (CXStringSet * set); */

/* *** Translation unit manipulation *** */

/* <https://clang.llvm.org/doxygen/group__CINDEX__TRANSLATION__UNIT.html> */

/* OMITTED: CXString          clang_getTranslationUnitSpelling (CXTranslationUnit CTUnit); */

/* OMITTED: CXTranslationUnit clang_createTranslationUnitFromSourceFile (CXIndex CIdx, const char * source_filename, int num_clang_command_line_args, const char * const * clang_command_line_args, unsigned num_unsaved_files, struct CXUnsavedFile * unsaved_files); */

/* OMITTED: CXTranslationUnit clang_createTranslationUnit (CXIndex CIdx, const char * ast_filename); */

/* OMITTED: enum CXErrorCode  clang_createTranslationUnit2 (CXIndex CIdx, const char * ast_filename, CXTranslationUnit * out_TU); */

/* OMITTED: unsigned          clang_defaultEditingTranslationUnitOptions (void); */

/* OMITTED: enum CXErrorCode  clang_parseTranslationUnit2FullArgv (CXIndex CIdx, const char * source_filename, const char * const * command_line_args, int num_command_line_args, struct CXUnsavedFile * unsaved_files, unsigned num_unsaved_files, unsigned options, CXTranslationUnit * out_TU); */

/* OMITTED: unsigned          clang_defaultSaveOptions (CXTranslationUnit TU); */

/* OMITTED: int               clang_saveTranslationUnit (CXTranslationUnit TU, const char * FileName, unsigned options); */

/* OMITTED: unsigned          clang_suspendTranslationUnit (CXTranslationUnit TU); */

/* OMITTED: unsigned          clang_defaultReparseOptions (CXTranslationUnit TU); */

/* OMITTED: int               clang_reparseTranslationUnit (CXTranslationUnit TU, unsigned num_unsaved_files, struct CXUnsavedFile * unsaved_files, unsigned options); */

/* OMITTED: const char *      clang_getTUResourceUsageName (enum CXTUResourceUsageKind kind); */

/* OMITTED: CXTUResourceUsage clang_getCXTUResourceUsage (CXTranslationUnit TU); */

/* OMITTED: void              clang_disposeCXTUResourceUsage (CXTUResourceUsage usage); */

static inline void wrap_TargetInfo_getTriple(CXTargetInfo Info, CXString * result) {
  *result = clang_TargetInfo_getTriple(Info);
}

/* OMITTED: int               clang_TargetInfo_getPointerWidth (CXTargetInfo Info); */

/* *** Cursor manipulations *** */

/* <https://clang.llvm.org/doxygen/group__CINDEX__CURSOR__MANIP.html> */

static inline void wrap_getNullCursor(CXCursor * result) {
  *result = clang_getNullCursor();
}

static inline void wrap_getTranslationUnitCursor(CXTranslationUnit TU, CXCursor * result) {
  *result = clang_getTranslationUnitCursor(TU);
}

static inline unsigned wrap_equalCursors(const CXCursor * C1, const CXCursor * C2) {
  return clang_equalCursors(*C1, *C2);
}

static inline int wrap_Cursor_isNull(const CXCursor * C) {
  return clang_Cursor_isNull(*C);
}

static inline unsigned wrap_hashCursor(const CXCursor * C) {
  return clang_hashCursor(*C);
}

static inline enum CXCursorKind wrap_getCursorKind(const CXCursor * C) {
  return clang_getCursorKind(*C);
}

static inline unsigned wrap_isInvalidDeclaration(const CXCursor * C) {
  return clang_isInvalidDeclaration(*C);
}

static inline unsigned wrap_Cursor_hasAttrs(const CXCursor * C) {
  return clang_Cursor_hasAttrs(*C);
}

static inline enum CXLinkageKind wrap_getCursorLinkage(const CXCursor * cursor) {
  return clang_getCursorLinkage(*cursor);
}

static inline enum CXVisibilityKind wrap_getCursorVisibility(const CXCursor * cursor) {
  return clang_getCursorVisibility(*cursor);
}

static inline enum CXAvailabilityKind wrap_getCursorAvailability(const CXCursor * cursor) {
  return clang_getCursorAvailability(*cursor);
}

/* OMITTED: int                     clang_getCursorPlatformAvailability (CXCursor cursor, int * always_deprecated, CXString * deprecated_message, int * always_unavailable, CXString * unavailable_message, CXPlatformAvailability * availability, int availability_size); */

/* OMITTED: void                    clang_disposeCXPlatformAvailability (CXPlatformAvailability * availability); */

static inline void wrap_Cursor_getVarDeclInitializer(const CXCursor * cursor, CXCursor * result) {
  *result = clang_Cursor_getVarDeclInitializer(*cursor);
}

static inline int wrap_Cursor_hasVarDeclGlobalStorage(const CXCursor * cursor) {
  return clang_Cursor_hasVarDeclGlobalStorage(*cursor);
}

static inline int wrap_Cursor_hasVarDeclExternalStorage(const CXCursor * cursor) {
  return clang_Cursor_hasVarDeclExternalStorage(*cursor);
}

/* OMITTED: enum CXLanguageKind     clang_getCursorLanguage (CXCursor cursor); */

static inline enum CXTLSKind wrap_getCursorTLSKind(const CXCursor * cursor) {
  return clang_getCursorTLSKind(*cursor);
}

static inline CXTranslationUnit wrap_Cursor_getTranslationUnit(const CXCursor * cursor) {
  return clang_Cursor_getTranslationUnit(*cursor);
}

/* OMITTED: CXCursorSet             clang_createCXCursorSet (void); */

/* OMITTED: void                    clang_disposeCXCursorSet (CXCursorSet cset); */

/* OMITTED: unsigned                clang_CXCursorSet_contains (CXCursorSet cset, CXCursor cursor); */

/* OMITTED: unsigned                clang_CXCursorSet_insert (CXCursorSet cset, CXCursor cursor); */

static inline void wrap_getCursorSemanticParent(const CXCursor * cursor, CXCursor * result) {
  *result = clang_getCursorSemanticParent(*cursor);
}

static inline void wrap_getCursorLexicalParent(const CXCursor * cursor, CXCursor * result) {
  *result = clang_getCursorLexicalParent(*cursor);
}

/* OMITTED: void                    clang_getOverriddenCursors (CXCursor cursor, CXCursor * * overridden, unsigned * num_overridden); */

/* OMITTED: void                    clang_disposeOverriddenCursors (CXCursor * overridden); */

static inline CXFile wrap_getIncludedFile(const CXCursor * cursor) {
  return clang_getIncludedFile(*cursor);
}

/* *** Mapping between cursors and source code  *** */

/* <https://clang.llvm.org/doxygen/group__CINDEX__CURSOR__SOURCE.html> */

/* OMITTED: CXCursor         clang_getCursor (CXTranslationUnit TU, CXSourceLocation Source); */

static inline void wrap_getCursorLocation(const CXCursor * cursor, CXSourceLocation * result) {
  *result = clang_getCursorLocation(*cursor);
}

static inline void wrap_getCursorExtent(const CXCursor * cursor, CXSourceRange * result) {
  *result = clang_getCursorExtent(*cursor);
}

/* *** Type information for CXCursors *** */

/* <https://clang.llvm.org/doxygen/group__CINDEX__TYPES.html> */

static inline void wrap_getCursorType(const CXCursor * C, CXType * result) {
  *result = clang_getCursorType(*C);
}

static inline void wrap_getTypeSpelling(const CXType * CT, CXString * result) {
  *result = clang_getTypeSpelling(*CT);
}

static inline void wrap_getTypedefDeclUnderlyingType(const CXCursor * C, CXType * result) {
  *result = clang_getTypedefDeclUnderlyingType(*C);
}

static inline void wrap_getEnumDeclIntegerType(const CXCursor * C, CXType * result) {
  *result = clang_getEnumDeclIntegerType(*C);
}

static inline long long wrap_getEnumConstantDeclValue(const CXCursor * C) {
  return clang_getEnumConstantDeclValue(*C);
}

static inline unsigned long long wrap_getEnumConstantDeclUnsignedValue(const CXCursor * C) {
  return clang_getEnumConstantDeclUnsignedValue(*C);
}

static inline unsigned wrap_Cursor_isBitField(const CXCursor * C) {
  return clang_Cursor_isBitField(*C);
}

static inline int wrap_getFieldDeclBitWidth(const CXCursor * C) {
  return clang_getFieldDeclBitWidth(*C);
}

static inline int wrap_Cursor_getNumArguments(const CXCursor * C) {
  return clang_Cursor_getNumArguments(*C);
}

static inline void wrap_Cursor_getArgument(const CXCursor * C, unsigned i, CXCursor * result) {
  *result = clang_Cursor_getArgument(*C, i);
}

/* OMITTED: int                         clang_Cursor_getNumTemplateArguments (CXCursor C); */

/* OMITTED: enum CXTemplateArgumentKind clang_Cursor_getTemplateArgumentKind (CXCursor C, unsigned I); */

/* OMITTED: CXType                      clang_Cursor_getTemplateArgumentType (CXCursor C, unsigned I); */

/* OMITTED: long long                   clang_Cursor_getTemplateArgumentValue (CXCursor C, unsigned I); */

/* OMITTED: unsigned long long          clang_Cursor_getTemplateArgumentUnsignedValue (CXCursor C, unsigned I); */

static inline unsigned wrap_equalTypes(const CXType * A, const CXType * B) {
  return clang_equalTypes(*A, *B);
}

static inline void wrap_getCanonicalType(const CXType * T, CXType * result) {
  *result = clang_getCanonicalType(*T);
}

static inline unsigned wrap_isConstQualifiedType(const CXType * T) {
  return clang_isConstQualifiedType(*T);
}

static inline unsigned wrap_Cursor_isMacroFunctionLike(const CXCursor * C) {
  return clang_Cursor_isMacroFunctionLike(*C);
}

static inline unsigned wrap_Cursor_isMacroBuiltin(const CXCursor * C) {
  return clang_Cursor_isMacroBuiltin(*C);
}

static inline unsigned wrap_Cursor_isFunctionInlined(const CXCursor * C) {
  return clang_Cursor_isFunctionInlined(*C);
}

static inline unsigned wrap_isVolatileQualifiedType(const CXType * T) {
  return clang_isVolatileQualifiedType(*T);
}

static inline unsigned wrap_isRestrictQualifiedType(const CXType * T) {
  return clang_isRestrictQualifiedType(*T);
}

static inline unsigned wrap_getAddressSpace(const CXType * T) {
  return clang_getAddressSpace(*T);
}

static inline void wrap_getTypedefName(const CXType * CT, CXString * result) {
  *result = clang_getTypedefName(*CT);
}

static inline void wrap_getPointeeType(const CXType * T, CXType * result) {
  *result = clang_getPointeeType(*T);
}

/* OMITTED: CXType                      clang_getUnqualifiedType (CXType CT); // NOTE: does not exist before clang-16, so we define a custom wrapper in clang_wrappers.h */

/* OMITTED: CXType                      clang_getNonReferenceType (CXType CT); */

static inline void wrap_getTypeDeclaration(const CXType * T, CXCursor * result) {
  *result = clang_getTypeDeclaration(*T);
}

/* OMITTED: CXString                    clang_getDeclObjCTypeEncoding (CXCursor C); */

/* OMITTED: CXString                    clang_Type_getObjCEncoding (CXType type); */

static inline void wrap_getTypeKindSpelling(enum CXTypeKind K, CXString * result) {
  *result = clang_getTypeKindSpelling(K);
}

/* OMITTED: enum CXCallingConv          clang_getFunctionTypeCallingConv (CXType T); */

static inline void wrap_getResultType(const CXType * T, CXType * result) {
  *result = clang_getResultType(*T);
}

/* OMITTED: int                         clang_getExceptionSpecificationType (CXType T); */

static inline int wrap_getNumArgTypes(const CXType * T) {
  return clang_getNumArgTypes(*T);
}

static inline void wrap_getArgType(const CXType * T, unsigned i, CXType * result) {
  *result = clang_getArgType(*T, i);
}

static inline void wrap_Type_getObjCObjectBaseType(const CXType * T, CXType * result) {
  *result = clang_Type_getObjCObjectBaseType(*T);
}

static inline unsigned wrap_Type_getNumObjCProtocolRefs(const CXType * T) {
  return clang_Type_getNumObjCProtocolRefs(*T);
}

static inline void wrap_Type_getObjCProtocolDecl(const CXType * T, unsigned i, CXCursor * result) {
  *result = clang_Type_getObjCProtocolDecl(*T, i);
}

static inline unsigned wrap_Type_getNumObjCTypeArgs(const CXType * T) {
  return clang_Type_getNumObjCTypeArgs(*T);
}

static inline void wrap_Type_getObjCTypeArg(const CXType * T, unsigned i, CXType * result) {
  *result = clang_Type_getObjCTypeArg(*T, i);
}

static inline unsigned wrap_isFunctionTypeVariadic(const CXType * T) {
  return clang_isFunctionTypeVariadic(*T);
}

static inline void wrap_getCursorResultType(const CXCursor * C, CXType * result) {
  *result = clang_getCursorResultType(*C);
}

static inline int wrap_getCursorExceptionSpecificationType(const CXCursor * C) {
  return clang_getCursorExceptionSpecificationType(*C);
}

static inline unsigned wrap_isPODType(const CXType * T) {
  return clang_isPODType(*T);
}

static inline void wrap_getElementType(const CXType * T, CXType * result) {
  *result = clang_getElementType(*T);
}

static inline long long wrap_getNumElements(const CXType * T) {
  return clang_getNumElements(*T);
}

static inline void wrap_getArrayElementType(const CXType * T, CXType * result) {
  *result = clang_getArrayElementType(*T);
}

static inline long long wrap_getArraySize(const CXType * T) {
  return clang_getArraySize(*T);
}

static inline void wrap_Type_getNamedType(const CXType * T, CXType * result) {
  *result = clang_Type_getNamedType(*T);
}

static inline unsigned wrap_Type_isTransparentTagTypedef(const CXType * T) {
  return clang_Type_isTransparentTagTypedef(*T);
}

/* OMITTED: enum CXTypeNullabilityKind  clang_Type_getNullability (CXType T); */

static inline long long wrap_Type_getAlignOf(const CXType * T) {
  return clang_Type_getAlignOf(*T);
}

/* OMITTED: CXType                      clang_Type_getClassType (CXType T); */

static inline long long wrap_Type_getSizeOf(const CXType * T) {
  return clang_Type_getSizeOf(*T);
}

static inline long long wrap_Type_getOffsetOf(const CXType * T, const char * S) {
  return clang_Type_getOffsetOf(*T, S);
}

static inline void wrap_Type_getModifiedType(const CXType * T, CXType * result) {
  *result = clang_Type_getModifiedType(*T);
}

static inline void wrap_Type_getValueType(const CXType * CT, CXType * result) {
  *result = clang_Type_getValueType(*CT);
}

static inline long long wrap_Cursor_getOffsetOfField(const CXCursor * C) {
  return clang_Cursor_getOffsetOfField(*C);
}

static inline unsigned wrap_Cursor_isAnonymous(const CXCursor * C) {
  return clang_Cursor_isAnonymous(*C);
}

static inline unsigned wrap_Cursor_isAnonymousRecordDecl(const CXCursor * C) {
  return clang_Cursor_isAnonymousRecordDecl(*C);
}

/* OMITTED: unsigned                    clang_Cursor_isInlineNamespace (CXCursor C); */

/* OMITTED: int                         clang_Type_getNumTemplateArguments (CXType T); */

/* OMITTED: CXType                      clang_Type_getTemplateArgumentAsType (CXType T, unsigned i); */

/* OMITTED: enum CXRefQualifierKind     clang_Type_getCXXRefQualifier (CXType T); */

/* OMITTED: unsigned                    clang_isVirtualBase (CXCursor C); */

/* OMITTED: long long                   clang_getOffsetOfBase (CXCursor Parent, CXCursor Base); */

/* OMITTED: enum CX_CXXAccessSpecifier  clang_getCXXAccessSpecifier (CXCursor C); */

/* OMITTED: enum CX_BinaryOperatorKind  clang_Cursor_getBinaryOpcode (CXCursor C); */

/* OMITTED: CXString                    clang_Cursor_getBinaryOpcodeStr (enum CX_BinaryOperatorKind Op); */

static inline enum CX_StorageClass wrap_Cursor_getStorageClass(const CXCursor * C) {
  return clang_Cursor_getStorageClass(*C);
}

/* OMITTED: unsigned                    clang_getNumOverloadedDecls (CXCursor cursor); */

/* OMITTED: CXCursor                    clang_getOverloadedDecl (CXCursor cursor, unsigned index); */

/* *** Traversing the AST with cursors *** */

/* <https://clang.llvm.org/doxygen/group__CINDEX__CURSOR__TRAVERSAL.html> */

/* OMITTED: unsigned clang_visitChildren (CXCursor parent, CXCursorVisitor visitor, CXClientData client_data); */

/* OMITTED: unsigned clang_visitChildrenWithBlock (CXCursor parent, CXCursorVisitorBlock block); */

/* *** Cross-referencing in the AST  *** */

/* <https://clang.llvm.org/doxygen/group__CINDEX__CURSOR__XREF.html> */

/* OMITTED: CXString         clang_getCursorUSR (CXCursor); */

/* OMITTED: CXString         clang_constructUSR_ObjCClass (const char * class_name); */

/* OMITTED: CXString         clang_constructUSR_ObjCCategory (const char * class_name, const char * category_name); */

/* OMITTED: CXString         clang_constructUSR_ObjCProtocol (const char * protocol_name); */

/* OMITTED: CXString         clang_constructUSR_ObjCIvar (const char * name, CXString classUSR); */

/* OMITTED: CXString         clang_constructUSR_ObjCMethod (const char * name, unsigned isInstanceMethod, CXString classUSR); */

/* OMITTED: CXString         clang_constructUSR_ObjCProperty (const char * property, CXString classUSR); */

static inline void wrap_getCursorSpelling(const CXCursor * C, CXString * result) {
  *result = clang_getCursorSpelling(*C);
}

static inline void wrap_Cursor_getSpellingNameRange(const CXCursor * C, unsigned pieceIndex, unsigned options, CXSourceRange * result) {
  *result = clang_Cursor_getSpellingNameRange(*C, pieceIndex, options);
}

/* OMITTED: unsigned         clang_PrintingPolicy_getProperty (CXPrintingPolicy Policy, enum CXPrintingPolicyProperty Property); */

/* OMITTED: void             clang_PrintingPolicy_setProperty (CXPrintingPolicy Policy, enum CXPrintingPolicyProperty Property, unsigned Value); */

static inline CXPrintingPolicy wrap_getCursorPrintingPolicy(const CXCursor * C) {
  return clang_getCursorPrintingPolicy(*C);
}

static inline void wrap_getCursorPrettyPrinted(const CXCursor * Cursor, CXPrintingPolicy Policy, CXString * result) {
  *result = clang_getCursorPrettyPrinted(*Cursor, Policy);
}

/* OMITTED: CXString         clang_getTypePrettyPrinted (CXType CT, CXPrintingPolicy cxPolicy); */

/* OMITTED: CXString         clang_getFullyQualifiedName (CXType CT, CXPrintingPolicy Policy, unsigned WithGlobalNsPrefix); */

static inline void wrap_getCursorDisplayName(const CXCursor * C, CXString * result) {
  *result = clang_getCursorDisplayName(*C);
}

static inline void wrap_getCursorReferenced(const CXCursor * C, CXCursor * result) {
  *result = clang_getCursorReferenced(*C);
}

static inline void wrap_getCursorDefinition(const CXCursor * C, CXCursor * result) {
  *result = clang_getCursorDefinition(*C);
}

static inline unsigned wrap_isCursorDefinition(const CXCursor * C) {
  return clang_isCursorDefinition(*C);
}

static inline void wrap_getCanonicalCursor(const CXCursor * C, CXCursor * result) {
  *result = clang_getCanonicalCursor(*C);
}

/* OMITTED: int              clang_Cursor_getObjCSelectorIndex (CXCursor); */

/* OMITTED: int              clang_Cursor_isDynamicCall (CXCursor C); */

/* OMITTED: CXType           clang_Cursor_getReceiverType (CXCursor C); */

/* OMITTED: unsigned         clang_Cursor_getObjCPropertyAttributes (CXCursor C, unsigned reserved); */

/* OMITTED: CXString         clang_Cursor_getObjCPropertyGetterName (CXCursor C); */

/* OMITTED: CXString         clang_Cursor_getObjCPropertySetterName (CXCursor C); */

/* OMITTED: unsigned         clang_Cursor_getObjCDeclQualifiers (CXCursor C); */

/* OMITTED: unsigned         clang_Cursor_isObjCOptional (CXCursor C); */

/* OMITTED: unsigned         clang_Cursor_isVariadic (CXCursor C); */

/* OMITTED: unsigned         clang_Cursor_isExternalSymbol (CXCursor C, CXString * language, CXString * definedIn, unsigned * isGenerated); */

/* OMITTED: CXSourceRange    clang_Cursor_getCommentRange (CXCursor C); */

static inline void wrap_Cursor_getRawCommentText(const CXCursor * C, CXString * result) {
  *result = clang_Cursor_getRawCommentText(*C);
}

static inline void wrap_Cursor_getBriefCommentText(const CXCursor * C, CXString * result) {
  *result = clang_Cursor_getBriefCommentText(*C);
}

/* *** Token extraction and manipulation *** */

/* <https://clang.llvm.org/doxygen/group__CINDEX__LEX.html> */

static inline CXToken * wrap_getToken(CXTranslationUnit TU, const CXSourceLocation * Location) {
  return clang_getToken(TU, *Location);
}

static inline CXTokenKind wrap_getTokenKind(const CXToken * Token) {
  return clang_getTokenKind(*Token);
}

static inline void wrap_getTokenSpelling(CXTranslationUnit TU, const CXToken * Token, CXString * result) {
  *result = clang_getTokenSpelling(TU, *Token);
}

static inline void wrap_getTokenLocation(CXTranslationUnit TU, const CXToken * Token, CXSourceLocation * result) {
  *result = clang_getTokenLocation(TU, *Token);
}

static inline void wrap_getTokenExtent(CXTranslationUnit TU, const CXToken * Token, CXSourceRange * result) {
  *result = clang_getTokenExtent(TU, *Token);
}

static inline void wrap_tokenize(CXTranslationUnit TU, const CXSourceRange * Range, CXToken * * Tokens, unsigned * NumTokens) {
  return clang_tokenize(TU, *Range, Tokens, NumTokens);
}

/* *** Debugging facilities *** */

/* <https://clang.llvm.org/doxygen/group__CINDEX__DEBUG.html> */

static inline void wrap_getCursorKindSpelling(enum CXCursorKind Kind, CXString * result) {
  *result = clang_getCursorKindSpelling(Kind);
}

/* OMITTED: void     clang_getDefinitionSpellingAndExtent (CXCursor, const char * * startBuf, const char * * endBuf, unsigned * startLine, unsigned * startColumn, unsigned * endLine, unsigned * endColumn); */

/* OMITTED: void     clang_enableStackTraces (void); */

/* OMITTED: void     clang_executeOnThread (void(*fn)(void *), void * user_data, unsigned stack_size); // NOTE: function pointer syntax not supported by the libclang-bootstrap parser */

/* *** Miscellaneous utility functions *** */

/* <https://clang.llvm.org/doxygen/group__CINDEX__MISC.html> */

static inline void wrap_getClangVersion(CXString * result) {
  *result = clang_getClangVersion();
}

/* OMITTED: void               clang_toggleCrashRecovery (unsigned isEnabled); */

/* OMITTED: void               clang_getInclusions (CXTranslationUnit tu, CXInclusionVisitor visitor, CXClientData client_data); */

static inline CXEvalResult wrap_Cursor_Evaluate(const CXCursor * C) {
  return clang_Cursor_Evaluate(*C);
}