Module Clang__.Clang__bindings

val get_build_session_timestamp : unit -> int

Return the timestamp for use with Clang's -fbuild-session-timestamp= option.

type cxvirtualfileoverlay
val virtual_file_overlay_create : int -> cxvirtualfileoverlay

Create a CXVirtualFileOverlay object. Must be disposed with clang_VirtualFileOverlay_dispose().

type cxerrorcode =
| Failure

A generic error code, no further details are available.

| Crashed

libclang crashed while performing the requested operation.

| InvalidArguments

The function detected that the arguments violate the function contract.

| ASTReadError

An AST deserialization error has occurred.

Error codes returned by libclang routines.

val virtual_file_overlay_add_file_mapping : cxvirtualfileoverlay -> virtual_path:string -> real_path:string -> (unit, cxerrorcode) Stdcompat.result

Map an absolute virtual file path to an absolute real one. The virtual path must be canonicalized (not contain "."/"..").

val virtual_file_overlay_set_case_sensitivity : cxvirtualfileoverlay -> int -> (unit, cxerrorcode) Stdcompat.result

Set the case sensitivity for the CXVirtualFileOverlay object. The CXVirtualFileOverlay object is case-sensitive by default, this option can be used to override the default.

val virtual_file_overlay_write_to_buffer : cxvirtualfileoverlay -> int -> (string, cxerrorcode) Stdcompat.result

Write out the CXVirtualFileOverlay object to a char buffer.

type cxmodulemapdescriptor
val module_map_descriptor_create : int -> cxmodulemapdescriptor

Create a CXModuleMapDescriptor object. Must be disposed with clang_ModuleMapDescriptor_dispose().

val module_map_descriptor_set_framework_module_name : cxmodulemapdescriptor -> string -> (unit, cxerrorcode) Stdcompat.result

Sets the framework module name that the module.map describes.

val module_map_descriptor_set_umbrella_header : cxmodulemapdescriptor -> string -> (unit, cxerrorcode) Stdcompat.result

Sets the umbrealla header name that the module.map describes.

val module_map_descriptor_write_to_buffer : cxmodulemapdescriptor -> int -> (string, cxerrorcode) Stdcompat.result

Write out the CXModuleMapDescriptor object to a char buffer.

type cxindex
val create_index : exclude_declarations_from_pch:bool -> display_diagnostics:bool -> cxindex

Provides a shared context for creating translation units.

module Cxglobaloptflags : sig ... end
val cxindex_set_global_options : cxindex -> Cxglobaloptflags.t -> unit

Sets general options associated with a CXIndex.

val cxindex_get_global_options : cxindex -> Cxglobaloptflags.t

Gets the general options associated with a CXIndex.

val cxindex_set_invocation_emission_path_option : cxindex -> string -> unit

Sets the invocation emission path option in a CXIndex.

type cxfile
val get_file_name : cxfile -> string

Retrieve the complete file and path name of the given file.

val get_file_time : cxfile -> int

Retrieve the last modification time of the given file.

type cxfileuniqueid = int * int * int

Uniquely identifies a CXFile, that refers to the same underlying file, across an indexing session.

val get_file_unique_id : cxfile -> cxfileuniqueid option

Retrieve the unique ID for the given file.

type cxtranslationunit
val is_file_multiple_include_guarded : cxtranslationunit -> cxfile -> bool

Determine whether the given header is guarded against multiple inclusions, either with the conventional #ifndef/#define/#endif macro guards or with #pragma once.

val get_file : cxtranslationunit -> string -> cxfile

Retrieve a file handle within the given translation unit.

val get_file_contents : cxtranslationunit -> cxfile -> string option

Retrieve the buffer associated with the given file.

val file_is_equal : cxfile -> cxfile -> bool

Returns non-zero if the file1 and file2 point to the same file, or they are both NULL.

type cxsourcelocation

Identifies a specific source location within a translation unit.

val get_null_location : unit -> cxsourcelocation

Retrieve a NULL (invalid) source location.

val equal_locations : cxsourcelocation -> cxsourcelocation -> bool

Determine whether two source locations, which must refer into the same translation unit, refer to exactly the same point in the source code.

val get_location : cxtranslationunit -> cxfile -> line:int -> column:int -> cxsourcelocation

Retrieves the source location associated with a given file/line/column in a particular translation unit.

val get_location_for_offset : cxtranslationunit -> cxfile -> int -> cxsourcelocation

Retrieves the source location associated with a given character offset in a particular translation unit.

val location_is_in_system_header : cxsourcelocation -> bool

Returns non-zero if the given source location is in a system header.

val location_is_from_main_file : cxsourcelocation -> bool

Returns non-zero if the given source location is in the main file of the corresponding translation unit.

type cxsourcerange

Identifies a half-open character range in the source code.

val get_null_range : unit -> cxsourcerange

Retrieve a NULL (invalid) source range.

val get_range : cxsourcelocation -> cxsourcelocation -> cxsourcerange

Retrieve a source range given the beginning and ending source locations.

val equal_ranges : cxsourcerange -> cxsourcerange -> bool

Determine whether two ranges are equivalent.

val range_is_null : cxsourcerange -> bool

Returns non-zero if range is null.

val get_expansion_location : cxsourcelocation -> cxfile * int * int * int

Retrieve the file, line, column, and offset represented by the given source location.

val get_presumed_location : cxsourcelocation -> string * int * int

Retrieve the file, line and column represented by the given source location, as specified in a # line directive.

val get_instantiation_location : cxsourcelocation -> cxfile * int * int * int

Legacy API to retrieve the file, line, column, and offset represented by the given source location.

val get_spelling_location : cxsourcelocation -> cxfile * int * int * int

Retrieve the file, line, column, and offset represented by the given source location.

val get_file_location : cxsourcelocation -> cxfile * int * int * int

Retrieve the file, line, column, and offset represented by the given source location.

val get_range_start : cxsourcerange -> cxsourcelocation

Retrieve a source location representing the first character within a source range.

val get_range_end : cxsourcerange -> cxsourcelocation

Retrieve a source location representing the last character within a source range.

val get_skipped_ranges : cxtranslationunit -> cxfile -> cxsourcerange array

Retrieve all ranges that were skipped by the preprocessor.

val get_all_skipped_ranges : cxtranslationunit -> cxsourcerange array

Retrieve all ranges from all files that were skipped by the preprocessor.

type cxdiagnosticset
val get_num_diagnostics_in_set : cxdiagnosticset -> int

Determine the number of diagnostics in a CXDiagnosticSet.

type cxdiagnostic
val get_diagnostic_in_set : cxdiagnosticset -> int -> cxdiagnostic

Retrieve a diagnostic associated with the given CXDiagnosticSet.

type cxloaddiag_error =
| Unknown

Indicates that an unknown error occurred while attempting to deserialize diagnostics.

| CannotLoad

Indicates that the file containing the serialized diagnostics could not be opened.

| InvalidFile

Indicates that the serialized diagnostics file is invalid or corrupt.

Describes the kind of error that occurred (if any) in a call to clang_loadDiagnostics.

val load_diagnostics : string -> (cxdiagnosticset, cxloaddiag_error * string) Stdcompat.result

Deserialize a set of diagnostics from a Clang diagnostics bitcode file.

val get_child_diagnostics : cxdiagnostic -> cxdiagnosticset

Retrieve the child diagnostics of a CXDiagnostic.

val get_num_diagnostics : cxtranslationunit -> int

Determine the number of diagnostics produced for the given translation unit.

val get_diagnostic : cxtranslationunit -> int -> cxdiagnostic

Retrieve a diagnostic associated with the given translation unit.

val get_diagnostic_set_from_tu : cxtranslationunit -> cxdiagnosticset

Retrieve the complete set of diagnostics associated with a translation unit.

module Cxdiagnosticdisplayoptions : sig ... end
val format_diagnostic : cxdiagnostic -> Cxdiagnosticdisplayoptions.t -> string

Format the given diagnostic in a manner that is suitable for display.

val default_diagnostic_display_options : unit -> Cxdiagnosticdisplayoptions.t

Retrieve the set of display options most similar to the default behavior of the clang compiler.

type cxdiagnosticseverity =
| Ignored

A diagnostic that has been suppressed, e.g., by a command-line option.

| Note

This diagnostic is a note that should be attached to the previous (non-note) diagnostic.

| Warning

This diagnostic indicates suspicious code that may not be wrong.

| Error

This diagnostic indicates that the code is ill-formed.

| Fatal

This diagnostic indicates that the code is ill-formed such that future parser recovery is unlikely to produce useful results.

Describes the severity of a particular diagnostic.

val get_diagnostic_severity : cxdiagnostic -> cxdiagnosticseverity

Determine the severity of the given diagnostic.

val get_diagnostic_location : cxdiagnostic -> cxsourcelocation

Retrieve the source location of the given diagnostic.

val get_diagnostic_spelling : cxdiagnostic -> string

Retrieve the text of the given diagnostic.

val get_diagnostic_option : cxdiagnostic -> string * string

Retrieve the name of the command-line option that enabled this diagnostic.

val get_diagnostic_category : cxdiagnostic -> int

Retrieve the category number for this diagnostic.

val get_diagnostic_category_text : cxdiagnostic -> string

Retrieve the diagnostic category text for a given diagnostic.

val get_diagnostic_num_ranges : cxdiagnostic -> int

Determine the number of source ranges associated with the given diagnostic.

val get_diagnostic_range : cxdiagnostic -> int -> cxsourcerange

Retrieve a source range associated with the diagnostic.

val get_diagnostic_num_fix_its : cxdiagnostic -> int

Determine the number of fix-it hints associated with the given diagnostic.

val get_diagnostic_fix_it : cxdiagnostic -> int -> cxsourcerange -> string * cxsourcerange

Retrieve the replacement information for a given fix-it.

val get_translation_unit_spelling : cxtranslationunit -> string

Get the original translation unit source file name.

type cxunsavedfile = {
filename : string;

The file whose contents have not yet been saved.

contents : string;

A buffer containing the unsaved contents of this file.

}

Provides the contents of a file that has not yet been saved to disk.

val create_translation_unit_from_source_file : cxindex -> string -> string array -> cxunsavedfile array -> cxtranslationunit

Return the CXTranslationUnit for a given source file and the provided command line arguments one would pass to the compiler.

val create_translation_unit : cxindex -> string -> cxtranslationunit

Same as clang_createTranslationUnit2, but returns the CXTranslationUnit instead of an error code. In case of an error this routine returns a NULL CXTranslationUnit, without further detailed error codes.

val create_translation_unit2 : cxindex -> string -> (cxtranslationunit, cxerrorcode) Stdcompat.result

Create a translation unit from an AST file ( -emit-ast).

module Cxtranslationunit_flags : sig ... end
val default_editing_translation_unit_options : unit -> Cxtranslationunit_flags.t

Returns the set of flags that is suitable for parsing a translation unit that is being edited.

val parse_translation_unit : cxindex -> string -> string array -> cxunsavedfile array -> Cxtranslationunit_flags.t -> cxtranslationunit option

Same as clang_parseTranslationUnit2, but returns the CXTranslationUnit instead of an error code. In case of an error this routine returns a NULL CXTranslationUnit, without further detailed error codes.

val parse_translation_unit2 : cxindex -> string -> string array -> cxunsavedfile array -> Cxtranslationunit_flags.t -> (cxtranslationunit, cxerrorcode) Stdcompat.result

Parse the given source file and the translation unit corresponding to that file.

val parse_translation_unit2_full_argv : cxindex -> string -> string array -> cxunsavedfile array -> Cxtranslationunit_flags.t -> (cxtranslationunit, cxerrorcode) Stdcompat.result

Same as clang_parseTranslationUnit2 but requires a full command line for command_line_args including argv[0]. This is useful if the standard library paths are relative to the binary.

val default_save_options : cxtranslationunit -> int

Returns the set of flags that is suitable for saving a translation unit.

type cxsaveerror =
| Unknown

Indicates that an unknown error occurred while attempting to save the file.

| TranslationErrors

Indicates that errors during translation prevented this attempt to save the translation unit.

| InvalidTU

Indicates that the translation unit to be saved was somehow invalid (e.g., NULL).

Describes the kind of error that occurred (if any) in a call to clang_saveTranslationUnit().

module Cxsavetranslationunit_flags : sig ... end
val save_translation_unit : cxtranslationunit -> string -> Cxsavetranslationunit_flags.t -> (unit, cxsaveerror) Stdcompat.result

Saves a translation unit into a serialized representation of that translation unit on disk.

val suspend_translation_unit : cxtranslationunit -> int

Suspend a translation unit in order to free memory associated with it.

module Cxreparse_flags : sig ... end
val default_reparse_options : cxtranslationunit -> Cxreparse_flags.t

Returns the set of flags that is suitable for reparsing a translation unit.

val reparse_translation_unit : cxtranslationunit -> cxunsavedfile array -> Cxreparse_flags.t -> (unit, cxerrorcode) Stdcompat.result

Reparse the source files that produced this translation unit.

type cxturesourceusagekind =
| AST
| Identifiers
| Selectors
| GlobalCompletionResults
| SourceManagerContentCache
| AST_SideTables
| SourceManager_Membuffer_Malloc
| SourceManager_Membuffer_MMap
| ExternalASTSource_Membuffer_Malloc
| ExternalASTSource_Membuffer_MMap
| Preprocessor
| PreprocessingRecord
| SourceManager_DataStructures
| Preprocessor_HeaderSearch

Categorizes how memory is being used by a translation unit.

val get_turesource_usage_name : cxturesourceusagekind -> string

Returns the human-readable null-terminated C string that represents the name of the memory category. This string should never be freed.

type cxturesourceusage

The memory usage of a CXTranslationUnit, broken into categories.

val get_cxturesource_usage : cxtranslationunit -> cxturesourceusage

Return the memory usage of a translation unit. This object should be released with clang_disposeCXTUResourceUsage().

type cxtargetinfo
val get_translation_unit_target_info : cxtranslationunit -> cxtargetinfo

Get target information for this translation unit.

val target_info_get_triple : cxtargetinfo -> string

Get the normalized target triple as a string.

val target_info_get_pointer_width : cxtargetinfo -> int

Get the pointer width of the target in bits.

type cxcursorkind =
| UnexposedDecl

A declaration whose specific kind is not exposed via this interface.

| StructDecl

A C or C++ struct.

| UnionDecl

A C or C++ union.

| ClassDecl

A C++ class.

| EnumDecl

An enumeration.

| FieldDecl

A field (in C) or non-static data member (in C++) in a struct, union, or C++ class.

| EnumConstantDecl

An enumerator constant.

| FunctionDecl

A function.

| VarDecl

A variable.

| ParmDecl

A function or method parameter.

| ObjCInterfaceDecl

An Objective-C @interface.

| ObjCCategoryDecl

An Objective-C @interface for a category.

| ObjCProtocolDecl

An Objective-C @protocol declaration.

| ObjCPropertyDecl

An Objective-C @property declaration.

| ObjCIvarDecl

An Objective-C instance variable.

| ObjCInstanceMethodDecl

An Objective-C instance method.

| ObjCClassMethodDecl

An Objective-C class method.

| ObjCImplementationDecl

An Objective-C @implementation.

| ObjCCategoryImplDecl

An Objective-C @implementation for a category.

| TypedefDecl

A typedef.

| CXXMethod

A C++ class method.

| Namespace

A C++ namespace.

| LinkageSpec

A linkage specification, e.g. 'extern "C"'.

| Constructor

A C++ constructor.

| Destructor

A C++ destructor.

| ConversionFunction

A C++ conversion function.

| TemplateTypeParameter

A C++ template type parameter.

| NonTypeTemplateParameter

A C++ non-type template parameter.

| TemplateTemplateParameter

A C++ template template parameter.

| FunctionTemplate

A C++ function template.

| ClassTemplate

A C++ class template.

| ClassTemplatePartialSpecialization

A C++ class template partial specialization.

| NamespaceAlias

A C++ namespace alias declaration.

| UsingDirective

A C++ using directive.

| UsingDeclaration

A C++ using declaration.

| TypeAliasDecl

A C++ alias declaration

| ObjCSynthesizeDecl

An Objective-C @synthesize definition.

| ObjCDynamicDecl

An Objective-C @dynamic definition.

| CXXAccessSpecifier

An access specifier.

| ObjCSuperClassRef

An access specifier.

| ObjCProtocolRef

An access specifier.

| ObjCClassRef

An access specifier.

| TypeRef

A reference to a type declaration.

| CXXBaseSpecifier

A reference to a type declaration.

| TemplateRef

A reference to a class template, function template, template template parameter, or class template partial specialization.

| NamespaceRef

A reference to a namespace or namespace alias.

| MemberRef

A reference to a member of a struct, union, or class that occurs in some non-expression context, e.g., a designated initializer.

| LabelRef

A reference to a labeled statement.

| OverloadedDeclRef

A reference to a set of overloaded functions or function templates that has not yet been resolved to a specific function or function template.

| VariableRef

A reference to a variable that occurs in some non-expression context, e.g., a C++ lambda capture list.

| InvalidFile

A reference to a variable that occurs in some non-expression context, e.g., a C++ lambda capture list.

| NoDeclFound

A reference to a variable that occurs in some non-expression context, e.g., a C++ lambda capture list.

| NotImplemented

A reference to a variable that occurs in some non-expression context, e.g., a C++ lambda capture list.

| InvalidCode

A reference to a variable that occurs in some non-expression context, e.g., a C++ lambda capture list.

| UnexposedExpr

An expression whose specific kind is not exposed via this interface.

| DeclRefExpr

An expression that refers to some value declaration, such as a function, variable, or enumerator.

| MemberRefExpr

An expression that refers to a member of a struct, union, class, Objective-C class, etc.

| CallExpr

An expression that calls a function.

| ObjCMessageExpr

An expression that sends a message to an Objective-C object or class.

| BlockExpr

An expression that represents a block literal.

| IntegerLiteral

An integer literal.

| FloatingLiteral

A floating point number literal.

| ImaginaryLiteral

An imaginary number literal.

| StringLiteral

A string literal.

| CharacterLiteral

A character literal.

| ParenExpr

A parenthesized expression, e.g. "(1)".

| UnaryOperator

This represents the unary-expression's (except sizeof and alignof).

| ArraySubscriptExpr

[C99 6.5.2.1] Array Subscripting.

| BinaryOperator

A builtin binary operation expression such as "x + y" or "x <= y".

| CompoundAssignOperator

Compound assignment such as "+=".

| ConditionalOperator

The ?: ternary operator.

| CStyleCastExpr

An explicit cast in C (C99 6.5.4) or a C-style cast in C++ (C++ [expr.cast]), which uses the syntax (Type)expr.

| CompoundLiteralExpr

[C99 6.5.2.5]

| InitListExpr

Describes an C or C++ initializer list.

| AddrLabelExpr

The GNU address of label extension, representing &&label.

| StmtExpr

This is the GNU Statement Expression extension: ({int X=4; X;})

| GenericSelectionExpr

Represents a C11 generic selection.

| GNUNullExpr

Implements the GNU __null extension, which is a name for a null pointer constant that has integral type (e.g., int or long) and is the same size and alignment as a pointer.

| CXXStaticCastExpr

C++'s static_cast<> expression.

| CXXDynamicCastExpr

C++'s dynamic_cast<> expression.

| CXXReinterpretCastExpr

C++'s reinterpret_cast<> expression.

| CXXConstCastExpr

C++'s const_cast<> expression.

| CXXFunctionalCastExpr

Represents an explicit C++ type conversion that uses "functional" notion (C++ [expr.type.conv]).

| CXXTypeidExpr

A C++ typeid expression (C++ [expr.typeid]).

| CXXBoolLiteralExpr

[C++ 2.13.5] C++ Boolean Literal.

| CXXNullPtrLiteralExpr

[C++0x 2.14.7] C++ Pointer Literal.

| CXXThisExpr

Represents the "this" expression in C++

| CXXThrowExpr

[C++ 15] C++ Throw Expression.

| CXXNewExpr

A new expression for memory allocation and constructor calls, e.g: "new CXXNewExpr(foo)".

| CXXDeleteExpr

A delete expression for memory deallocation and destructor calls, e.g. "delete[] pArray".

| UnaryExpr

A unary expression. (noexcept, sizeof, or other traits)

| ObjCStringLiteral

An Objective-C string literal i.e. "foo".

| ObjCEncodeExpr

An Objective-C @encode expression.

| ObjCSelectorExpr

An Objective-C @selector expression.

| ObjCProtocolExpr

An Objective-C @protocol expression.

| ObjCBridgedCastExpr

An Objective-C "bridged" cast expression, which casts between Objective-C pointers and C pointers, transferring ownership in the process.

| PackExpansionExpr

Represents a C++0x pack expansion that produces a sequence of expressions.

| SizeOfPackExpr

Represents an expression that computes the length of a parameter pack.

| LambdaExpr
| ObjCBoolLiteralExpr

Objective-c Boolean Literal.

| ObjCSelfExpr

Represents the "self" expression in an Objective-C method.

| OMPArraySectionExpr

OpenMP 4.0 [2.4, Array Section].

| ObjCAvailabilityCheckExpr

Represents an (...) check.

| UnexposedStmt

A statement whose specific kind is not exposed via this interface.

| LabelStmt

A labelled statement in a function.

| CompoundStmt

A group of statements like { stmt stmt }.

| CaseStmt

A case statement.

| DefaultStmt

A default statement.

| IfStmt

An if statement

| SwitchStmt

A switch statement.

| WhileStmt

A while statement.

| DoStmt

A do statement.

| ForStmt

A for statement.

| GotoStmt

A goto statement.

| IndirectGotoStmt

An indirect goto statement.

| ContinueStmt

A continue statement.

| BreakStmt

A break statement.

| ReturnStmt

A return statement.

| GCCAsmStmt

A GCC inline assembly statement extension.

| ObjCAtTryStmt

Objective-C's overall @try-@catch-@finally statement.

| ObjCAtCatchStmt

Objective-C's @catch statement.

| ObjCAtFinallyStmt

Objective-C's @finally statement.

| ObjCAtThrowStmt

Objective-C's @throw statement.

| ObjCAtSynchronizedStmt

Objective-C's @synchronized statement.

| ObjCAutoreleasePoolStmt

Objective-C's autorelease pool statement.

| ObjCForCollectionStmt

Objective-C's collection statement.

| CXXCatchStmt

C++'s catch statement.

| CXXTryStmt

C++'s try statement.

| CXXForRangeStmt

C++'s for (* : *) statement.

| SEHTryStmt

Windows Structured Exception Handling's try statement.

| SEHExceptStmt

Windows Structured Exception Handling's except statement.

| SEHFinallyStmt

Windows Structured Exception Handling's finally statement.

| MSAsmStmt

A MS inline assembly statement extension.

| NullStmt

The null statement ";": C99 6.8.3p3.

| DeclStmt

Adaptor class for mixing declarations with statements and expressions.

| OMPParallelDirective

OpenMP parallel directive.

| OMPSimdDirective

OpenMP SIMD directive.

| OMPForDirective

OpenMP for directive.

| OMPSectionsDirective

OpenMP sections directive.

| OMPSectionDirective

OpenMP section directive.

| OMPSingleDirective

OpenMP single directive.

| OMPParallelForDirective

OpenMP parallel for directive.

| OMPParallelSectionsDirective

OpenMP parallel sections directive.

| OMPTaskDirective

OpenMP task directive.

| OMPMasterDirective

OpenMP master directive.

| OMPCriticalDirective

OpenMP critical directive.

| OMPTaskyieldDirective

OpenMP taskyield directive.

| OMPBarrierDirective

OpenMP barrier directive.

| OMPTaskwaitDirective

OpenMP taskwait directive.

| OMPFlushDirective

OpenMP flush directive.

| SEHLeaveStmt

Windows Structured Exception Handling's leave statement.

| OMPOrderedDirective

OpenMP ordered directive.

| OMPAtomicDirective

OpenMP atomic directive.

| OMPForSimdDirective

OpenMP for SIMD directive.

| OMPParallelForSimdDirective

OpenMP parallel for SIMD directive.

| OMPTargetDirective

OpenMP target directive.

| OMPTeamsDirective

OpenMP teams directive.

| OMPTaskgroupDirective

OpenMP taskgroup directive.

| OMPCancellationPointDirective

OpenMP cancellation point directive.

| OMPCancelDirective

OpenMP cancel directive.

| OMPTargetDataDirective

OpenMP target data directive.

| OMPTaskLoopDirective

OpenMP taskloop directive.

| OMPTaskLoopSimdDirective

OpenMP taskloop simd directive.

| OMPDistributeDirective

OpenMP distribute directive.

| OMPTargetEnterDataDirective

OpenMP target enter data directive.

| OMPTargetExitDataDirective

OpenMP target exit data directive.

| OMPTargetParallelDirective

OpenMP target parallel directive.

| OMPTargetParallelForDirective

OpenMP target parallel for directive.

| OMPTargetUpdateDirective

OpenMP target update directive.

| OMPDistributeParallelForDirective

OpenMP distribute parallel for directive.

| OMPDistributeParallelForSimdDirective

OpenMP distribute parallel for simd directive.

| OMPDistributeSimdDirective

OpenMP distribute simd directive.

| OMPTargetParallelForSimdDirective

OpenMP target parallel for simd directive.

| OMPTargetSimdDirective

OpenMP target simd directive.

| OMPTeamsDistributeDirective

OpenMP teams distribute directive.

| OMPTeamsDistributeSimdDirective

OpenMP teams distribute simd directive.

| OMPTeamsDistributeParallelForSimdDirective

OpenMP teams distribute parallel for simd directive.

| OMPTeamsDistributeParallelForDirective

OpenMP teams distribute parallel for directive.

| OMPTargetTeamsDirective

OpenMP target teams directive.

| OMPTargetTeamsDistributeDirective

OpenMP target teams distribute directive.

| OMPTargetTeamsDistributeParallelForDirective

OpenMP target teams distribute parallel for directive.

| OMPTargetTeamsDistributeParallelForSimdDirective

OpenMP target teams distribute parallel for simd directive.

| OMPTargetTeamsDistributeSimdDirective

OpenMP target teams distribute simd directive.

| TranslationUnit

Cursor that represents the translation unit itself.

| UnexposedAttr

An attribute whose specific kind is not exposed via this interface.

| IBActionAttr

An attribute whose specific kind is not exposed via this interface.

| IBOutletAttr

An attribute whose specific kind is not exposed via this interface.

| IBOutletCollectionAttr

An attribute whose specific kind is not exposed via this interface.

| CXXFinalAttr

An attribute whose specific kind is not exposed via this interface.

| CXXOverrideAttr

An attribute whose specific kind is not exposed via this interface.

| AnnotateAttr

An attribute whose specific kind is not exposed via this interface.

| AsmLabelAttr

An attribute whose specific kind is not exposed via this interface.

| PackedAttr

An attribute whose specific kind is not exposed via this interface.

| PureAttr

An attribute whose specific kind is not exposed via this interface.

| ConstAttr

An attribute whose specific kind is not exposed via this interface.

| NoDuplicateAttr

An attribute whose specific kind is not exposed via this interface.

| CUDAConstantAttr

An attribute whose specific kind is not exposed via this interface.

| CUDADeviceAttr

An attribute whose specific kind is not exposed via this interface.

| CUDAGlobalAttr

An attribute whose specific kind is not exposed via this interface.

| CUDAHostAttr

An attribute whose specific kind is not exposed via this interface.

| CUDASharedAttr

An attribute whose specific kind is not exposed via this interface.

| VisibilityAttr

An attribute whose specific kind is not exposed via this interface.

| DLLExport

An attribute whose specific kind is not exposed via this interface.

| DLLImport

An attribute whose specific kind is not exposed via this interface.

| PreprocessingDirective

An attribute whose specific kind is not exposed via this interface.

| MacroDefinition

An attribute whose specific kind is not exposed via this interface.

| MacroExpansion

An attribute whose specific kind is not exposed via this interface.

| InclusionDirective

An attribute whose specific kind is not exposed via this interface.

| ModuleImportDecl

A module import declaration.

| TypeAliasTemplateDecl

A module import declaration.

| StaticAssert

A static_assert or _Static_assert node

| FriendDecl

a friend declaration.

| OverloadCandidate

A code completion overload candidate.

Describes the kind of entity that a cursor refers to.

type cxcursor

A cursor representing some element in the abstract syntax tree for a translation unit.

val get_null_cursor : unit -> cxcursor

Retrieve the NULL cursor, which represents no entity.

val get_translation_unit_cursor : cxtranslationunit -> cxcursor

Retrieve the cursor that represents the given translation unit.

val equal_cursors : cxcursor -> cxcursor -> bool

Determine whether two cursors are equivalent.

val cursor_is_null : cxcursor -> bool

Returns non-zero if cursor is null.

val hash_cursor : cxcursor -> int

Compute a hash value for the given cursor.

val get_cursor_kind : cxcursor -> cxcursorkind

Retrieve the kind of the given cursor.

val is_declaration : cxcursorkind -> bool

Determine whether the given cursor kind represents a declaration.

val is_reference : cxcursorkind -> bool

Determine whether the given cursor kind represents a simple reference.

val is_expression : cxcursorkind -> bool

Determine whether the given cursor kind represents an expression.

val is_statement : cxcursorkind -> bool

Determine whether the given cursor kind represents a statement.

val is_attribute : cxcursorkind -> bool

Determine whether the given cursor kind represents an attribute.

val cursor_has_attrs : cxcursor -> int

Determine whether the given cursor has any attributes.

val is_invalid : cxcursorkind -> bool

Determine whether the given cursor kind represents an invalid cursor.

val is_translation_unit : cxcursorkind -> bool

Determine whether the given cursor kind represents a translation unit.

val is_preprocessing : cxcursorkind -> bool

Determine whether the given cursor represents a preprocessing element, such as a preprocessor directive or macro instantiation.

val is_unexposed : cxcursorkind -> bool

Determine whether the given cursor represents a currently unexposed piece of the AST (e.g., CXCursor_UnexposedStmt).

type cxlinkagekind =
| Invalid

This value indicates that no linkage information is available for a provided CXCursor.

| NoLinkage

This is the linkage for variables, parameters, and so on that have automatic storage. This covers normal (non-extern) local variables.

| Internal

This is the linkage for static variables and static functions.

| UniqueExternal

This is the linkage for entities with external linkage that live in C++ anonymous namespaces.

| External

This is the linkage for entities with true, external linkage.

Describe the linkage of the entity referred to by a cursor.

val get_cursor_linkage : cxcursor -> cxlinkagekind

Determine the linkage of the entity referred to by a given cursor.

type cxvisibilitykind =
| Invalid

This value indicates that no visibility information is available for a provided CXCursor.

| Hidden

Symbol not seen by the linker.

| Protected

Symbol seen by the linker but resolves to a symbol inside this object.

| Default

Symbol seen by the linker and acts like a normal symbol.

val get_cursor_visibility : cxcursor -> cxvisibilitykind

Describe the visibility of the entity referred to by a cursor.

type cxavailabilitykind =
| Available

The entity is available.

| Deprecated

The entity is available, but has been deprecated (and its use is not recommended).

| NotAvailable

The entity is not available; any use of it will be an error.

| NotAccessible

The entity is available, but not accessible; any use of it will be an error.

Describes the availability of a particular entity, which indicates whether the use of this entity will result in a warning or error due to it being deprecated or unavailable.

val get_cursor_availability : cxcursor -> cxavailabilitykind

Determine the availability of the entity that this cursor refers to, taking the current target platform into account.

type cxlanguagekind =
| Invalid
| C
| ObjC
| CPlusPlus

Describe the "language" of the entity referred to by a cursor.

val get_cursor_language : cxcursor -> cxlanguagekind

Determine the "language" of the entity referred to by a given cursor.

type cxtlskind =
| None
| Dynamic
| Static

Describe the "thread-local storage (TLS) kind" of the declaration referred to by a cursor.

val get_cursor_tlskind : cxcursor -> cxtlskind

Determine the "thread-local storage (TLS) kind" of the declaration referred to by a cursor.

type cxcursorset
val create_cxcursor_set : unit -> cxcursorset

Creates an empty CXCursorSet.

val cxcursor_set_contains : cxcursorset -> cxcursor -> int

Queries a CXCursorSet to see if it contains a specific CXCursor.

val cxcursor_set_insert : cxcursorset -> cxcursor -> int

Inserts a CXCursor into a CXCursorSet.

val get_cursor_semantic_parent : cxcursor -> cxcursor

Determine the semantic parent of the given cursor.

val get_cursor_lexical_parent : cxcursor -> cxcursor

Determine the lexical parent of the given cursor.

val get_overridden_cursors : cxcursor -> cxcursor array

Determine the set of methods that are overridden by the given method.

val get_included_file : cxcursor -> cxfile

Retrieve the file that is included by the given inclusion directive cursor.

val get_cursor : cxtranslationunit -> cxsourcelocation -> cxcursor

Map a source location to the cursor that describes the entity at that location in the source code.

val get_cursor_location : cxcursor -> cxsourcelocation

Retrieve the physical location of the source constructor referenced by the given cursor.

val get_cursor_extent : cxcursor -> cxsourcerange

Retrieve the physical extent of the source construct referenced by the given cursor.

type cxtypekind =
| Invalid

Represents an invalid type (e.g., where no type is available).

| Unexposed

A type whose specific kind is not exposed via this interface.

| Void

A type whose specific kind is not exposed via this interface.

| Bool

A type whose specific kind is not exposed via this interface.

| Char_U

A type whose specific kind is not exposed via this interface.

| UChar

A type whose specific kind is not exposed via this interface.

| Char16

A type whose specific kind is not exposed via this interface.

| Char32

A type whose specific kind is not exposed via this interface.

| UShort

A type whose specific kind is not exposed via this interface.

| UInt

A type whose specific kind is not exposed via this interface.

| ULong

A type whose specific kind is not exposed via this interface.

| ULongLong

A type whose specific kind is not exposed via this interface.

| UInt128

A type whose specific kind is not exposed via this interface.

| Char_S

A type whose specific kind is not exposed via this interface.

| SChar

A type whose specific kind is not exposed via this interface.

| WChar

A type whose specific kind is not exposed via this interface.

| Short

A type whose specific kind is not exposed via this interface.

| Int

A type whose specific kind is not exposed via this interface.

| Long

A type whose specific kind is not exposed via this interface.

| LongLong

A type whose specific kind is not exposed via this interface.

| Int128

A type whose specific kind is not exposed via this interface.

| Float

A type whose specific kind is not exposed via this interface.

| Double

A type whose specific kind is not exposed via this interface.

| LongDouble

A type whose specific kind is not exposed via this interface.

| NullPtr

A type whose specific kind is not exposed via this interface.

| Overload

A type whose specific kind is not exposed via this interface.

| Dependent

A type whose specific kind is not exposed via this interface.

| ObjCId

A type whose specific kind is not exposed via this interface.

| ObjCClass

A type whose specific kind is not exposed via this interface.

| ObjCSel

A type whose specific kind is not exposed via this interface.

| Float128

A type whose specific kind is not exposed via this interface.

| Half

A type whose specific kind is not exposed via this interface.

| Float16

A type whose specific kind is not exposed via this interface.

| Complex

A type whose specific kind is not exposed via this interface.

| Pointer

A type whose specific kind is not exposed via this interface.

| BlockPointer

A type whose specific kind is not exposed via this interface.

| LValueReference

A type whose specific kind is not exposed via this interface.

| RValueReference

A type whose specific kind is not exposed via this interface.

| Record

A type whose specific kind is not exposed via this interface.

| Enum

A type whose specific kind is not exposed via this interface.

| Typedef

A type whose specific kind is not exposed via this interface.

| ObjCInterface

A type whose specific kind is not exposed via this interface.

| ObjCObjectPointer

A type whose specific kind is not exposed via this interface.

| FunctionNoProto

A type whose specific kind is not exposed via this interface.

| FunctionProto

A type whose specific kind is not exposed via this interface.

| ConstantArray

A type whose specific kind is not exposed via this interface.

| Vector

A type whose specific kind is not exposed via this interface.

| IncompleteArray

A type whose specific kind is not exposed via this interface.

| VariableArray

A type whose specific kind is not exposed via this interface.

| DependentSizedArray

A type whose specific kind is not exposed via this interface.

| MemberPointer

A type whose specific kind is not exposed via this interface.

| Auto

A type whose specific kind is not exposed via this interface.

| Elaborated

Represents a type that was referred to using an elaborated type keyword.

| Pipe

Represents a type that was referred to using an elaborated type keyword.

| OCLImage1dRO

Represents a type that was referred to using an elaborated type keyword.

| OCLImage1dArrayRO

Represents a type that was referred to using an elaborated type keyword.

| OCLImage1dBufferRO

Represents a type that was referred to using an elaborated type keyword.

| OCLImage2dRO

Represents a type that was referred to using an elaborated type keyword.

| OCLImage2dArrayRO

Represents a type that was referred to using an elaborated type keyword.

| OCLImage2dDepthRO

Represents a type that was referred to using an elaborated type keyword.

| OCLImage2dArrayDepthRO

Represents a type that was referred to using an elaborated type keyword.

| OCLImage2dMSAARO

Represents a type that was referred to using an elaborated type keyword.

| OCLImage2dArrayMSAARO

Represents a type that was referred to using an elaborated type keyword.

| OCLImage2dMSAADepthRO

Represents a type that was referred to using an elaborated type keyword.

| OCLImage2dArrayMSAADepthRO

Represents a type that was referred to using an elaborated type keyword.

| OCLImage3dRO

Represents a type that was referred to using an elaborated type keyword.

| OCLImage1dWO

Represents a type that was referred to using an elaborated type keyword.

| OCLImage1dArrayWO

Represents a type that was referred to using an elaborated type keyword.

| OCLImage1dBufferWO

Represents a type that was referred to using an elaborated type keyword.

| OCLImage2dWO

Represents a type that was referred to using an elaborated type keyword.

| OCLImage2dArrayWO

Represents a type that was referred to using an elaborated type keyword.

| OCLImage2dDepthWO

Represents a type that was referred to using an elaborated type keyword.

| OCLImage2dArrayDepthWO

Represents a type that was referred to using an elaborated type keyword.

| OCLImage2dMSAAWO

Represents a type that was referred to using an elaborated type keyword.

| OCLImage2dArrayMSAAWO

Represents a type that was referred to using an elaborated type keyword.

| OCLImage2dMSAADepthWO

Represents a type that was referred to using an elaborated type keyword.

| OCLImage2dArrayMSAADepthWO

Represents a type that was referred to using an elaborated type keyword.

| OCLImage3dWO

Represents a type that was referred to using an elaborated type keyword.

| OCLImage1dRW

Represents a type that was referred to using an elaborated type keyword.

| OCLImage1dArrayRW

Represents a type that was referred to using an elaborated type keyword.

| OCLImage1dBufferRW

Represents a type that was referred to using an elaborated type keyword.

| OCLImage2dRW

Represents a type that was referred to using an elaborated type keyword.

| OCLImage2dArrayRW

Represents a type that was referred to using an elaborated type keyword.

| OCLImage2dDepthRW

Represents a type that was referred to using an elaborated type keyword.

| OCLImage2dArrayDepthRW

Represents a type that was referred to using an elaborated type keyword.

| OCLImage2dMSAARW

Represents a type that was referred to using an elaborated type keyword.

| OCLImage2dArrayMSAARW

Represents a type that was referred to using an elaborated type keyword.

| OCLImage2dMSAADepthRW

Represents a type that was referred to using an elaborated type keyword.

| OCLImage2dArrayMSAADepthRW

Represents a type that was referred to using an elaborated type keyword.

| OCLImage3dRW

Represents a type that was referred to using an elaborated type keyword.

| OCLSampler

Represents a type that was referred to using an elaborated type keyword.

| OCLEvent

Represents a type that was referred to using an elaborated type keyword.

| OCLQueue

Represents a type that was referred to using an elaborated type keyword.

| OCLReserveID

Represents a type that was referred to using an elaborated type keyword.

Describes the kind of type

type cxtype

The type of an element in the abstract syntax tree.

val get_type_kind : cxtype -> cxtypekind
val get_cursor_type : cxcursor -> cxtype

Retrieve the type of a CXCursor (if any).

val get_type_spelling : cxtype -> string

Pretty-print the underlying type using the rules of the language of the translation unit from which it came.

val get_typedef_decl_underlying_type : cxcursor -> cxtype

Retrieve the underlying type of a typedef declaration.

val get_enum_decl_integer_type : cxcursor -> cxtype

Retrieve the integer type of an enum declaration.

val get_enum_constant_decl_value : cxcursor -> int

Retrieve the integer value of an enum constant declaration as a signed long long.

val get_enum_constant_decl_unsigned_value : cxcursor -> int

Retrieve the integer value of an enum constant declaration as an unsigned long long.

val get_field_decl_bit_width : cxcursor -> int

Retrieve the bit width of a bit field declaration as an integer.

val cursor_get_num_arguments : cxcursor -> int

Retrieve the number of non-variadic arguments associated with a given cursor.

val cursor_get_argument : cxcursor -> int -> cxcursor

Retrieve the argument cursor of a function or method.

val cursor_get_num_template_arguments : cxcursor -> int

Returns the number of template args of a function decl representing a template specialization.

type cxtemplateargumentkind =
| Null
| Type
| Declaration
| NullPtr
| Integral
| Template
| TemplateExpansion
| Expression
| Pack
| Invalid

Describes the kind of a template argument.

val cursor_get_template_argument_kind : cxcursor -> int -> cxtemplateargumentkind

Retrieve the kind of the I'th template argument of the CXCursor C.

val cursor_get_template_argument_type : cxcursor -> int -> cxtype

Retrieve a CXType representing the type of a TemplateArgument of a function decl representing a template specialization.

val cursor_get_template_argument_value : cxcursor -> int -> int

Retrieve the value of an Integral TemplateArgument (of a function decl representing a template specialization) as a signed long long.

val cursor_get_template_argument_unsigned_value : cxcursor -> int -> int

Retrieve the value of an Integral TemplateArgument (of a function decl representing a template specialization) as an unsigned long long.

val equal_types : cxtype -> cxtype -> bool

Determine whether two CXTypes represent the same type.

val get_canonical_type : cxtype -> cxtype

Return the canonical type for a CXType.

val is_const_qualified_type : cxtype -> bool

Determine whether a CXType has the "const" qualifier set, without looking through typedefs that may have added "const" at a different level.

val cursor_is_macro_function_like : cxcursor -> bool

Determine whether a CXCursor that is a macro, is function like.

val cursor_is_macro_builtin : cxcursor -> bool

Determine whether a CXCursor that is a macro, is a builtin one.

val cursor_is_function_inlined : cxcursor -> bool

Determine whether a CXCursor that is a function declaration, is an inline declaration.

val is_volatile_qualified_type : cxtype -> bool

Determine whether a CXType has the "volatile" qualifier set, without looking through typedefs that may have added "volatile" at a different level.

val is_restrict_qualified_type : cxtype -> bool

Determine whether a CXType has the "restrict" qualifier set, without looking through typedefs that may have added "restrict" at a different level.

val get_address_space : cxtype -> int

Returns the address space of the given type.

val get_typedef_name : cxtype -> string

Returns the typedef name of the given type.

val get_pointee_type : cxtype -> cxtype

For pointer types, returns the type of the pointee.

val get_type_declaration : cxtype -> cxcursor

Return the cursor for the declaration of the given type.

val get_decl_obj_ctype_encoding : cxcursor -> string

Returns the Objective-C type encoding for the specified declaration.

val type_get_obj_cencoding : cxtype -> string

Returns the Objective-C type encoding for the specified CXType.

val get_type_kind_spelling : cxtypekind -> string

Retrieve the spelling of a given CXTypeKind.

type cxcallingconv =
| Default
| C
| X86StdCall
| X86FastCall
| X86ThisCall
| X86Pascal
| AAPCS
| AAPCS_VFP
| X86RegCall
| IntelOclBicc
| Win64
| X86_64SysV
| X86VectorCall
| Swift
| PreserveMost
| PreserveAll
| Invalid
| Unexposed

Describes the calling convention of a function type

val get_function_type_calling_conv : cxtype -> cxcallingconv

Retrieve the calling convention associated with a function type.

val get_result_type : cxtype -> cxtype

Retrieve the return type associated with a function type.

val get_exception_specification_type : cxtype -> int

Retrieve the exception specification type associated with a function type.

val get_num_arg_types : cxtype -> int

Retrieve the number of non-variadic parameters associated with a function type.

val get_arg_type : cxtype -> int -> cxtype

Retrieve the type of a parameter of a function type.

val is_function_type_variadic : cxtype -> bool

Return 1 if the CXType is a variadic function type, and 0 otherwise.

val get_cursor_result_type : cxcursor -> cxtype

Retrieve the return type associated with a given cursor.

val get_cursor_exception_specification_type : cxcursor -> int

Retrieve the exception specification type associated with a given cursor.

val is_podtype : cxtype -> bool

Return 1 if the CXType is a POD (plain old data) type, and 0 otherwise.

val get_element_type : cxtype -> cxtype

Return the element type of an array, complex, or vector type.

val get_num_elements : cxtype -> int

Return the number of elements of an array or vector type.

val get_array_element_type : cxtype -> cxtype

Return the element type of an array type.

val get_array_size : cxtype -> int

Return the array size of a constant array.

val type_get_named_type : cxtype -> cxtype

Retrieve the type named by the qualified-id.

val type_is_transparent_tag_typedef : cxtype -> bool

Determine if a typedef is 'transparent' tag.

val type_get_align_of : cxtype -> int

Return the alignment of a type in bytes as per C++[expr.alignof] standard.

val type_get_class_type : cxtype -> cxtype

Return the class type of an member pointer type.

val type_get_size_of : cxtype -> int

Return the size of a type in bytes as per C++[expr.sizeof] standard.

val type_get_offset_of : cxtype -> string -> int

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]

val cursor_get_offset_of_field : cxcursor -> int

Return the offset of the field represented by the Cursor.

val cursor_is_anonymous : cxcursor -> bool

Determine whether the given cursor represents an anonymous record declaration.

val type_get_num_template_arguments : cxtype -> int

Returns the number of template arguments for given template specialization, or -1 if type T is not a template specialization.

val type_get_template_argument_as_type : cxtype -> int -> cxtype

Returns the type template argument of a template class specialization at given index.

type cxrefqualifierkind =
| None

No ref-qualifier was provided.

| LValue

An lvalue ref-qualifier was provided ( &).

| RValue

An rvalue ref-qualifier was provided ( &&).

val type_get_cxxref_qualifier : cxtype -> cxrefqualifierkind

Retrieve the ref-qualifier kind of a function or method.

val cursor_is_bit_field : cxcursor -> bool

Returns non-zero if the cursor specifies a Record member that is a bitfield.

val is_virtual_base : cxcursor -> bool

Returns 1 if the base class specified by the cursor with kind CX_CXXBaseSpecifier is virtual.

type cx_cxxaccessspecifier =
| CXXInvalidAccessSpecifier
| CXXPublic
| CXXProtected
| CXXPrivate

Represents the C++ access control level to a base class for a cursor with kind CX_CXXBaseSpecifier.

val get_cxxaccess_specifier : cxcursor -> cx_cxxaccessspecifier

Returns the access control level for the referenced object.

type cx_storageclass =
| Invalid
| None
| Extern
| Static
| PrivateExtern
| OpenCLWorkGroupLocal
| Auto
| Register

Represents the storage classes as declared in the source. CX_SC_Invalid was added for the case that the passed cursor in not a declaration.

val cursor_get_storage_class : cxcursor -> cx_storageclass

Returns the storage class for a function or variable declaration.

val get_num_overloaded_decls : cxcursor -> int

Determine the number of overloaded declarations referenced by a CXCursor_OverloadedDeclRef cursor.

val get_overloaded_decl : cxcursor -> int -> cxcursor

Retrieve a cursor for one of the overloaded declarations referenced by a CXCursor_OverloadedDeclRef cursor.

val get_iboutlet_collection_type : cxcursor -> cxtype

For cursors representing an iboutletcollection attribute, this function returns the collection element type.

type cxchildvisitresult =
| Break

Terminates the cursor traversal.

| Continue

Continues the cursor traversal with the next sibling of the cursor just visited, without visiting its children.

| Recurse

Recursively traverse the children of this cursor, using the same visitor and client data.

Describes how the traversal of the children of a particular cursor should proceed after visiting a particular child cursor.

val visit_children : cxcursor -> (cxcursor -> cxcursor -> cxchildvisitresult) -> bool

Visit the children of a particular cursor.

val get_cursor_usr : cxcursor -> string

Retrieve a Unified Symbol Resolution (USR) for the entity referenced by the given cursor.

val get_cursor_spelling : cxcursor -> string

Retrieve a name for the entity referenced by this cursor.

val cursor_get_spelling_name_range : cxcursor -> piece_index:int -> options:int -> cxsourcerange

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.

val get_cursor_display_name : cxcursor -> string

Retrieve the display name for the entity referenced by this cursor.

val get_cursor_referenced : cxcursor -> cxcursor

For a cursor that is a reference, retrieve a cursor representing the entity that it references.

val get_cursor_definition : cxcursor -> cxcursor

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.

val is_cursor_definition : cxcursor -> bool

Determine whether the declaration pointed to by this cursor is also a definition of that entity.

val get_canonical_cursor : cxcursor -> cxcursor

Retrieve the canonical cursor corresponding to the given cursor.

val cursor_get_obj_cselector_index : cxcursor -> int

If the cursor points to a selector identifier in an Objective-C method or message expression, this returns the selector index.

val cursor_is_dynamic_call : cxcursor -> bool

Given a cursor pointing to a C++ method call or an Objective-C message, returns non-zero if the method/message is "dynamic", meaning:

val cursor_get_receiver_type : cxcursor -> cxtype

Given a cursor pointing to an Objective-C message or property reference, or C++ method call, returns the CXType of the receiver.

val cursor_get_obj_cproperty_attributes : cxcursor -> int -> int

Given a cursor that represents a property declaration, return the associated property attributes. The bits are formed from CXObjCPropertyAttrKind.

val cursor_get_obj_cdecl_qualifiers : cxcursor -> int

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.

val cursor_is_obj_coptional : cxcursor -> bool

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".

val cursor_is_variadic : cxcursor -> bool

Returns non-zero if the given cursor is a variadic function or method.

val cursor_is_external_symbol : cxcursor -> (string * string * int) option

Returns non-zero if the given cursor points to a symbol marked with external_source_symbol attribute.

val cursor_get_comment_range : cxcursor -> cxsourcerange

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.

val cursor_get_raw_comment_text : cxcursor -> string

Given a cursor that represents a declaration, return the associated comment text, including comment markers.

val cursor_get_brief_comment_text : cxcursor -> string option

Given a cursor that represents a documentable entity (e.g., declaration), return the associated \brief paragraph; otherwise return the first paragraph.

val cursor_get_mangling : cxcursor -> string

Retrieve the CXString representing the mangled name of the cursor.

val cursor_get_cxxmanglings : cxcursor -> string array

Retrieve the CXStrings representing the mangled symbols of the C++ constructor or destructor at the cursor.

val cursor_get_obj_cmanglings : cxcursor -> string array

Retrieve the CXStrings representing the mangled symbols of the ObjC class interface or implementation at the cursor.

type cxmodule
val cursor_get_module : cxcursor -> cxmodule

Given a CXCursor_ModuleImportDecl cursor, return the associated module.

val get_module_for_file : cxtranslationunit -> cxfile -> cxmodule

Given a CXFile header file, return the module that contains it, if one exists.

val module_get_astfile : cxmodule -> cxfile

Returns the module file where the provided module object came from.

val module_get_parent : cxmodule -> cxmodule

Returns the parent of a sub-module or NULL if the given module is top-level, e.g. for 'std.vector' it will return the 'std' module.

val module_get_name : cxmodule -> string

Returns the name of the module, e.g. for the 'std.vector' sub-module it will return "vector".

val module_get_full_name : cxmodule -> string

Returns the full name of the module, e.g. "std.vector".

val module_is_system : cxmodule -> bool

Returns non-zero if the module is a system one.

val module_get_num_top_level_headers : cxtranslationunit -> cxmodule -> int

Returns the number of top level headers associated with this module.

val module_get_top_level_header : cxtranslationunit -> cxmodule -> int -> cxfile

Returns the specified top level header associated with the module.

val cxxconstructor_is_converting_constructor : cxcursor -> bool

Determine if a C++ constructor is a converting constructor.

val cxxconstructor_is_copy_constructor : cxcursor -> bool

Determine if a C++ constructor is a copy constructor.

val cxxconstructor_is_default_constructor : cxcursor -> bool

Determine if a C++ constructor is the default constructor.

val cxxconstructor_is_move_constructor : cxcursor -> bool

Determine if a C++ constructor is a move constructor.

val cxxfield_is_mutable : cxcursor -> bool

Determine if a C++ field is declared 'mutable'.

val cxxmethod_is_defaulted : cxcursor -> bool

Determine if a C++ method is declared '= default'.

val cxxmethod_is_pure_virtual : cxcursor -> bool

Determine if a C++ member function or member function template is pure virtual.

val cxxmethod_is_static : cxcursor -> bool

Determine if a C++ member function or member function template is declared 'static'.

val cxxmethod_is_virtual : cxcursor -> bool

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.

val cxxrecord_is_abstract : cxcursor -> bool

Determine if a C++ record is abstract, i.e. whether a class or struct has a pure virtual member function.

val enum_decl_is_scoped : cxcursor -> bool

Determine if an enum declaration refers to a scoped enum.

val cxxmethod_is_const : cxcursor -> bool

Determine if a C++ member function or member function template is declared 'const'.

val get_template_cursor_kind : cxcursor -> cxcursorkind

Given a cursor that represents a template, determine the cursor kind of the specializations would be generated by instantiating the template.

val get_specialized_cursor_template : cxcursor -> cxcursor

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.

val get_cursor_reference_name_range : cxcursor -> name_flags:int -> piece_index:int -> cxsourcerange

Given a cursor that references something else, return the source range covering that reference.

type cxtokenkind =
| Punctuation

A token that contains some kind of punctuation.

| Keyword

A language keyword.

| Identifier

An identifier (that is not a keyword).

| Literal

A numeric, string, or character literal.

| Comment

A comment.

Describes a kind of token.

type cxtoken

Describes a single preprocessing token.

val get_token_kind : cxtoken -> cxtokenkind

Determine the kind of the given token.

val get_token_spelling : cxtranslationunit -> cxtoken -> string

Determine the spelling of the given token.

val get_token_location : cxtranslationunit -> cxtoken -> cxsourcelocation

Retrieve the source location of the given token.

val get_token_extent : cxtranslationunit -> cxtoken -> cxsourcerange

Retrieve a source range that covers the given token.

val get_cursor_kind_spelling : cxcursorkind -> string

These routines are used for testing and debugging, only, and should not be relied upon.

val enable_stack_traces : unit -> unit
type cxcompletionchunkkind =
| Optional

A code-completion string that describes "optional" text that could be a part of the template (but is not required).

| TypedText

Text that a user would be expected to type to get this code-completion result.

| Text

Text that should be inserted as part of a code-completion result.

| Placeholder

Placeholder text that should be replaced by the user.

| Informative

Informative text that should be displayed but never inserted as part of the template.

| CurrentParameter

Text that describes the current parameter when code-completion is referring to function call, message send, or template specialization.

| LeftParen

A left parenthesis ('('), used to initiate a function call or signal the beginning of a function parameter list.

| RightParen

A right parenthesis (')'), used to finish a function call or signal the end of a function parameter list.

| LeftBracket

A left bracket ('[').

| RightBracket

A right bracket (']').

| LeftBrace

A left brace ('{').

| RightBrace

A right brace ('}').

| LeftAngle

A left angle bracket ('<').

| RightAngle

A right angle bracket ('>').

| Comma

A comma separator (',').

| ResultType

Text that specifies the result type of a given result.

| Colon

A colon (':').

| SemiColon

A semicolon (';').

| Equal

An '=' sign.

| HorizontalSpace

Horizontal space (' ').

| VerticalSpace

Vertical space ('\n'), after which it is generally a good idea to perform indentation.

Describes a single piece of text within a code-completion string.

type cxcompletionstring
val get_completion_chunk_kind : cxcompletionstring -> int -> cxcompletionchunkkind

Determine the kind of a particular chunk within a completion string.

val get_completion_chunk_text : cxcompletionstring -> int -> string

Retrieve the text associated with a particular chunk within a completion string.

val get_completion_chunk_completion_string : cxcompletionstring -> int -> cxcompletionstring

Retrieve the completion string associated with a particular chunk within a completion string.

val get_num_completion_chunks : cxcompletionstring -> int

Retrieve the number of chunks in the given code-completion string.

val get_completion_priority : cxcompletionstring -> int

Determine the priority of this code completion.

val get_completion_availability : cxcompletionstring -> cxavailabilitykind

Determine the availability of the entity that this code-completion string refers to.

val get_completion_num_annotations : cxcompletionstring -> int

Retrieve the number of annotations associated with the given completion string.

val get_completion_annotation : cxcompletionstring -> int -> string

Retrieve the annotation associated with the given completion string.

val get_completion_parent : cxcompletionstring -> string

Retrieve the parent context of the given completion string.

val get_completion_brief_comment : cxcompletionstring -> string

Retrieve the brief documentation comment attached to the declaration that corresponds to the given completion string.

val get_cursor_completion_string : cxcursor -> cxcompletionstring

Retrieve a completion string for an arbitrary declaration or macro definition cursor.

val default_code_complete_options : unit -> int

Returns a default set of code-completion options that can be passed to clang_codeCompleteAt().

val get_clang_version : unit -> string

Return a version string, suitable for showing to a user, but not intended to be parsed (the format is not guaranteed to be stable).

val toggle_crash_recovery : int -> unit

Enable/disable crash recovery.

type cxevalresult
val cursor_evaluate : cxcursor -> cxevalresult

If cursor is a statement declaration tries to evaluate the statement and if its variable, tries to evaluate its initializer, into its corresponding type.

type cxevalresultkind =
| Int
| Float
| ObjCStrLiteral
| StrLiteral
| CFStr
| Other
| UnExposed
val eval_result_get_kind : cxevalresult -> cxevalresultkind

Returns the kind of the evaluated result.

val eval_result_get_as_int : cxevalresult -> int

Returns the evaluation result as integer if the kind is Int.

val eval_result_get_as_long_long : cxevalresult -> int

Returns the evaluation result as a long long integer if the kind is Int. This prevents overflows that may happen if the result is returned with clang_EvalResult_getAsInt.

val eval_result_is_unsigned_int : cxevalresult -> bool

Returns a non-zero value if the kind is Int and the evaluation result resulted in an unsigned integer.

val eval_result_get_as_unsigned : cxevalresult -> int

Returns the evaluation result as an unsigned integer if the kind is Int and clang_EvalResult_isUnsignedInt is non-zero.

val eval_result_get_as_double : cxevalresult -> float

Returns the evaluation result as double if the kind is double.

val eval_result_get_as_str : cxevalresult -> string

Returns the evaluation result as a constant string if the kind is other than Int or float. User must not free this pointer, instead call clang_EvalResult_dispose on the CXEvalResult returned by clang_Cursor_Evaluate.

type cxremapping
val get_remappings : string -> cxremapping

Retrieve a remapping.

val get_remappings_from_file_list : string array -> cxremapping

Retrieve a remapping.

val remap_get_num_files : cxremapping -> int

Determine the number of remappings.

type cxindexaction
val index_action_create : cxindex -> cxindexaction

An indexing action/session, to be applied to one or multiple translation units.

type cxvisitorresult =
| Break
| Continue

@{

val type_visit_fields : cxtype -> (cxcursor -> cxvisitorresult) -> bool

Visit the fields of a particular type.

type cxversion = {
major : int;

The major version number, e.g., the '10' in '10.7.3'. A negative value indicates that there is no version number at all.

minor : int;

The minor version number, e.g., the '7' in '10.7.3'. This value will be negative if no minor version number was provided, e.g., for version '10'.

subminor : int;

The subminor version number, e.g., the '3' in '10.7.3'. This value will be negative if no minor or subminor version number was provided, e.g., in version '10' or '10.7'.

}

Describes a version number of the form major.minor.subminor.

val ext_get_version : unit -> cxversion
type cxint
val equal_cxint : cxint -> cxint -> bool
val compare_cxint : cxint -> cxint -> int
val ext_integer_literal_get_value : cxcursor -> cxint
val ext_int_is_valid : cxint -> bool
val ext_int_to_string : cxint -> int -> bool -> string
val ext_int_round_to_double : cxint -> bool -> float
val ext_int_bits_to_float : cxint -> float
val ext_int_get_bit_width : cxint -> int
val ext_int_get_active_bits : cxint -> int
val ext_int_get_min_signed_bits : cxint -> int
val ext_int_get_bool_value : cxint -> bool
val ext_int_get_zext_value : cxint -> int
val ext_int_get_sext_value : cxint -> int
val ext_int_get_zext_value64 : cxint -> Stdcompat.Int64.t
val ext_int_get_sext_value64 : cxint -> Stdcompat.Int64.t
type cxfloat
val equal_cxfloat : cxfloat -> cxfloat -> bool
val compare_cxfloat : cxfloat -> cxfloat -> int
val ext_floating_literal_get_value : cxcursor -> cxfloat
val ext_float_is_valid : cxfloat -> bool
val ext_float_to_string : cxfloat -> string
type clang_ext_fltsemantics =
| IEEEhalf
| IEEEsingle
| IEEEdouble
| IEEEquad
| PPCDoubleDouble
| X87DoubleExtended
| Bogus
| Invalid
val ext_float_get_semantics : cxfloat -> clang_ext_fltsemantics
val ext_float_convert_to_float : cxfloat -> float
val ext_float_convert_to_double : cxfloat -> float
val ext_string_literal_get_string : cxcursor -> string
val ext_string_literal_get_bytes : cxcursor -> string
val ext_string_literal_get_byte_length : cxcursor -> int
val ext_string_literal_get_char_byte_width : cxcursor -> int
type clang_ext_stringkind =
| Ascii
| Wide
| UTF8
| UTF16
| UTF32
| InvalidStringKind
val ext_string_literal_get_kind : cxcursor -> clang_ext_stringkind
type clang_ext_unaryoperatorkind =
| PostInc
| PostDec
| PreInc
| PreDec
| AddrOf
| Deref
| Plus
| Minus
| Not
| LNot
| Real
| Imag
| Extension
| Coawait
| InvalidUnaryOperator
val ext_unary_operator_get_opcode : cxcursor -> clang_ext_unaryoperatorkind
val ext_unary_operator_get_opcode_spelling : clang_ext_unaryoperatorkind -> string
type clang_ext_binaryoperatorkind =
| PtrMemD
| PtrMemI
| Mul
| Div
| Rem
| Add
| Sub
| Shl
| Shr
| Cmp
| LT
| GT
| LE
| GE
| EQ
| NE
| And
| Xor
| Or
| LAnd
| LOr
| Assign
| MulAssign
| DivAssign
| RemAssign
| AddAssign
| SubAssign
| ShlAssign
| ShrAssign
| AndAssign
| XorAssign
| OrAssign
| Comma
| InvalidBinaryOperator
val ext_binary_operator_get_opcode : cxcursor -> clang_ext_binaryoperatorkind
val ext_binary_operator_get_opcode_spelling : clang_ext_binaryoperatorkind -> string
val ext_for_stmt_get_children_set : cxcursor -> int
val ext_if_stmt_get_children_set : cxcursor -> int
val ext_if_stmt_get_init : cxcursor -> cxcursor
val ext_switch_stmt_get_children_set : cxcursor -> int
val ext_switch_stmt_get_init : cxcursor -> cxcursor
val ext_while_stmt_get_children_set : cxcursor -> int
type clang_ext_elaboratedtypekeyword =
| Struct
| Interface
| Union
| Class
| Enum
| Typename
| NoKeyword
val ext_elaborated_type_get_keyword : cxtype -> clang_ext_elaboratedtypekeyword
val ext_elaborated_type_get_keyword_spelling : clang_ext_elaboratedtypekeyword -> string
val ext_var_decl_has_init : cxcursor -> bool
val ext_var_decl_is_constexpr : cxcursor -> bool
val ext_member_ref_expr_is_arrow : cxcursor -> bool
val ext_stmt_get_class_name : cxcursor -> string
val ext_stmt_get_class_kind : cxcursor -> int
type clang_ext_cursorkind =
| ImplicitCastExpr
| BinaryConditionalOperator
| UnaryExprOrTypeTraitExpr
| EmptyDecl
| LinkageSpecDecl
| Unknown
val ext_get_cursor_kind : cxcursor -> clang_ext_cursorkind
type clang_ext_declkind =
| InvalidDecl
| AccessSpec
| Block
| Captured
| ClassScopeFunctionSpecialization
| Empty
| Export
| ExternCContext
| FileScopeAsm
| Friend
| FriendTemplate
| Import
| LinkageSpec
| Label
| Namespace
| NamespaceAlias
| ObjCCompatibleAlias
| ObjCCategory
| ObjCCategoryImpl
| ObjCImplementation
| ObjCInterface
| ObjCProtocol
| ObjCMethod
| ObjCProperty
| BuiltinTemplate
| ClassTemplate
| FunctionTemplate
| TypeAliasTemplate
| VarTemplate
| TemplateTemplateParm
| Enum
| Record
| CXXRecord
| ClassTemplateSpecialization
| ClassTemplatePartialSpecialization
| TemplateTypeParm
| ObjCTypeParam
| TypeAlias
| Typedef
| UnresolvedUsingTypename
| Using
| UsingDirective
| UsingPack
| UsingShadow
| ConstructorUsingShadow
| Binding
| Field
| ObjCAtDefsField
| ObjCIvar
| Function
| CXXDeductionGuide
| CXXMethod
| CXXConstructor
| CXXConversion
| CXXDestructor
| MSProperty
| NonTypeTemplateParm
| Var
| Decomposition
| ImplicitParam
| OMPCapturedExpr
| ParmVar
| VarTemplateSpecialization
| VarTemplatePartialSpecialization
| EnumConstant
| IndirectField
| OMPDeclareReduction
| UnresolvedUsingValue
| OMPThreadPrivate
| ObjCPropertyImpl
| PragmaComment
| PragmaDetectMismatch
| StaticAssert
| TranslationUnit
| UnknownDecl
val ext_decl_get_kind : cxcursor -> clang_ext_declkind
type clang_ext_stmtkind =
| InvalidStmt
| GCCAsmStmt
| MSAsmStmt
| AttributedStmt
| BreakStmt
| CXXCatchStmt
| CXXForRangeStmt
| CXXTryStmt
| CapturedStmt
| CompoundStmt
| ContinueStmt
| CoreturnStmt
| CoroutineBodyStmt
| DeclStmt
| DoStmt
| BinaryConditionalOperator
| ConditionalOperator
| AddrLabelExpr
| ArrayInitIndexExpr
| ArrayInitLoopExpr
| ArraySubscriptExpr
| ArrayTypeTraitExpr
| AsTypeExpr
| AtomicExpr
| BinaryOperator
| CompoundAssignOperator
| BlockExpr
| CXXBindTemporaryExpr
| CXXBoolLiteralExpr
| CXXConstructExpr
| CXXTemporaryObjectExpr
| CXXDefaultArgExpr
| CXXDefaultInitExpr
| CXXDeleteExpr
| CXXDependentScopeMemberExpr
| CXXFoldExpr
| CXXInheritedCtorInitExpr
| CXXNewExpr
| CXXNoexceptExpr
| CXXNullPtrLiteralExpr
| CXXPseudoDestructorExpr
| CXXScalarValueInitExpr
| CXXStdInitializerListExpr
| CXXThisExpr
| CXXThrowExpr
| CXXTypeidExpr
| CXXUnresolvedConstructExpr
| CXXUuidofExpr
| CallExpr
| CUDAKernelCallExpr
| CXXMemberCallExpr
| CXXOperatorCallExpr
| UserDefinedLiteral
| CStyleCastExpr
| CXXFunctionalCastExpr
| CXXConstCastExpr
| CXXDynamicCastExpr
| CXXReinterpretCastExpr
| CXXStaticCastExpr
| ObjCBridgedCastExpr
| ImplicitCastExpr
| CharacterLiteral
| ChooseExpr
| CompoundLiteralExpr
| ConvertVectorExpr
| CoawaitExpr
| CoyieldExpr
| DeclRefExpr
| DependentCoawaitExpr
| DependentScopeDeclRefExpr
| DesignatedInitExpr
| DesignatedInitUpdateExpr
| ExprWithCleanups
| ExpressionTraitExpr
| ExtVectorElementExpr
| FloatingLiteral
| FunctionParmPackExpr
| GNUNullExpr
| GenericSelectionExpr
| ImaginaryLiteral
| ImplicitValueInitExpr
| InitListExpr
| IntegerLiteral
| LambdaExpr
| MSPropertyRefExpr
| MSPropertySubscriptExpr
| MaterializeTemporaryExpr
| MemberExpr
| NoInitExpr
| OMPArraySectionExpr
| ObjCArrayLiteral
| ObjCAvailabilityCheckExpr
| ObjCBoolLiteralExpr
| ObjCBoxedExpr
| ObjCDictionaryLiteral
| ObjCEncodeExpr
| ObjCIndirectCopyRestoreExpr
| ObjCIsaExpr
| ObjCIvarRefExpr
| ObjCMessageExpr
| ObjCPropertyRefExpr
| ObjCProtocolExpr
| ObjCSelectorExpr
| ObjCStringLiteral
| ObjCSubscriptRefExpr
| OffsetOfExpr
| OpaqueValueExpr
| UnresolvedLookupExpr
| UnresolvedMemberExpr
| PackExpansionExpr
| ParenExpr
| ParenListExpr
| PredefinedExpr
| PseudoObjectExpr
| ShuffleVectorExpr
| SizeOfPackExpr
| StmtExpr
| StringLiteral
| SubstNonTypeTemplateParmExpr
| SubstNonTypeTemplateParmPackExpr
| TypeTraitExpr
| TypoExpr
| UnaryExprOrTypeTraitExpr
| UnaryOperator
| VAArgExpr
| ForStmt
| GotoStmt
| IfStmt
| IndirectGotoStmt
| LabelStmt
| MSDependentExistsStmt
| NullStmt
| OMPAtomicDirective
| OMPBarrierDirective
| OMPCancelDirective
| OMPCancellationPointDirective
| OMPCriticalDirective
| OMPFlushDirective
| OMPDistributeDirective
| OMPDistributeParallelForDirective
| OMPDistributeParallelForSimdDirective
| OMPDistributeSimdDirective
| OMPForDirective
| OMPForSimdDirective
| OMPParallelForDirective
| OMPParallelForSimdDirective
| OMPSimdDirective
| OMPTargetParallelForSimdDirective
| OMPTargetSimdDirective
| OMPTargetTeamsDistributeDirective
| OMPTargetTeamsDistributeParallelForDirective
| OMPTargetTeamsDistributeParallelForSimdDirective
| OMPTargetTeamsDistributeSimdDirective
| OMPTaskLoopDirective
| OMPTaskLoopSimdDirective
| OMPTeamsDistributeDirective
| OMPTeamsDistributeParallelForDirective
| OMPTeamsDistributeParallelForSimdDirective
| OMPTeamsDistributeSimdDirective
| OMPMasterDirective
| OMPOrderedDirective
| OMPParallelDirective
| OMPParallelSectionsDirective
| OMPSectionDirective
| OMPSectionsDirective
| OMPSingleDirective
| OMPTargetDataDirective
| OMPTargetDirective
| OMPTargetEnterDataDirective
| OMPTargetExitDataDirective
| OMPTargetParallelDirective
| OMPTargetParallelForDirective
| OMPTargetTeamsDirective
| OMPTargetUpdateDirective
| OMPTaskDirective
| OMPTaskgroupDirective
| OMPTaskwaitDirective
| OMPTaskyieldDirective
| OMPTeamsDirective
| ObjCAtCatchStmt
| ObjCAtFinallyStmt
| ObjCAtSynchronizedStmt
| ObjCAtThrowStmt
| ObjCAtTryStmt
| ObjCAutoreleasePoolStmt
| ObjCForCollectionStmt
| ReturnStmt
| SEHExceptStmt
| SEHFinallyStmt
| SEHLeaveStmt
| SEHTryStmt
| CaseStmt
| DefaultStmt
| SwitchStmt
| WhileStmt
| UnknownStmt
val ext_stmt_get_kind : cxcursor -> clang_ext_stmtkind
type clang_ext_typekind =
| InvalidType
| Builtin
| Complex
| Pointer
| BlockPointer
| LValueReference
| RValueReference
| MemberPointer
| ConstantArray
| IncompleteArray
| VariableArray
| DependentSizedArray
| DependentSizedExtVector
| DependentAddressSpace
| Vector
| ExtVector
| FunctionProto
| FunctionNoProto
| UnresolvedUsing
| Paren
| Typedef
| Adjusted
| Decayed
| TypeOfExpr
| TypeOf
| Decltype
| UnaryTransform
| Record
| Enum
| Elaborated
| Attributed
| TemplateTypeParm
| SubstTemplateTypeParm
| SubstTemplateTypeParmPack
| TemplateSpecialization
| Auto
| DeducedTemplateSpecialization
| InjectedClassName
| DependentName
| DependentTemplateSpecialization
| PackExpansion
| ObjCTypeParam
| ObjCObject
| ObjCInterface
| ObjCObjectPointer
| Pipe
| Atomic
| UnknownType
val ext_type_get_kind : cxtype -> clang_ext_typekind
val ext_get_type_kind : cxtype -> clang_ext_typekind
val ext_get_inner_type : cxtype -> cxtype
val ext_declarator_decl_get_size_expr : cxcursor -> cxcursor
val ext_variable_array_type_get_size_expr : cxtype -> cxcursor
val ext_character_literal_get_character_kind : cxcursor -> clang_ext_stringkind
val ext_character_literal_get_value : cxcursor -> int
type clang_ext_unaryexpr =
| SizeOf
| AlignOf
| VecStep
| OpenMPRequiredSimdAlign
| PreferredAlignOf
val ext_unary_expr_get_kind : cxcursor -> clang_ext_unaryexpr
val ext_unary_expr_is_argument_type : cxcursor -> bool
type clang_ext_typeloc
val ext_unary_expr_get_argument_type_loc : cxcursor -> clang_ext_typeloc
val ext_type_get_named_type : cxtype -> cxtype
type clang_ext_attrkind =
| NoAttr
| FallThrough
| Suppress
| SwiftContext
| SwiftErrorResult
| SwiftIndirectResult
| Annotate
| CFConsumed
| CarriesDependency
| NSConsumed
| NonNull
| PassObjectSize
| AMDGPUFlatWorkGroupSize
| AMDGPUNumSGPR
| AMDGPUNumVGPR
| AMDGPUWavesPerEU
| ARMInterrupt
| AVRInterrupt
| AVRSignal
| AcquireCapability
| AcquiredAfter
| AcquiredBefore
| AlignMac68k
| Aligned
| AllocAlign
| AllocSize
| AlwaysInline
| AnalyzerNoReturn
| AnyX86Interrupt
| AnyX86NoCallerSavedRegisters
| ArcWeakrefUnavailable
| ArgumentWithTypeTag
| AsmLabel
| AssertCapability
| AssertExclusiveLock
| AssertSharedLock
| AssumeAligned
| Availability
| Blocks
| C11NoReturn
| CDecl
| CFAuditedTransfer
| CFReturnsNotRetained
| CFReturnsRetained
| CFUnknownTransfer
| CUDAConstant
| CUDADevice
| CUDAGlobal
| CUDAHost
| CUDAInvalidTarget
| CUDALaunchBounds
| CUDAShared
| CXX11NoReturn
| CallableWhen
| Capability
| CapturedRecord
| Cleanup
| Cold
| Common
| Const
| Constructor
| Consumable
| ConsumableAutoCast
| ConsumableSetOnRead
| Convergent
| DLLExport
| DLLImport
| Deprecated
| Destructor
| DiagnoseIf
| DisableTailCalls
| EmptyBases
| EnableIf
| EnumExtensibility
| ExclusiveTrylockFunction
| ExternalSourceSymbol
| FastCall
| Final
| FlagEnum
| Flatten
| Format
| FormatArg
| GNUInline
| GuardedBy
| GuardedVar
| Hot
| IBAction
| IBOutlet
| IBOutletCollection
| InitPriority
| IntelOclBicc
| InternalLinkage
| LTOVisibilityPublic
| LayoutVersion
| LockReturned
| LocksExcluded
| MSABI
| MSInheritance
| MSNoVTable
| MSP430Interrupt
| MSStruct
| MSVtorDisp
| MaxFieldAlignment
| MayAlias
| MicroMips
| MinSize
| Mips16
| MipsInterrupt
| MipsLongCall
| MipsShortCall
| NSConsumesSelf
| NSReturnsAutoreleased
| NSReturnsNotRetained
| NSReturnsRetained
| Naked
| NoAlias
| NoCommon
| NoDebug
| NoDuplicate
| NoInline
| NoInstrumentFunction
| NoMicroMips
| NoMips16
| NoReturn
| NoSanitize
| NoSplitStack
| NoThreadSafetyAnalysis
| NoThrow
| NotTailCalled
| OMPCaptureNoInit
| OMPThreadPrivateDecl
| ObjCBridge
| ObjCBridgeMutable
| ObjCBridgeRelated
| ObjCException
| ObjCExplicitProtocolImpl
| ObjCIndependentClass
| ObjCMethodFamily
| ObjCNSObject
| ObjCPreciseLifetime
| ObjCRequiresPropertyDefs
| ObjCRequiresSuper
| ObjCReturnsInnerPointer
| ObjCRootClass
| ObjCSubclassingRestricted
| OpenCLIntelReqdSubGroupSize
| OpenCLKernel
| OpenCLUnrollHint
| OptimizeNone
| Override
| Ownership
| Packed
| ParamTypestate
| Pascal
| Pcs
| PragmaClangBSSSection
| PragmaClangDataSection
| PragmaClangRodataSection
| PragmaClangTextSection
| PreserveAll
| PreserveMost
| PtGuardedBy
| PtGuardedVar
| Pure
| RegCall
| ReleaseCapability
| ReqdWorkGroupSize
| RequireConstantInit
| RequiresCapability
| Restrict
| ReturnTypestate
| ReturnsNonNull
| ReturnsTwice
| ScopedLockable
| Section
| SelectAny
| Sentinel
| SetTypestate
| SharedTrylockFunction
| StdCall
| SwiftCall
| SysVABI
| TLSModel
| Target
| TestTypestate
| ThisCall
| TransparentUnion
| TryAcquireCapability
| TypeTagForDatatype
| TypeVisibility
| Unavailable
| Unused
| Used
| Uuid
| VecReturn
| VecTypeHint
| VectorCall
| Visibility
| WarnUnused
| WarnUnusedResult
| Weak
| WeakImport
| WeakRef
| WorkGroupSizeHint
| X86ForceAlignArgPointer
| XRayInstrument
| XRayLogArgs
| AbiTag
| Alias
| AlignValue
| IFunc
| InitSeg
| LoopHint
| Mode
| NoEscape
| OMPCaptureKind
| OMPDeclareSimdDecl
| OMPDeclareTargetDecl
| ObjCBoxable
| ObjCDesignatedInitializer
| ObjCRuntimeName
| ObjCRuntimeVisible
| OpenCLAccess
| Overloadable
| RenderScriptKernel
| Thread
val ext_attr_kind_get_spelling : clang_ext_attrkind -> string
val ext_cxxmethod_is_defaulted : cxcursor -> bool
val ext_cxxmethod_is_const : cxcursor -> bool
val ext_cxxconstructor_is_explicit : cxcursor -> bool
val ext_function_decl_is_deleted : cxcursor -> bool
val ext_function_decl_get_num_params : cxcursor -> int
val ext_function_decl_get_param_decl : cxcursor -> int -> cxcursor
val ext_function_decl_is_constexpr : cxcursor -> bool
module Clang_ext_languageids : sig ... end
val ext_linkage_spec_decl_get_language_ids : cxcursor -> Clang_ext_languageids.t
val ext_template_type_parm_decl_get_default_argument : cxcursor -> cxtype
type clang_ext_templatename_namekind =
| Template
| OverloadedTemplate
| QualifiedTemplate
| DependentTemplate
| SubstTemplateTemplateParm
| SubstTemplateTemplateParmPack
| InvalidNameKind
type clang_ext_templatename
val ext_template_name_get_kind : clang_ext_templatename -> clang_ext_templatename_namekind
val ext_template_name_get_as_template_decl : clang_ext_templatename -> cxcursor
type clang_ext_templateargument
val ext_template_argument_get_kind : clang_ext_templateargument -> cxtemplateargumentkind
val ext_template_argument_get_as_type : clang_ext_templateargument -> cxtype
val ext_template_argument_get_as_decl : clang_ext_templateargument -> cxcursor
val ext_template_argument_get_null_ptr_type : clang_ext_templateargument -> cxtype
val ext_template_argument_get_as_template_or_template_pattern : clang_ext_templateargument -> clang_ext_templatename
val ext_template_argument_get_as_integral : clang_ext_templateargument -> cxint
val ext_template_argument_get_integral_type : clang_ext_templateargument -> cxtype
val ext_template_argument_get_as_expr : clang_ext_templateargument -> cxcursor
val ext_template_argument_get_pack_size : clang_ext_templateargument -> int
val ext_template_argument_get_pack_argument : clang_ext_templateargument -> int -> clang_ext_templateargument
val ext_template_argument_get_pack_expansion_pattern : clang_ext_templateargument -> clang_ext_templateargument
val ext_template_specialization_type_get_template_name : cxtype -> clang_ext_templatename
val ext_template_specialization_type_get_num_args : cxtype -> int
val ext_template_specialization_type_get_argument : cxtype -> int -> clang_ext_templateargument
val ext_friend_decl_get_friend_decl : cxcursor -> cxcursor
val ext_friend_decl_get_friend_type : cxcursor -> cxtype
val ext_field_decl_get_in_class_initializer : cxcursor -> cxcursor
val ext_generic_selection_expr_get_assoc_type : cxcursor -> int -> cxtype
val ext_template_parm_is_parameter_pack : cxcursor -> bool
val ext_template_decl_get_templated_decl : cxcursor -> cxcursor
type clang_ext_predefinedexpr_identkind =
| Func
| Function
| LFunction
| FuncDName
| FuncSig
| LFuncSig
| PrettyFunction
| PrettyFunctionNoVirtual
| InvalidPredefinedExpr
val ext_predefined_expr_get_ident_kind : cxcursor -> clang_ext_predefinedexpr_identkind
val ext_predefined_expr_get_function_name : cxcursor -> string
val ext_predefined_expr_compute_name : clang_ext_predefinedexpr_identkind -> cxcursor -> string
val ext_lambda_expr_is_mutable : cxcursor -> bool
val ext_lambda_expr_has_explicit_parameters : cxcursor -> bool
val ext_lambda_expr_has_explicit_result_type : cxcursor -> bool
type clang_ext_lambdacapturedefault =
| CaptureNone
| ByCopy
| ByRef
val ext_lambda_expr_get_capture_default : cxcursor -> clang_ext_lambdacapturedefault
type clang_ext_lambdacapture
val ext_lambda_expr_get_captures : cxcursor -> (clang_ext_lambdacapture -> unit) -> unit
val ext_lambda_expr_get_call_operator : cxcursor -> cxcursor
type clang_ext_lambdacapturekind =
| This
| StarThis
| ByCopy
| ByRef
| VLAType
val ext_lambda_capture_get_kind : clang_ext_lambdacapture -> clang_ext_lambdacapturekind
val ext_lambda_capture_get_captured_var : clang_ext_lambdacapture -> cxcursor
val ext_lambda_capture_is_implicit : clang_ext_lambdacapture -> bool
val ext_lambda_capture_is_pack_expansion : clang_ext_lambdacapture -> bool
val ext_cxxnew_expr_get_allocated_type_loc : cxcursor -> clang_ext_typeloc
val ext_cxxnew_expr_get_array_size : cxcursor -> cxcursor
val ext_cxxnew_expr_get_num_placement_args : cxcursor -> int
val ext_cxxnew_expr_get_placement_arg : cxcursor -> int -> cxcursor
val ext_cxxnew_expr_get_initializer : cxcursor -> cxcursor
val ext_cxxdelete_expr_is_global_delete : cxcursor -> bool
val ext_cxxdelete_expr_is_array_form : cxcursor -> bool
val ext_cxxtypeid_expr_is_type_operand : cxcursor -> bool
val ext_cxxtypeid_expr_get_type_operand : cxcursor -> clang_ext_typeloc
val ext_cxxtypeid_expr_get_expr_operand : cxcursor -> cxcursor
type clang_ext_langstandards =
| C89
| C94
| Gnu89
| C99
| Gnu99
| C11
| Gnu11
| C17
| Gnu17
| Cxx98
| Gnucxx98
| Cxx11
| Gnucxx11
| Cxx14
| Gnucxx14
| Cxx17
| Gnucxx17
| Cxx2a
| Gnucxx2a
| Opencl10
| Opencl11
| Opencl12
| Opencl20
| Cuda
| InvalidLang
val ext_lang_standard_get_name : clang_ext_langstandards -> string
val ext_lang_standard_of_name : string -> clang_ext_langstandards
val ext_pack_expansion_get_pattern : cxtype -> cxtype
val ext_cxxfold_expr_is_right_fold : cxcursor -> bool
val ext_cxxfold_expr_get_operator : cxcursor -> clang_ext_binaryoperatorkind
val ext_cxxbool_literal_expr_get_value : cxcursor -> bool
val ext_call_expr_get_callee : cxcursor -> cxcursor
val ext_call_expr_get_num_args : cxcursor -> int
val ext_call_expr_get_arg : cxcursor -> int -> cxcursor
val ext_size_of_pack_expr_get_pack : cxcursor -> cxcursor
val ext_decltype_type_get_underlying_expr : cxtype -> cxcursor
val ext_namespace_decl_is_inline : cxcursor -> bool
type clang_ext_overloadedoperatorkind =
| InvalidOverloadedOperator
| New
| Delete
| Array_New
| Array_Delete
| Plus
| Minus
| Star
| Slash
| Percent
| Caret
| Amp
| Pipe
| Tilde
| Exclaim
| Equal
| Less
| Greater
| PlusEqual
| MinusEqual
| StarEqual
| SlashEqual
| PercentEqual
| CaretEqual
| AmpEqual
| PipeEqual
| LessLess
| GreaterGreater
| LessLessEqual
| GreaterGreaterEqual
| EqualEqual
| ExclaimEqual
| LessEqual
| GreaterEqual
| Spaceship
| AmpAmp
| PipePipe
| PlusPlus
| MinusMinus
| Comma
| ArrowStar
| Arrow
| Call
| Subscript
| Conditional
| Coawait
val ext_overloaded_operator_get_spelling : clang_ext_overloadedoperatorkind -> string
type clang_ext_declarationnamekind =
| Identifier
| ObjCZeroArgSelector
| ObjCOneArgSelector
| ObjCMultiArgSelector
| CXXConstructorName
| CXXDestructorName
| CXXConversionFunctionName
| CXXDeductionGuideName
| CXXOperatorName
| CXXLiteralOperatorName
| CXXUsingDirective
| InvalidDeclarationName
type clang_ext_declarationname
val ext_declaration_name_get_kind : clang_ext_declarationname -> clang_ext_declarationnamekind
val ext_declaration_name_get_cxxoverloaded_operator : clang_ext_declarationname -> clang_ext_overloadedoperatorkind
val ext_declaration_name_get_cxxname_type : clang_ext_declarationname -> cxtype
val ext_declaration_name_get_as_identifier : clang_ext_declarationname -> string
val ext_declaration_name_get_cxxdeduction_guide_template : clang_ext_declarationname -> cxcursor
val ext_declaration_name_get_cxxliteral_identifier : clang_ext_declarationname -> string
val ext_decl_get_name : cxcursor -> clang_ext_declarationname
val ext_using_directive_decl_get_nominated_namespace : cxcursor -> cxcursor
type clang_ext_nestednamespecifierkind =
| InvalidNestedNameSpecifier
| Identifier
| Namespace
| NamespaceAlias
| TypeSpec
| TypeSpecWithTemplate
| Global
| Super
type clang_ext_nestednamespecifier
val ext_nested_name_specifier_get_kind : clang_ext_nestednamespecifier -> clang_ext_nestednamespecifierkind
val ext_nested_name_specifier_get_prefix : clang_ext_nestednamespecifier -> clang_ext_nestednamespecifier
val ext_nested_name_specifier_get_as_identifier : clang_ext_nestednamespecifier -> string
val ext_nested_name_specifier_get_as_namespace : clang_ext_nestednamespecifier -> cxcursor
val ext_nested_name_specifier_get_as_type : clang_ext_nestednamespecifier -> cxtype
type clang_ext_nestednamespecifierloc
val ext_nested_name_specifier_loc_get_nested_name_specifier : clang_ext_nestednamespecifierloc -> clang_ext_nestednamespecifier
val ext_nested_name_specifier_loc_get_prefix : clang_ext_nestednamespecifierloc -> clang_ext_nestednamespecifierloc
val ext_nested_name_specifier_loc_get_as_type_loc : clang_ext_nestednamespecifierloc -> clang_ext_typeloc
val ext_decl_get_nested_name_specifier_loc : cxcursor -> clang_ext_nestednamespecifierloc
val ext_type_loc_get_qualifier_loc : clang_ext_typeloc -> clang_ext_nestednamespecifierloc
val ext_type_get_qualifier : cxtype -> clang_ext_nestednamespecifier
val ext_tag_decl_is_complete_definition : cxcursor -> bool
val ext_cxxpseudo_destructor_expr_get_destroyed_type_loc : cxcursor -> clang_ext_typeloc
val ext_cursor_get_num_template_args : cxcursor -> int
val ext_cursor_get_template_arg : cxcursor -> int -> clang_ext_templateargument
type clang_ext_templateparameterlist
val ext_template_parameter_list_size : clang_ext_templateparameterlist -> int
val ext_template_parameter_list_get_param : clang_ext_templateparameterlist -> int -> cxcursor
val ext_template_parameter_list_get_requires_clause : clang_ext_templateparameterlist -> cxcursor
val ext_template_decl_get_template_parameters : cxcursor -> clang_ext_templateparameterlist
val ext_template_decl_get_parameter_count : cxcursor -> int
val ext_template_decl_get_parameter : cxcursor -> int -> cxcursor
val ext_subst_non_type_template_parm_expr_get_replacement : cxcursor -> cxcursor
val ext_attributed_stmt_get_attribute_count : cxcursor -> int
val ext_attributed_stmt_get_attribute_kind : cxcursor -> int -> clang_ext_attrkind
val ext_attributed_stmt_get_attrs : cxcursor -> (cxcursor -> unit) -> unit
val ext_decomposition_decl_get_bindings_count : cxcursor -> int
val ext_decomposition_decl_get_bindings : cxcursor -> int -> cxcursor
val ext_attr_get_kind : cxcursor -> clang_ext_attrkind
type clang_ext_exceptionspecificationtype =
| NoExceptionSpecification
| DynamicNone
| Dynamic
| MSAny
| NoThrow
| BasicNoexcept
| DependentNoexcept
| NoexceptFalse
| NoexceptTrue
| Unevaluated
| Uninstantiated
| Unparsed
val ext_function_proto_type_get_exception_spec_type : cxtype -> clang_ext_exceptionspecificationtype
val ext_function_proto_type_get_num_exceptions : cxtype -> int
val ext_function_proto_type_get_exception_type : cxtype -> int -> cxtype
val ext_function_proto_type_get_noexcept_expr : cxtype -> cxcursor
val ext_asm_stmt_get_asm_string : cxcursor -> string
val ext_asm_stmt_get_num_outputs : cxcursor -> int
val ext_asm_stmt_get_output_constraint : cxcursor -> int -> string
val ext_asm_stmt_get_output_expr : cxcursor -> int -> cxcursor
val ext_asm_stmt_get_num_inputs : cxcursor -> int
val ext_asm_stmt_get_input_constraint : cxcursor -> int -> string
val ext_asm_stmt_get_input_expr : cxcursor -> int -> cxcursor
val ext_declarator_decl_get_type_loc : cxcursor -> clang_ext_typeloc
type clang_ext_typeloc_class =
| Qualified
| Builtin
| Complex
| Pointer
| BlockPointer
| LValueReference
| RValueReference
| MemberPointer
| ConstantArray
| IncompleteArray
| VariableArray
| DependentSizedArray
| DependentSizedExtVector
| DependentAddressSpace
| Vector
| ExtVector
| FunctionProto
| FunctionNoProto
| UnresolvedUsing
| Paren
| Typedef
| Adjusted
| Decayed
| TypeOfExpr
| TypeOf
| Decltype
| UnaryTransform
| Record
| Enum
| Elaborated
| Attributed
| TemplateTypeParm
| SubstTemplateTypeParm
| SubstTemplateTypeParmPack
| TemplateSpecialization
| Auto
| DeducedTemplateSpecialization
| InjectedClassName
| DependentName
| DependentTemplateSpecialization
| PackExpansion
| ObjCTypeParam
| ObjCObject
| ObjCInterface
| ObjCObjectPointer
| Pipe
| Atomic
| InvalidTypeLoc
val ext_type_loc_get_class : clang_ext_typeloc -> clang_ext_typeloc_class
val ext_type_loc_get_type : clang_ext_typeloc -> cxtype
val ext_array_type_loc_get_size_expr : clang_ext_typeloc -> cxcursor
val ext_array_type_loc_get_element_loc : clang_ext_typeloc -> clang_ext_typeloc
val ext_paren_type_loc_get_inner_loc : clang_ext_typeloc -> clang_ext_typeloc
val ext_pointer_like_type_loc_get_pointee_loc : clang_ext_typeloc -> clang_ext_typeloc
val ext_member_pointer_type_loc_get_class_loc : clang_ext_typeloc -> clang_ext_typeloc
val ext_qualified_type_loc_get_unqualified_loc : clang_ext_typeloc -> clang_ext_typeloc
val ext_function_type_loc_get_return_loc : clang_ext_typeloc -> clang_ext_typeloc
val ext_function_type_loc_get_num_params : clang_ext_typeloc -> int
val ext_function_type_loc_get_param : clang_ext_typeloc -> int -> cxcursor
val ext_init_list_expr_get_syntactic_form : cxcursor -> cxcursor
val ext_init_list_expr_get_semantic_form : cxcursor -> cxcursor
val ext_init_list_expr_get_num_inits : cxcursor -> int
val ext_init_list_expr_get_init : cxcursor -> int -> cxcursor
val ext_designated_init_expr_size : cxcursor -> int
type clang_ext_designatedinitexpr_designatorkind =
| FieldDesignator
| ArrayDesignator
| ArrayRangeDesignator
val ext_designated_init_expr_get_kind : cxcursor -> int -> clang_ext_designatedinitexpr_designatorkind
val ext_designated_init_expr_get_field : cxcursor -> int -> cxcursor
val ext_designated_init_expr_get_array_index : cxcursor -> int -> cxcursor
val ext_designated_init_expr_get_array_range_start : cxcursor -> int -> cxcursor
val ext_designated_init_expr_get_array_range_end : cxcursor -> int -> cxcursor
val ext_designated_init_expr_get_init : cxcursor -> cxcursor
val ext_concept_decl_get_constraint_expr : cxcursor -> cxcursor
type clang_ext_requirementkind =
| Type
| Simple
| Compound
| Nested
type clang_ext_requirement
val ext_requirement_get_kind : clang_ext_requirement -> clang_ext_requirementkind
val ext_type_requirement_get_type : clang_ext_requirement -> clang_ext_typeloc
val ext_expr_requirement_get_expr : clang_ext_requirement -> cxcursor
val ext_expr_requirement_return_type_get_type_constraint_template_parameter_list : clang_ext_requirement -> clang_ext_templateparameterlist
val ext_expr_requirement_return_type_get_type_constraint : clang_ext_requirement -> cxcursor
val ext_nested_requirement_get_constraint_expr : clang_ext_requirement -> cxcursor
val ext_requires_expr_get_local_parameter_count : cxcursor -> int
val ext_requires_expr_get_local_parameter : cxcursor -> int -> cxcursor
val ext_requires_expr_get_requirement_count : cxcursor -> int
val ext_requires_expr_get_requirement : cxcursor -> int -> clang_ext_requirement
val ext_decl_context_visit_decls : cxcursor -> (cxcursor -> cxcursor -> cxchildvisitresult) -> bool
val ext_tag_decl_get_tag_kind : cxcursor -> clang_ext_elaboratedtypekeyword
val ext_decl_has_attrs : cxcursor -> bool
val ext_decl_get_attr_count : cxcursor -> int
val ext_decl_get_attr : cxcursor -> int -> cxcursor
val ext_cursor_kind_is_attr : cxcursorkind -> bool
val ext_function_decl_is_inline_specified : cxcursor -> bool
val ext_function_decl_is_inlined : cxcursor -> bool
val ext_cursor_get_type_loc : cxcursor -> clang_ext_typeloc
val ext_cxxfor_range_stmt_get_loop_variable : cxcursor -> cxcursor
val ext_cxxfor_range_stmt_get_range_init : cxcursor -> cxcursor
val ext_cxxfor_range_stmt_get_body : cxcursor -> cxcursor
val ext_attributed_type_loc_get_modified_loc : clang_ext_typeloc -> clang_ext_typeloc
val ext_attributed_type_loc_get_attr : clang_ext_typeloc -> cxcursor
val ext_attributed_type_get_modified_type : cxtype -> cxtype
val ext_attributed_type_get_attr_kind : cxtype -> clang_ext_attrkind
val ext_elaborated_type_loc_get_named_type_loc : clang_ext_typeloc -> clang_ext_typeloc
val ext_pack_expansion_type_loc_get_pattern_loc : clang_ext_typeloc -> clang_ext_typeloc
val ext_typedef_decl_get_underlying_type_loc : cxcursor -> clang_ext_typeloc
val ext_cxxmethod_decl_get_parent : cxcursor -> cxcursor
val ext_injected_class_name_type_get_injected_specialization_type : cxtype -> cxtype
val ext_type_get_unqualified_type : cxtype -> cxtype
type clang_ext_acquirecapability_spelling =
| GNU_acquire_capability
| CXX11_clang_acquire_capability
| GNU_acquire_shared_capability
| CXX11_clang_acquire_shared_capability
| GNU_exclusive_lock_function
| GNU_shared_lock_function
| SpellingNotCalculated
val ext_acquire_capability_get_spelling : cxcursor -> clang_ext_acquirecapability_spelling
type clang_ext_aligned_spelling =
| GNU_aligned
| CXX11_gnu_aligned
| Declspec_align
| Keyword_alignas
| Keyword_Alignas
| SpellingNotCalculated
val ext_aligned_get_spelling : cxcursor -> clang_ext_aligned_spelling
type clang_ext_alwaysinline_spelling =
| GNU_always_inline
| CXX11_gnu_always_inline
| Keyword_forceinline
| SpellingNotCalculated
val ext_always_inline_get_spelling : cxcursor -> clang_ext_alwaysinline_spelling
type clang_ext_argumentwithtypetag_spelling =
| GNU_argument_with_type_tag
| CXX11_clang_argument_with_type_tag
| C2x_clang_argument_with_type_tag
| GNU_pointer_with_type_tag
| CXX11_clang_pointer_with_type_tag
| C2x_clang_pointer_with_type_tag
| SpellingNotCalculated
val ext_argument_with_type_tag_get_spelling : cxcursor -> clang_ext_argumentwithtypetag_spelling
type clang_ext_assertcapability_spelling =
| GNU_assert_capability
| CXX11_clang_assert_capability
| GNU_assert_shared_capability
| CXX11_clang_assert_shared_capability
| SpellingNotCalculated
val ext_assert_capability_get_spelling : cxcursor -> clang_ext_assertcapability_spelling
type clang_ext_capability_spelling =
| GNU_capability
| CXX11_clang_capability
| GNU_shared_capability
| CXX11_clang_shared_capability
| SpellingNotCalculated
val ext_capability_get_spelling : cxcursor -> clang_ext_capability_spelling
type clang_ext_constinit_spelling =
| Keyword_constinit
| GNU_require_constant_initialization
| CXX11_clang_require_constant_initialization
| SpellingNotCalculated
val ext_const_init_get_spelling : cxcursor -> clang_ext_constinit_spelling
type clang_ext_final_spelling =
| Keyword_final
| Keyword_sealed
| SpellingNotCalculated
val ext_final_get_spelling : cxcursor -> clang_ext_final_spelling
type clang_ext_loophint_spelling =
| Pragma_clang_loop
| Pragma_unroll
| Pragma_nounroll
| Pragma_unroll_and_jam
| Pragma_nounroll_and_jam
| SpellingNotCalculated
val ext_loop_hint_get_spelling : cxcursor -> clang_ext_loophint_spelling
type clang_ext_msinheritance_spelling =
| Keyword_single_inheritance
| Keyword_multiple_inheritance
| Keyword_virtual_inheritance
| Keyword_unspecified_inheritance
| SpellingNotCalculated
val ext_msinheritance_get_spelling : cxcursor -> clang_ext_msinheritance_spelling
type clang_ext_mipslongcall_spelling =
| GNU_long_call
| CXX11_gnu_long_call
| GNU_far
| CXX11_gnu_far
| SpellingNotCalculated
val ext_mips_long_call_get_spelling : cxcursor -> clang_ext_mipslongcall_spelling
type clang_ext_mipsshortcall_spelling =
| GNU_short_call
| CXX11_gnu_short_call
| GNU_near
| CXX11_gnu_near
| SpellingNotCalculated
val ext_mips_short_call_get_spelling : cxcursor -> clang_ext_mipsshortcall_spelling
type clang_ext_openclaccess_spelling =
| Keyword_read_only
| Keyword_write_only
| Keyword_read_write
| SpellingNotCalculated
val ext_open_claccess_get_spelling : cxcursor -> clang_ext_openclaccess_spelling
type clang_ext_openclconstantaddressspace_spelling =
| Keyword_constant
| GNU_opencl_constant
| CXX11_clang_opencl_constant
| C2x_clang_opencl_constant
| SpellingNotCalculated
val ext_open_clconstant_address_space_get_spelling : cxcursor -> clang_ext_openclconstantaddressspace_spelling
type clang_ext_openclgenericaddressspace_spelling =
| Keyword_generic
| GNU_opencl_generic
| CXX11_clang_opencl_generic
| C2x_clang_opencl_generic
| SpellingNotCalculated
val ext_open_clgeneric_address_space_get_spelling : cxcursor -> clang_ext_openclgenericaddressspace_spelling
type clang_ext_openclglobaladdressspace_spelling =
| Keyword_global
| GNU_opencl_global
| CXX11_clang_opencl_global
| C2x_clang_opencl_global
| SpellingNotCalculated
val ext_open_clglobal_address_space_get_spelling : cxcursor -> clang_ext_openclglobaladdressspace_spelling
type clang_ext_opencllocaladdressspace_spelling =
| Keyword_local
| GNU_opencl_local
| CXX11_clang_opencl_local
| C2x_clang_opencl_local
| SpellingNotCalculated
val ext_open_cllocal_address_space_get_spelling : cxcursor -> clang_ext_opencllocaladdressspace_spelling
type clang_ext_openclprivateaddressspace_spelling =
| Keyword_private
| GNU_opencl_private
| CXX11_clang_opencl_private
| C2x_clang_opencl_private
| SpellingNotCalculated
val ext_open_clprivate_address_space_get_spelling : cxcursor -> clang_ext_openclprivateaddressspace_spelling
type clang_ext_ownership_spelling =
| GNU_ownership_holds
| CXX11_clang_ownership_holds
| C2x_clang_ownership_holds
| GNU_ownership_returns
| CXX11_clang_ownership_returns
| C2x_clang_ownership_returns
| GNU_ownership_takes
| CXX11_clang_ownership_takes
| C2x_clang_ownership_takes
| SpellingNotCalculated
val ext_ownership_get_spelling : cxcursor -> clang_ext_ownership_spelling
type clang_ext_passobjectsize_spelling =
| GNU_pass_object_size
| CXX11_clang_pass_object_size
| C2x_clang_pass_object_size
| GNU_pass_dynamic_object_size
| CXX11_clang_pass_dynamic_object_size
| C2x_clang_pass_dynamic_object_size
| SpellingNotCalculated
val ext_pass_object_size_get_spelling : cxcursor -> clang_ext_passobjectsize_spelling
type clang_ext_releasecapability_spelling =
| GNU_release_capability
| CXX11_clang_release_capability
| GNU_release_shared_capability
| CXX11_clang_release_shared_capability
| GNU_release_generic_capability
| CXX11_clang_release_generic_capability
| GNU_unlock_function
| CXX11_clang_unlock_function
| SpellingNotCalculated
val ext_release_capability_get_spelling : cxcursor -> clang_ext_releasecapability_spelling
type clang_ext_requirescapability_spelling =
| GNU_requires_capability
| CXX11_clang_requires_capability
| GNU_exclusive_locks_required
| CXX11_clang_exclusive_locks_required
| GNU_requires_shared_capability
| CXX11_clang_requires_shared_capability
| GNU_shared_locks_required
| CXX11_clang_shared_locks_required
| SpellingNotCalculated
val ext_requires_capability_get_spelling : cxcursor -> clang_ext_requirescapability_spelling
type clang_ext_restrict_spelling =
| Declspec_restrict
| GNU_malloc
| CXX11_gnu_malloc
| SpellingNotCalculated
val ext_restrict_get_spelling : cxcursor -> clang_ext_restrict_spelling
type clang_ext_section_spelling =
| GNU_section
| CXX11_gnu_section
| Declspec_allocate
| SpellingNotCalculated
val ext_section_get_spelling : cxcursor -> clang_ext_section_spelling
type clang_ext_tryacquirecapability_spelling =
| GNU_try_acquire_capability
| CXX11_clang_try_acquire_capability
| GNU_try_acquire_shared_capability
| CXX11_clang_try_acquire_shared_capability
| SpellingNotCalculated
val ext_try_acquire_capability_get_spelling : cxcursor -> clang_ext_tryacquirecapability_spelling
type clang_ext_unused_spelling =
| CXX11_maybe_unused
| GNU_unused
| CXX11_gnu_unused
| C2x_maybe_unused
| SpellingNotCalculated
val ext_unused_get_spelling : cxcursor -> clang_ext_unused_spelling
type clang_ext_warnunusedresult_spelling =
| CXX11_nodiscard
| C2x_nodiscard
| CXX11_clang_warn_unused_result
| GNU_warn_unused_result
| CXX11_gnu_warn_unused_result
| SpellingNotCalculated
val ext_warn_unused_result_get_spelling : cxcursor -> clang_ext_warnunusedresult_spelling
type clang_ext_xrayinstrument_spelling =
| GNU_xray_always_instrument
| CXX11_clang_xray_always_instrument
| C2x_clang_xray_always_instrument
| GNU_xray_never_instrument
| CXX11_clang_xray_never_instrument
| C2x_clang_xray_never_instrument
| SpellingNotCalculated
val ext_xray_instrument_get_spelling : cxcursor -> clang_ext_xrayinstrument_spelling
val ext_ompdeclare_simd_decl_attr_get_uniforms_size : cxcursor -> int
type clang_ext_returntypestateattr_consumedstate =
| Unknown
| Consumed
| Unconsumed
val ext_return_typestate_attr_get_state : cxcursor -> clang_ext_returntypestateattr_consumedstate
val ext_attrs_get_aliasee_length : cxcursor -> int
val ext_obj_cruntime_name_attr_get_metadata_name : cxcursor -> string
val ext_ompdeclare_variant_attr_get_impl_vendors : cxcursor -> (string -> unit) -> unit
val ext_ifunc_attr_get_resolver : cxcursor -> string
val ext_patchable_function_entry_attr_get_offset : cxcursor -> int
val ext_assume_aligned_attr_get_offset : cxcursor -> cxcursor
val ext_web_assembly_import_name_attr_get_import_name_length : cxcursor -> int
val ext_sentinel_attr_get_sentinel : cxcursor -> int
val ext_attrs_get_success_value : cxcursor -> cxcursor
val ext_attrs_get_cpus_size : cxcursor -> int
val ext_tlsmodel_attr_get_model_length : cxcursor -> int
type clang_ext_paramtypestateattr_consumedstate =
| Unknown
| Consumed
| Unconsumed
val ext_param_typestate_attr_get_param_state : cxcursor -> clang_ext_paramtypestateattr_consumedstate
val ext_external_source_symbol_attr_get_generated_declaration : cxcursor -> bool
val ext_suppress_attr_get_diagnostic_identifiers : cxcursor -> (string -> unit) -> unit
val ext_attrs_get_deref_type : cxcursor -> clang_ext_typeloc
val ext_type_tag_for_datatype_attr_get_matching_ctype : cxcursor -> clang_ext_typeloc
val ext_annotate_attr_get_annotation_length : cxcursor -> int
val ext_ompdeclare_variant_attr_get_device_kinds : cxcursor -> (string -> unit) -> unit
val ext_layout_version_attr_get_version : cxcursor -> int
val ext_sentinel_attr_get_null_pos : cxcursor -> int
val ext_ompdeclare_simd_decl_attr_get_aligneds : cxcursor -> (cxcursor -> unit) -> unit
val ext_attrs_get_args_size : cxcursor -> int
val ext_ompdeclare_variant_attr_get_ctx_selectors_size : cxcursor -> int
val ext_cudalaunch_bounds_attr_get_min_blocks : cxcursor -> cxcursor
val ext_ompdeclare_variant_attr_get_impl_vendors_size : cxcursor -> int
val ext_external_source_symbol_attr_get_defined_in_length : cxcursor -> int
val ext_ompcapture_kind_attr_get_capture_kind : cxcursor -> int
val ext_format_attr_get_type : cxcursor -> string
val ext_pass_object_size_attr_get_type : cxcursor -> int
type clang_ext_blocksattr_blocktype =
| ByRef
val ext_blocks_attr_get_type : cxcursor -> clang_ext_blocksattr_blocktype
val ext_asm_label_attr_get_label : cxcursor -> string
val ext_availability_attr_get_platform : cxcursor -> string
val ext_attrs_get_max : cxcursor -> cxcursor
val ext_target_attr_get_features_str : cxcursor -> string
val ext_callable_when_attr_get_callable_states_size : cxcursor -> int
type clang_ext_testtypestateattr_consumedstate =
| Consumed
| Unconsumed
val ext_test_typestate_attr_get_test_state : cxcursor -> clang_ext_testtypestateattr_consumedstate
val ext_init_priority_attr_get_priority : cxcursor -> int
val ext_attrs_get_priority : cxcursor -> int
type clang_ext_ompdeclaretargetdeclattr_maptypety =
| To
val ext_ompdeclare_target_decl_attr_get_map_type : cxcursor -> clang_ext_ompdeclaretargetdeclattr_maptypety
val ext_attrs_get_ydim : cxcursor -> int
val ext_cleanup_attr_get_function_decl : cxcursor -> clang_ext_declarationname
type clang_ext_versiontuple = {
major : int;
minor : int;
subminor : int;
build : int;
}
val ext_availability_attr_get_obsoleted : cxcursor -> clang_ext_versiontuple
val ext_init_seg_attr_get_section : cxcursor -> string
val ext_external_source_symbol_attr_get_defined_in : cxcursor -> string
val ext_alloc_size_attr_get_num_elems_param : cxcursor -> int
val ext_ompdeclare_variant_attr_get_ctx_selectors : cxcursor -> (int -> unit) -> unit
val ext_ifunc_attr_get_resolver_length : cxcursor -> int
val ext_asm_label_attr_get_label_length : cxcursor -> int
val ext_abi_tag_attr_get_tags_size : cxcursor -> int
val ext_cudalaunch_bounds_attr_get_max_threads : cxcursor -> cxcursor
val ext_arm_mve_alias_attr_get_builtin_name : cxcursor -> string
val ext_web_assembly_import_module_attr_get_import_module : cxcursor -> string
val ext_no_sanitize_attr_get_sanitizers_size : cxcursor -> int
val ext_callback_attr_get_encoding_size : cxcursor -> int
val ext_attrs_get_xdim : cxcursor -> int
val ext_attrs_get_aliasee : cxcursor -> string
val ext_attrs_get_handle_type : cxcursor -> string
val ext_web_assembly_import_module_attr_get_import_module_length : cxcursor -> int
val ext_ompdeclare_simd_decl_attr_get_linears : cxcursor -> (cxcursor -> unit) -> unit
val ext_availability_attr_get_deprecated : cxcursor -> clang_ext_versiontuple
val ext_web_assembly_export_name_attr_get_export_name : cxcursor -> string
val ext_argument_with_type_tag_attr_get_is_pointer : cxcursor -> bool
val ext_uuid_attr_get_guid_length : cxcursor -> int
val ext_ompdeclare_simd_decl_attr_get_aligneds_size : cxcursor -> int
val ext_attrs_get_message_length : cxcursor -> int
type clang_ext_pcsattr_pcstype =
| AAPCS
| AAPCS_VFP
val ext_pcs_attr_get_pcs : cxcursor -> clang_ext_pcsattr_pcstype
val ext_callback_attr_get_encoding : cxcursor -> (int -> unit) -> unit
val ext_attrs_get_argument_kind : cxcursor -> string
val ext_availability_attr_get_unavailable : cxcursor -> bool
val ext_ompallocate_decl_attr_get_allocator : cxcursor -> cxcursor
val ext_annotate_attr_get_annotation : cxcursor -> string
val ext_ompdeclare_variant_attr_get_variant_func_ref : cxcursor -> cxcursor
val ext_no_builtin_attr_get_builtin_names_size : cxcursor -> int
val ext_attrs_get_replacement : cxcursor -> string
val ext_amdgpunum_sgprattr_get_num_sgpr : cxcursor -> int
val ext_ompdeclare_simd_decl_attr_get_simdlen : cxcursor -> cxcursor
val ext_target_attr_get_features_str_length : cxcursor -> int
val ext_aligned_attr_get_alignment_expr : cxcursor -> cxcursor
val ext_ompdeclare_simd_decl_attr_get_steps : cxcursor -> (cxcursor -> unit) -> unit
val ext_tlsmodel_attr_get_model : cxcursor -> string
val ext_ompdeclare_simd_decl_attr_get_modifiers : cxcursor -> (int -> unit) -> unit
val ext_format_attr_get_first_arg : cxcursor -> int
val ext_amdgpunum_vgprattr_get_num_vgpr : cxcursor -> int
type clang_ext_mipsinterruptattr_interrupttype =
| Sw0
| Sw1
| Hw0
| Hw1
| Hw2
| Hw3
| Hw4
| Hw5
| Eic
val ext_mips_interrupt_attr_get_interrupt : cxcursor -> clang_ext_mipsinterruptattr_interrupttype
type clang_ext_arminterruptattr_interrupttype =
| IRQ
| FIQ
| SWI
| ABORT
| UNDEF
| Generic
val ext_arminterrupt_attr_get_interrupt : cxcursor -> clang_ext_arminterruptattr_interrupttype
type clang_ext_riscvinterruptattr_interrupttype =
| User
| Supervisor
| Machine
val ext_riscvinterrupt_attr_get_interrupt : cxcursor -> clang_ext_riscvinterruptattr_interrupttype
val ext_attrs_get_min : cxcursor -> cxcursor
type clang_ext_enumextensibilityattr_kind =
| Closed
| Open
val ext_enum_extensibility_attr_get_extensibility : cxcursor -> clang_ext_enumextensibilityattr_kind
val ext_alloc_align_attr_get_param_index : cxcursor -> int
val ext_availability_attr_get_introduced : cxcursor -> clang_ext_versiontuple
val ext_max_field_alignment_attr_get_alignment : cxcursor -> int
val ext_attrs_get_alignment : cxcursor -> cxcursor
val ext_address_space_attr_get_address_space : cxcursor -> int
val ext_mode_attr_get_mode : cxcursor -> string
val ext_attrs_get_arg : cxcursor -> cxcursor
val ext_attrs_get_cpus : cxcursor -> (string -> unit) -> unit
val ext_open_clintel_reqd_sub_group_size_attr_get_sub_group_size : cxcursor -> int
val ext_argument_with_type_tag_attr_get_argument_idx : cxcursor -> int
val ext_ompdeclare_variant_attr_get_scores : cxcursor -> (cxcursor -> unit) -> unit
val ext_availability_attr_get_strict : cxcursor -> bool
type clang_ext_cfguardattr_guardarg =
| Nocf
val ext_cfguard_attr_get_guard : cxcursor -> clang_ext_cfguardattr_guardarg
val ext_ownership_attr_get_module : cxcursor -> string
val ext_min_vector_width_attr_get_vector_width : cxcursor -> int
val ext_type_tag_for_datatype_attr_get_layout_compatible : cxcursor -> bool
val ext_init_seg_attr_get_section_length : cxcursor -> int
val ext_vec_type_hint_attr_get_type_hint : cxcursor -> clang_ext_typeloc
val ext_ompdeclare_variant_attr_get_ctx_selector_sets_size : cxcursor -> int
val ext_ompdeclare_variant_attr_get_ctx_selector_sets : cxcursor -> (int -> unit) -> unit
val ext_external_source_symbol_attr_get_language_length : cxcursor -> int
val ext_obj_cruntime_name_attr_get_metadata_name_length : cxcursor -> int
type clang_ext_consumableattr_consumedstate =
| Unknown
| Consumed
| Unconsumed
val ext_consumable_attr_get_default_state : cxcursor -> clang_ext_consumableattr_consumedstate
val ext_attrs_get_bridged_type : cxcursor -> string
val ext_ompdeclare_simd_decl_attr_get_modifiers_size : cxcursor -> int
type clang_ext_settypestateattr_consumedstate =
| Unknown
| Consumed
| Unconsumed
val ext_set_typestate_attr_get_new_state : cxcursor -> clang_ext_settypestateattr_consumedstate
val ext_ompreferenced_var_attr_get_ref : cxcursor -> cxcursor
val ext_alloc_size_attr_get_elem_size_param : cxcursor -> int
type clang_ext_visibilityattr_visibilitytype =
| Default
| Hidden
| Protected
val ext_visibility_attr_get_visibility : cxcursor -> clang_ext_visibilityattr_visibilitytype
type clang_ext_typevisibilityattr_visibilitytype =
| Default
| Hidden
| Protected
val ext_type_visibility_attr_get_visibility : cxcursor -> clang_ext_typevisibilityattr_visibilitytype
val ext_external_source_symbol_attr_get_language : cxcursor -> string
val ext_attrs_get_replacement_length : cxcursor -> int
val ext_ompdeclare_simd_decl_attr_get_alignments_size : cxcursor -> int
val ext_ompdeclare_simd_decl_attr_get_linears_size : cxcursor -> int
val ext_xray_log_args_attr_get_argument_count : cxcursor -> int
val ext_attrs_get_message : cxcursor -> string
val ext_argument_with_type_tag_attr_get_type_tag_idx : cxcursor -> int
val ext_uuid_attr_get_guid : cxcursor -> string
val ext_attrs_get_zdim : cxcursor -> int
val ext_attrs_get_handle_type_length : cxcursor -> int
val ext_ompdeclare_simd_decl_attr_get_uniforms : cxcursor -> (cxcursor -> unit) -> unit
type clang_ext_loophintattr_optiontype =
| Vectorize
| VectorizeWidth
| Interleave
| InterleaveCount
| Unroll
| UnrollCount
| UnrollAndJam
| UnrollAndJamCount
| PipelineDisabled
| PipelineInitiationInterval
| Distribute
| VectorizePredicate
val ext_loop_hint_attr_get_option : cxcursor -> clang_ext_loophintattr_optiontype
val ext_web_assembly_import_name_attr_get_import_name : cxcursor -> string
val ext_ompdeclare_variant_attr_get_device_kinds_size : cxcursor -> int
val ext_no_sanitize_attr_get_sanitizers : cxcursor -> (string -> unit) -> unit
type clang_ext_callablewhenattr_consumedstate =
| Unknown
| Consumed
| Unconsumed
val ext_callable_when_attr_get_callable_states : cxcursor -> (clang_ext_callablewhenattr_consumedstate -> unit) -> unit
val ext_ompdeclare_variant_attr_get_scores_size : cxcursor -> int
type clang_ext_ompdeclaresimddeclattr_branchstatety =
| Undefined
| Inbranch
| Notinbranch
val ext_ompdeclare_simd_decl_attr_get_branch_state : cxcursor -> clang_ext_ompdeclaresimddeclattr_branchstatety
val ext_asm_label_attr_get_is_literal_label : cxcursor -> bool
val ext_format_arg_attr_get_format_idx : cxcursor -> int
val ext_format_attr_get_format_idx : cxcursor -> int
val ext_type_tag_for_datatype_attr_get_must_be_null : cxcursor -> bool
type clang_ext_ompallocatedeclattr_allocatortypety =
| OMPDefaultMemAlloc
| OMPLargeCapMemAlloc
| OMPConstMemAlloc
| OMPHighBWMemAlloc
| OMPLowLatMemAlloc
| OMPCGroupMemAlloc
| OMPPTeamMemAlloc
| OMPThreadMemAlloc
| OMPUserDefinedMemAlloc
val ext_ompallocate_decl_attr_get_allocator_type : cxcursor -> clang_ext_ompallocatedeclattr_allocatortypety
val ext_attrs_get_name_length : cxcursor -> int
val ext_attrs_get_name : cxcursor -> string
val ext_suppress_attr_get_diagnostic_identifiers_size : cxcursor -> int
val ext_ompdeclare_simd_decl_attr_get_steps_size : cxcursor -> int
val ext_web_assembly_export_name_attr_get_export_name_length : cxcursor -> int
val ext_ompdeclare_simd_decl_attr_get_alignments : cxcursor -> (cxcursor -> unit) -> unit
val ext_msvtor_disp_attr_get_vdm : cxcursor -> int
val ext_attrs_get_cond : cxcursor -> cxcursor
val ext_iboutlet_collection_attr_get_interface : cxcursor -> clang_ext_typeloc
type clang_ext_objcmethodfamilyattr_familykind =
| None
| Alloc
| Copy
| Init
| MutableCopy
| New
val ext_obj_cmethod_family_attr_get_family : cxcursor -> clang_ext_objcmethodfamilyattr_familykind
val ext_attrs_get_kind : cxcursor -> string
val ext_patchable_function_entry_attr_get_count : cxcursor -> int
val ext_abi_tag_attr_get_tags : cxcursor -> (string -> unit) -> unit
val ext_msp430_interrupt_attr_get_number : cxcursor -> int
val ext_open_clunroll_hint_attr_get_unroll_hint : cxcursor -> int
val ext_no_builtin_attr_get_builtin_names : cxcursor -> (string -> unit) -> unit
val ext_msinheritance_attr_get_best_case : cxcursor -> bool
val ext_non_null_attr_get_args : cxcursor -> (int -> unit) -> unit
val ext_acquire_capability_attr_get_args : cxcursor -> (cxcursor -> unit) -> unit