Skip to content

Instantly share code, notes, and snippets.

@dirx

dirx/ffi-clang-based-header-file-parsing.php

Last active December 18, 2020 20:50
Show Gist options
  • Save dirx/3c9c78e922430936496385fd75afcfd1 to your computer and use it in GitHub Desktop.
Save dirx/3c9c78e922430936496385fd75afcfd1 to your computer and use it in GitHub Desktop.
Download ZIP
Raw
ffi-clang-based-header-file-parsing.php
<?php
/**
* just trying to parse a header file with clang bound with php ffi ... it´s a start...
* and - yes - by binding ffi with ffi.... btw ... ieaks
*
* playing around in php74 cli buster docker image ...
* requires php ffi ext (libffi-dev) installed, clang 10 (libclang-common-10-dev libclang-10-dev)
*
* libc dlsym docs
* http://manpages.ubuntu.com/manpages/bionic/man3/dlsym.3.html
* lib clang-c docs
* http://clang.llvm.org/doxygen/Index_8h.html
* https://clang.llvm.org/docs/ClangCommandLineReference.html
* libffi docs
* http://www.chiark.greenend.org.uk/doc/libffi-dev/html/The-Basics.html#The-Basics
*/
declare(strict_types=1);
require(__DIR__ . '/vendor/autoload.php');
// libc - for function pointers
$libc = FFI::cdef(
"
void *dlopen(const char *filename, int flags);
int dlclose(void *handle);
void *dlsym(void *handle, const char *symbol);
char *dlerror(void);
"
);
// libffi binding - why? because php 7.4.2 ffi ext does not support structs as return values or params (only pointers to....)
//$file = '/usr/include/x86_64-linux-gnu/ffi.h';
//$file = __DIR__ . '/ffi.h.parsed';
//$parsedHContent = file_get_contents($file);
$parsedHContent = <<<CDEF
typedef unsigned long ffi_arg;
typedef signed long ffi_sarg;
typedef enum ffi_abi {
FFI_FIRST_ABI = 0,
FFI_SYSV,
FFI_UNIX64,
FFI_THISCALL,
FFI_FASTCALL,
FFI_STDCALL,
FFI_PASCAL,
FFI_REGISTER,
FFI_LAST_ABI,
FFI_DEFAULT_ABI = FFI_UNIX64,
} ffi_abi;
typedef long int ptrdiff_t;
typedef int wchar_t;
typedef struct _ffi_type {
size_t size;
unsigned short alignment;
unsigned short type;
struct _ffi_type **elements;
} ffi_type;
typedef enum {
FFI_OK = 0,
FFI_BAD_TYPEDEF,
FFI_BAD_ABI,
} ffi_status;
typedef unsigned FFI_TYPE;
typedef struct {
ffi_abi abi;
unsigned nargs;
ffi_type **arg_types;
ffi_type *rtype;
unsigned bytes;
unsigned flags;
} ffi_cif;
typedef union {
ffi_sarg sint;
ffi_arg uint;
float flt;
char data[8];
void *ptr;
} ffi_raw;
typedef ffi_raw ffi_java_raw;
void ffi_raw_call(ffi_cif *cif, void(*fn)(void), void *rvalue, ffi_raw *avalue);
void ffi_ptrarray_to_raw(ffi_cif *cif, void **args, ffi_raw *raw);
void ffi_raw_to_ptrarray(ffi_cif *cif, ffi_raw *raw, void **args);
size_t ffi_raw_size(ffi_cif *cif);
void ffi_java_raw_call(ffi_cif *cif, void(*fn)(void), void *rvalue, ffi_java_raw *avalue);
void ffi_java_ptrarray_to_raw(ffi_cif *cif, void **args, ffi_java_raw *raw);
void ffi_java_raw_to_ptrarray(ffi_cif *cif, ffi_java_raw *raw, void **args);
size_t ffi_java_raw_size(ffi_cif *cif);
typedef struct {
char tramp[24];
ffi_cif *cif;
void(*fun)(ffi_cif *, void *, void **, void *);
void *user_data;
} ffi_closure;
void * ffi_closure_alloc(size_t size, void **code);
void ffi_closure_free(void *);
ffi_status ffi_prep_closure(ffi_closure *, ffi_cif *, void(*fun)(ffi_cif *, void *, void **, void *), void *user_data);
ffi_status ffi_prep_closure_loc(ffi_closure *, ffi_cif *, void(*fun)(ffi_cif *, void *, void **, void *), void *user_data, void *codeloc);
typedef struct {
char tramp[24];
ffi_cif *cif;
void(*translate_args)(ffi_cif *, void *, void **, void *);
void *this_closure;
void(*fun)(ffi_cif *, void *, ffi_raw *, void *);
void *user_data;
} ffi_raw_closure;
typedef struct {
char tramp[24];
ffi_cif *cif;
void(*translate_args)(ffi_cif *, void *, void **, void *);
void *this_closure;
void(*fun)(ffi_cif *, void *, ffi_java_raw *, void *);
void *user_data;
} ffi_java_raw_closure;
ffi_status ffi_prep_raw_closure(ffi_raw_closure *, ffi_cif *cif, void(*fun)(ffi_cif *, void *, ffi_raw *, void *), void *user_data);
ffi_status ffi_prep_raw_closure_loc(ffi_raw_closure *, ffi_cif *cif, void(*fun)(ffi_cif *, void *, ffi_raw *, void *), void *user_data, void *codeloc);
ffi_status ffi_prep_java_raw_closure(ffi_java_raw_closure *, ffi_cif *cif, void(*fun)(ffi_cif *, void *, ffi_java_raw *, void *), void *user_data);
ffi_status ffi_prep_java_raw_closure_loc(ffi_java_raw_closure *, ffi_cif *cif, void(*fun)(ffi_cif *, void *, ffi_java_raw *, void *), void *user_data, void *codeloc);
ffi_status ffi_prep_cif(ffi_cif *cif, ffi_abi abi, unsigned int nargs, ffi_type *rtype, ffi_type **atypes);
ffi_status ffi_prep_cif_var(ffi_cif *cif, ffi_abi abi, unsigned int nfixedargs, unsigned int ntotalargs, ffi_type *rtype, ffi_type **atypes);
void ffi_call(ffi_cif *cif, void(*fn)(void), void *rvalue, void **avalue);
CDEF;
$ffi = \FFI::cdef(
$parsedHContent,
'/usr/lib/x86_64-linux-gnu/libffi.so.6'
);
// abi type
const FFI_FIRST_ABI = 0;
const FFI_SYSV = 1;
const FFI_UNIX64 = 2;
const FFI_THISCALL = 3;
const FFI_FASTCALL = 4;
const FFI_STDCALL = 5;
const FFI_PASCAL = 6;
const FFI_REGISTER = 7;
const FFI_LAST_ABI = 8;
const FFI_DEFAULT_ABI = FFI_UNIX64;
// ffi types
const FFI_TYPE_VOID = 0;
const FFI_TYPE_INT = 1;
const FFI_TYPE_FLOAT = 2;
const FFI_TYPE_DOUBLE = 3;
const FFI_TYPE_LONGDOUBLE = 4;
const FFI_TYPE_UINT8 = 5;
const FFI_TYPE_SINT8 = 6;
const FFI_TYPE_UINT16 = 7;
const FFI_TYPE_SINT16 = 8;
const FFI_TYPE_UINT32 = 9;
const FFI_TYPE_SINT32 = 10;
const FFI_TYPE_UINT64 = 11;
const FFI_TYPE_SINT64 = 12;
const FFI_TYPE_STRUCT = 13;
const FFI_TYPE_POINTER = 14;
const FFI_TYPE_COMPLEX = 15;
const FFI_TYPE_LAST = FFI_TYPE_COMPLEX;
// ffi status
const FFI_OK = 0;
const FFI_BAD_TYPEDEF = 1;
const FFI_BAD_ABI = 2;
//$file = '/usr/lib/llvm-10/include/clang-c/Index.h';
//$file = __DIR__ . '/Index.h.parsed';
//$parsedHContent = file_get_contents($file);
$parsedHContent = <<<CDEF
typedef int time_t;
enum CXErrorCode {
CXError_Success = 0,
CXError_Failure = 1,
CXError_Crashed = 2,
CXError_InvalidArguments = 3,
CXError_ASTReadError = 4,
};
typedef struct {
void *data;
unsigned private_flags;
} CXString;
typedef struct {
CXString *Strings;
unsigned Count;
} CXStringSet;
char * clang_getCString(CXString string);
void clang_disposeString(CXString string);
void clang_disposeStringSet(CXStringSet *set);
unsigned long long clang_getBuildSessionTimestamp(void);
typedef struct CXVirtualFileOverlayImpl * CXVirtualFileOverlay;
CXVirtualFileOverlay clang_VirtualFileOverlay_create(unsigned options);
enum CXErrorCode clang_VirtualFileOverlay_addFileMapping(CXVirtualFileOverlay, char *virtualPath, char *realPath);
enum CXErrorCode clang_VirtualFileOverlay_setCaseSensitivity(CXVirtualFileOverlay, int caseSensitive);
enum CXErrorCode clang_VirtualFileOverlay_writeToBuffer(CXVirtualFileOverlay, unsigned options, char **out_buffer_ptr, unsigned *out_buffer_size);
void clang_free(void *buffer);
void clang_VirtualFileOverlay_dispose(CXVirtualFileOverlay);
typedef struct CXModuleMapDescriptorImpl * CXModuleMapDescriptor;
CXModuleMapDescriptor clang_ModuleMapDescriptor_create(unsigned options);
enum CXErrorCode clang_ModuleMapDescriptor_setFrameworkModuleName(CXModuleMapDescriptor, char *name);
enum CXErrorCode clang_ModuleMapDescriptor_setUmbrellaHeader(CXModuleMapDescriptor, char *name);
enum CXErrorCode clang_ModuleMapDescriptor_writeToBuffer(CXModuleMapDescriptor, unsigned options, char **out_buffer_ptr, unsigned *out_buffer_size);
void clang_ModuleMapDescriptor_dispose(CXModuleMapDescriptor);
typedef void * CXIndex;
typedef struct CXTargetInfoImpl * CXTargetInfo;
typedef struct CXTranslationUnitImpl * CXTranslationUnit;
typedef void * CXClientData;
struct CXUnsavedFile {
char *Filename;
char *Contents;
unsigned long Length;
};
enum CXAvailabilityKind {
CXAvailability_Available,
CXAvailability_Deprecated,
CXAvailability_NotAvailable,
CXAvailability_NotAccessible,
};
typedef struct CXVersion {
int Major;
int Minor;
int Subminor;
} CXVersion;
enum CXCursor_ExceptionSpecificationKind {
CXCursor_ExceptionSpecificationKind_None,
CXCursor_ExceptionSpecificationKind_DynamicNone,
CXCursor_ExceptionSpecificationKind_Dynamic,
CXCursor_ExceptionSpecificationKind_MSAny,
CXCursor_ExceptionSpecificationKind_BasicNoexcept,
CXCursor_ExceptionSpecificationKind_ComputedNoexcept,
CXCursor_ExceptionSpecificationKind_Unevaluated,
CXCursor_ExceptionSpecificationKind_Uninstantiated,
CXCursor_ExceptionSpecificationKind_Unparsed,
CXCursor_ExceptionSpecificationKind_NoThrow,
};
CXIndex clang_createIndex(int excludeDeclarationsFromPCH, int displayDiagnostics);
void clang_disposeIndex(CXIndex index);
typedef enum {
CXGlobalOpt_None = 0x0,
CXGlobalOpt_ThreadBackgroundPriorityForIndexing = 0x1,
CXGlobalOpt_ThreadBackgroundPriorityForEditing = 0x2,
CXGlobalOpt_ThreadBackgroundPriorityForAll = (CXGlobalOpt_ThreadBackgroundPriorityForIndexing | CXGlobalOpt_ThreadBackgroundPriorityForEditing),
} CXGlobalOptFlags;
void clang_CXIndex_setGlobalOptions(CXIndex, unsigned options);
unsigned clang_CXIndex_getGlobalOptions(CXIndex);
void clang_CXIndex_setInvocationEmissionPathOption(CXIndex, char *Path);
typedef void * CXFile;
CXString clang_getFileName(CXFile SFile);
time_t clang_getFileTime(CXFile SFile);
typedef struct {
unsigned long long data[3];
} CXFileUniqueID;
int clang_getFileUniqueID(CXFile file, CXFileUniqueID *outID);
unsigned clang_isFileMultipleIncludeGuarded(CXTranslationUnit tu, CXFile file);
CXFile clang_getFile(CXTranslationUnit tu, char *file_name);
char * clang_getFileContents(CXTranslationUnit tu, CXFile file, size_t *size);
int clang_File_isEqual(CXFile file1, CXFile file2);
CXString clang_File_tryGetRealPathName(CXFile file);
typedef struct {
void *ptr_data[2];
unsigned int_data;
} CXSourceLocation;
typedef struct {
void *ptr_data[2];
unsigned begin_int_data;
unsigned end_int_data;
} CXSourceRange;
CXSourceLocation clang_getNullLocation(void);
unsigned clang_equalLocations(CXSourceLocation loc1, CXSourceLocation loc2);
CXSourceLocation clang_getLocation(CXTranslationUnit tu, CXFile file, unsigned line, unsigned column);
CXSourceLocation clang_getLocationForOffset(CXTranslationUnit tu, CXFile file, unsigned offset);
int clang_Location_isInSystemHeader(CXSourceLocation location);
int clang_Location_isFromMainFile(CXSourceLocation location);
CXSourceRange clang_getNullRange(void);
CXSourceRange clang_getRange(CXSourceLocation begin, CXSourceLocation end);
unsigned clang_equalRanges(CXSourceRange range1, CXSourceRange range2);
int clang_Range_isNull(CXSourceRange range);
void clang_getExpansionLocation(CXSourceLocation location, CXFile *file, unsigned *line, unsigned *column, unsigned *offset);
void clang_getPresumedLocation(CXSourceLocation location, CXString *filename, unsigned *line, unsigned *column);
void clang_getInstantiationLocation(CXSourceLocation location, CXFile *file, unsigned *line, unsigned *column, unsigned *offset);
void clang_getSpellingLocation(CXSourceLocation location, CXFile *file, unsigned *line, unsigned *column, unsigned *offset);
void clang_getFileLocation(CXSourceLocation location, CXFile *file, unsigned *line, unsigned *column, unsigned *offset);
CXSourceLocation clang_getRangeStart(CXSourceRange range);
CXSourceLocation clang_getRangeEnd(CXSourceRange range);
typedef struct {
unsigned count;
CXSourceRange *ranges;
} CXSourceRangeList;
CXSourceRangeList * clang_getSkippedRanges(CXTranslationUnit tu, CXFile file);
CXSourceRangeList * clang_getAllSkippedRanges(CXTranslationUnit tu);
void clang_disposeSourceRangeList(CXSourceRangeList *ranges);
enum CXDiagnosticSeverity {
CXDiagnostic_Ignored = 0,
CXDiagnostic_Note = 1,
CXDiagnostic_Warning = 2,
CXDiagnostic_Error = 3,
CXDiagnostic_Fatal = 4,
};
typedef void * CXDiagnostic;
typedef void * CXDiagnosticSet;
unsigned clang_getNumDiagnosticsInSet(CXDiagnosticSet Diags);
CXDiagnostic clang_getDiagnosticInSet(CXDiagnosticSet Diags, unsigned Index);
enum CXLoadDiag_Error {
CXLoadDiag_None = 0,
CXLoadDiag_Unknown = 1,
CXLoadDiag_CannotLoad = 2,
CXLoadDiag_InvalidFile = 3,
};
CXDiagnosticSet clang_loadDiagnostics(char *file, enum CXLoadDiag_Error *error, CXString *errorString);
void clang_disposeDiagnosticSet(CXDiagnosticSet Diags);
CXDiagnosticSet clang_getChildDiagnostics(CXDiagnostic D);
unsigned clang_getNumDiagnostics(CXTranslationUnit Unit);
CXDiagnostic clang_getDiagnostic(CXTranslationUnit Unit, unsigned Index);
CXDiagnosticSet clang_getDiagnosticSetFromTU(CXTranslationUnit Unit);
void clang_disposeDiagnostic(CXDiagnostic Diagnostic);
enum CXDiagnosticDisplayOptions {
CXDiagnostic_DisplaySourceLocation = 0x01,
CXDiagnostic_DisplayColumn = 0x02,
CXDiagnostic_DisplaySourceRanges = 0x04,
CXDiagnostic_DisplayOption = 0x08,
CXDiagnostic_DisplayCategoryId = 0x10,
CXDiagnostic_DisplayCategoryName = 0x20,
};
CXString clang_formatDiagnostic(CXDiagnostic Diagnostic, unsigned Options);
unsigned clang_defaultDiagnosticDisplayOptions(void);
enum CXDiagnosticSeverity clang_getDiagnosticSeverity(CXDiagnostic);
CXSourceLocation clang_getDiagnosticLocation(CXDiagnostic);
CXString clang_getDiagnosticSpelling(CXDiagnostic);
CXString clang_getDiagnosticOption(CXDiagnostic Diag, CXString *Disable);
unsigned clang_getDiagnosticCategory(CXDiagnostic);
CXString clang_getDiagnosticCategoryName(unsigned Category);
CXString clang_getDiagnosticCategoryText(CXDiagnostic);
unsigned clang_getDiagnosticNumRanges(CXDiagnostic);
CXSourceRange clang_getDiagnosticRange(CXDiagnostic Diagnostic, unsigned Range);
unsigned clang_getDiagnosticNumFixIts(CXDiagnostic Diagnostic);
CXString clang_getDiagnosticFixIt(CXDiagnostic Diagnostic, unsigned FixIt, CXSourceRange *ReplacementRange);
CXString clang_getTranslationUnitSpelling(CXTranslationUnit CTUnit);
CXTranslationUnit clang_createTranslationUnitFromSourceFile(CXIndex CIdx, char *source_filename, int num_clang_command_line_args, char **clang_command_line_args, unsigned num_unsaved_files, struct CXUnsavedFile *unsaved_files);
CXTranslationUnit clang_createTranslationUnit(CXIndex CIdx, char *ast_filename);
enum CXErrorCode clang_createTranslationUnit2(CXIndex CIdx, char *ast_filename, CXTranslationUnit *out_TU);
enum CXTranslationUnit_Flags {
CXTranslationUnit_None = 0x0,
CXTranslationUnit_DetailedPreprocessingRecord = 0x01,
CXTranslationUnit_Incomplete = 0x02,
CXTranslationUnit_PrecompiledPreamble = 0x04,
CXTranslationUnit_CacheCompletionResults = 0x08,
CXTranslationUnit_ForSerialization = 0x10,
CXTranslationUnit_CXXChainedPCH = 0x20,
CXTranslationUnit_SkipFunctionBodies = 0x40,
CXTranslationUnit_IncludeBriefCommentsInCodeCompletion = 0x80,
CXTranslationUnit_CreatePreambleOnFirstParse = 0x100,
CXTranslationUnit_KeepGoing = 0x200,
CXTranslationUnit_SingleFileParse = 0x400,
CXTranslationUnit_LimitSkipFunctionBodiesToPreamble = 0x800,
CXTranslationUnit_IncludeAttributedTypes = 0x1000,
CXTranslationUnit_VisitImplicitAttributes = 0x2000,
CXTranslationUnit_IgnoreNonErrorsFromIncludedFiles = 0x4000,
CXTranslationUnit_RetainExcludedConditionalBlocks = 0x8000,
};
unsigned clang_defaultEditingTranslationUnitOptions(void);
CXTranslationUnit clang_parseTranslationUnit(CXIndex CIdx, char *source_filename, char **command_line_args, int num_command_line_args, struct CXUnsavedFile *unsaved_files, unsigned num_unsaved_files, unsigned options);
enum CXErrorCode clang_parseTranslationUnit2(CXIndex CIdx, char *source_filename, char **command_line_args, int num_command_line_args, struct CXUnsavedFile *unsaved_files, unsigned num_unsaved_files, unsigned options, CXTranslationUnit *out_TU);
enum CXErrorCode clang_parseTranslationUnit2FullArgv(CXIndex CIdx, char *source_filename, char **command_line_args, int num_command_line_args, struct CXUnsavedFile *unsaved_files, unsigned num_unsaved_files, unsigned options, CXTranslationUnit *out_TU);
enum CXSaveTranslationUnit_Flags {
CXSaveTranslationUnit_None = 0x0,
};
unsigned clang_defaultSaveOptions(CXTranslationUnit TU);
enum CXSaveError {
CXSaveError_None = 0,
CXSaveError_Unknown = 1,
CXSaveError_TranslationErrors = 2,
CXSaveError_InvalidTU = 3,
};
int clang_saveTranslationUnit(CXTranslationUnit TU, char *FileName, unsigned options);
unsigned clang_suspendTranslationUnit(CXTranslationUnit);
void clang_disposeTranslationUnit(CXTranslationUnit);
enum CXReparse_Flags {
CXReparse_None = 0x0,
};
unsigned clang_defaultReparseOptions(CXTranslationUnit TU);
int clang_reparseTranslationUnit(CXTranslationUnit TU, unsigned num_unsaved_files, struct CXUnsavedFile *unsaved_files, unsigned options);
enum CXTUResourceUsageKind {
CXTUResourceUsage_AST = 1,
CXTUResourceUsage_Identifiers = 2,
CXTUResourceUsage_Selectors = 3,
CXTUResourceUsage_GlobalCompletionResults = 4,
CXTUResourceUsage_SourceManagerContentCache = 5,
CXTUResourceUsage_AST_SideTables = 6,
CXTUResourceUsage_SourceManager_Membuffer_Malloc = 7,
CXTUResourceUsage_SourceManager_Membuffer_MMap = 8,
CXTUResourceUsage_ExternalASTSource_Membuffer_Malloc = 9,
CXTUResourceUsage_ExternalASTSource_Membuffer_MMap = 10,
CXTUResourceUsage_Preprocessor = 11,
CXTUResourceUsage_PreprocessingRecord = 12,
CXTUResourceUsage_SourceManager_DataStructures = 13,
CXTUResourceUsage_Preprocessor_HeaderSearch = 14,
CXTUResourceUsage_MEMORY_IN_BYTES_BEGIN = CXTUResourceUsage_AST,
CXTUResourceUsage_MEMORY_IN_BYTES_END = CXTUResourceUsage_Preprocessor_HeaderSearch,
CXTUResourceUsage_First = CXTUResourceUsage_AST,
CXTUResourceUsage_Last = CXTUResourceUsage_Preprocessor_HeaderSearch,
};
char * clang_getTUResourceUsageName(enum CXTUResourceUsageKind kind);
typedef struct CXTUResourceUsageEntry {
enum CXTUResourceUsageKind kind;
unsigned long amount;
} CXTUResourceUsageEntry;
typedef struct CXTUResourceUsage {
void *data;
unsigned numEntries;
CXTUResourceUsageEntry *entries;
} CXTUResourceUsage;
CXTUResourceUsage clang_getCXTUResourceUsage(CXTranslationUnit TU);
void clang_disposeCXTUResourceUsage(CXTUResourceUsage usage);
CXTargetInfo clang_getTranslationUnitTargetInfo(CXTranslationUnit CTUnit);
void clang_TargetInfo_dispose(CXTargetInfo Info);
CXString clang_TargetInfo_getTriple(CXTargetInfo Info);
int clang_TargetInfo_getPointerWidth(CXTargetInfo Info);
enum CXCursorKind {
CXCursor_UnexposedDecl = 1,
CXCursor_StructDecl = 2,
CXCursor_UnionDecl = 3,
CXCursor_ClassDecl = 4,
CXCursor_EnumDecl = 5,
CXCursor_FieldDecl = 6,
CXCursor_EnumConstantDecl = 7,
CXCursor_FunctionDecl = 8,
CXCursor_VarDecl = 9,
CXCursor_ParmDecl = 10,
CXCursor_ObjCInterfaceDecl = 11,
CXCursor_ObjCCategoryDecl = 12,
CXCursor_ObjCProtocolDecl = 13,
CXCursor_ObjCPropertyDecl = 14,
CXCursor_ObjCIvarDecl = 15,
CXCursor_ObjCInstanceMethodDecl = 16,
CXCursor_ObjCClassMethodDecl = 17,
CXCursor_ObjCImplementationDecl = 18,
CXCursor_ObjCCategoryImplDecl = 19,
CXCursor_TypedefDecl = 20,
CXCursor_CXXMethod = 21,
CXCursor_Namespace = 22,
CXCursor_LinkageSpec = 23,
CXCursor_Constructor = 24,
CXCursor_Destructor = 25,
CXCursor_ConversionFunction = 26,
CXCursor_TemplateTypeParameter = 27,
CXCursor_NonTypeTemplateParameter = 28,
CXCursor_TemplateTemplateParameter = 29,
CXCursor_FunctionTemplate = 30,
CXCursor_ClassTemplate = 31,
CXCursor_ClassTemplatePartialSpecialization = 32,
CXCursor_NamespaceAlias = 33,
CXCursor_UsingDirective = 34,
CXCursor_UsingDeclaration = 35,
CXCursor_TypeAliasDecl = 36,
CXCursor_ObjCSynthesizeDecl = 37,
CXCursor_ObjCDynamicDecl = 38,
CXCursor_CXXAccessSpecifier = 39,
CXCursor_FirstDecl = CXCursor_UnexposedDecl,
CXCursor_LastDecl = CXCursor_CXXAccessSpecifier,
CXCursor_FirstRef = 40,
CXCursor_ObjCSuperClassRef = 40,
CXCursor_ObjCProtocolRef = 41,
CXCursor_ObjCClassRef = 42,
CXCursor_TypeRef = 43,
CXCursor_CXXBaseSpecifier = 44,
CXCursor_TemplateRef = 45,
CXCursor_NamespaceRef = 46,
CXCursor_MemberRef = 47,
CXCursor_LabelRef = 48,
CXCursor_OverloadedDeclRef = 49,
CXCursor_VariableRef = 50,
CXCursor_LastRef = CXCursor_VariableRef,
CXCursor_FirstInvalid = 70,
CXCursor_InvalidFile = 70,
CXCursor_NoDeclFound = 71,
CXCursor_NotImplemented = 72,
CXCursor_InvalidCode = 73,
CXCursor_LastInvalid = CXCursor_InvalidCode,
CXCursor_FirstExpr = 100,
CXCursor_UnexposedExpr = 100,
CXCursor_DeclRefExpr = 101,
CXCursor_MemberRefExpr = 102,
CXCursor_CallExpr = 103,
CXCursor_ObjCMessageExpr = 104,
CXCursor_BlockExpr = 105,
CXCursor_IntegerLiteral = 106,
CXCursor_FloatingLiteral = 107,
CXCursor_ImaginaryLiteral = 108,
CXCursor_StringLiteral = 109,
CXCursor_CharacterLiteral = 110,
CXCursor_ParenExpr = 111,
CXCursor_UnaryOperator = 112,
CXCursor_ArraySubscriptExpr = 113,
CXCursor_BinaryOperator = 114,
CXCursor_CompoundAssignOperator = 115,
CXCursor_ConditionalOperator = 116,
CXCursor_CStyleCastExpr = 117,
CXCursor_CompoundLiteralExpr = 118,
CXCursor_InitListExpr = 119,
CXCursor_AddrLabelExpr = 120,
CXCursor_StmtExpr = 121,
CXCursor_GenericSelectionExpr = 122,
CXCursor_GNUNullExpr = 123,
CXCursor_CXXStaticCastExpr = 124,
CXCursor_CXXDynamicCastExpr = 125,
CXCursor_CXXReinterpretCastExpr = 126,
CXCursor_CXXConstCastExpr = 127,
CXCursor_CXXFunctionalCastExpr = 128,
CXCursor_CXXTypeidExpr = 129,
CXCursor_CXXBoolLiteralExpr = 130,
CXCursor_CXXNullPtrLiteralExpr = 131,
CXCursor_CXXThisExpr = 132,
CXCursor_CXXThrowExpr = 133,
CXCursor_CXXNewExpr = 134,
CXCursor_CXXDeleteExpr = 135,
CXCursor_UnaryExpr = 136,
CXCursor_ObjCStringLiteral = 137,
CXCursor_ObjCEncodeExpr = 138,
CXCursor_ObjCSelectorExpr = 139,
CXCursor_ObjCProtocolExpr = 140,
CXCursor_ObjCBridgedCastExpr = 141,
CXCursor_PackExpansionExpr = 142,
CXCursor_SizeOfPackExpr = 143,
CXCursor_LambdaExpr = 144,
CXCursor_ObjCBoolLiteralExpr = 145,
CXCursor_ObjCSelfExpr = 146,
CXCursor_OMPArraySectionExpr = 147,
CXCursor_ObjCAvailabilityCheckExpr = 148,
CXCursor_FixedPointLiteral = 149,
CXCursor_LastExpr = CXCursor_FixedPointLiteral,
CXCursor_FirstStmt = 200,
CXCursor_UnexposedStmt = 200,
CXCursor_LabelStmt = 201,
CXCursor_CompoundStmt = 202,
CXCursor_CaseStmt = 203,
CXCursor_DefaultStmt = 204,
CXCursor_IfStmt = 205,
CXCursor_SwitchStmt = 206,
CXCursor_WhileStmt = 207,
CXCursor_DoStmt = 208,
CXCursor_ForStmt = 209,
CXCursor_GotoStmt = 210,
CXCursor_IndirectGotoStmt = 211,
CXCursor_ContinueStmt = 212,
CXCursor_BreakStmt = 213,
CXCursor_ReturnStmt = 214,
CXCursor_GCCAsmStmt = 215,
CXCursor_AsmStmt = CXCursor_GCCAsmStmt,
CXCursor_ObjCAtTryStmt = 216,
CXCursor_ObjCAtCatchStmt = 217,
CXCursor_ObjCAtFinallyStmt = 218,
CXCursor_ObjCAtThrowStmt = 219,
CXCursor_ObjCAtSynchronizedStmt = 220,
CXCursor_ObjCAutoreleasePoolStmt = 221,
CXCursor_ObjCForCollectionStmt = 222,
CXCursor_CXXCatchStmt = 223,
CXCursor_CXXTryStmt = 224,
CXCursor_CXXForRangeStmt = 225,
CXCursor_SEHTryStmt = 226,
CXCursor_SEHExceptStmt = 227,
CXCursor_SEHFinallyStmt = 228,
CXCursor_MSAsmStmt = 229,
CXCursor_NullStmt = 230,
CXCursor_DeclStmt = 231,
CXCursor_OMPParallelDirective = 232,
CXCursor_OMPSimdDirective = 233,
CXCursor_OMPForDirective = 234,
CXCursor_OMPSectionsDirective = 235,
CXCursor_OMPSectionDirective = 236,
CXCursor_OMPSingleDirective = 237,
CXCursor_OMPParallelForDirective = 238,
CXCursor_OMPParallelSectionsDirective = 239,
CXCursor_OMPTaskDirective = 240,
CXCursor_OMPMasterDirective = 241,
CXCursor_OMPCriticalDirective = 242,
CXCursor_OMPTaskyieldDirective = 243,
CXCursor_OMPBarrierDirective = 244,
CXCursor_OMPTaskwaitDirective = 245,
CXCursor_OMPFlushDirective = 246,
CXCursor_SEHLeaveStmt = 247,
CXCursor_OMPOrderedDirective = 248,
CXCursor_OMPAtomicDirective = 249,
CXCursor_OMPForSimdDirective = 250,
CXCursor_OMPParallelForSimdDirective = 251,
CXCursor_OMPTargetDirective = 252,
CXCursor_OMPTeamsDirective = 253,
CXCursor_OMPTaskgroupDirective = 254,
CXCursor_OMPCancellationPointDirective = 255,
CXCursor_OMPCancelDirective = 256,
CXCursor_OMPTargetDataDirective = 257,
CXCursor_OMPTaskLoopDirective = 258,
CXCursor_OMPTaskLoopSimdDirective = 259,
CXCursor_OMPDistributeDirective = 260,
CXCursor_OMPTargetEnterDataDirective = 261,
CXCursor_OMPTargetExitDataDirective = 262,
CXCursor_OMPTargetParallelDirective = 263,
CXCursor_OMPTargetParallelForDirective = 264,
CXCursor_OMPTargetUpdateDirective = 265,
CXCursor_OMPDistributeParallelForDirective = 266,
CXCursor_OMPDistributeParallelForSimdDirective = 267,
CXCursor_OMPDistributeSimdDirective = 268,
CXCursor_OMPTargetParallelForSimdDirective = 269,
CXCursor_OMPTargetSimdDirective = 270,
CXCursor_OMPTeamsDistributeDirective = 271,
CXCursor_OMPTeamsDistributeSimdDirective = 272,
CXCursor_OMPTeamsDistributeParallelForSimdDirective = 273,
CXCursor_OMPTeamsDistributeParallelForDirective = 274,
CXCursor_OMPTargetTeamsDirective = 275,
CXCursor_OMPTargetTeamsDistributeDirective = 276,
CXCursor_OMPTargetTeamsDistributeParallelForDirective = 277,
CXCursor_OMPTargetTeamsDistributeParallelForSimdDirective = 278,
CXCursor_OMPTargetTeamsDistributeSimdDirective = 279,
CXCursor_BuiltinBitCastExpr = 280,
CXCursor_OMPMasterTaskLoopDirective = 281,
CXCursor_OMPParallelMasterTaskLoopDirective = 282,
CXCursor_OMPMasterTaskLoopSimdDirective = 283,
CXCursor_OMPParallelMasterTaskLoopSimdDirective = 284,
CXCursor_OMPParallelMasterDirective = 285,
CXCursor_LastStmt = CXCursor_OMPParallelMasterDirective,
CXCursor_TranslationUnit = 300,
CXCursor_FirstAttr = 400,
CXCursor_UnexposedAttr = 400,
CXCursor_IBActionAttr = 401,
CXCursor_IBOutletAttr = 402,
CXCursor_IBOutletCollectionAttr = 403,
CXCursor_CXXFinalAttr = 404,
CXCursor_CXXOverrideAttr = 405,
CXCursor_AnnotateAttr = 406,
CXCursor_AsmLabelAttr = 407,
CXCursor_PackedAttr = 408,
CXCursor_PureAttr = 409,
CXCursor_ConstAttr = 410,
CXCursor_NoDuplicateAttr = 411,
CXCursor_CUDAConstantAttr = 412,
CXCursor_CUDADeviceAttr = 413,
CXCursor_CUDAGlobalAttr = 414,
CXCursor_CUDAHostAttr = 415,
CXCursor_CUDASharedAttr = 416,
CXCursor_VisibilityAttr = 417,
CXCursor_DLLExport = 418,
CXCursor_DLLImport = 419,
CXCursor_NSReturnsRetained = 420,
CXCursor_NSReturnsNotRetained = 421,
CXCursor_NSReturnsAutoreleased = 422,
CXCursor_NSConsumesSelf = 423,
CXCursor_NSConsumed = 424,
CXCursor_ObjCException = 425,
CXCursor_ObjCNSObject = 426,
CXCursor_ObjCIndependentClass = 427,
CXCursor_ObjCPreciseLifetime = 428,
CXCursor_ObjCReturnsInnerPointer = 429,
CXCursor_ObjCRequiresSuper = 430,
CXCursor_ObjCRootClass = 431,
CXCursor_ObjCSubclassingRestricted = 432,
CXCursor_ObjCExplicitProtocolImpl = 433,
CXCursor_ObjCDesignatedInitializer = 434,
CXCursor_ObjCRuntimeVisible = 435,
CXCursor_ObjCBoxable = 436,
CXCursor_FlagEnum = 437,
CXCursor_ConvergentAttr = 438,
CXCursor_WarnUnusedAttr = 439,
CXCursor_WarnUnusedResultAttr = 440,
CXCursor_AlignedAttr = 441,
CXCursor_LastAttr = CXCursor_AlignedAttr,
CXCursor_PreprocessingDirective = 500,
CXCursor_MacroDefinition = 501,
CXCursor_MacroExpansion = 502,
CXCursor_MacroInstantiation = CXCursor_MacroExpansion,
CXCursor_InclusionDirective = 503,
CXCursor_FirstPreprocessing = CXCursor_PreprocessingDirective,
CXCursor_LastPreprocessing = CXCursor_InclusionDirective,
CXCursor_ModuleImportDecl = 600,
CXCursor_TypeAliasTemplateDecl = 601,
CXCursor_StaticAssert = 602,
CXCursor_FriendDecl = 603,
CXCursor_FirstExtraDecl = CXCursor_ModuleImportDecl,
CXCursor_LastExtraDecl = CXCursor_FriendDecl,
CXCursor_OverloadCandidate = 700,
};
typedef struct {
enum CXCursorKind kind;
int xdata;
void *data[3];
} CXCursor;
CXCursor clang_getNullCursor(void);
CXCursor clang_getTranslationUnitCursor(CXTranslationUnit);
unsigned clang_equalCursors(CXCursor, CXCursor);
int clang_Cursor_isNull(CXCursor cursor);
unsigned clang_hashCursor(CXCursor);
enum CXCursorKind clang_getCursorKind(CXCursor);
unsigned clang_isDeclaration(enum CXCursorKind);
unsigned clang_isInvalidDeclaration(CXCursor);
unsigned clang_isReference(enum CXCursorKind);
unsigned clang_isExpression(enum CXCursorKind);
unsigned clang_isStatement(enum CXCursorKind);
unsigned clang_isAttribute(enum CXCursorKind);
unsigned clang_Cursor_hasAttrs(CXCursor C);
unsigned clang_isInvalid(enum CXCursorKind);
unsigned clang_isTranslationUnit(enum CXCursorKind);
unsigned clang_isPreprocessing(enum CXCursorKind);
unsigned clang_isUnexposed(enum CXCursorKind);
enum CXLinkageKind {
CXLinkage_Invalid,
CXLinkage_NoLinkage,
CXLinkage_Internal,
CXLinkage_UniqueExternal,
CXLinkage_External,
};
enum CXLinkageKind clang_getCursorLinkage(CXCursor cursor);
enum CXVisibilityKind {
CXVisibility_Invalid,
CXVisibility_Hidden,
CXVisibility_Protected,
CXVisibility_Default,
};
enum CXVisibilityKind clang_getCursorVisibility(CXCursor cursor);
enum CXAvailabilityKind clang_getCursorAvailability(CXCursor cursor);
typedef struct CXPlatformAvailability {
CXString Platform;
CXVersion Introduced;
CXVersion Deprecated;
CXVersion Obsoleted;
int Unavailable;
CXString Message;
} CXPlatformAvailability;
int clang_getCursorPlatformAvailability(CXCursor cursor, int *always_deprecated, CXString *deprecated_message, int *always_unavailable, CXString *unavailable_message, CXPlatformAvailability *availability, int availability_size);
void clang_disposeCXPlatformAvailability(CXPlatformAvailability *availability);
enum CXLanguageKind {
CXLanguage_Invalid = 0,
CXLanguage_C,
CXLanguage_ObjC,
CXLanguage_CPlusPlus,
};
enum CXLanguageKind clang_getCursorLanguage(CXCursor cursor);
enum CXTLSKind {
CXTLS_None = 0,
CXTLS_Dynamic,
CXTLS_Static,
};
enum CXTLSKind clang_getCursorTLSKind(CXCursor cursor);
CXTranslationUnit clang_Cursor_getTranslationUnit(CXCursor);
typedef struct CXCursorSetImpl * CXCursorSet;
CXCursorSet clang_createCXCursorSet(void);
void clang_disposeCXCursorSet(CXCursorSet cset);
unsigned clang_CXCursorSet_contains(CXCursorSet cset, CXCursor cursor);
unsigned clang_CXCursorSet_insert(CXCursorSet cset, CXCursor cursor);
CXCursor clang_getCursorSemanticParent(CXCursor cursor);
CXCursor clang_getCursorLexicalParent(CXCursor cursor);
void clang_getOverriddenCursors(CXCursor cursor, CXCursor **overridden, unsigned *num_overridden);
void clang_disposeOverriddenCursors(CXCursor *overridden);
CXFile clang_getIncludedFile(CXCursor cursor);
CXCursor clang_getCursor(CXTranslationUnit, CXSourceLocation);
CXSourceLocation clang_getCursorLocation(CXCursor);
CXSourceRange clang_getCursorExtent(CXCursor);
enum CXTypeKind {
CXType_Invalid = 0,
CXType_Unexposed = 1,
CXType_Void = 2,
CXType_Bool = 3,
CXType_Char_U = 4,
CXType_UChar = 5,
CXType_Char16 = 6,
CXType_Char32 = 7,
CXType_UShort = 8,
CXType_UInt = 9,
CXType_ULong = 10,
CXType_ULongLong = 11,
CXType_UInt128 = 12,
CXType_Char_S = 13,
CXType_SChar = 14,
CXType_WChar = 15,
CXType_Short = 16,
CXType_Int = 17,
CXType_Long = 18,
CXType_LongLong = 19,
CXType_Int128 = 20,
CXType_Float = 21,
CXType_Double = 22,
CXType_LongDouble = 23,
CXType_NullPtr = 24,
CXType_Overload = 25,
CXType_Dependent = 26,
CXType_ObjCId = 27,
CXType_ObjCClass = 28,
CXType_ObjCSel = 29,
CXType_Float128 = 30,
CXType_Half = 31,
CXType_Float16 = 32,
CXType_ShortAccum = 33,
CXType_Accum = 34,
CXType_LongAccum = 35,
CXType_UShortAccum = 36,
CXType_UAccum = 37,
CXType_ULongAccum = 38,
CXType_FirstBuiltin = CXType_Void,
CXType_LastBuiltin = CXType_ULongAccum,
CXType_Complex = 100,
CXType_Pointer = 101,
CXType_BlockPointer = 102,
CXType_LValueReference = 103,
CXType_RValueReference = 104,
CXType_Record = 105,
CXType_Enum = 106,
CXType_Typedef = 107,
CXType_ObjCInterface = 108,
CXType_ObjCObjectPointer = 109,
CXType_FunctionNoProto = 110,
CXType_FunctionProto = 111,
CXType_ConstantArray = 112,
CXType_Vector = 113,
CXType_IncompleteArray = 114,
CXType_VariableArray = 115,
CXType_DependentSizedArray = 116,
CXType_MemberPointer = 117,
CXType_Auto = 118,
CXType_Elaborated = 119,
CXType_Pipe = 120,
CXType_OCLImage1dRO = 121,
CXType_OCLImage1dArrayRO = 122,
CXType_OCLImage1dBufferRO = 123,
CXType_OCLImage2dRO = 124,
CXType_OCLImage2dArrayRO = 125,
CXType_OCLImage2dDepthRO = 126,
CXType_OCLImage2dArrayDepthRO = 127,
CXType_OCLImage2dMSAARO = 128,
CXType_OCLImage2dArrayMSAARO = 129,
CXType_OCLImage2dMSAADepthRO = 130,
CXType_OCLImage2dArrayMSAADepthRO = 131,
CXType_OCLImage3dRO = 132,
CXType_OCLImage1dWO = 133,
CXType_OCLImage1dArrayWO = 134,
CXType_OCLImage1dBufferWO = 135,
CXType_OCLImage2dWO = 136,
CXType_OCLImage2dArrayWO = 137,
CXType_OCLImage2dDepthWO = 138,
CXType_OCLImage2dArrayDepthWO = 139,
CXType_OCLImage2dMSAAWO = 140,
CXType_OCLImage2dArrayMSAAWO = 141,
CXType_OCLImage2dMSAADepthWO = 142,
CXType_OCLImage2dArrayMSAADepthWO = 143,
CXType_OCLImage3dWO = 144,
CXType_OCLImage1dRW = 145,
CXType_OCLImage1dArrayRW = 146,
CXType_OCLImage1dBufferRW = 147,
CXType_OCLImage2dRW = 148,
CXType_OCLImage2dArrayRW = 149,
CXType_OCLImage2dDepthRW = 150,
CXType_OCLImage2dArrayDepthRW = 151,
CXType_OCLImage2dMSAARW = 152,
CXType_OCLImage2dArrayMSAARW = 153,
CXType_OCLImage2dMSAADepthRW = 154,
CXType_OCLImage2dArrayMSAADepthRW = 155,
CXType_OCLImage3dRW = 156,
CXType_OCLSampler = 157,
CXType_OCLEvent = 158,
CXType_OCLQueue = 159,
CXType_OCLReserveID = 160,
CXType_ObjCObject = 161,
CXType_ObjCTypeParam = 162,
CXType_Attributed = 163,
CXType_OCLIntelSubgroupAVCMcePayload = 164,
CXType_OCLIntelSubgroupAVCImePayload = 165,
CXType_OCLIntelSubgroupAVCRefPayload = 166,
CXType_OCLIntelSubgroupAVCSicPayload = 167,
CXType_OCLIntelSubgroupAVCMceResult = 168,
CXType_OCLIntelSubgroupAVCImeResult = 169,
CXType_OCLIntelSubgroupAVCRefResult = 170,
CXType_OCLIntelSubgroupAVCSicResult = 171,
CXType_OCLIntelSubgroupAVCImeResultSingleRefStreamout = 172,
CXType_OCLIntelSubgroupAVCImeResultDualRefStreamout = 173,
CXType_OCLIntelSubgroupAVCImeSingleRefStreamin = 174,
CXType_OCLIntelSubgroupAVCImeDualRefStreamin = 175,
CXType_ExtVector = 176,
};
enum CXCallingConv {
CXCallingConv_Default = 0,
CXCallingConv_C = 1,
CXCallingConv_X86StdCall = 2,
CXCallingConv_X86FastCall = 3,
CXCallingConv_X86ThisCall = 4,
CXCallingConv_X86Pascal = 5,
CXCallingConv_AAPCS = 6,
CXCallingConv_AAPCS_VFP = 7,
CXCallingConv_X86RegCall = 8,
CXCallingConv_IntelOclBicc = 9,
CXCallingConv_Win64 = 10,
CXCallingConv_X86_64Win64 = CXCallingConv_Win64,
CXCallingConv_X86_64SysV = 11,
CXCallingConv_X86VectorCall = 12,
CXCallingConv_Swift = 13,
CXCallingConv_PreserveMost = 14,
CXCallingConv_PreserveAll = 15,
CXCallingConv_AArch64VectorCall = 16,
CXCallingConv_Invalid = 100,
CXCallingConv_Unexposed = 200,
};
typedef struct {
enum CXTypeKind kind;
void *data[2];
} CXType;
CXType clang_getCursorType(CXCursor C);
CXString clang_getTypeSpelling(CXType CT);
CXType clang_getTypedefDeclUnderlyingType(CXCursor C);
CXType clang_getEnumDeclIntegerType(CXCursor C);
long long clang_getEnumConstantDeclValue(CXCursor C);
unsigned long long clang_getEnumConstantDeclUnsignedValue(CXCursor C);
int clang_getFieldDeclBitWidth(CXCursor C);
int clang_Cursor_getNumArguments(CXCursor C);
CXCursor clang_Cursor_getArgument(CXCursor C, unsigned i);
enum CXTemplateArgumentKind {
CXTemplateArgumentKind_Null,
CXTemplateArgumentKind_Type,
CXTemplateArgumentKind_Declaration,
CXTemplateArgumentKind_NullPtr,
CXTemplateArgumentKind_Integral,
CXTemplateArgumentKind_Template,
CXTemplateArgumentKind_TemplateExpansion,
CXTemplateArgumentKind_Expression,
CXTemplateArgumentKind_Pack,
CXTemplateArgumentKind_Invalid,
};
int clang_Cursor_getNumTemplateArguments(CXCursor C);
enum CXTemplateArgumentKind clang_Cursor_getTemplateArgumentKind(CXCursor C, unsigned I);
CXType clang_Cursor_getTemplateArgumentType(CXCursor C, unsigned I);
long long clang_Cursor_getTemplateArgumentValue(CXCursor C, unsigned I);
unsigned long long clang_Cursor_getTemplateArgumentUnsignedValue(CXCursor C, unsigned I);
unsigned clang_equalTypes(CXType A, CXType B);
CXType clang_getCanonicalType(CXType T);
unsigned clang_isConstQualifiedType(CXType T);
unsigned clang_Cursor_isMacroFunctionLike(CXCursor C);
unsigned clang_Cursor_isMacroBuiltin(CXCursor C);
unsigned clang_Cursor_isFunctionInlined(CXCursor C);
unsigned clang_isVolatileQualifiedType(CXType T);
unsigned clang_isRestrictQualifiedType(CXType T);
unsigned clang_getAddressSpace(CXType T);
CXString clang_getTypedefName(CXType CT);
CXType clang_getPointeeType(CXType T);
CXCursor clang_getTypeDeclaration(CXType T);
CXString clang_getDeclObjCTypeEncoding(CXCursor C);
CXString clang_Type_getObjCEncoding(CXType type);
CXString clang_getTypeKindSpelling(enum CXTypeKind K);
enum CXCallingConv clang_getFunctionTypeCallingConv(CXType T);
CXType clang_getResultType(CXType T);
int clang_getExceptionSpecificationType(CXType T);
int clang_getNumArgTypes(CXType T);
CXType clang_getArgType(CXType T, unsigned i);
CXType clang_Type_getObjCObjectBaseType(CXType T);
unsigned clang_Type_getNumObjCProtocolRefs(CXType T);
CXCursor clang_Type_getObjCProtocolDecl(CXType T, unsigned i);
unsigned clang_Type_getNumObjCTypeArgs(CXType T);
CXType clang_Type_getObjCTypeArg(CXType T, unsigned i);
unsigned clang_isFunctionTypeVariadic(CXType T);
CXType clang_getCursorResultType(CXCursor C);
int clang_getCursorExceptionSpecificationType(CXCursor C);
unsigned clang_isPODType(CXType T);
CXType clang_getElementType(CXType T);
long long clang_getNumElements(CXType T);
CXType clang_getArrayElementType(CXType T);
long long clang_getArraySize(CXType T);
CXType clang_Type_getNamedType(CXType T);
unsigned clang_Type_isTransparentTagTypedef(CXType T);
enum CXTypeNullabilityKind {
CXTypeNullability_NonNull = 0,
CXTypeNullability_Nullable = 1,
CXTypeNullability_Unspecified = 2,
CXTypeNullability_Invalid = 3,
};
enum CXTypeNullabilityKind clang_Type_getNullability(CXType T);
enum CXTypeLayoutError {
CXTypeLayoutError_Invalid = (- 1),
CXTypeLayoutError_Incomplete = (- 2),
CXTypeLayoutError_Dependent = (- 3),
CXTypeLayoutError_NotConstantSize = (- 4),
CXTypeLayoutError_InvalidFieldName = (- 5),
CXTypeLayoutError_Undeduced = (- 6),
};
long long clang_Type_getAlignOf(CXType T);
CXType clang_Type_getClassType(CXType T);
long long clang_Type_getSizeOf(CXType T);
long long clang_Type_getOffsetOf(CXType T, char *S);
CXType clang_Type_getModifiedType(CXType T);
long long clang_Cursor_getOffsetOfField(CXCursor C);
unsigned clang_Cursor_isAnonymous(CXCursor C);
unsigned clang_Cursor_isAnonymousRecordDecl(CXCursor C);
unsigned clang_Cursor_isInlineNamespace(CXCursor C);
enum CXRefQualifierKind {
CXRefQualifier_None = 0,
CXRefQualifier_LValue,
CXRefQualifier_RValue,
};
int clang_Type_getNumTemplateArguments(CXType T);
CXType clang_Type_getTemplateArgumentAsType(CXType T, unsigned i);
enum CXRefQualifierKind clang_Type_getCXXRefQualifier(CXType T);
unsigned clang_Cursor_isBitField(CXCursor C);
unsigned clang_isVirtualBase(CXCursor);
enum CX_CXXAccessSpecifier {
CX_CXXInvalidAccessSpecifier,
CX_CXXPublic,
CX_CXXProtected,
CX_CXXPrivate,
};
enum CX_CXXAccessSpecifier clang_getCXXAccessSpecifier(CXCursor);
enum CX_StorageClass {
CX_SC_Invalid,
CX_SC_None,
CX_SC_Extern,
CX_SC_Static,
CX_SC_PrivateExtern,
CX_SC_OpenCLWorkGroupLocal,
CX_SC_Auto,
CX_SC_Register,
};
enum CX_StorageClass clang_Cursor_getStorageClass(CXCursor);
unsigned clang_getNumOverloadedDecls(CXCursor cursor);
CXCursor clang_getOverloadedDecl(CXCursor cursor, unsigned index);
CXType clang_getIBOutletCollectionType(CXCursor);
enum CXChildVisitResult {
CXChildVisit_Break,
CXChildVisit_Continue,
CXChildVisit_Recurse,
};
typedef enum CXChildVisitResult(*CXCursorVisitor)(CXCursor cursor, CXCursor parent, CXClientData client_data);
unsigned clang_visitChildren(CXCursor parent, CXCursorVisitor visitor, CXClientData client_data);
CXString clang_getCursorUSR(CXCursor);
CXString clang_constructUSR_ObjCClass(char *class_name);
CXString clang_constructUSR_ObjCCategory(char *class_name, char *category_name);
CXString clang_constructUSR_ObjCProtocol(char *protocol_name);
CXString clang_constructUSR_ObjCIvar(char *name, CXString classUSR);
CXString clang_constructUSR_ObjCMethod(char *name, unsigned isInstanceMethod, CXString classUSR);
CXString clang_constructUSR_ObjCProperty(char *property, CXString classUSR);
CXString clang_getCursorSpelling(CXCursor);
CXSourceRange clang_Cursor_getSpellingNameRange(CXCursor, unsigned pieceIndex, unsigned options);
typedef void * CXPrintingPolicy;
enum CXPrintingPolicyProperty {
CXPrintingPolicy_Indentation,
CXPrintingPolicy_SuppressSpecifiers,
CXPrintingPolicy_SuppressTagKeyword,
CXPrintingPolicy_IncludeTagDefinition,
CXPrintingPolicy_SuppressScope,
CXPrintingPolicy_SuppressUnwrittenScope,
CXPrintingPolicy_SuppressInitializers,
CXPrintingPolicy_ConstantArraySizeAsWritten,
CXPrintingPolicy_AnonymousTagLocations,
CXPrintingPolicy_SuppressStrongLifetime,
CXPrintingPolicy_SuppressLifetimeQualifiers,
CXPrintingPolicy_SuppressTemplateArgsInCXXConstructors,
CXPrintingPolicy_Bool,
CXPrintingPolicy_Restrict,
CXPrintingPolicy_Alignof,
CXPrintingPolicy_UnderscoreAlignof,
CXPrintingPolicy_UseVoidForZeroParams,
CXPrintingPolicy_TerseOutput,
CXPrintingPolicy_PolishForDeclaration,
CXPrintingPolicy_Half,
CXPrintingPolicy_MSWChar,
CXPrintingPolicy_IncludeNewlines,
CXPrintingPolicy_MSVCFormatting,
CXPrintingPolicy_ConstantsAsWritten,
CXPrintingPolicy_SuppressImplicitBase,
CXPrintingPolicy_FullyQualifiedName,
CXPrintingPolicy_LastProperty = CXPrintingPolicy_FullyQualifiedName,
};
unsigned clang_PrintingPolicy_getProperty(CXPrintingPolicy Policy, enum CXPrintingPolicyProperty Property);
void clang_PrintingPolicy_setProperty(CXPrintingPolicy Policy, enum CXPrintingPolicyProperty Property, unsigned Value);
CXPrintingPolicy clang_getCursorPrintingPolicy(CXCursor);
void clang_PrintingPolicy_dispose(CXPrintingPolicy Policy);
CXString clang_getCursorPrettyPrinted(CXCursor Cursor, CXPrintingPolicy Policy);
CXString clang_getCursorDisplayName(CXCursor);
CXCursor clang_getCursorReferenced(CXCursor);
CXCursor clang_getCursorDefinition(CXCursor);
unsigned clang_isCursorDefinition(CXCursor);
CXCursor clang_getCanonicalCursor(CXCursor);
int clang_Cursor_getObjCSelectorIndex(CXCursor);
int clang_Cursor_isDynamicCall(CXCursor C);
CXType clang_Cursor_getReceiverType(CXCursor C);
typedef enum {
CXObjCPropertyAttr_noattr = 0x00,
CXObjCPropertyAttr_readonly = 0x01,
CXObjCPropertyAttr_getter = 0x02,
CXObjCPropertyAttr_assign = 0x04,
CXObjCPropertyAttr_readwrite = 0x08,
CXObjCPropertyAttr_retain = 0x10,
CXObjCPropertyAttr_copy = 0x20,
CXObjCPropertyAttr_nonatomic = 0x40,
CXObjCPropertyAttr_setter = 0x80,
CXObjCPropertyAttr_atomic = 0x100,
CXObjCPropertyAttr_weak = 0x200,
CXObjCPropertyAttr_strong = 0x400,
CXObjCPropertyAttr_unsafe_unretained = 0x800,
CXObjCPropertyAttr_class = 0x1000,
} CXObjCPropertyAttrKind;
unsigned clang_Cursor_getObjCPropertyAttributes(CXCursor C, unsigned reserved);
CXString clang_Cursor_getObjCPropertyGetterName(CXCursor C);
CXString clang_Cursor_getObjCPropertySetterName(CXCursor C);
typedef enum {
CXObjCDeclQualifier_None = 0x0,
CXObjCDeclQualifier_In = 0x1,
CXObjCDeclQualifier_Inout = 0x2,
CXObjCDeclQualifier_Out = 0x4,
CXObjCDeclQualifier_Bycopy = 0x8,
CXObjCDeclQualifier_Byref = 0x10,
CXObjCDeclQualifier_Oneway = 0x20,
} CXObjCDeclQualifierKind;
unsigned clang_Cursor_getObjCDeclQualifiers(CXCursor C);
unsigned clang_Cursor_isObjCOptional(CXCursor C);
unsigned clang_Cursor_isVariadic(CXCursor C);
unsigned clang_Cursor_isExternalSymbol(CXCursor C, CXString *language, CXString *definedIn, unsigned *isGenerated);
CXSourceRange clang_Cursor_getCommentRange(CXCursor C);
CXString clang_Cursor_getRawCommentText(CXCursor C);
CXString clang_Cursor_getBriefCommentText(CXCursor C);
CXString clang_Cursor_getMangling(CXCursor);
CXStringSet * clang_Cursor_getCXXManglings(CXCursor);
CXStringSet * clang_Cursor_getObjCManglings(CXCursor);
typedef void * CXModule;
CXModule clang_Cursor_getModule(CXCursor C);
CXModule clang_getModuleForFile(CXTranslationUnit, CXFile);
CXFile clang_Module_getASTFile(CXModule Module);
CXModule clang_Module_getParent(CXModule Module);
CXString clang_Module_getName(CXModule Module);
CXString clang_Module_getFullName(CXModule Module);
int clang_Module_isSystem(CXModule Module);
unsigned clang_Module_getNumTopLevelHeaders(CXTranslationUnit, CXModule Module);
CXFile clang_Module_getTopLevelHeader(CXTranslationUnit, CXModule Module, unsigned Index);
unsigned clang_CXXConstructor_isConvertingConstructor(CXCursor C);
unsigned clang_CXXConstructor_isCopyConstructor(CXCursor C);
unsigned clang_CXXConstructor_isDefaultConstructor(CXCursor C);
unsigned clang_CXXConstructor_isMoveConstructor(CXCursor C);
unsigned clang_CXXField_isMutable(CXCursor C);
unsigned clang_CXXMethod_isDefaulted(CXCursor C);
unsigned clang_CXXMethod_isPureVirtual(CXCursor C);
unsigned clang_CXXMethod_isStatic(CXCursor C);
unsigned clang_CXXMethod_isVirtual(CXCursor C);
unsigned clang_CXXRecord_isAbstract(CXCursor C);
unsigned clang_EnumDecl_isScoped(CXCursor C);
unsigned clang_CXXMethod_isConst(CXCursor C);
enum CXCursorKind clang_getTemplateCursorKind(CXCursor C);
CXCursor clang_getSpecializedCursorTemplate(CXCursor C);
CXSourceRange clang_getCursorReferenceNameRange(CXCursor C, unsigned NameFlags, unsigned PieceIndex);
enum CXNameRefFlags {
CXNameRange_WantQualifier = 0x1,
CXNameRange_WantTemplateArgs = 0x2,
CXNameRange_WantSinglePiece = 0x4,
};
typedef enum CXTokenKind {
CXToken_Punctuation,
CXToken_Keyword,
CXToken_Identifier,
CXToken_Literal,
CXToken_Comment,
} CXTokenKind;
typedef struct {
unsigned int_data[4];
void *ptr_data;
} CXToken;
CXToken * clang_getToken(CXTranslationUnit TU, CXSourceLocation Location);
CXTokenKind clang_getTokenKind(CXToken);
CXString clang_getTokenSpelling(CXTranslationUnit, CXToken);
CXSourceLocation clang_getTokenLocation(CXTranslationUnit, CXToken);
CXSourceRange clang_getTokenExtent(CXTranslationUnit, CXToken);
void clang_tokenize(CXTranslationUnit TU, CXSourceRange Range, CXToken **Tokens, unsigned *NumTokens);
void clang_annotateTokens(CXTranslationUnit TU, CXToken *Tokens, unsigned NumTokens, CXCursor *Cursors);
void clang_disposeTokens(CXTranslationUnit TU, CXToken *Tokens, unsigned NumTokens);
CXString clang_getCursorKindSpelling(enum CXCursorKind Kind);
void clang_getDefinitionSpellingAndExtent(CXCursor, char **startBuf, char **endBuf, unsigned *startLine, unsigned *startColumn, unsigned *endLine, unsigned *endColumn);
void clang_enableStackTraces(void);
void clang_executeOnThread(void(*fn)(void *), void *user_data, unsigned stack_size);
typedef void * CXCompletionString;
typedef struct {
enum CXCursorKind CursorKind;
CXCompletionString CompletionString;
} CXCompletionResult;
enum CXCompletionChunkKind {
CXCompletionChunk_Optional,
CXCompletionChunk_TypedText,
CXCompletionChunk_Text,
CXCompletionChunk_Placeholder,
CXCompletionChunk_Informative,
CXCompletionChunk_CurrentParameter,
CXCompletionChunk_LeftParen,
CXCompletionChunk_RightParen,
CXCompletionChunk_LeftBracket,
CXCompletionChunk_RightBracket,
CXCompletionChunk_LeftBrace,
CXCompletionChunk_RightBrace,
CXCompletionChunk_LeftAngle,
CXCompletionChunk_RightAngle,
CXCompletionChunk_Comma,
CXCompletionChunk_ResultType,
CXCompletionChunk_Colon,
CXCompletionChunk_SemiColon,
CXCompletionChunk_Equal,
CXCompletionChunk_HorizontalSpace,
CXCompletionChunk_VerticalSpace,
};
enum CXCompletionChunkKind clang_getCompletionChunkKind(CXCompletionString completion_string, unsigned chunk_number);
CXString clang_getCompletionChunkText(CXCompletionString completion_string, unsigned chunk_number);
CXCompletionString clang_getCompletionChunkCompletionString(CXCompletionString completion_string, unsigned chunk_number);
unsigned clang_getNumCompletionChunks(CXCompletionString completion_string);
unsigned clang_getCompletionPriority(CXCompletionString completion_string);
enum CXAvailabilityKind clang_getCompletionAvailability(CXCompletionString completion_string);
unsigned clang_getCompletionNumAnnotations(CXCompletionString completion_string);
CXString clang_getCompletionAnnotation(CXCompletionString completion_string, unsigned annotation_number);
CXString clang_getCompletionParent(CXCompletionString completion_string, enum CXCursorKind *kind);
CXString clang_getCompletionBriefComment(CXCompletionString completion_string);
CXCompletionString clang_getCursorCompletionString(CXCursor cursor);
typedef struct {
CXCompletionResult *Results;
unsigned NumResults;
} CXCodeCompleteResults;
unsigned clang_getCompletionNumFixIts(CXCodeCompleteResults *results, unsigned completion_index);
CXString clang_getCompletionFixIt(CXCodeCompleteResults *results, unsigned completion_index, unsigned fixit_index, CXSourceRange *replacement_range);
enum CXCodeComplete_Flags {
CXCodeComplete_IncludeMacros = 0x01,
CXCodeComplete_IncludeCodePatterns = 0x02,
CXCodeComplete_IncludeBriefComments = 0x04,
CXCodeComplete_SkipPreamble = 0x08,
CXCodeComplete_IncludeCompletionsWithFixIts = 0x10,
};
enum CXCompletionContext {
CXCompletionContext_Unexposed = 0,
CXCompletionContext_AnyType = (1 << 0),
CXCompletionContext_AnyValue = (1 << 1),
CXCompletionContext_ObjCObjectValue = (1 << 2),
CXCompletionContext_ObjCSelectorValue = (1 << 3),
CXCompletionContext_CXXClassTypeValue = (1 << 4),
CXCompletionContext_DotMemberAccess = (1 << 5),
CXCompletionContext_ArrowMemberAccess = (1 << 6),
CXCompletionContext_ObjCPropertyAccess = (1 << 7),
CXCompletionContext_EnumTag = (1 << 8),
CXCompletionContext_UnionTag = (1 << 9),
CXCompletionContext_StructTag = (1 << 10),
CXCompletionContext_ClassTag = (1 << 11),
CXCompletionContext_Namespace = (1 << 12),
CXCompletionContext_NestedNameSpecifier = (1 << 13),
CXCompletionContext_ObjCInterface = (1 << 14),
CXCompletionContext_ObjCProtocol = (1 << 15),
CXCompletionContext_ObjCCategory = (1 << 16),
CXCompletionContext_ObjCInstanceMessage = (1 << 17),
CXCompletionContext_ObjCClassMessage = (1 << 18),
CXCompletionContext_ObjCSelectorName = (1 << 19),
CXCompletionContext_MacroName = (1 << 20),
CXCompletionContext_NaturalLanguage = (1 << 21),
CXCompletionContext_IncludedFile = (1 << 22),
CXCompletionContext_Unknown = ((1 << 23) - 1),
};
unsigned clang_defaultCodeCompleteOptions(void);
CXCodeCompleteResults * clang_codeCompleteAt(CXTranslationUnit TU, char *complete_filename, unsigned complete_line, unsigned complete_column, struct CXUnsavedFile *unsaved_files, unsigned num_unsaved_files, unsigned options);
void clang_sortCodeCompletionResults(CXCompletionResult *Results, unsigned NumResults);
void clang_disposeCodeCompleteResults(CXCodeCompleteResults *Results);
unsigned clang_codeCompleteGetNumDiagnostics(CXCodeCompleteResults *Results);
CXDiagnostic clang_codeCompleteGetDiagnostic(CXCodeCompleteResults *Results, unsigned Index);
unsigned long long clang_codeCompleteGetContexts(CXCodeCompleteResults *Results);
enum CXCursorKind clang_codeCompleteGetContainerKind(CXCodeCompleteResults *Results, unsigned *IsIncomplete);
CXString clang_codeCompleteGetContainerUSR(CXCodeCompleteResults *Results);
CXString clang_codeCompleteGetObjCSelector(CXCodeCompleteResults *Results);
CXString clang_getClangVersion(void);
void clang_toggleCrashRecovery(unsigned isEnabled);
typedef void(*CXInclusionVisitor)(CXFile included_file, CXSourceLocation *inclusion_stack, unsigned include_len, CXClientData client_data);
void clang_getInclusions(CXTranslationUnit tu, CXInclusionVisitor visitor, CXClientData client_data);
typedef enum {
CXEval_Int = 1,
CXEval_Float = 2,
CXEval_ObjCStrLiteral = 3,
CXEval_StrLiteral = 4,
CXEval_CFStr = 5,
CXEval_Other = 6,
CXEval_UnExposed = 0,
} CXEvalResultKind;
typedef void * CXEvalResult;
CXEvalResult clang_Cursor_Evaluate(CXCursor C);
CXEvalResultKind clang_EvalResult_getKind(CXEvalResult E);
int clang_EvalResult_getAsInt(CXEvalResult E);
long long clang_EvalResult_getAsLongLong(CXEvalResult E);
unsigned clang_EvalResult_isUnsignedInt(CXEvalResult E);
unsigned long long clang_EvalResult_getAsUnsigned(CXEvalResult E);
double clang_EvalResult_getAsDouble(CXEvalResult E);
char * clang_EvalResult_getAsStr(CXEvalResult E);
void clang_EvalResult_dispose(CXEvalResult E);
typedef void * CXRemapping;
CXRemapping clang_getRemappings(char *path);
CXRemapping clang_getRemappingsFromFileList(char **filePaths, unsigned numFiles);
unsigned clang_remap_getNumFiles(CXRemapping);
void clang_remap_getFilenames(CXRemapping, unsigned index, CXString *original, CXString *transformed);
void clang_remap_dispose(CXRemapping);
enum CXVisitorResult {
CXVisit_Break,
CXVisit_Continue,
};
typedef struct CXCursorAndRangeVisitor {
void *context;
enum CXVisitorResult(*visit)(void *context, CXCursor, CXSourceRange);
} CXCursorAndRangeVisitor;
typedef enum {
CXResult_Success = 0,
CXResult_Invalid = 1,
CXResult_VisitBreak = 2,
} CXResult;
CXResult clang_findReferencesInFile(CXCursor cursor, CXFile file, CXCursorAndRangeVisitor visitor);
CXResult clang_findIncludesInFile(CXTranslationUnit TU, CXFile file, CXCursorAndRangeVisitor visitor);
typedef void * CXIdxClientFile;
typedef void * CXIdxClientEntity;
typedef void * CXIdxClientContainer;
typedef void * CXIdxClientASTFile;
typedef struct {
void *ptr_data[2];
unsigned int_data;
} CXIdxLoc;
typedef struct {
CXIdxLoc hashLoc;
char *filename;
CXFile file;
int isImport;
int isAngled;
int isModuleImport;
} CXIdxIncludedFileInfo;
typedef struct {
CXFile file;
CXModule module;
CXIdxLoc loc;
int isImplicit;
} CXIdxImportedASTFileInfo;
typedef enum {
CXIdxEntity_Unexposed = 0,
CXIdxEntity_Typedef = 1,
CXIdxEntity_Function = 2,
CXIdxEntity_Variable = 3,
CXIdxEntity_Field = 4,
CXIdxEntity_EnumConstant = 5,
CXIdxEntity_ObjCClass = 6,
CXIdxEntity_ObjCProtocol = 7,
CXIdxEntity_ObjCCategory = 8,
CXIdxEntity_ObjCInstanceMethod = 9,
CXIdxEntity_ObjCClassMethod = 10,
CXIdxEntity_ObjCProperty = 11,
CXIdxEntity_ObjCIvar = 12,
CXIdxEntity_Enum = 13,
CXIdxEntity_Struct = 14,
CXIdxEntity_Union = 15,
CXIdxEntity_CXXClass = 16,
CXIdxEntity_CXXNamespace = 17,
CXIdxEntity_CXXNamespaceAlias = 18,
CXIdxEntity_CXXStaticVariable = 19,
CXIdxEntity_CXXStaticMethod = 20,
CXIdxEntity_CXXInstanceMethod = 21,
CXIdxEntity_CXXConstructor = 22,
CXIdxEntity_CXXDestructor = 23,
CXIdxEntity_CXXConversionFunction = 24,
CXIdxEntity_CXXTypeAlias = 25,
CXIdxEntity_CXXInterface = 26,
} CXIdxEntityKind;
typedef enum {
CXIdxEntityLang_None = 0,
CXIdxEntityLang_C = 1,
CXIdxEntityLang_ObjC = 2,
CXIdxEntityLang_CXX = 3,
CXIdxEntityLang_Swift = 4,
} CXIdxEntityLanguage;
typedef enum {
CXIdxEntity_NonTemplate = 0,
CXIdxEntity_Template = 1,
CXIdxEntity_TemplatePartialSpecialization = 2,
CXIdxEntity_TemplateSpecialization = 3,
} CXIdxEntityCXXTemplateKind;
typedef enum {
CXIdxAttr_Unexposed = 0,
CXIdxAttr_IBAction = 1,
CXIdxAttr_IBOutlet = 2,
CXIdxAttr_IBOutletCollection = 3,
} CXIdxAttrKind;
typedef struct {
CXIdxAttrKind kind;
CXCursor cursor;
CXIdxLoc loc;
} CXIdxAttrInfo;
typedef struct {
CXIdxEntityKind kind;
CXIdxEntityCXXTemplateKind templateKind;
CXIdxEntityLanguage lang;
char *name;
char *USR;
CXCursor cursor;
CXIdxAttrInfo **attributes;
unsigned numAttributes;
} CXIdxEntityInfo;
typedef struct {
CXCursor cursor;
} CXIdxContainerInfo;
typedef struct {
CXIdxAttrInfo *attrInfo;
CXIdxEntityInfo *objcClass;
CXCursor classCursor;
CXIdxLoc classLoc;
} CXIdxIBOutletCollectionAttrInfo;
typedef enum {
CXIdxDeclFlag_Skipped = 0x1,
} CXIdxDeclInfoFlags;
typedef struct {
CXIdxEntityInfo *entityInfo;
CXCursor cursor;
CXIdxLoc loc;
CXIdxContainerInfo *semanticContainer;
CXIdxContainerInfo *lexicalContainer;
int isRedeclaration;
int isDefinition;
int isContainer;
CXIdxContainerInfo *declAsContainer;
int isImplicit;
CXIdxAttrInfo **attributes;
unsigned numAttributes;
unsigned flags;
} CXIdxDeclInfo;
typedef enum {
CXIdxObjCContainer_ForwardRef = 0,
CXIdxObjCContainer_Interface = 1,
CXIdxObjCContainer_Implementation = 2,
} CXIdxObjCContainerKind;
typedef struct {
CXIdxDeclInfo *declInfo;
CXIdxObjCContainerKind kind;
} CXIdxObjCContainerDeclInfo;
typedef struct {
CXIdxEntityInfo *base;
CXCursor cursor;
CXIdxLoc loc;
} CXIdxBaseClassInfo;
typedef struct {
CXIdxEntityInfo *protocol;
CXCursor cursor;
CXIdxLoc loc;
} CXIdxObjCProtocolRefInfo;
typedef struct {
CXIdxObjCProtocolRefInfo **protocols;
unsigned numProtocols;
} CXIdxObjCProtocolRefListInfo;
typedef struct {
CXIdxObjCContainerDeclInfo *containerInfo;
CXIdxBaseClassInfo *superInfo;
CXIdxObjCProtocolRefListInfo *protocols;
} CXIdxObjCInterfaceDeclInfo;
typedef struct {
CXIdxObjCContainerDeclInfo *containerInfo;
CXIdxEntityInfo *objcClass;
CXCursor classCursor;
CXIdxLoc classLoc;
CXIdxObjCProtocolRefListInfo *protocols;
} CXIdxObjCCategoryDeclInfo;
typedef struct {
CXIdxDeclInfo *declInfo;
CXIdxEntityInfo *getter;
CXIdxEntityInfo *setter;
} CXIdxObjCPropertyDeclInfo;
typedef struct {
CXIdxDeclInfo *declInfo;
CXIdxBaseClassInfo **bases;
unsigned numBases;
} CXIdxCXXClassDeclInfo;
typedef enum {
CXIdxEntityRef_Direct = 1,
CXIdxEntityRef_Implicit = 2,
} CXIdxEntityRefKind;
typedef enum {
CXSymbolRole_None = 0,
CXSymbolRole_Declaration = (1 << 0),
CXSymbolRole_Definition = (1 << 1),
CXSymbolRole_Reference = (1 << 2),
CXSymbolRole_Read = (1 << 3),
CXSymbolRole_Write = (1 << 4),
CXSymbolRole_Call = (1 << 5),
CXSymbolRole_Dynamic = (1 << 6),
CXSymbolRole_AddressOf = (1 << 7),
CXSymbolRole_Implicit = (1 << 8),
} CXSymbolRole;
typedef struct {
CXIdxEntityRefKind kind;
CXCursor cursor;
CXIdxLoc loc;
CXIdxEntityInfo *referencedEntity;
CXIdxEntityInfo *parentEntity;
CXIdxContainerInfo *container;
CXSymbolRole role;
} CXIdxEntityRefInfo;
typedef struct {
int(*abortQuery)(CXClientData client_data, void *reserved);
void(*diagnostic)(CXClientData client_data, CXDiagnosticSet, void *reserved);
CXIdxClientFile(*enteredMainFile)(CXClientData client_data, CXFile mainFile, void *reserved);
CXIdxClientFile(*ppIncludedFile)(CXClientData client_data, CXIdxIncludedFileInfo *);
CXIdxClientASTFile(*importedASTFile)(CXClientData client_data, CXIdxImportedASTFileInfo *);
CXIdxClientContainer(*startedTranslationUnit)(CXClientData client_data, void *reserved);
void(*indexDeclaration)(CXClientData client_data, CXIdxDeclInfo *);
void(*indexEntityReference)(CXClientData client_data, CXIdxEntityRefInfo *);
} IndexerCallbacks;
int clang_index_isEntityObjCContainerKind(CXIdxEntityKind);
CXIdxObjCContainerDeclInfo * clang_index_getObjCContainerDeclInfo(CXIdxDeclInfo *);
CXIdxObjCInterfaceDeclInfo * clang_index_getObjCInterfaceDeclInfo(CXIdxDeclInfo *);
CXIdxObjCCategoryDeclInfo * clang_index_getObjCCategoryDeclInfo(CXIdxDeclInfo *);
CXIdxObjCProtocolRefListInfo * clang_index_getObjCProtocolRefListInfo(CXIdxDeclInfo *);
CXIdxObjCPropertyDeclInfo * clang_index_getObjCPropertyDeclInfo(CXIdxDeclInfo *);
CXIdxIBOutletCollectionAttrInfo * clang_index_getIBOutletCollectionAttrInfo(CXIdxAttrInfo *);
CXIdxCXXClassDeclInfo * clang_index_getCXXClassDeclInfo(CXIdxDeclInfo *);
CXIdxClientContainer clang_index_getClientContainer(CXIdxContainerInfo *);
void clang_index_setClientContainer(CXIdxContainerInfo *, CXIdxClientContainer);
CXIdxClientEntity clang_index_getClientEntity(CXIdxEntityInfo *);
void clang_index_setClientEntity(CXIdxEntityInfo *, CXIdxClientEntity);
typedef void * CXIndexAction;
CXIndexAction clang_IndexAction_create(CXIndex CIdx);
void clang_IndexAction_dispose(CXIndexAction);
typedef enum {
CXIndexOpt_None = 0x0,
CXIndexOpt_SuppressRedundantRefs = 0x1,
CXIndexOpt_IndexFunctionLocalSymbols = 0x2,
CXIndexOpt_IndexImplicitTemplateInstantiations = 0x4,
CXIndexOpt_SuppressWarnings = 0x8,
CXIndexOpt_SkipParsedBodiesInSession = 0x10,
} CXIndexOptFlags;
int clang_indexSourceFile(CXIndexAction, CXClientData client_data, IndexerCallbacks *index_callbacks, unsigned index_callbacks_size, unsigned index_options, char *source_filename, char **command_line_args, int num_command_line_args, struct CXUnsavedFile *unsaved_files, unsigned num_unsaved_files, CXTranslationUnit *out_TU, unsigned TU_options);
int clang_indexSourceFileFullArgv(CXIndexAction, CXClientData client_data, IndexerCallbacks *index_callbacks, unsigned index_callbacks_size, unsigned index_options, char *source_filename, char **command_line_args, int num_command_line_args, struct CXUnsavedFile *unsaved_files, unsigned num_unsaved_files, CXTranslationUnit *out_TU, unsigned TU_options);
int clang_indexTranslationUnit(CXIndexAction, CXClientData client_data, IndexerCallbacks *index_callbacks, unsigned index_callbacks_size, unsigned index_options, CXTranslationUnit);
void clang_indexLoc_getFileLocation(CXIdxLoc loc, CXIdxClientFile *indexFile, CXFile *file, unsigned *line, unsigned *column, unsigned *offset);
CXSourceLocation clang_indexLoc_getCXSourceLocation(CXIdxLoc loc);
typedef enum CXVisitorResult(*CXFieldVisitor)(CXCursor C, CXClientData client_data);
unsigned clang_Type_visitFields(CXType T, CXFieldVisitor visitor, CXClientData client_data);
CDEF;
$clang = \FFI::cdef(
$parsedHContent,
'/usr/lib/llvm-10/lib/libclang.so'
);
const CXChildVisit_Break = 0;
const CXChildVisit_Continue = 1;
const CXChildVisit_Recurse = 2;
// test clang binding
$xstring = $clang->clang_getClangVersion();
$version = $clang->clang_getCString($xstring);
var_dump($xstring, FFI::string($version));
// prepare parsing a header file ...
$index = $clang->clang_createIndex(1, 1);
var_dump($index);
// prepare clang options (https://clang.llvm.org/docs/ClangCommandLineReference.html)
function getCDataFromString(string $value)
{
$value .= "\0";
$size = strlen($value);
$cdata = FFI::new('char[' . $size . ']', false, true);
FFI::memcpy($cdata, $value, $size);
return FFI::cast('char*', $cdata);
}
$args = $clang->new('char*[2]');
$args[0] = getCDataFromString('-I/usr/lib/llvm-10/include/');
$args[1] = getCDataFromString('-I/usr/include/');
$translationUnit = $clang->clang_createTranslationUnitFromSourceFile(
$index,
'/usr/lib/llvm-10/include/clang-c/Index.h',
1, // two params
FFI::cast('char**', $args),
0,
null
);
var_dump($translationUnit);
print_r($translationUnit[0]);
// so let´s workaround with ffi because of this:
//$cursor = $ffi->clang_getNullCursor(); // Uncaught FFI\Exception: FFI return struct/union is not implemented > not yet supported ...
//$cursor = $ffi->clang_getTranslationUnitCursor($translationUnit); // Uncaught FFI\Exception: FFI return struct/union is not implemented > not yet supported ...
// prepare the clang_getTranslationUnitCursor Call InterFace
$clang_getTranslationUnitCursor_cif = $ffi->new('ffi_cif');
// define some ffi base types -- it´s a workaround for base types defined in https://github.com/libffi/libffi/blob/65da63abc843fe448aaa86015d094cf016f325ba/src/types.c#L69
// ffi_type_uint32
$struct_uint32 = FFI::new(
'struct test_uint32 {
char a;
uint32_t b;
}'
);
$ffi_type_uint32 = $ffi->new('ffi_type', false, true);
$ffi_type_uint32->size = FFI::sizeof($struct_uint32->b);
$ffi_type_uint32->alignment = FFI::alignof($struct_uint32->b);
$ffi_type_uint32->type = FFI_TYPE_UINT32;
$ffi_type_uint32->elements = null;
// ffi_type_pointer
$struct_pointer = FFI::new(
'struct test_pointer {
char a;
void* b;
}'
);
$ffi_type_pointer = $ffi->new('ffi_type', false, true);
$ffi_type_pointer->size = FFI::sizeof($struct_pointer->b);
$ffi_type_pointer->alignment = FFI::alignof($struct_pointer->b);
$ffi_type_pointer->type = FFI_TYPE_POINTER;
$ffi_type_pointer->elements = null;
// prepare return type
$rTypeElements = $ffi->new('ffi_type*[6]', false, true);
//$rTypeElements[0] = FFI::addr($ffi->new('ffi_type_uint32', false, true)); // kind
$rTypeElements[0] = FFI::addr($ffi_type_uint32); // kind
$rTypeElements[1] = FFI::addr($ffi_type_uint32); // xdata
$rTypeElements[1] = FFI::addr($ffi_type_uint32); // xdata
$rTypeElements[2] = FFI::addr($ffi_type_pointer); // data[0]
$rTypeElements[3] = FFI::addr($ffi_type_pointer); // data[1]
$rTypeElements[4] = FFI::addr($ffi_type_pointer); // data[2]
$rTypeElements[5] = null;
$rType = $ffi->new('ffi_type', false, true);
$rType->size = 0;
$rType->alignment = 0;
$rType->type = FFI_TYPE_STRUCT;
$rType->elements = $ffi->cast('ffi_type**', FFI::addr($rTypeElements));
$argTypes = $ffi->new('ffi_type*[1]', false, true);
$argTypes[0] = FFI::addr($ffi_type_pointer); // pointer to CXTranslationUnit
$argTypes = $ffi->cast('ffi_type**', FFI::addr($argTypes));
print_r($rType);
print_r($argTypes);
$ffiStatus = $ffi->ffi_prep_cif(
FFI::addr($clang_getTranslationUnitCursor_cif),
FFI_DEFAULT_ABI,
1,
FFI::addr($rType),
$argTypes
);
print_r($clang_getTranslationUnitCursor_cif);
switch ($ffiStatus) {
case FFI_BAD_TYPEDEF:
throw new Exception('Prepare cif: bad typedef');
breaK;
case FFI_BAD_ABI:
throw new Exception('Prepare cif: bad abi');
breaK;
}
// lets call the function
$clang_getTranslationUnitCursor = $libc->dlsym(null, 'clang_getTranslationUnitCursor'); // function pointer
$err = $libc->dlerror();
if ($err !== null) {
throw new Exception(FFI::string($err));
}
print_r($clang_getTranslationUnitCursor);
$cursor = $clang->new('CXCursor', false, true); // return
$values = $ffi->new('void*[1]', false, true); // params
$values[0] = FFI::addr($translationUnit);
$ffi->ffi_call(FFI::addr($clang_getTranslationUnitCursor_cif), $clang_getTranslationUnitCursor, FFI::addr($cursor), $values);
print_r($cursor);
print_r($clang->cast('CXCursor', $cursor));
$visitor = function (...$args) {
print_r($args);
return CXChildVisit_Continue;
};
// todo: struct <anonymous> not accepted by ffi ... tsss... again ffi via ffi ???
$clang->clang_visitChildren($cursor, $visitor, 0);
$clang->clang_disposeTranslationUnit($translationUnit);
$clang->clang_disposeIndex($index);
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment