const (AccessSpecifier_InvalidAccessSpecifier =C.CX_CXXInvalidAccessSpecifierAccessSpecifier_Public                    =C.CX_CXXPublicAccessSpecifier_Protected                 =C.CX_CXXProtectedAccessSpecifier_Private                   =C.CX_CXXPrivate)

const (// The entity is available.Availability_AvailableAvailabilityKind =C.CXAvailability_Available// The entity is available, but has been deprecated (and its use is not recommended).Availability_Deprecated =C.CXAvailability_Deprecated// The entity is not available; any use of it will be an error.Availability_NotAvailable =C.CXAvailability_NotAvailable// The entity is available, but not accessible; any use of it will be an error.Availability_NotAccessible =C.CXAvailability_NotAccessible)

const (CallingConv_DefaultCallingConv =C.CXCallingConv_DefaultCallingConv_C                             =C.CXCallingConv_CCallingConv_X86StdCall                    =C.CXCallingConv_X86StdCallCallingConv_X86FastCall                   =C.CXCallingConv_X86FastCallCallingConv_X86ThisCall                   =C.CXCallingConv_X86ThisCallCallingConv_X86Pascal                     =C.CXCallingConv_X86PascalCallingConv_AAPCS                         =C.CXCallingConv_AAPCSCallingConv_AAPCS_VFP                     =C.CXCallingConv_AAPCS_VFPCallingConv_X86RegCall                    =C.CXCallingConv_X86RegCallCallingConv_IntelOclBicc                  =C.CXCallingConv_IntelOclBiccCallingConv_Win64                         =C.CXCallingConv_Win64CallingConv_X86_64Win64                   =C.CXCallingConv_X86_64Win64CallingConv_X86_64SysV                    =C.CXCallingConv_X86_64SysVCallingConv_X86VectorCall                 =C.CXCallingConv_X86VectorCallCallingConv_Swift                         =C.CXCallingConv_SwiftCallingConv_PreserveMost                  =C.CXCallingConv_PreserveMostCallingConv_PreserveAll                   =C.CXCallingConv_PreserveAllCallingConv_AArch64VectorCall             =C.CXCallingConv_AArch64VectorCallCallingConv_Invalid                       =C.CXCallingConv_InvalidCallingConv_Unexposed                     =C.CXCallingConv_Unexposed)

const (// Terminates the cursor traversal.ChildVisit_BreakChildVisitResult =C.CXChildVisit_Break// Continues the cursor traversal with the next sibling of the cursor just visited, without visiting its children.ChildVisit_Continue =C.CXChildVisit_Continue// Recursively traverse the children of this cursor, using the same visitor and client data.ChildVisit_Recurse =C.CXChildVisit_Recurse)

const (// Whether to include macros within the set of code completions returned.CodeComplete_IncludeMacrosCodeComplete_Flags =C.CXCodeComplete_IncludeMacros// Whether to include code patterns for language constructs within the set of code completions, e.g., for loops.CodeComplete_IncludeCodePatterns =C.CXCodeComplete_IncludeCodePatterns// Whether to include brief documentation within the set of code completions returned.CodeComplete_IncludeBriefComments =C.CXCodeComplete_IncludeBriefComments// Whether to speed up completion by omitting top- or namespace-level entities defined in the preamble. There's no guarantee any particular entity is omitted. This may be useful if the headers are indexed externally.CodeComplete_SkipPreamble =C.CXCodeComplete_SkipPreamble// Whether to include completions with small fix-its, e.g. change '.' to '->' on member access, etc.CodeComplete_IncludeCompletionsWithFixIts =C.CXCodeComplete_IncludeCompletionsWithFixIts)

const (// Command argument should be rendered in a normal font.CommentInlineCommandRenderKind_NormalCommentInlineCommandRenderKind =C.CXCommentInlineCommandRenderKind_Normal// Command argument should be rendered in a bold font.CommentInlineCommandRenderKind_Bold =C.CXCommentInlineCommandRenderKind_Bold// Command argument should be rendered in a monospaced font.CommentInlineCommandRenderKind_Monospaced =C.CXCommentInlineCommandRenderKind_Monospaced// Command argument should be rendered emphasized (typically italic font).CommentInlineCommandRenderKind_Emphasized =C.CXCommentInlineCommandRenderKind_Emphasized// Command argument should not be rendered (since it only defines an anchor).CommentInlineCommandRenderKind_Anchor =C.CXCommentInlineCommandRenderKind_Anchor)

const (// Null comment. No AST node is constructed at the requested location because there is no text or a syntax error.Comment_NullCommentKind =C.CXComment_Null// Plain text. Inline content.Comment_Text =C.CXComment_Text/*A command with word-like arguments that is considered inline content.For example: \command.*/Comment_InlineCommand =C.CXComment_InlineCommand/*HTML start tag with attributes (name-value pairs). Consideredinline content.For example:\verbatim<br> <br /> <a href="http://example.org/">\endverbatim*/Comment_HTMLStartTag =C.CXComment_HTMLStartTag/*HTML end tag. Considered inline content.For example:\verbatim</a>\endverbatim*/Comment_HTMLEndTag =C.CXComment_HTMLEndTag// A paragraph, contains inline comment. The paragraph itself is block content.Comment_Paragraph =C.CXComment_Paragraph/*A command that has zero or more word-like arguments (number ofword-like arguments depends on command name) and a paragraph as anargument. Block command is block content.Paragraph argument is also a child of the block command.For example: \has 0 word-like arguments and a paragraph argument.AST nodes of special kinds that parser knows about (e. g., \\paramcommand) have their own node kinds.*/Comment_BlockCommand =C.CXComment_BlockCommand/*A \Parameter or \\arg command that describes the function parameter(name, passing direction, description).For example: \Parameter [in] ParamName description.*/Comment_ParamCommand =C.CXComment_ParamCommand/*A \\tparam command that describes a template parameter (name anddescription).For example: \\tparam T description.*/Comment_TParamCommand =C.CXComment_TParamCommand/*A verbatim block command (e. g., preformatted code). Verbatimblock has an opening and a closing command and contains multiple lines oftext (CXComment_VerbatimBlockLine child nodes).For example:\\verbatimaaa\\endverbatim*/Comment_VerbatimBlockCommand =C.CXComment_VerbatimBlockCommand// A line of text that is contained within a CXComment_VerbatimBlockCommand node.Comment_VerbatimBlockLine =C.CXComment_VerbatimBlockLine// A verbatim line command. Verbatim line has an opening command, a single line of text (up to the newline after the opening command) and has no closing command.Comment_VerbatimLine =C.CXComment_VerbatimLine// A full comment attached to a declaration, contains block content.Comment_FullComment =C.CXComment_FullComment)

const (// The parameter is an input parameter.CommentParamPassDirection_InCommentParamPassDirection =C.CXCommentParamPassDirection_In// The parameter is an output parameter.CommentParamPassDirection_Out =C.CXCommentParamPassDirection_Out// The parameter is an input and output parameter.CommentParamPassDirection_InOut =C.CXCommentParamPassDirection_InOut)

const (/*A code-completion string that describes "optional" text thatcould be a part of the template (but is not required).The Optional chunk is the only kind of chunk that has a code-completionstring for its representation, which is accessible viaclang_getCompletionChunkCompletionString(). The code-completion stringdescribes an additional part of the template that is completely optional.For example, optional chunks can be used to describe the placeholders forarguments that match up with defaulted function parameters, e.g. given:\codevoid f(int x, float y = 3.14, double z = 2.71828);\endcodeThe code-completion string for this function would contain:- a TypedText chunk for "f".- a LeftParen chunk for "(".- a Placeholder chunk for "int x"- an Optional chunk containing the remaining defaulted arguments, e.g.,- a Comma chunk for ","- a Placeholder chunk for "float y"- an Optional chunk containing the last defaulted argument:- a Comma chunk for ","- a Placeholder chunk for "double z"- a RightParen chunk for ")"There are many ways to handle Optional chunks. Two simple approaches are:- Completely ignore optional chunks, in which case the template for thefunction "f" would only include the first parameter ("int x").- Fully expand all optional chunks, in which case the template for thefunction "f" would have all of the parameters.*/CompletionChunk_OptionalCompletionChunkKind =C.CXCompletionChunk_Optional/*Text that a user would be expected to type to get thiscode-completion result.There will be exactly one "typed text" chunk in a semantic string, whichwill typically provide the spelling of a keyword or the name of adeclaration that could be used at the current code point. Clients areexpected to filter the code-completion results based on the text in thischunk.*/CompletionChunk_TypedText =C.CXCompletionChunk_TypedText/*Text that should be inserted as part of a code-completion result.A "text" chunk represents text that is part of the template to beinserted into user code should this particular code-completion resultbe selected.*/CompletionChunk_Text =C.CXCompletionChunk_Text/*Placeholder text that should be replaced by the user.A "placeholder" chunk marks a place where the user should insert textinto the code-completion template. For example, placeholders might markthe function parameters for a function declaration, to indicate that theuser should provide arguments for each of those parameters. The actualtext in a placeholder is a suggestion for the text to display beforethe user replaces the placeholder with real code.*/CompletionChunk_Placeholder =C.CXCompletionChunk_Placeholder/*Informative text that should be displayed but never inserted aspart of the template.An "informative" chunk contains annotations that can be displayed tohelp the user decide whether a particular code-completion result is theright option, but which is not part of the actual template to be insertedby code completion.*/CompletionChunk_Informative =C.CXCompletionChunk_Informative/*Text that describes the current parameter when code-completion isreferring to function call, message send, or template specialization.A "current parameter" chunk occurs when code-completion is providinginformation about a parameter corresponding to the argument at thecode-completion point. For example, given a function\codeint add(int x, int y);\endcodeand the source code add(, where the code-completion point is after the"(", the code-completion string will contain a "current parameter" chunkfor "int x", indicating that the current argument will initialize thatparameter. After typing further, to add(17, (where the code-completionpoint is after the ","), the code-completion string will contain a"current parameter" chunk to "int y".*/CompletionChunk_CurrentParameter =C.CXCompletionChunk_CurrentParameter// A left parenthesis ('('), used to initiate a function call or signal the beginning of a function parameter list.CompletionChunk_LeftParen =C.CXCompletionChunk_LeftParen// A right parenthesis (')'), used to finish a function call or signal the end of a function parameter list.CompletionChunk_RightParen =C.CXCompletionChunk_RightParen// A left bracket ('[').CompletionChunk_LeftBracket =C.CXCompletionChunk_LeftBracket// A right bracket (']').CompletionChunk_RightBracket =C.CXCompletionChunk_RightBracket// A left brace ('{').CompletionChunk_LeftBrace =C.CXCompletionChunk_LeftBrace// A right brace ('}').CompletionChunk_RightBrace =C.CXCompletionChunk_RightBrace// A left angle bracket ('<').CompletionChunk_LeftAngle =C.CXCompletionChunk_LeftAngle// A right angle bracket ('>').CompletionChunk_RightAngle =C.CXCompletionChunk_RightAngle// A comma separator (',').CompletionChunk_Comma =C.CXCompletionChunk_Comma/*Text that specifies the result type of a given result.This special kind of informative chunk is not meant to be inserted intothe text buffer. Rather, it is meant to illustrate the type that anexpression using the given completion string would have.*/CompletionChunk_ResultType =C.CXCompletionChunk_ResultType// A colon (':').CompletionChunk_Colon =C.CXCompletionChunk_Colon// A semicolon (';').CompletionChunk_SemiColon =C.CXCompletionChunk_SemiColon// An '=' sign.CompletionChunk_Equal =C.CXCompletionChunk_Equal// Horizontal space (' ').CompletionChunk_HorizontalSpace =C.CXCompletionChunk_HorizontalSpace// Vertical space ('\\n'), after which it is generally a good idea to perform indentation.CompletionChunk_VerticalSpace =C.CXCompletionChunk_VerticalSpace)

const (// The context for completions is unexposed, as only Clang results should be included. (This is equivalent to having no context bits set.)CompletionContext_UnexposedCompletionContext =C.CXCompletionContext_Unexposed// Completions for any possible type should be included in the results.CompletionContext_AnyType =C.CXCompletionContext_AnyType// Completions for any possible value (variables, function calls, etc.) should be included in the results.CompletionContext_AnyValue =C.CXCompletionContext_AnyValue// Completions for values that resolve to an Objective-C object should be included in the results.CompletionContext_ObjCObjectValue =C.CXCompletionContext_ObjCObjectValue// Completions for values that resolve to an Objective-C selector should be included in the results.CompletionContext_ObjCSelectorValue =C.CXCompletionContext_ObjCSelectorValue// Completions for values that resolve to a C++ class type should be included in the results.CompletionContext_CXXClassTypeValue =C.CXCompletionContext_CXXClassTypeValue// Completions for fields of the member being accessed using the dot operator should be included in the results.CompletionContext_DotMemberAccess =C.CXCompletionContext_DotMemberAccess// Completions for fields of the member being accessed using the arrow operator should be included in the results.CompletionContext_ArrowMemberAccess =C.CXCompletionContext_ArrowMemberAccess// Completions for properties of the Objective-C object being accessed using the dot operator should be included in the results.CompletionContext_ObjCPropertyAccess =C.CXCompletionContext_ObjCPropertyAccess// Completions for enum tags should be included in the results.CompletionContext_EnumTag =C.CXCompletionContext_EnumTag// Completions for union tags should be included in the results.CompletionContext_UnionTag =C.CXCompletionContext_UnionTag// Completions for struct tags should be included in the results.CompletionContext_StructTag =C.CXCompletionContext_StructTag// Completions for C++ class names should be included in the results.CompletionContext_ClassTag =C.CXCompletionContext_ClassTag// Completions for C++ namespaces and namespace aliases should be included in the results.CompletionContext_Namespace =C.CXCompletionContext_Namespace// Completions for C++ nested name specifiers should be included in the results.CompletionContext_NestedNameSpecifier =C.CXCompletionContext_NestedNameSpecifier// Completions for Objective-C interfaces (classes) should be included in the results.CompletionContext_ObjCInterface =C.CXCompletionContext_ObjCInterface// Completions for Objective-C protocols should be included in the results.CompletionContext_ObjCProtocol =C.CXCompletionContext_ObjCProtocol// Completions for Objective-C categories should be included in the results.CompletionContext_ObjCCategory =C.CXCompletionContext_ObjCCategory// Completions for Objective-C instance messages should be included in the results.CompletionContext_ObjCInstanceMessage =C.CXCompletionContext_ObjCInstanceMessage// Completions for Objective-C class messages should be included in the results.CompletionContext_ObjCClassMessage =C.CXCompletionContext_ObjCClassMessage// Completions for Objective-C selector names should be included in the results.CompletionContext_ObjCSelectorName =C.CXCompletionContext_ObjCSelectorName// Completions for preprocessor macro names should be included in the results.CompletionContext_MacroName =C.CXCompletionContext_MacroName// Natural language completions should be included in the results.CompletionContext_NaturalLanguage =C.CXCompletionContext_NaturalLanguage// #include file completions should be included in the results.CompletionContext_IncludedFile =C.CXCompletionContext_IncludedFile// The current context is unknown, so set all contexts.CompletionContext_Unknown =C.CXCompletionContext_Unknown)

const (// The cursor has no exception specification.Cursor_ExceptionSpecificationKind_NoneCursor_ExceptionSpecificationKind =C.CXCursor_ExceptionSpecificationKind_None// The cursor has exception specification throw()Cursor_ExceptionSpecificationKind_DynamicNone =C.CXCursor_ExceptionSpecificationKind_DynamicNone// The cursor has exception specification throw(T1, T2)Cursor_ExceptionSpecificationKind_Dynamic =C.CXCursor_ExceptionSpecificationKind_Dynamic// The cursor has exception specification throw(...).Cursor_ExceptionSpecificationKind_MSAny =C.CXCursor_ExceptionSpecificationKind_MSAny// The cursor has exception specification basic noexcept.Cursor_ExceptionSpecificationKind_BasicNoexcept =C.CXCursor_ExceptionSpecificationKind_BasicNoexcept// The cursor has exception specification computed noexcept.Cursor_ExceptionSpecificationKind_ComputedNoexcept =C.CXCursor_ExceptionSpecificationKind_ComputedNoexcept// The exception specification has not yet been evaluated.Cursor_ExceptionSpecificationKind_Unevaluated =C.CXCursor_ExceptionSpecificationKind_Unevaluated// The exception specification has not yet been instantiated.Cursor_ExceptionSpecificationKind_Uninstantiated =C.CXCursor_ExceptionSpecificationKind_Uninstantiated// The exception specification has not been parsed yet.Cursor_ExceptionSpecificationKind_Unparsed =C.CXCursor_ExceptionSpecificationKind_Unparsed// The cursor has a __declspec(nothrow) exception specification.Cursor_ExceptionSpecificationKind_NoThrow =C.CXCursor_ExceptionSpecificationKind_NoThrow)

const (/*A declaration whose specific kind is not exposed via thisinterface.Unexposed declarations have the same operations as any other kindof declaration; one can extract their location information,spelling, find their definitions, etc. However, the specific kindof the declaration is not reported.*/Cursor_UnexposedDeclCursorKind =C.CXCursor_UnexposedDecl// A C or C++ struct.Cursor_StructDecl =C.CXCursor_StructDecl// A C or C++ union.Cursor_UnionDecl =C.CXCursor_UnionDecl// A C++ class.Cursor_ClassDecl =C.CXCursor_ClassDecl// An enumeration.Cursor_EnumDecl =C.CXCursor_EnumDecl// A field (in C) or non-static data member (in C++) in a struct, union, or C++ class.Cursor_FieldDecl =C.CXCursor_FieldDecl// An enumerator constant.Cursor_EnumConstantDecl =C.CXCursor_EnumConstantDecl// A function.Cursor_FunctionDecl =C.CXCursor_FunctionDecl// A variable.Cursor_VarDecl =C.CXCursor_VarDecl// A function or method parameter.Cursor_ParmDecl =C.CXCursor_ParmDecl// An Objective-C \@interface.Cursor_ObjCInterfaceDecl =C.CXCursor_ObjCInterfaceDecl// An Objective-C \@interface for a category.Cursor_ObjCCategoryDecl =C.CXCursor_ObjCCategoryDecl// An Objective-C \@protocol declaration.Cursor_ObjCProtocolDecl =C.CXCursor_ObjCProtocolDecl// An Objective-C \@property declaration.Cursor_ObjCPropertyDecl =C.CXCursor_ObjCPropertyDecl// An Objective-C instance variable.Cursor_ObjCIvarDecl =C.CXCursor_ObjCIvarDecl// An Objective-C instance method.Cursor_ObjCInstanceMethodDecl =C.CXCursor_ObjCInstanceMethodDecl// An Objective-C class method.Cursor_ObjCClassMethodDecl =C.CXCursor_ObjCClassMethodDecl// An Objective-C \@implementation.Cursor_ObjCImplementationDecl =C.CXCursor_ObjCImplementationDecl// An Objective-C \@implementation for a category.Cursor_ObjCCategoryImplDecl =C.CXCursor_ObjCCategoryImplDecl// A typedef.Cursor_TypedefDecl =C.CXCursor_TypedefDecl// A C++ class method.Cursor_CXXMethod =C.CXCursor_CXXMethod// A C++ namespace.Cursor_Namespace =C.CXCursor_Namespace// A linkage specification, e.g. 'extern "C"'.Cursor_LinkageSpec =C.CXCursor_LinkageSpec// A C++ constructor.Cursor_Constructor =C.CXCursor_Constructor// A C++ destructor.Cursor_Destructor =C.CXCursor_Destructor// A C++ conversion function.Cursor_ConversionFunction =C.CXCursor_ConversionFunction// A C++ template type parameter.Cursor_TemplateTypeParameter =C.CXCursor_TemplateTypeParameter// A C++ non-type template parameter.Cursor_NonTypeTemplateParameter =C.CXCursor_NonTypeTemplateParameter// A C++ template template parameter.Cursor_TemplateTemplateParameter =C.CXCursor_TemplateTemplateParameter// A C++ function template.Cursor_FunctionTemplate =C.CXCursor_FunctionTemplate// A C++ class template.Cursor_ClassTemplate =C.CXCursor_ClassTemplate// A C++ class template partial specialization.Cursor_ClassTemplatePartialSpecialization =C.CXCursor_ClassTemplatePartialSpecialization// A C++ namespace alias declaration.Cursor_NamespaceAlias =C.CXCursor_NamespaceAlias// A C++ using directive.Cursor_UsingDirective =C.CXCursor_UsingDirective// A C++ using declaration.Cursor_UsingDeclaration =C.CXCursor_UsingDeclaration// A C++ alias declarationCursor_TypeAliasDecl =C.CXCursor_TypeAliasDecl// An Objective-C \@synthesize definition.Cursor_ObjCSynthesizeDecl =C.CXCursor_ObjCSynthesizeDecl// An Objective-C \@dynamic definition.Cursor_ObjCDynamicDecl =C.CXCursor_ObjCDynamicDecl// An access specifier.Cursor_CXXAccessSpecifier =C.CXCursor_CXXAccessSpecifier// An access specifier.Cursor_FirstDecl =C.CXCursor_FirstDecl// An access specifier.Cursor_LastDecl =C.CXCursor_LastDecl// An access specifier.Cursor_FirstRef =C.CXCursor_FirstRef// An access specifier.Cursor_ObjCSuperClassRef =C.CXCursor_ObjCSuperClassRef// An access specifier.Cursor_ObjCProtocolRef =C.CXCursor_ObjCProtocolRef// An access specifier.Cursor_ObjCClassRef =C.CXCursor_ObjCClassRef/*A reference to a type declaration.A type reference occurs anywhere where a type is named but notdeclared. For example, given:\codetypedef unsigned size_type;size_type size;\endcodeThe typedef is a declaration of size_type (CXCursor_TypedefDecl),while the type of the variable "size" is referenced. The cursorreferenced by the type of size is the typedef for size_type.*/Cursor_TypeRef =C.CXCursor_TypeRef/*A reference to a type declaration.A type reference occurs anywhere where a type is named but notdeclared. For example, given:\codetypedef unsigned size_type;size_type size;\endcodeThe typedef is a declaration of size_type (CXCursor_TypedefDecl),while the type of the variable "size" is referenced. The cursorreferenced by the type of size is the typedef for size_type.*/Cursor_CXXBaseSpecifier =C.CXCursor_CXXBaseSpecifier// A reference to a class template, function template, template template parameter, or class template partial specialization.Cursor_TemplateRef =C.CXCursor_TemplateRef// A reference to a namespace or namespace alias.Cursor_NamespaceRef =C.CXCursor_NamespaceRef// A reference to a member of a struct, union, or class that occurs in some non-expression context, e.g., a designated initializer.Cursor_MemberRef =C.CXCursor_MemberRef/*A reference to a labeled statement.This cursor kind is used to describe the jump to "start_over" in thegoto statement in the following example:\codestart_over:++counter;goto start_over;\endcodeA label reference cursor refers to a label statement.*/Cursor_LabelRef =C.CXCursor_LabelRef/*A reference to a set of overloaded functions or function templatesthat has not yet been resolved to a specific function or function template.An overloaded declaration reference cursor occurs in C++ templates wherea dependent name refers to a function. For example:\codetemplate<typename T> void swap(T&, T&);struct X { ... };void swap(X&, X&);template<typename T>void reverse(T* first, T* last) {while (first < last - 1) {swap(*first, *--last);++first;}}struct Y { };void swap(Y&, Y&);\endcodeHere, the identifier "swap" is associated with an overloaded declarationreference. In the template definition, "swap" refers to either of the two"swap" functions declared above, so both results will be available. Atinstantiation time, "swap" may also refer to other functions found viaargument-dependent lookup (e.g., the "swap" function at the end of theexample).The functions clang_getNumOverloadedDecls() andclang_getOverloadedDecl() can be used to retrieve the definitionsreferenced by this cursor.*/Cursor_OverloadedDeclRef =C.CXCursor_OverloadedDeclRef// A reference to a variable that occurs in some non-expression context, e.g., a C++ lambda capture list.Cursor_VariableRef =C.CXCursor_VariableRef// A reference to a variable that occurs in some non-expression context, e.g., a C++ lambda capture list.Cursor_LastRef =C.CXCursor_LastRef// A reference to a variable that occurs in some non-expression context, e.g., a C++ lambda capture list.Cursor_FirstInvalid =C.CXCursor_FirstInvalid// A reference to a variable that occurs in some non-expression context, e.g., a C++ lambda capture list.Cursor_InvalidFile =C.CXCursor_InvalidFile// A reference to a variable that occurs in some non-expression context, e.g., a C++ lambda capture list.Cursor_NoDeclFound =C.CXCursor_NoDeclFound// A reference to a variable that occurs in some non-expression context, e.g., a C++ lambda capture list.Cursor_NotImplemented =C.CXCursor_NotImplemented// A reference to a variable that occurs in some non-expression context, e.g., a C++ lambda capture list.Cursor_InvalidCode =C.CXCursor_InvalidCode// A reference to a variable that occurs in some non-expression context, e.g., a C++ lambda capture list.Cursor_LastInvalid =C.CXCursor_LastInvalid// A reference to a variable that occurs in some non-expression context, e.g., a C++ lambda capture list.Cursor_FirstExpr =C.CXCursor_FirstExpr/*An expression whose specific kind is not exposed via thisinterface.Unexposed expressions have the same operations as any other kindof expression; one can extract their location information,spelling, children, etc. However, the specific kind of theexpression is not reported.*/Cursor_UnexposedExpr =C.CXCursor_UnexposedExpr// An expression that refers to some value declaration, such as a function, variable, or enumerator.Cursor_DeclRefExpr =C.CXCursor_DeclRefExpr// An expression that refers to a member of a struct, union, class, Objective-C class, etc.Cursor_MemberRefExpr =C.CXCursor_MemberRefExpr// An expression that calls a function.Cursor_CallExpr =C.CXCursor_CallExpr// An expression that sends a message to an Objective-C  object or class.Cursor_ObjCMessageExpr =C.CXCursor_ObjCMessageExpr// An expression that represents a block literal.Cursor_BlockExpr =C.CXCursor_BlockExpr// An integer literal.Cursor_IntegerLiteral =C.CXCursor_IntegerLiteral// A floating point number literal.Cursor_FloatingLiteral =C.CXCursor_FloatingLiteral// An imaginary number literal.Cursor_ImaginaryLiteral =C.CXCursor_ImaginaryLiteral// A string literal.Cursor_StringLiteral =C.CXCursor_StringLiteral// A character literal.Cursor_CharacterLiteral =C.CXCursor_CharacterLiteral/*A parenthesized expression, e.g. "(1)".This AST node is only formed if full location information is requested.*/Cursor_ParenExpr =C.CXCursor_ParenExpr// This represents the unary-expression's (except sizeof and alignof).Cursor_UnaryOperator =C.CXCursor_UnaryOperator// [C99 6.5.2.1] Array Subscripting.Cursor_ArraySubscriptExpr =C.CXCursor_ArraySubscriptExpr// A builtin binary operation expression such as "x + y" or "x <= y".Cursor_BinaryOperator =C.CXCursor_BinaryOperator// Compound assignment such as "+=".Cursor_CompoundAssignOperator =C.CXCursor_CompoundAssignOperator// The ?: ternary operator.Cursor_ConditionalOperator =C.CXCursor_ConditionalOperator/*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.For example: (int)f.*/Cursor_CStyleCastExpr =C.CXCursor_CStyleCastExpr// [C99 6.5.2.5]Cursor_CompoundLiteralExpr =C.CXCursor_CompoundLiteralExpr// Describes an C or C++ initializer list.Cursor_InitListExpr =C.CXCursor_InitListExpr// The GNU address of label extension, representing &&label.Cursor_AddrLabelExpr =C.CXCursor_AddrLabelExpr// This is the GNU Statement Expression extension: ({int X=4; X;})Cursor_StmtExpr =C.CXCursor_StmtExpr// Represents a C11 generic selection.Cursor_GenericSelectionExpr =C.CXCursor_GenericSelectionExpr/*Implements the GNU __null extension, which is a name for a nullpointer constant that has integral type (e.g., int or long) and is the samesize and alignment as a pointer.The __null extension is typically only used by system headers, which defineNULL as __null in C++ rather than using 0 (which is an integer that may notmatch the size of a pointer).*/Cursor_GNUNullExpr =C.CXCursor_GNUNullExpr// C++'s static_cast<> expression.Cursor_CXXStaticCastExpr =C.CXCursor_CXXStaticCastExpr// C++'s dynamic_cast<> expression.Cursor_CXXDynamicCastExpr =C.CXCursor_CXXDynamicCastExpr// C++'s reinterpret_cast<> expression.Cursor_CXXReinterpretCastExpr =C.CXCursor_CXXReinterpretCastExpr// C++'s const_cast<> expression.Cursor_CXXConstCastExpr =C.CXCursor_CXXConstCastExpr/*Represents an explicit C++ type conversion that uses "functional"notion (C++ [expr.type.conv]).Example:\codex = int(0.5);\endcode*/Cursor_CXXFunctionalCastExpr =C.CXCursor_CXXFunctionalCastExpr// A C++ typeid expression (C++ [expr.typeid]).Cursor_CXXTypeidExpr =C.CXCursor_CXXTypeidExpr// [C++ 2.13.5] C++ Boolean Literal.Cursor_CXXBoolLiteralExpr =C.CXCursor_CXXBoolLiteralExpr// [C++0x 2.14.7] C++ Pointer Literal.Cursor_CXXNullPtrLiteralExpr =C.CXCursor_CXXNullPtrLiteralExpr// Represents the "this" expression in C++Cursor_CXXThisExpr =C.CXCursor_CXXThisExpr/*[C++ 15] C++ Throw Expression.This handles 'throw' and 'throw' assignment-expression. Whenassignment-expression isn't present, Op will be null.*/Cursor_CXXThrowExpr =C.CXCursor_CXXThrowExpr// A new expression for memory allocation and constructor calls, e.g: "new CXXNewExpr(foo)".Cursor_CXXNewExpr =C.CXCursor_CXXNewExpr// A delete expression for memory deallocation and destructor calls, e.g. "delete[] pArray".Cursor_CXXDeleteExpr =C.CXCursor_CXXDeleteExpr// A unary expression. (noexcept, sizeof, or other traits)Cursor_UnaryExpr =C.CXCursor_UnaryExpr// An Objective-C string literal i.e. @"foo".Cursor_ObjCStringLiteral =C.CXCursor_ObjCStringLiteral// An Objective-C \@encode expression.Cursor_ObjCEncodeExpr =C.CXCursor_ObjCEncodeExpr// An Objective-C \@selector expression.Cursor_ObjCSelectorExpr =C.CXCursor_ObjCSelectorExpr// An Objective-C \@protocol expression.Cursor_ObjCProtocolExpr =C.CXCursor_ObjCProtocolExpr/*An Objective-C "bridged" cast expression, which casts betweenObjective-C pointers and C pointers, transferring ownership in the process.\codeNSString *str = (__bridge_transfer NSString *)CFCreateString();\endcode*/Cursor_ObjCBridgedCastExpr =C.CXCursor_ObjCBridgedCastExpr/*Represents a C++0x pack expansion that produces a sequence ofexpressions.A pack expansion expression contains a pattern (which itself is anexpression) followed by an ellipsis. For example:\codetemplate<typename F, typename ...Types>void forward(F f, Types &&...args) {f(static_cast<Types&&>(args)...);}\endcode*/Cursor_PackExpansionExpr =C.CXCursor_PackExpansionExpr/*Represents an expression that computes the length of a parameterpack.\codetemplate<typename ...Types>struct count {static const unsigned value = sizeof...(Types);};\endcode*/Cursor_SizeOfPackExpr =C.CXCursor_SizeOfPackExprCursor_LambdaExpr     =C.CXCursor_LambdaExpr// Objective-c Boolean Literal.Cursor_ObjCBoolLiteralExpr =C.CXCursor_ObjCBoolLiteralExpr// Represents the "self" expression in an Objective-C method.Cursor_ObjCSelfExpr =C.CXCursor_ObjCSelfExpr// OpenMP 5.0 [2.1.5, Array Section].Cursor_OMPArraySectionExpr =C.CXCursor_OMPArraySectionExpr// Represents an @available(...) check.Cursor_ObjCAvailabilityCheckExpr =C.CXCursor_ObjCAvailabilityCheckExpr// Fixed point literalCursor_FixedPointLiteral =C.CXCursor_FixedPointLiteral// OpenMP 5.0 [2.1.4, Array Shaping].Cursor_OMPArrayShapingExpr =C.CXCursor_OMPArrayShapingExpr// OpenMP 5.0 [2.1.6 Iterators]Cursor_OMPIteratorExpr =C.CXCursor_OMPIteratorExpr// OpenCL's addrspace_cast<> expression.Cursor_CXXAddrspaceCastExpr =C.CXCursor_CXXAddrspaceCastExpr// OpenCL's addrspace_cast<> expression.Cursor_LastExpr =C.CXCursor_LastExpr// OpenCL's addrspace_cast<> expression.Cursor_FirstStmt =C.CXCursor_FirstStmt/*A statement whose specific kind is not exposed via thisinterface.Unexposed statements have the same operations as any other kind ofstatement; one can extract their location information, spelling,children, etc. However, the specific kind of the statement is notreported.*/Cursor_UnexposedStmt =C.CXCursor_UnexposedStmt/*A labelled statement in a function.This cursor kind is used to describe the "start_over:" label statement inthe following example:\codestart_over:++counter;\endcode*/Cursor_LabelStmt =C.CXCursor_LabelStmt/*A group of statements like { stmt stmt }.This cursor kind is used to describe compound statements, e.g. functionbodies.*/Cursor_CompoundStmt =C.CXCursor_CompoundStmt// A case statement.Cursor_CaseStmt =C.CXCursor_CaseStmt// A default statement.Cursor_DefaultStmt =C.CXCursor_DefaultStmt// An if statementCursor_IfStmt =C.CXCursor_IfStmt// A switch statement.Cursor_SwitchStmt =C.CXCursor_SwitchStmt// A while statement.Cursor_WhileStmt =C.CXCursor_WhileStmt// A do statement.Cursor_DoStmt =C.CXCursor_DoStmt// A for statement.Cursor_ForStmt =C.CXCursor_ForStmt// A goto statement.Cursor_GotoStmt =C.CXCursor_GotoStmt// An indirect goto statement.Cursor_IndirectGotoStmt =C.CXCursor_IndirectGotoStmt// A continue statement.Cursor_ContinueStmt =C.CXCursor_ContinueStmt// A break statement.Cursor_BreakStmt =C.CXCursor_BreakStmt// A return statement.Cursor_ReturnStmt =C.CXCursor_ReturnStmt// A GCC inline assembly statement extension.Cursor_GCCAsmStmt =C.CXCursor_GCCAsmStmt// A GCC inline assembly statement extension.Cursor_AsmStmt =C.CXCursor_AsmStmt// Objective-C's overall \@try-\@catch-\@finally statement.Cursor_ObjCAtTryStmt =C.CXCursor_ObjCAtTryStmt// Objective-C's \@catch statement.Cursor_ObjCAtCatchStmt =C.CXCursor_ObjCAtCatchStmt// Objective-C's \@finally statement.Cursor_ObjCAtFinallyStmt =C.CXCursor_ObjCAtFinallyStmt// Objective-C's \@throw statement.Cursor_ObjCAtThrowStmt =C.CXCursor_ObjCAtThrowStmt// Objective-C's \@synchronized statement.Cursor_ObjCAtSynchronizedStmt =C.CXCursor_ObjCAtSynchronizedStmt// Objective-C's autorelease pool statement.Cursor_ObjCAutoreleasePoolStmt =C.CXCursor_ObjCAutoreleasePoolStmt// Objective-C's collection statement.Cursor_ObjCForCollectionStmt =C.CXCursor_ObjCForCollectionStmt// C++'s catch statement.Cursor_CXXCatchStmt =C.CXCursor_CXXCatchStmt// C++'s try statement.Cursor_CXXTryStmt =C.CXCursor_CXXTryStmt// C++'s for (* : *) statement.Cursor_CXXForRangeStmt =C.CXCursor_CXXForRangeStmt// Windows Structured Exception Handling's try statement.Cursor_SEHTryStmt =C.CXCursor_SEHTryStmt// Windows Structured Exception Handling's except statement.Cursor_SEHExceptStmt =C.CXCursor_SEHExceptStmt// Windows Structured Exception Handling's finally statement.Cursor_SEHFinallyStmt =C.CXCursor_SEHFinallyStmt// A MS inline assembly statement extension.Cursor_MSAsmStmt =C.CXCursor_MSAsmStmt/*The null statement ";": C99 6.8.3p3.This cursor kind is used to describe the null statement.*/Cursor_NullStmt =C.CXCursor_NullStmt// Adaptor class for mixing declarations with statements and expressions.Cursor_DeclStmt =C.CXCursor_DeclStmt// OpenMP parallel directive.Cursor_OMPParallelDirective =C.CXCursor_OMPParallelDirective// OpenMP SIMD directive.Cursor_OMPSimdDirective =C.CXCursor_OMPSimdDirective// OpenMP for directive.Cursor_OMPForDirective =C.CXCursor_OMPForDirective// OpenMP sections directive.Cursor_OMPSectionsDirective =C.CXCursor_OMPSectionsDirective// OpenMP section directive.Cursor_OMPSectionDirective =C.CXCursor_OMPSectionDirective// OpenMP single directive.Cursor_OMPSingleDirective =C.CXCursor_OMPSingleDirective// OpenMP parallel for directive.Cursor_OMPParallelForDirective =C.CXCursor_OMPParallelForDirective// OpenMP parallel sections directive.Cursor_OMPParallelSectionsDirective =C.CXCursor_OMPParallelSectionsDirective// OpenMP task directive.Cursor_OMPTaskDirective =C.CXCursor_OMPTaskDirective// OpenMP master directive.Cursor_OMPMasterDirective =C.CXCursor_OMPMasterDirective// OpenMP critical directive.Cursor_OMPCriticalDirective =C.CXCursor_OMPCriticalDirective// OpenMP taskyield directive.Cursor_OMPTaskyieldDirective =C.CXCursor_OMPTaskyieldDirective// OpenMP barrier directive.Cursor_OMPBarrierDirective =C.CXCursor_OMPBarrierDirective// OpenMP taskwait directive.Cursor_OMPTaskwaitDirective =C.CXCursor_OMPTaskwaitDirective// OpenMP flush directive.Cursor_OMPFlushDirective =C.CXCursor_OMPFlushDirective// Windows Structured Exception Handling's leave statement.Cursor_SEHLeaveStmt =C.CXCursor_SEHLeaveStmt// OpenMP ordered directive.Cursor_OMPOrderedDirective =C.CXCursor_OMPOrderedDirective// OpenMP atomic directive.Cursor_OMPAtomicDirective =C.CXCursor_OMPAtomicDirective// OpenMP for SIMD directive.Cursor_OMPForSimdDirective =C.CXCursor_OMPForSimdDirective// OpenMP parallel for SIMD directive.Cursor_OMPParallelForSimdDirective =C.CXCursor_OMPParallelForSimdDirective// OpenMP target directive.Cursor_OMPTargetDirective =C.CXCursor_OMPTargetDirective// OpenMP teams directive.Cursor_OMPTeamsDirective =C.CXCursor_OMPTeamsDirective// OpenMP taskgroup directive.Cursor_OMPTaskgroupDirective =C.CXCursor_OMPTaskgroupDirective// OpenMP cancellation point directive.Cursor_OMPCancellationPointDirective =C.CXCursor_OMPCancellationPointDirective// OpenMP cancel directive.Cursor_OMPCancelDirective =C.CXCursor_OMPCancelDirective// OpenMP target data directive.Cursor_OMPTargetDataDirective =C.CXCursor_OMPTargetDataDirective// OpenMP taskloop directive.Cursor_OMPTaskLoopDirective =C.CXCursor_OMPTaskLoopDirective// OpenMP taskloop simd directive.Cursor_OMPTaskLoopSimdDirective =C.CXCursor_OMPTaskLoopSimdDirective// OpenMP distribute directive.Cursor_OMPDistributeDirective =C.CXCursor_OMPDistributeDirective// OpenMP target enter data directive.Cursor_OMPTargetEnterDataDirective =C.CXCursor_OMPTargetEnterDataDirective// OpenMP target exit data directive.Cursor_OMPTargetExitDataDirective =C.CXCursor_OMPTargetExitDataDirective// OpenMP target parallel directive.Cursor_OMPTargetParallelDirective =C.CXCursor_OMPTargetParallelDirective// OpenMP target parallel for directive.Cursor_OMPTargetParallelForDirective =C.CXCursor_OMPTargetParallelForDirective// OpenMP target update directive.Cursor_OMPTargetUpdateDirective =C.CXCursor_OMPTargetUpdateDirective// OpenMP distribute parallel for directive.Cursor_OMPDistributeParallelForDirective =C.CXCursor_OMPDistributeParallelForDirective// OpenMP distribute parallel for simd directive.Cursor_OMPDistributeParallelForSimdDirective =C.CXCursor_OMPDistributeParallelForSimdDirective// OpenMP distribute simd directive.Cursor_OMPDistributeSimdDirective =C.CXCursor_OMPDistributeSimdDirective// OpenMP target parallel for simd directive.Cursor_OMPTargetParallelForSimdDirective =C.CXCursor_OMPTargetParallelForSimdDirective// OpenMP target simd directive.Cursor_OMPTargetSimdDirective =C.CXCursor_OMPTargetSimdDirective// OpenMP teams distribute directive.Cursor_OMPTeamsDistributeDirective =C.CXCursor_OMPTeamsDistributeDirective// OpenMP teams distribute simd directive.Cursor_OMPTeamsDistributeSimdDirective =C.CXCursor_OMPTeamsDistributeSimdDirective// OpenMP teams distribute parallel for simd directive.Cursor_OMPTeamsDistributeParallelForSimdDirective =C.CXCursor_OMPTeamsDistributeParallelForSimdDirective// OpenMP teams distribute parallel for directive.Cursor_OMPTeamsDistributeParallelForDirective =C.CXCursor_OMPTeamsDistributeParallelForDirective// OpenMP target teams directive.Cursor_OMPTargetTeamsDirective =C.CXCursor_OMPTargetTeamsDirective// OpenMP target teams distribute directive.Cursor_OMPTargetTeamsDistributeDirective =C.CXCursor_OMPTargetTeamsDistributeDirective// OpenMP target teams distribute parallel for directive.Cursor_OMPTargetTeamsDistributeParallelForDirective =C.CXCursor_OMPTargetTeamsDistributeParallelForDirective// OpenMP target teams distribute parallel for simd directive.Cursor_OMPTargetTeamsDistributeParallelForSimdDirective =C.CXCursor_OMPTargetTeamsDistributeParallelForSimdDirective// OpenMP target teams distribute simd directive.Cursor_OMPTargetTeamsDistributeSimdDirective =C.CXCursor_OMPTargetTeamsDistributeSimdDirective// C++2a std::bit_cast expression.Cursor_BuiltinBitCastExpr =C.CXCursor_BuiltinBitCastExpr// OpenMP master taskloop directive.Cursor_OMPMasterTaskLoopDirective =C.CXCursor_OMPMasterTaskLoopDirective// OpenMP parallel master taskloop directive.Cursor_OMPParallelMasterTaskLoopDirective =C.CXCursor_OMPParallelMasterTaskLoopDirective// OpenMP master taskloop simd directive.Cursor_OMPMasterTaskLoopSimdDirective =C.CXCursor_OMPMasterTaskLoopSimdDirective// OpenMP parallel master taskloop simd directive.Cursor_OMPParallelMasterTaskLoopSimdDirective =C.CXCursor_OMPParallelMasterTaskLoopSimdDirective// OpenMP parallel master directive.Cursor_OMPParallelMasterDirective =C.CXCursor_OMPParallelMasterDirective// OpenMP depobj directive.Cursor_OMPDepobjDirective =C.CXCursor_OMPDepobjDirective// OpenMP scan directive.Cursor_OMPScanDirective =C.CXCursor_OMPScanDirective// OpenMP scan directive.Cursor_LastStmt =C.CXCursor_LastStmt/*Cursor that represents the translation unit itself.The translation unit cursor exists primarily to act as the rootcursor for traversing the contents of a translation unit.*/Cursor_TranslationUnit =C.CXCursor_TranslationUnit/*Cursor that represents the translation unit itself.The translation unit cursor exists primarily to act as the rootcursor for traversing the contents of a translation unit.*/Cursor_FirstAttr =C.CXCursor_FirstAttr// An attribute whose specific kind is not exposed via this interface.Cursor_UnexposedAttr =C.CXCursor_UnexposedAttr// An attribute whose specific kind is not exposed via this interface.Cursor_IBActionAttr =C.CXCursor_IBActionAttr// An attribute whose specific kind is not exposed via this interface.Cursor_IBOutletAttr =C.CXCursor_IBOutletAttr// An attribute whose specific kind is not exposed via this interface.Cursor_IBOutletCollectionAttr =C.CXCursor_IBOutletCollectionAttr// An attribute whose specific kind is not exposed via this interface.Cursor_CXXFinalAttr =C.CXCursor_CXXFinalAttr// An attribute whose specific kind is not exposed via this interface.Cursor_CXXOverrideAttr =C.CXCursor_CXXOverrideAttr// An attribute whose specific kind is not exposed via this interface.Cursor_AnnotateAttr =C.CXCursor_AnnotateAttr// An attribute whose specific kind is not exposed via this interface.Cursor_AsmLabelAttr =C.CXCursor_AsmLabelAttr// An attribute whose specific kind is not exposed via this interface.Cursor_PackedAttr =C.CXCursor_PackedAttr// An attribute whose specific kind is not exposed via this interface.Cursor_PureAttr =C.CXCursor_PureAttr// An attribute whose specific kind is not exposed via this interface.Cursor_ConstAttr =C.CXCursor_ConstAttr// An attribute whose specific kind is not exposed via this interface.Cursor_NoDuplicateAttr =C.CXCursor_NoDuplicateAttr// An attribute whose specific kind is not exposed via this interface.Cursor_CUDAConstantAttr =C.CXCursor_CUDAConstantAttr// An attribute whose specific kind is not exposed via this interface.Cursor_CUDADeviceAttr =C.CXCursor_CUDADeviceAttr// An attribute whose specific kind is not exposed via this interface.Cursor_CUDAGlobalAttr =C.CXCursor_CUDAGlobalAttr// An attribute whose specific kind is not exposed via this interface.Cursor_CUDAHostAttr =C.CXCursor_CUDAHostAttr// An attribute whose specific kind is not exposed via this interface.Cursor_CUDASharedAttr =C.CXCursor_CUDASharedAttr// An attribute whose specific kind is not exposed via this interface.Cursor_VisibilityAttr =C.CXCursor_VisibilityAttr// An attribute whose specific kind is not exposed via this interface.Cursor_DLLExport =C.CXCursor_DLLExport// An attribute whose specific kind is not exposed via this interface.Cursor_DLLImport =C.CXCursor_DLLImport// An attribute whose specific kind is not exposed via this interface.Cursor_NSReturnsRetained =C.CXCursor_NSReturnsRetained// An attribute whose specific kind is not exposed via this interface.Cursor_NSReturnsNotRetained =C.CXCursor_NSReturnsNotRetained// An attribute whose specific kind is not exposed via this interface.Cursor_NSReturnsAutoreleased =C.CXCursor_NSReturnsAutoreleased// An attribute whose specific kind is not exposed via this interface.Cursor_NSConsumesSelf =C.CXCursor_NSConsumesSelf// An attribute whose specific kind is not exposed via this interface.Cursor_NSConsumed =C.CXCursor_NSConsumed// An attribute whose specific kind is not exposed via this interface.Cursor_ObjCException =C.CXCursor_ObjCException// An attribute whose specific kind is not exposed via this interface.Cursor_ObjCNSObject =C.CXCursor_ObjCNSObject// An attribute whose specific kind is not exposed via this interface.Cursor_ObjCIndependentClass =C.CXCursor_ObjCIndependentClass// An attribute whose specific kind is not exposed via this interface.Cursor_ObjCPreciseLifetime =C.CXCursor_ObjCPreciseLifetime// An attribute whose specific kind is not exposed via this interface.Cursor_ObjCReturnsInnerPointer =C.CXCursor_ObjCReturnsInnerPointer// An attribute whose specific kind is not exposed via this interface.Cursor_ObjCRequiresSuper =C.CXCursor_ObjCRequiresSuper// An attribute whose specific kind is not exposed via this interface.Cursor_ObjCRootClass =C.CXCursor_ObjCRootClass// An attribute whose specific kind is not exposed via this interface.Cursor_ObjCSubclassingRestricted =C.CXCursor_ObjCSubclassingRestricted// An attribute whose specific kind is not exposed via this interface.Cursor_ObjCExplicitProtocolImpl =C.CXCursor_ObjCExplicitProtocolImpl// An attribute whose specific kind is not exposed via this interface.Cursor_ObjCDesignatedInitializer =C.CXCursor_ObjCDesignatedInitializer// An attribute whose specific kind is not exposed via this interface.Cursor_ObjCRuntimeVisible =C.CXCursor_ObjCRuntimeVisible// An attribute whose specific kind is not exposed via this interface.Cursor_ObjCBoxable =C.CXCursor_ObjCBoxable// An attribute whose specific kind is not exposed via this interface.Cursor_FlagEnum =C.CXCursor_FlagEnum// An attribute whose specific kind is not exposed via this interface.Cursor_ConvergentAttr =C.CXCursor_ConvergentAttr// An attribute whose specific kind is not exposed via this interface.Cursor_WarnUnusedAttr =C.CXCursor_WarnUnusedAttr// An attribute whose specific kind is not exposed via this interface.Cursor_WarnUnusedResultAttr =C.CXCursor_WarnUnusedResultAttr// An attribute whose specific kind is not exposed via this interface.Cursor_AlignedAttr =C.CXCursor_AlignedAttr// An attribute whose specific kind is not exposed via this interface.Cursor_LastAttr =C.CXCursor_LastAttr// An attribute whose specific kind is not exposed via this interface.Cursor_PreprocessingDirective =C.CXCursor_PreprocessingDirective// An attribute whose specific kind is not exposed via this interface.Cursor_MacroDefinition =C.CXCursor_MacroDefinition// An attribute whose specific kind is not exposed via this interface.Cursor_MacroExpansion =C.CXCursor_MacroExpansion// An attribute whose specific kind is not exposed via this interface.Cursor_MacroInstantiation =C.CXCursor_MacroInstantiation// An attribute whose specific kind is not exposed via this interface.Cursor_InclusionDirective =C.CXCursor_InclusionDirective// An attribute whose specific kind is not exposed via this interface.Cursor_FirstPreprocessing =C.CXCursor_FirstPreprocessing// An attribute whose specific kind is not exposed via this interface.Cursor_LastPreprocessing =C.CXCursor_LastPreprocessing// A module import declaration.Cursor_ModuleImportDecl =C.CXCursor_ModuleImportDecl// A module import declaration.Cursor_TypeAliasTemplateDecl =C.CXCursor_TypeAliasTemplateDecl// A static_assert or _Static_assert nodeCursor_StaticAssert =C.CXCursor_StaticAssert// a friend declaration.Cursor_FriendDecl =C.CXCursor_FriendDecl// a friend declaration.Cursor_FirstExtraDecl =C.CXCursor_FirstExtraDecl// a friend declaration.Cursor_LastExtraDecl =C.CXCursor_LastExtraDecl// A code completion overload candidate.Cursor_OverloadCandidate =C.CXCursor_OverloadCandidate)

const (DeclQualifier_NoneDeclQualifierKind =C.CXObjCDeclQualifier_NoneDeclQualifier_In                       =C.CXObjCDeclQualifier_InDeclQualifier_Inout                    =C.CXObjCDeclQualifier_InoutDeclQualifier_Out                      =C.CXObjCDeclQualifier_OutDeclQualifier_Bycopy                   =C.CXObjCDeclQualifier_BycopyDeclQualifier_Byref                    =C.CXObjCDeclQualifier_ByrefDeclQualifier_Oneway                   =C.CXObjCDeclQualifier_Oneway)

const (/*Display the source-location information where thediagnostic was located.When set, diagnostics will be prefixed by the file, line, and(optionally) column to which the diagnostic refers. For example,\codetest.c:28: warning: extra tokens at end of #endif directive\endcodeThis option corresponds to the clang flag -fshow-source-location.*/Diagnostic_DisplaySourceLocationDiagnosticDisplayOptions =C.CXDiagnostic_DisplaySourceLocation/*If displaying the source-location information of thediagnostic, also include the column number.This option corresponds to the clang flag -fshow-column.*/Diagnostic_DisplayColumn =C.CXDiagnostic_DisplayColumn/*If displaying the source-location information of thediagnostic, also include information about source ranges in amachine-parsable format.This option corresponds to the clang flag-fdiagnostics-print-source-range-info.*/Diagnostic_DisplaySourceRanges =C.CXDiagnostic_DisplaySourceRanges/*Display the option name associated with this diagnostic, if any.The option name displayed (e.g., -Wconversion) will be placed in bracketsafter the diagnostic text. This option corresponds to the clang flag-fdiagnostics-show-option.*/Diagnostic_DisplayOption =C.CXDiagnostic_DisplayOption/*Display the category number associated with this diagnostic, if any.The category number is displayed within brackets after the diagnostic text.This option corresponds to the clang flag-fdiagnostics-show-category=id.*/Diagnostic_DisplayCategoryId =C.CXDiagnostic_DisplayCategoryId/*Display the category name associated with this diagnostic, if any.The category name is displayed within brackets after the diagnostic text.This option corresponds to the clang flag-fdiagnostics-show-category=name.*/Diagnostic_DisplayCategoryName =C.CXDiagnostic_DisplayCategoryName)

const (// A diagnostic that has been suppressed, e.g., by a command-line option.Diagnostic_IgnoredDiagnosticSeverity =C.CXDiagnostic_Ignored// This diagnostic is a note that should be attached to the previous (non-note) diagnostic.Diagnostic_Note =C.CXDiagnostic_Note// This diagnostic indicates suspicious code that may not be wrong.Diagnostic_Warning =C.CXDiagnostic_Warning// This diagnostic indicates that the code is ill-formed.Diagnostic_Error =C.CXDiagnostic_Error// This diagnostic indicates that the code is ill-formed such that future parser recovery is unlikely to produce useful results.Diagnostic_Fatal =C.CXDiagnostic_Fatal)

const (// No error.Error_SuccessErrorCode =C.CXError_Success/*A generic error code, no further details are available.Errors of this kind can get their own specific error codes in futurelibclang versions.*/Error_Failure =C.CXError_Failure// libclang crashed while performing the requested operation.Error_Crashed =C.CXError_Crashed// The function detected that the arguments violate the function contract.Error_InvalidArguments =C.CXError_InvalidArguments// An AST deserialization error has occurred.Error_ASTReadError =C.CXError_ASTReadError)

const (Eval_IntEvalResultKind =C.CXEval_IntEval_Float                         =C.CXEval_FloatEval_ObjCStrLiteral                =C.CXEval_ObjCStrLiteralEval_StrLiteral                    =C.CXEval_StrLiteralEval_CFStr                         =C.CXEval_CFStrEval_Other                         =C.CXEval_OtherEval_UnExposed                     =C.CXEval_UnExposed)

const (// Used to indicate that no special CXIndex options are needed.GlobalOpt_NoneGlobalOptFlags =C.CXGlobalOpt_None/*Used to indicate that threads that libclang creates for indexingpurposes should use background priority.Affects #clang_indexSourceFile, #clang_indexTranslationUnit,#clang_parseTranslationUnit, #clang_saveTranslationUnit.*/GlobalOpt_ThreadBackgroundPriorityForIndexing =C.CXGlobalOpt_ThreadBackgroundPriorityForIndexing/*Used to indicate that threads that libclang creates for editingpurposes should use background priority.Affects #clang_reparseTranslationUnit, #clang_codeCompleteAt,#clang_annotateTokens*/GlobalOpt_ThreadBackgroundPriorityForEditing =C.CXGlobalOpt_ThreadBackgroundPriorityForEditing// Used to indicate that all threads that libclang creates should use background priority.GlobalOpt_ThreadBackgroundPriorityForAll =C.CXGlobalOpt_ThreadBackgroundPriorityForAll)

const (IdxAttr_UnexposedIdxAttrKind =C.CXIdxAttr_UnexposedIdxAttr_IBAction                       =C.CXIdxAttr_IBActionIdxAttr_IBOutlet                       =C.CXIdxAttr_IBOutletIdxAttr_IBOutletCollection             =C.CXIdxAttr_IBOutletCollection)

const (IdxEntity_NonTemplateIdxEntityCXXTemplateKind =C.CXIdxEntity_NonTemplateIdxEntity_Template                                               =C.CXIdxEntity_TemplateIdxEntity_TemplatePartialSpecialization                          =C.CXIdxEntity_TemplatePartialSpecializationIdxEntity_TemplateSpecialization                                 =C.CXIdxEntity_TemplateSpecialization)

const (IdxEntity_UnexposedIdxEntityKind =C.CXIdxEntity_UnexposedIdxEntity_Typedef                             =C.CXIdxEntity_TypedefIdxEntity_Function                            =C.CXIdxEntity_FunctionIdxEntity_Variable                            =C.CXIdxEntity_VariableIdxEntity_Field                               =C.CXIdxEntity_FieldIdxEntity_EnumConstant                        =C.CXIdxEntity_EnumConstantIdxEntity_ObjCClass                           =C.CXIdxEntity_ObjCClassIdxEntity_ObjCProtocol                        =C.CXIdxEntity_ObjCProtocolIdxEntity_ObjCCategory                        =C.CXIdxEntity_ObjCCategoryIdxEntity_ObjCInstanceMethod                  =C.CXIdxEntity_ObjCInstanceMethodIdxEntity_ObjCClassMethod                     =C.CXIdxEntity_ObjCClassMethodIdxEntity_ObjCProperty                        =C.CXIdxEntity_ObjCPropertyIdxEntity_ObjCIvar                            =C.CXIdxEntity_ObjCIvarIdxEntity_Enum                                =C.CXIdxEntity_EnumIdxEntity_Struct                              =C.CXIdxEntity_StructIdxEntity_Union                               =C.CXIdxEntity_UnionIdxEntity_CXXClass                            =C.CXIdxEntity_CXXClassIdxEntity_CXXNamespace                        =C.CXIdxEntity_CXXNamespaceIdxEntity_CXXNamespaceAlias                   =C.CXIdxEntity_CXXNamespaceAliasIdxEntity_CXXStaticVariable                   =C.CXIdxEntity_CXXStaticVariableIdxEntity_CXXStaticMethod                     =C.CXIdxEntity_CXXStaticMethodIdxEntity_CXXInstanceMethod                   =C.CXIdxEntity_CXXInstanceMethodIdxEntity_CXXConstructor                      =C.CXIdxEntity_CXXConstructorIdxEntity_CXXDestructor                       =C.CXIdxEntity_CXXDestructorIdxEntity_CXXConversionFunction               =C.CXIdxEntity_CXXConversionFunctionIdxEntity_CXXTypeAlias                        =C.CXIdxEntity_CXXTypeAliasIdxEntity_CXXInterface                        =C.CXIdxEntity_CXXInterface)

const (IdxEntityLang_NoneIdxEntityLanguage =C.CXIdxEntityLang_NoneIdxEntityLang_C                       =C.CXIdxEntityLang_CIdxEntityLang_ObjC                    =C.CXIdxEntityLang_ObjCIdxEntityLang_CXX                     =C.CXIdxEntityLang_CXXIdxEntityLang_Swift                   =C.CXIdxEntityLang_Swift)

const (IdxObjCContainer_ForwardRefIdxObjCContainerKind =C.CXIdxObjCContainer_ForwardRefIdxObjCContainer_Interface                           =C.CXIdxObjCContainer_InterfaceIdxObjCContainer_Implementation                      =C.CXIdxObjCContainer_Implementation)

const (// Used to indicate that no special indexing options are needed.IndexOpt_NoneIndexOptFlags =C.CXIndexOpt_None// Used to indicate that IndexerCallbacks#indexEntityReference should be invoked for only one reference of an entity per source file that does not also include a declaration/definition of the entity.IndexOpt_SuppressRedundantRefs =C.CXIndexOpt_SuppressRedundantRefs// Function-local symbols should be indexed. If this is not set function-local symbols will be ignored.IndexOpt_IndexFunctionLocalSymbols =C.CXIndexOpt_IndexFunctionLocalSymbols// Implicit function/class template instantiations should be indexed. If this is not set, implicit instantiations will be ignored.IndexOpt_IndexImplicitTemplateInstantiations =C.CXIndexOpt_IndexImplicitTemplateInstantiations// Suppress all compiler warnings when parsing for indexing.IndexOpt_SuppressWarnings =C.CXIndexOpt_SuppressWarnings// Skip a function/method body that was already parsed during an indexing session associated with a CXIndexAction object. Bodies in system headers are always skipped.IndexOpt_SkipParsedBodiesInSession =C.CXIndexOpt_SkipParsedBodiesInSession)

const (Language_InvalidLanguageKind =C.CXLanguage_InvalidLanguage_C                      =C.CXLanguage_CLanguage_ObjC                   =C.CXLanguage_ObjCLanguage_CPlusPlus              =C.CXLanguage_CPlusPlus)

const (// This value indicates that no linkage information is available for a provided CXCursor.Linkage_InvalidLinkageKind =C.CXLinkage_Invalid// This is the linkage for variables, parameters, and so on that have automatic storage. This covers normal (non-extern) local variables.Linkage_NoLinkage =C.CXLinkage_NoLinkage// This is the linkage for static variables and static functions.Linkage_Internal =C.CXLinkage_Internal// This is the linkage for entities with external linkage that live in C++ anonymous namespaces.Linkage_UniqueExternal =C.CXLinkage_UniqueExternal// This is the linkage for entities with true, external linkage.Linkage_External =C.CXLinkage_External)

const (// Indicates that no error occurred.LoadDiag_NoneLoadDiag_Error =C.CXLoadDiag_None// Indicates that an unknown error occurred while attempting to deserialize diagnostics.LoadDiag_Unknown =C.CXLoadDiag_Unknown// Indicates that the file containing the serialized diagnostics could not be opened.LoadDiag_CannotLoad =C.CXLoadDiag_CannotLoad// Indicates that the serialized diagnostics file is invalid or corrupt.LoadDiag_InvalidFile =C.CXLoadDiag_InvalidFile)

const (// Include the nested-name-specifier, e.g. Foo:: in x.Foo::y, in the range.NameRange_WantQualifierNameRefFlags =C.CXNameRange_WantQualifier// Include the explicit template arguments, e.g. \<int> in x.f<int>, in the range.NameRange_WantTemplateArgs =C.CXNameRange_WantTemplateArgs/*If the name is non-contiguous, return the full spanning range.Non-contiguous names occur in Objective-C when a selector with two or moreparameters is used, or in C++ when using an operator:\code[object doSomething:here withValue:there]; // Objective-Creturn some_vector[1]; // C++\endcode*/NameRange_WantSinglePiece =C.CXNameRange_WantSinglePiece)

const (PrintingPolicy_IndentationPrintingPolicyProperty =C.CXPrintingPolicy_IndentationPrintingPolicy_SuppressSpecifiers                                           =C.CXPrintingPolicy_SuppressSpecifiersPrintingPolicy_SuppressTagKeyword                                           =C.CXPrintingPolicy_SuppressTagKeywordPrintingPolicy_IncludeTagDefinition                                         =C.CXPrintingPolicy_IncludeTagDefinitionPrintingPolicy_SuppressScope                                                =C.CXPrintingPolicy_SuppressScopePrintingPolicy_SuppressUnwrittenScope                                       =C.CXPrintingPolicy_SuppressUnwrittenScopePrintingPolicy_SuppressInitializers                                         =C.CXPrintingPolicy_SuppressInitializersPrintingPolicy_ConstantArraySizeAsWritten                                   =C.CXPrintingPolicy_ConstantArraySizeAsWrittenPrintingPolicy_AnonymousTagLocations                                        =C.CXPrintingPolicy_AnonymousTagLocationsPrintingPolicy_SuppressStrongLifetime                                       =C.CXPrintingPolicy_SuppressStrongLifetimePrintingPolicy_SuppressLifetimeQualifiers                                   =C.CXPrintingPolicy_SuppressLifetimeQualifiersPrintingPolicy_SuppressTemplateArgsInCXXConstructors                        =C.CXPrintingPolicy_SuppressTemplateArgsInCXXConstructorsPrintingPolicy_Bool                                                         =C.CXPrintingPolicy_BoolPrintingPolicy_Restrict                                                     =C.CXPrintingPolicy_RestrictPrintingPolicy_Alignof                                                      =C.CXPrintingPolicy_AlignofPrintingPolicy_UnderscoreAlignof                                            =C.CXPrintingPolicy_UnderscoreAlignofPrintingPolicy_UseVoidForZeroParams                                         =C.CXPrintingPolicy_UseVoidForZeroParamsPrintingPolicy_TerseOutput                                                  =C.CXPrintingPolicy_TerseOutputPrintingPolicy_PolishForDeclaration                                         =C.CXPrintingPolicy_PolishForDeclarationPrintingPolicy_Half                                                         =C.CXPrintingPolicy_HalfPrintingPolicy_MSWChar                                                      =C.CXPrintingPolicy_MSWCharPrintingPolicy_IncludeNewlines                                              =C.CXPrintingPolicy_IncludeNewlinesPrintingPolicy_MSVCFormatting                                               =C.CXPrintingPolicy_MSVCFormattingPrintingPolicy_ConstantsAsWritten                                           =C.CXPrintingPolicy_ConstantsAsWrittenPrintingPolicy_SuppressImplicitBase                                         =C.CXPrintingPolicy_SuppressImplicitBasePrintingPolicy_FullyQualifiedName                                           =C.CXPrintingPolicy_FullyQualifiedNamePrintingPolicy_LastProperty                                                 =C.CXPrintingPolicy_LastProperty)

const (PropertyAttr_noattrPropertyAttrKind =C.CXObjCPropertyAttr_noattrPropertyAttr_readonly                           =C.CXObjCPropertyAttr_readonlyPropertyAttr_getter                             =C.CXObjCPropertyAttr_getterPropertyAttr_assign                             =C.CXObjCPropertyAttr_assignPropertyAttr_readwrite                          =C.CXObjCPropertyAttr_readwritePropertyAttr_retain                             =C.CXObjCPropertyAttr_retainPropertyAttr_copy                               =C.CXObjCPropertyAttr_copyPropertyAttr_nonatomic                          =C.CXObjCPropertyAttr_nonatomicPropertyAttr_setter                             =C.CXObjCPropertyAttr_setterPropertyAttr_atomic                             =C.CXObjCPropertyAttr_atomicPropertyAttr_weak                               =C.CXObjCPropertyAttr_weakPropertyAttr_strong                             =C.CXObjCPropertyAttr_strongPropertyAttr_unsafe_unretained                  =C.CXObjCPropertyAttr_unsafe_unretainedPropertyAttr_class                              =C.CXObjCPropertyAttr_class)

const (// No ref-qualifier was provided.RefQualifier_NoneRefQualifierKind =C.CXRefQualifier_None// An lvalue ref-qualifier was provided (&).RefQualifier_LValue =C.CXRefQualifier_LValue// An rvalue ref-qualifier was provided (&&).RefQualifier_RValue =C.CXRefQualifier_RValue)

const (// Function returned successfully.Result_SuccessResult =C.CXResult_Success// One of the parameters was invalid for the function.Result_Invalid =C.CXResult_Invalid// The function was terminated by a callback (e.g. it returned CXVisit_Break)Result_VisitBreak =C.CXResult_VisitBreak)

const (// Indicates that no error occurred while saving a translation unit.SaveError_NoneSaveError =C.CXSaveError_None/*Indicates that an unknown error occurred while attempting to savethe file.This error typically indicates that file I/O failed when attempting towrite the file.*/SaveError_Unknown =C.CXSaveError_Unknown/*Indicates that errors during translation prevented this attemptto save the translation unit.Errors that prevent the translation unit from being saved can beextracted using clang_getNumDiagnostics() and clang_getDiagnostic().*/SaveError_TranslationErrors =C.CXSaveError_TranslationErrors// Indicates that the translation unit to be saved was somehow invalid (e.g., NULL).SaveError_InvalidTU =C.CXSaveError_InvalidTU)

const (SC_InvalidStorageClass =C.CX_SC_InvalidSC_None                              =C.CX_SC_NoneSC_Extern                            =C.CX_SC_ExternSC_Static                            =C.CX_SC_StaticSC_PrivateExtern                     =C.CX_SC_PrivateExternSC_OpenCLWorkGroupLocal              =C.CX_SC_OpenCLWorkGroupLocalSC_Auto                              =C.CX_SC_AutoSC_Register                          =C.CX_SC_Register)

const (SymbolRole_NoneSymbolRole =C.CXSymbolRole_NoneSymbolRole_Declaration            =C.CXSymbolRole_DeclarationSymbolRole_Definition             =C.CXSymbolRole_DefinitionSymbolRole_Reference              =C.CXSymbolRole_ReferenceSymbolRole_Read                   =C.CXSymbolRole_ReadSymbolRole_Write                  =C.CXSymbolRole_WriteSymbolRole_Call                   =C.CXSymbolRole_CallSymbolRole_Dynamic                =C.CXSymbolRole_DynamicSymbolRole_AddressOf              =C.CXSymbolRole_AddressOfSymbolRole_Implicit               =C.CXSymbolRole_Implicit)

const (TemplateArgumentKind_NullTemplateArgumentKind =C.CXTemplateArgumentKind_NullTemplateArgumentKind_Type                                   =C.CXTemplateArgumentKind_TypeTemplateArgumentKind_Declaration                            =C.CXTemplateArgumentKind_DeclarationTemplateArgumentKind_NullPtr                                =C.CXTemplateArgumentKind_NullPtrTemplateArgumentKind_Integral                               =C.CXTemplateArgumentKind_IntegralTemplateArgumentKind_Template                               =C.CXTemplateArgumentKind_TemplateTemplateArgumentKind_TemplateExpansion                      =C.CXTemplateArgumentKind_TemplateExpansionTemplateArgumentKind_Expression                             =C.CXTemplateArgumentKind_ExpressionTemplateArgumentKind_Pack                                   =C.CXTemplateArgumentKind_PackTemplateArgumentKind_Invalid                                =C.CXTemplateArgumentKind_Invalid)

const (TLS_NoneTLSKind =C.CXTLS_NoneTLS_Dynamic         =C.CXTLS_DynamicTLS_Static          =C.CXTLS_Static)

const (// A token that contains some kind of punctuation.Token_PunctuationTokenKind =C.CXToken_Punctuation// A language keyword.Token_Keyword =C.CXToken_Keyword// An identifier (that is not a keyword).Token_Identifier =C.CXToken_Identifier// A numeric, string, or character literal.Token_Literal =C.CXToken_Literal// A comment.Token_Comment =C.CXToken_Comment)

const (// Used to indicate that no special translation-unit options are needed.TranslationUnit_NoneTranslationUnit_Flags =C.CXTranslationUnit_None/*Used to indicate that the parser should construct a "detailed"preprocessing record, including all macro definitions and instantiations.Constructing a detailed preprocessing record requires more memoryand time to parse, since the information contained in the recordis usually not retained. However, it can be useful forapplications that require more detailed information about thebehavior of the preprocessor.*/TranslationUnit_DetailedPreprocessingRecord =C.CXTranslationUnit_DetailedPreprocessingRecord/*Used to indicate that the translation unit is incomplete.When a translation unit is considered "incomplete", semanticanalysis that is typically performed at the end of thetranslation unit will be suppressed. For example, this suppressesthe completion of tentative declarations in C and ofinstantiation of implicitly-instantiation function templates inC++. This option is typically used when parsing a header with theintent of producing a precompiled header.*/TranslationUnit_Incomplete =C.CXTranslationUnit_Incomplete/*Used to indicate that the translation unit should be built with animplicit precompiled header for the preamble.An implicit precompiled header is used as an optimization when aparticular translation unit is likely to be reparsed many timeswhen the sources aren't changing that often. In this case, animplicit precompiled header will be built containing all of theinitial includes at the top of the main file (what we refer to asthe "preamble" of the file). In subsequent parses, if thepreamble or the files in it have not changed, \cclang_reparseTranslationUnit() will re-use the implicitprecompiled header to improve parsing performance.*/TranslationUnit_PrecompiledPreamble =C.CXTranslationUnit_PrecompiledPreamble/*Used to indicate that the translation unit should cache somecode-completion results with each reparse of the source file.Caching of code-completion results is a performance optimization thatintroduces some overhead to reparsing but improves the performance ofcode-completion operations.*/TranslationUnit_CacheCompletionResults =C.CXTranslationUnit_CacheCompletionResults/*Used to indicate that the translation unit will be serialized withclang_saveTranslationUnit.This option is typically used when parsing a header with the intent ofproducing a precompiled header.*/TranslationUnit_ForSerialization =C.CXTranslationUnit_ForSerialization/*DEPRECATED: Enabled chained precompiled preambles in C++.Note: this is a *temporary* option that is available only whilewe are testing C++ precompiled preamble support. It is deprecated.*/TranslationUnit_CXXChainedPCH =C.CXTranslationUnit_CXXChainedPCH/*Used to indicate that function/method bodies should be skipped whileparsing.This option can be used to search for declarations/definitions whileignoring the usages.*/TranslationUnit_SkipFunctionBodies =C.CXTranslationUnit_SkipFunctionBodies// Used to indicate that brief documentation comments should be included into the set of code completions returned from this translation unit.TranslationUnit_IncludeBriefCommentsInCodeCompletion =C.CXTranslationUnit_IncludeBriefCommentsInCodeCompletion// Used to indicate that the precompiled preamble should be created on the first parse. Otherwise it will be created on the first reparse. This trades runtime on the first parse (serializing the preamble takes time) for reduced runtime on the second parse (can now reuse the preamble).TranslationUnit_CreatePreambleOnFirstParse =C.CXTranslationUnit_CreatePreambleOnFirstParse/*Do not stop processing when fatal errors are encountered.When fatal errors are encountered while parsing a translation unit,semantic analysis is typically stopped early when compiling code. A commonsource for fatal errors are unresolvable include files. For thepurposes of an IDE, this is undesirable behavior and as much informationas possible should be reported. Use this flag to enable this behavior.*/TranslationUnit_KeepGoing =C.CXTranslationUnit_KeepGoing// Sets the preprocessor in a mode for parsing a single file only.TranslationUnit_SingleFileParse =C.CXTranslationUnit_SingleFileParse/*Used in combination with CXTranslationUnit_SkipFunctionBodies toconstrain the skipping of function bodies to the preamble.The function bodies of the main file are not skipped.*/TranslationUnit_LimitSkipFunctionBodiesToPreamble =C.CXTranslationUnit_LimitSkipFunctionBodiesToPreamble// Used to indicate that attributed types should be included in CXType.TranslationUnit_IncludeAttributedTypes =C.CXTranslationUnit_IncludeAttributedTypes// Used to indicate that implicit attributes should be visited.TranslationUnit_VisitImplicitAttributes =C.CXTranslationUnit_VisitImplicitAttributes/*Used to indicate that non-errors from included files should be ignored.If set, clang_getDiagnosticSetFromTU() will not report e.g. warnings fromincluded files anymore. This speeds up clang_getDiagnosticSetFromTU() forthe case where these warnings are not of interest, as for an IDE forexample, which typically shows only the diagnostics in the main file.*/TranslationUnit_IgnoreNonErrorsFromIncludedFiles =C.CXTranslationUnit_IgnoreNonErrorsFromIncludedFiles// Tells the preprocessor not to skip excluded conditional blocks.TranslationUnit_RetainExcludedConditionalBlocks =C.CXTranslationUnit_RetainExcludedConditionalBlocks)

const (TUResourceUsage_ASTTUResourceUsageKind =C.CXTUResourceUsage_ASTTUResourceUsage_Identifiers                                            =C.CXTUResourceUsage_IdentifiersTUResourceUsage_Selectors                                              =C.CXTUResourceUsage_SelectorsTUResourceUsage_GlobalCompletionResults                                =C.CXTUResourceUsage_GlobalCompletionResultsTUResourceUsage_SourceManagerContentCache                              =C.CXTUResourceUsage_SourceManagerContentCacheTUResourceUsage_AST_SideTables                                         =C.CXTUResourceUsage_AST_SideTablesTUResourceUsage_SourceManager_Membuffer_Malloc                         =C.CXTUResourceUsage_SourceManager_Membuffer_MallocTUResourceUsage_SourceManager_Membuffer_MMap                           =C.CXTUResourceUsage_SourceManager_Membuffer_MMapTUResourceUsage_ExternalASTSource_Membuffer_Malloc                     =C.CXTUResourceUsage_ExternalASTSource_Membuffer_MallocTUResourceUsage_ExternalASTSource_Membuffer_MMap                       =C.CXTUResourceUsage_ExternalASTSource_Membuffer_MMapTUResourceUsage_Preprocessor                                           =C.CXTUResourceUsage_PreprocessorTUResourceUsage_PreprocessingRecord                                    =C.CXTUResourceUsage_PreprocessingRecordTUResourceUsage_SourceManager_DataStructures                           =C.CXTUResourceUsage_SourceManager_DataStructuresTUResourceUsage_Preprocessor_HeaderSearch                              =C.CXTUResourceUsage_Preprocessor_HeaderSearchTUResourceUsage_MEMORY_IN_BYTES_BEGIN                                  =C.CXTUResourceUsage_MEMORY_IN_BYTES_BEGINTUResourceUsage_MEMORY_IN_BYTES_END                                    =C.CXTUResourceUsage_MEMORY_IN_BYTES_ENDTUResourceUsage_First                                                  =C.CXTUResourceUsage_FirstTUResourceUsage_Last                                                   =C.CXTUResourceUsage_Last)

const (// Represents an invalid type (e.g., where no type is available).Type_InvalidTypeKind =C.CXType_Invalid// A type whose specific kind is not exposed via this interface.Type_Unexposed =C.CXType_Unexposed// A type whose specific kind is not exposed via this interface.Type_Void =C.CXType_Void// A type whose specific kind is not exposed via this interface.Type_Bool =C.CXType_Bool// A type whose specific kind is not exposed via this interface.Type_Char_U =C.CXType_Char_U// A type whose specific kind is not exposed via this interface.Type_UChar =C.CXType_UChar// A type whose specific kind is not exposed via this interface.Type_Char16 =C.CXType_Char16// A type whose specific kind is not exposed via this interface.Type_Char32 =C.CXType_Char32// A type whose specific kind is not exposed via this interface.Type_UShort =C.CXType_UShort// A type whose specific kind is not exposed via this interface.Type_UInt =C.CXType_UInt// A type whose specific kind is not exposed via this interface.Type_ULong =C.CXType_ULong// A type whose specific kind is not exposed via this interface.Type_ULongLong =C.CXType_ULongLong// A type whose specific kind is not exposed via this interface.Type_UInt128 =C.CXType_UInt128// A type whose specific kind is not exposed via this interface.Type_Char_S =C.CXType_Char_S// A type whose specific kind is not exposed via this interface.Type_SChar =C.CXType_SChar// A type whose specific kind is not exposed via this interface.Type_WChar =C.CXType_WChar// A type whose specific kind is not exposed via this interface.Type_Short =C.CXType_Short// A type whose specific kind is not exposed via this interface.Type_Int =C.CXType_Int// A type whose specific kind is not exposed via this interface.Type_Long =C.CXType_Long// A type whose specific kind is not exposed via this interface.Type_LongLong =C.CXType_LongLong// A type whose specific kind is not exposed via this interface.Type_Int128 =C.CXType_Int128// A type whose specific kind is not exposed via this interface.Type_Float =C.CXType_Float// A type whose specific kind is not exposed via this interface.Type_Double =C.CXType_Double// A type whose specific kind is not exposed via this interface.Type_LongDouble =C.CXType_LongDouble// A type whose specific kind is not exposed via this interface.Type_NullPtr =C.CXType_NullPtr// A type whose specific kind is not exposed via this interface.Type_Overload =C.CXType_Overload// A type whose specific kind is not exposed via this interface.Type_Dependent =C.CXType_Dependent// A type whose specific kind is not exposed via this interface.Type_ObjCId =C.CXType_ObjCId// A type whose specific kind is not exposed via this interface.Type_ObjCClass =C.CXType_ObjCClass// A type whose specific kind is not exposed via this interface.Type_ObjCSel =C.CXType_ObjCSel// A type whose specific kind is not exposed via this interface.Type_Float128 =C.CXType_Float128// A type whose specific kind is not exposed via this interface.Type_Half =C.CXType_Half// A type whose specific kind is not exposed via this interface.Type_Float16 =C.CXType_Float16// A type whose specific kind is not exposed via this interface.Type_ShortAccum =C.CXType_ShortAccum// A type whose specific kind is not exposed via this interface.Type_Accum =C.CXType_Accum// A type whose specific kind is not exposed via this interface.Type_LongAccum =C.CXType_LongAccum// A type whose specific kind is not exposed via this interface.Type_UShortAccum =C.CXType_UShortAccum// A type whose specific kind is not exposed via this interface.Type_UAccum =C.CXType_UAccum// A type whose specific kind is not exposed via this interface.Type_ULongAccum =C.CXType_ULongAccum// A type whose specific kind is not exposed via this interface.Type_BFloat16 =C.CXType_BFloat16// A type whose specific kind is not exposed via this interface.Type_FirstBuiltin =C.CXType_FirstBuiltin// A type whose specific kind is not exposed via this interface.Type_LastBuiltin =C.CXType_LastBuiltin// A type whose specific kind is not exposed via this interface.Type_Complex =C.CXType_Complex// A type whose specific kind is not exposed via this interface.Type_Pointer =C.CXType_Pointer// A type whose specific kind is not exposed via this interface.Type_BlockPointer =C.CXType_BlockPointer// A type whose specific kind is not exposed via this interface.Type_LValueReference =C.CXType_LValueReference// A type whose specific kind is not exposed via this interface.Type_RValueReference =C.CXType_RValueReference// A type whose specific kind is not exposed via this interface.Type_Record =C.CXType_Record// A type whose specific kind is not exposed via this interface.Type_Enum =C.CXType_Enum// A type whose specific kind is not exposed via this interface.Type_Typedef =C.CXType_Typedef// A type whose specific kind is not exposed via this interface.Type_ObjCInterface =C.CXType_ObjCInterface// A type whose specific kind is not exposed via this interface.Type_ObjCObjectPointer =C.CXType_ObjCObjectPointer// A type whose specific kind is not exposed via this interface.Type_FunctionNoProto =C.CXType_FunctionNoProto// A type whose specific kind is not exposed via this interface.Type_FunctionProto =C.CXType_FunctionProto// A type whose specific kind is not exposed via this interface.Type_ConstantArray =C.CXType_ConstantArray// A type whose specific kind is not exposed via this interface.Type_Vector =C.CXType_Vector// A type whose specific kind is not exposed via this interface.Type_IncompleteArray =C.CXType_IncompleteArray// A type whose specific kind is not exposed via this interface.Type_VariableArray =C.CXType_VariableArray// A type whose specific kind is not exposed via this interface.Type_DependentSizedArray =C.CXType_DependentSizedArray// A type whose specific kind is not exposed via this interface.Type_MemberPointer =C.CXType_MemberPointer// A type whose specific kind is not exposed via this interface.Type_Auto =C.CXType_Auto/*Represents a type that was referred to using an elaborated type keyword.E.g., struct S, or via a qualified name, e.g., N::M::type, or both.*/Type_Elaborated =C.CXType_Elaborated/*Represents a type that was referred to using an elaborated type keyword.E.g., struct S, or via a qualified name, e.g., N::M::type, or both.*/Type_Pipe =C.CXType_Pipe/*Represents a type that was referred to using an elaborated type keyword.E.g., struct S, or via a qualified name, e.g., N::M::type, or both.*/Type_OCLImage1dRO =C.CXType_OCLImage1dRO/*Represents a type that was referred to using an elaborated type keyword.E.g., struct S, or via a qualified name, e.g., N::M::type, or both.*/Type_OCLImage1dArrayRO =C.CXType_OCLImage1dArrayRO/*Represents a type that was referred to using an elaborated type keyword.E.g., struct S, or via a qualified name, e.g., N::M::type, or both.*/Type_OCLImage1dBufferRO =C.CXType_OCLImage1dBufferRO/*Represents a type that was referred to using an elaborated type keyword.E.g., struct S, or via a qualified name, e.g., N::M::type, or both.*/Type_OCLImage2dRO =C.CXType_OCLImage2dRO/*Represents a type that was referred to using an elaborated type keyword.E.g., struct S, or via a qualified name, e.g., N::M::type, or both.*/Type_OCLImage2dArrayRO =C.CXType_OCLImage2dArrayRO/*Represents a type that was referred to using an elaborated type keyword.E.g., struct S, or via a qualified name, e.g., N::M::type, or both.*/Type_OCLImage2dDepthRO =C.CXType_OCLImage2dDepthRO/*Represents a type that was referred to using an elaborated type keyword.E.g., struct S, or via a qualified name, e.g., N::M::type, or both.*/Type_OCLImage2dArrayDepthRO =C.CXType_OCLImage2dArrayDepthRO/*Represents a type that was referred to using an elaborated type keyword.E.g., struct S, or via a qualified name, e.g., N::M::type, or both.*/Type_OCLImage2dMSAARO =C.CXType_OCLImage2dMSAARO/*Represents a type that was referred to using an elaborated type keyword.E.g., struct S, or via a qualified name, e.g., N::M::type, or both.*/Type_OCLImage2dArrayMSAARO =C.CXType_OCLImage2dArrayMSAARO/*Represents a type that was referred to using an elaborated type keyword.E.g., struct S, or via a qualified name, e.g., N::M::type, or both.*/Type_OCLImage2dMSAADepthRO =C.CXType_OCLImage2dMSAADepthRO/*Represents a type that was referred to using an elaborated type keyword.E.g., struct S, or via a qualified name, e.g., N::M::type, or both.*/Type_OCLImage2dArrayMSAADepthRO =C.CXType_OCLImage2dArrayMSAADepthRO/*Represents a type that was referred to using an elaborated type keyword.E.g., struct S, or via a qualified name, e.g., N::M::type, or both.*/Type_OCLImage3dRO =C.CXType_OCLImage3dRO/*Represents a type that was referred to using an elaborated type keyword.E.g., struct S, or via a qualified name, e.g., N::M::type, or both.*/Type_OCLImage1dWO =C.CXType_OCLImage1dWO/*Represents a type that was referred to using an elaborated type keyword.E.g., struct S, or via a qualified name, e.g., N::M::type, or both.*/Type_OCLImage1dArrayWO =C.CXType_OCLImage1dArrayWO/*Represents a type that was referred to using an elaborated type keyword.E.g., struct S, or via a qualified name, e.g., N::M::type, or both.*/Type_OCLImage1dBufferWO =C.CXType_OCLImage1dBufferWO/*Represents a type that was referred to using an elaborated type keyword.E.g., struct S, or via a qualified name, e.g., N::M::type, or both.*/Type_OCLImage2dWO =C.CXType_OCLImage2dWO/*Represents a type that was referred to using an elaborated type keyword.E.g., struct S, or via a qualified name, e.g., N::M::type, or both.*/Type_OCLImage2dArrayWO =C.CXType_OCLImage2dArrayWO/*Represents a type that was referred to using an elaborated type keyword.E.g., struct S, or via a qualified name, e.g., N::M::type, or both.*/Type_OCLImage2dDepthWO =C.CXType_OCLImage2dDepthWO/*Represents a type that was referred to using an elaborated type keyword.E.g., struct S, or via a qualified name, e.g., N::M::type, or both.*/Type_OCLImage2dArrayDepthWO =C.CXType_OCLImage2dArrayDepthWO/*Represents a type that was referred to using an elaborated type keyword.E.g., struct S, or via a qualified name, e.g., N::M::type, or both.*/Type_OCLImage2dMSAAWO =C.CXType_OCLImage2dMSAAWO/*Represents a type that was referred to using an elaborated type keyword.E.g., struct S, or via a qualified name, e.g., N::M::type, or both.*/Type_OCLImage2dArrayMSAAWO =C.CXType_OCLImage2dArrayMSAAWO/*Represents a type that was referred to using an elaborated type keyword.E.g., struct S, or via a qualified name, e.g., N::M::type, or both.*/Type_OCLImage2dMSAADepthWO =C.CXType_OCLImage2dMSAADepthWO/*Represents a type that was referred to using an elaborated type keyword.E.g., struct S, or via a qualified name, e.g., N::M::type, or both.*/Type_OCLImage2dArrayMSAADepthWO =C.CXType_OCLImage2dArrayMSAADepthWO/*Represents a type that was referred to using an elaborated type keyword.E.g., struct S, or via a qualified name, e.g., N::M::type, or both.*/Type_OCLImage3dWO =C.CXType_OCLImage3dWO/*Represents a type that was referred to using an elaborated type keyword.E.g., struct S, or via a qualified name, e.g., N::M::type, or both.*/Type_OCLImage1dRW =C.CXType_OCLImage1dRW/*Represents a type that was referred to using an elaborated type keyword.E.g., struct S, or via a qualified name, e.g., N::M::type, or both.*/Type_OCLImage1dArrayRW =C.CXType_OCLImage1dArrayRW/*Represents a type that was referred to using an elaborated type keyword.E.g., struct S, or via a qualified name, e.g., N::M::type, or both.*/Type_OCLImage1dBufferRW =C.CXType_OCLImage1dBufferRW/*Represents a type that was referred to using an elaborated type keyword.E.g., struct S, or via a qualified name, e.g., N::M::type, or both.*/Type_OCLImage2dRW =C.CXType_OCLImage2dRW/*Represents a type that was referred to using an elaborated type keyword.E.g., struct S, or via a qualified name, e.g., N::M::type, or both.*/Type_OCLImage2dArrayRW =C.CXType_OCLImage2dArrayRW/*Represents a type that was referred to using an elaborated type keyword.E.g., struct S, or via a qualified name, e.g., N::M::type, or both.*/Type_OCLImage2dDepthRW =C.CXType_OCLImage2dDepthRW/*Represents a type that was referred to using an elaborated type keyword.E.g., struct S, or via a qualified name, e.g., N::M::type, or both.*/Type_OCLImage2dArrayDepthRW =C.CXType_OCLImage2dArrayDepthRW/*Represents a type that was referred to using an elaborated type keyword.E.g., struct S, or via a qualified name, e.g., N::M::type, or both.*/Type_OCLImage2dMSAARW =C.CXType_OCLImage2dMSAARW/*Represents a type that was referred to using an elaborated type keyword.E.g., struct S, or via a qualified name, e.g., N::M::type, or both.*/Type_OCLImage2dArrayMSAARW =C.CXType_OCLImage2dArrayMSAARW/*Represents a type that was referred to using an elaborated type keyword.E.g., struct S, or via a qualified name, e.g., N::M::type, or both.*/Type_OCLImage2dMSAADepthRW =C.CXType_OCLImage2dMSAADepthRW/*Represents a type that was referred to using an elaborated type keyword.E.g., struct S, or via a qualified name, e.g., N::M::type, or both.*/Type_OCLImage2dArrayMSAADepthRW =C.CXType_OCLImage2dArrayMSAADepthRW/*Represents a type that was referred to using an elaborated type keyword.E.g., struct S, or via a qualified name, e.g., N::M::type, or both.*/Type_OCLImage3dRW =C.CXType_OCLImage3dRW/*Represents a type that was referred to using an elaborated type keyword.E.g., struct S, or via a qualified name, e.g., N::M::type, or both.*/Type_OCLSampler =C.CXType_OCLSampler/*Represents a type that was referred to using an elaborated type keyword.E.g., struct S, or via a qualified name, e.g., N::M::type, or both.*/Type_OCLEvent =C.CXType_OCLEvent/*Represents a type that was referred to using an elaborated type keyword.E.g., struct S, or via a qualified name, e.g., N::M::type, or both.*/Type_OCLQueue =C.CXType_OCLQueue/*Represents a type that was referred to using an elaborated type keyword.E.g., struct S, or via a qualified name, e.g., N::M::type, or both.*/Type_OCLReserveID =C.CXType_OCLReserveID/*Represents a type that was referred to using an elaborated type keyword.E.g., struct S, or via a qualified name, e.g., N::M::type, or both.*/Type_ObjCObject =C.CXType_ObjCObject/*Represents a type that was referred to using an elaborated type keyword.E.g., struct S, or via a qualified name, e.g., N::M::type, or both.*/Type_ObjCTypeParam =C.CXType_ObjCTypeParam/*Represents a type that was referred to using an elaborated type keyword.E.g., struct S, or via a qualified name, e.g., N::M::type, or both.*/Type_Attributed =C.CXType_Attributed/*Represents a type that was referred to using an elaborated type keyword.E.g., struct S, or via a qualified name, e.g., N::M::type, or both.*/Type_OCLIntelSubgroupAVCMcePayload =C.CXType_OCLIntelSubgroupAVCMcePayload/*Represents a type that was referred to using an elaborated type keyword.E.g., struct S, or via a qualified name, e.g., N::M::type, or both.*/Type_OCLIntelSubgroupAVCImePayload =C.CXType_OCLIntelSubgroupAVCImePayload/*Represents a type that was referred to using an elaborated type keyword.E.g., struct S, or via a qualified name, e.g., N::M::type, or both.*/Type_OCLIntelSubgroupAVCRefPayload =C.CXType_OCLIntelSubgroupAVCRefPayload/*Represents a type that was referred to using an elaborated type keyword.E.g., struct S, or via a qualified name, e.g., N::M::type, or both.*/Type_OCLIntelSubgroupAVCSicPayload =C.CXType_OCLIntelSubgroupAVCSicPayload/*Represents a type that was referred to using an elaborated type keyword.E.g., struct S, or via a qualified name, e.g., N::M::type, or both.*/Type_OCLIntelSubgroupAVCMceResult =C.CXType_OCLIntelSubgroupAVCMceResult/*Represents a type that was referred to using an elaborated type keyword.E.g., struct S, or via a qualified name, e.g., N::M::type, or both.*/Type_OCLIntelSubgroupAVCImeResult =C.CXType_OCLIntelSubgroupAVCImeResult/*Represents a type that was referred to using an elaborated type keyword.E.g., struct S, or via a qualified name, e.g., N::M::type, or both.*/Type_OCLIntelSubgroupAVCRefResult =C.CXType_OCLIntelSubgroupAVCRefResult/*Represents a type that was referred to using an elaborated type keyword.E.g., struct S, or via a qualified name, e.g., N::M::type, or both.*/Type_OCLIntelSubgroupAVCSicResult =C.CXType_OCLIntelSubgroupAVCSicResult/*Represents a type that was referred to using an elaborated type keyword.E.g., struct S, or via a qualified name, e.g., N::M::type, or both.*/Type_OCLIntelSubgroupAVCImeResultSingleRefStreamout =C.CXType_OCLIntelSubgroupAVCImeResultSingleRefStreamout/*Represents a type that was referred to using an elaborated type keyword.E.g., struct S, or via a qualified name, e.g., N::M::type, or both.*/Type_OCLIntelSubgroupAVCImeResultDualRefStreamout =C.CXType_OCLIntelSubgroupAVCImeResultDualRefStreamout/*Represents a type that was referred to using an elaborated type keyword.E.g., struct S, or via a qualified name, e.g., N::M::type, or both.*/Type_OCLIntelSubgroupAVCImeSingleRefStreamin =C.CXType_OCLIntelSubgroupAVCImeSingleRefStreamin/*Represents a type that was referred to using an elaborated type keyword.E.g., struct S, or via a qualified name, e.g., N::M::type, or both.*/Type_OCLIntelSubgroupAVCImeDualRefStreamin =C.CXType_OCLIntelSubgroupAVCImeDualRefStreamin/*Represents a type that was referred to using an elaborated type keyword.E.g., struct S, or via a qualified name, e.g., N::M::type, or both.*/Type_ExtVector =C.CXType_ExtVector/*Represents a type that was referred to using an elaborated type keyword.E.g., struct S, or via a qualified name, e.g., N::M::type, or both.*/Type_Atomic =C.CXType_Atomic)

const (// Type is of kind CXType_Invalid.TypeLayoutError_InvalidTypeLayoutError =C.CXTypeLayoutError_Invalid// The type is an incomplete Type.TypeLayoutError_Incomplete =C.CXTypeLayoutError_Incomplete// The type is a dependent Type.TypeLayoutError_Dependent =C.CXTypeLayoutError_Dependent// The type is not a constant size type.TypeLayoutError_NotConstantSize =C.CXTypeLayoutError_NotConstantSize// The Field name is not valid for this record.TypeLayoutError_InvalidFieldName =C.CXTypeLayoutError_InvalidFieldName// The type is undeduced.TypeLayoutError_Undeduced =C.CXTypeLayoutError_Undeduced)

const (// Values of this type can never be null.TypeNullability_NonNullTypeNullabilityKind =C.CXTypeNullability_NonNull// Values of this type can be null.TypeNullability_Nullable =C.CXTypeNullability_Nullable// Whether values of this type can be null is (explicitly) unspecified. This captures a (fairly rare) case where we can't conclude anything about the nullability of the type even though it has been considered.TypeNullability_Unspecified =C.CXTypeNullability_Unspecified// Nullability is not applicable to this type.TypeNullability_Invalid =C.CXTypeNullability_Invalid// Generally behaves like Nullable, except when used in a block parameter that was imported into a swift async method. There, swift will assume that the parameter can get null even if no error occured. _Nullable parameters are assumed to only get null on error.TypeNullability_NullableResult =C.CXTypeNullability_NullableResult)

const (// This value indicates that no visibility information is available for a provided CXCursor.Visibility_InvalidVisibilityKind =C.CXVisibility_Invalid// Symbol not seen by the linker.Visibility_Hidden =C.CXVisibility_Hidden// Symbol seen by the linker but resolves to a symbol inside this object.Visibility_Protected =C.CXVisibility_Protected// Symbol seen by the linker and acts like a normal symbol.Visibility_Default =C.CXVisibility_Default)

funcConstructUSR_ObjCCategory¶

func ConstructUSR_ObjCCategory(classNamestring, categoryNamestring)string

Construct a USR for a specified Objective-C category.

funcConstructUSR_ObjCClass¶

func ConstructUSR_ObjCClass(classNamestring)string

Construct a USR for a specified Objective-C class.

funcConstructUSR_ObjCIvar¶

func ConstructUSR_ObjCIvar(namestring, classUSR cxstring)string

Construct a USR for a specified Objective-C instance variable and the USR for its containing class.

funcConstructUSR_ObjCMethod¶

func ConstructUSR_ObjCMethod(namestring, isInstanceMethoduint32, classUSR cxstring)string

Construct a USR for a specified Objective-C method and the USR for its containing class.

funcConstructUSR_ObjCProperty¶

func ConstructUSR_ObjCProperty(propertystring, classUSR cxstring)string

Construct a USR for a specified Objective-C property and the USR for its containing class.

funcConstructUSR_ObjCProtocol¶

func ConstructUSR_ObjCProtocol(protocolNamestring)string

Construct a USR for a specified Objective-C protocol.

funcDefaultCodeCompleteOptions¶

func DefaultCodeCompleteOptions()uint32

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

funcDefaultDiagnosticDisplayOptions¶

func DefaultDiagnosticDisplayOptions()uint32

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

Returns A set of display options suitable for use with \cclang_formatDiagnostic().

funcDefaultEditingTranslationUnitOptions¶

func DefaultEditingTranslationUnitOptions()uint32

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

The set of flags returned provide options for clang_parseTranslationUnit()to indicate that the translation unit is likely to be reparsed many times,either explicitly (via clang_reparseTranslationUnit()) or implicitly(e.g., by code completion (clang_codeCompletionAt())). The returned flagset contains an unspecified set of optimizations (e.g., the precompiledpreamble) geared toward improving the performance of these routines. Theset of optimizations enabled may change from one version to the next.

funcDispose¶

func Dispose(overridden []Cursor)

Free the set of overridden cursors returned by \c clang_getOverriddenCursors().

funcEnableStackTraces¶

func EnableStackTraces()

funcFromDirectory¶

func FromDirectory(buildDirstring) (CompilationDatabase_Error,CompilationDatabase)

Creates a compilation database from the database found in directorybuildDir. For example, CMake can output a compile_commands.json which canbe used to build the database.

It must be freed by clang_CompilationDatabase_dispose.

funcGetBuildSessionTimestamp¶

func GetBuildSessionTimestamp()uint64

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

funcGetClangVersion¶

func GetClangVersion()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).

funcGetDiagnosticCategoryName¶

func GetDiagnosticCategoryName(categoryuint32)string

Retrieve the name of a particular diagnostic category. Thisis now deprecated. Use clang_getDiagnosticCategoryText()instead.

Parameter Category A diagnostic category number, as returned byclang_getDiagnosticCategory().

Returns The name of the given diagnostic category.

funcInstallAbortingFatalErrorHandler¶

func InstallAbortingFatalErrorHandler()

Installs error handler that prints error message to stderr and calls abort(). Replaces currently installed error handler (if any).

funcLoadDiagnostics¶

func LoadDiagnostics(filestring) (LoadDiag_Error,string,DiagnosticSet)

Deserialize a set of diagnostics from a Clang diagnostics bitcodefile.

Parameter file The name of the file to deserialize.Parameter error A pointer to a enum value recording if there was a problemdeserializing the diagnostics.Parameter errorString A pointer to a CXString for recording the error stringif the file was not successfully loaded.

Returns A loaded CXDiagnosticSet if successful, and NULL otherwise. Thesediagnostics should be released using clang_disposeDiagnosticSet().

funcSortCodeCompletionResults¶

func SortCodeCompletionResults(results []CompletionResult)

Sort the code-completion results in case-insensitive alphabeticalorder.

Parameter Results The set of results to sort.Parameter NumResults The number of results in \p Results.

funcToggleCrashRecovery¶

func ToggleCrashRecovery(isEnableduint32)

Enable/disable crash recovery.

Parameter isEnabled Flag to indicate if crash recovery is enabled. A non-zerovalue enables crash recovery, while 0 disables it.

funcUninstallFatalErrorHandler¶

func UninstallFatalErrorHandler()

Removes currently installed error handler (if any). If no error handler is intalled, the default strategy is to print error message to stderr and call exit(1).

typeAccessSpecifier¶

type AccessSpecifieruint32

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

func (asAccessSpecifier) Spelling()string

func (asAccessSpecifier) String()string

typeAvailabilityKind¶

type AvailabilityKinduint32

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.

func (akAvailabilityKind) Spelling()string

func (akAvailabilityKind) String()string

typeCallingConv¶

type CallingConvuint32

Describes the calling convention of a function type

func (ccCallingConv) Spelling()string

func (ccCallingConv) String()string

typeChildVisitResult¶

type ChildVisitResultuint32

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

A value of this enumeration type should be returned by eachCXCursorVisitor to indicate how clang_visitChildren() proceed.

func GoClangCursorVisitor(cursor, parentC.CXCursor, cfctunsafe.Pointer) (statusChildVisitResult)

func (cvrChildVisitResult) Spelling()string

func (cvrChildVisitResult) String()string

typeClientData¶

type ClientData struct {// contains filtered or unexported fields}

Opaque pointer representing client data that will be passed through to various callbacks and visitors.

typeCodeCompleteResults¶

type CodeCompleteResults struct {// contains filtered or unexported fields}

Contains the results of code-completion.

This data structure contains the results of code completion, asproduced by clang_codeCompleteAt(). Its contents must be freed byclang_disposeCodeCompleteResults.

func (ccr *CodeCompleteResults) CompletionFixIt(completionIndexuint32, fixitIndexuint32) (SourceRange,string)

func (ccr *CodeCompleteResults) CompletionNumFixIts(completionIndexuint32)uint32

func (ccr *CodeCompleteResults) ContainerKind() (uint32,CursorKind)

func (ccr *CodeCompleteResults) ContainerUSR()string

func (ccr *CodeCompleteResults) Contexts()uint64

func (ccr *CodeCompleteResults) Diagnostic(indexuint32)Diagnostic

func (ccr *CodeCompleteResults) Diagnostics() []Diagnostic

func (ccr *CodeCompleteResults) Dispose()

func (ccr *CodeCompleteResults) NumDiagnostics()uint32

func (ccrCodeCompleteResults) NumResults()uint32

func (ccrCodeCompleteResults) Results() []CompletionResult

func (ccr *CodeCompleteResults) Selector()string

typeCodeComplete_Flags¶

type CodeComplete_Flagsuint32

Flags that can be passed to clang_codeCompleteAt() tomodify its behavior.

The enumerators in this enumeration can be bitwise-OR'd together toprovide multiple options to clang_codeCompleteAt().

func (ccfCodeComplete_Flags) Spelling()string

func (ccfCodeComplete_Flags) String()string

typeComment¶

type Comment struct {// contains filtered or unexported fields}

A parsed comment.

func (cComment) BlockCommandComment_getArgText(argIdxuint32)string

func (cComment) BlockCommandComment_getCommandName()string

func (cComment) BlockCommandComment_getNumArgs()uint32

func (cComment) BlockCommandComment_getParagraph()Comment

func (cComment) Child(childIdxuint32)Comment

func (cComment) FullComment_getAsHTML()string

func (cComment) FullComment_getAsXML()string

func (cComment) HTMLStartTagComment_IsSelfClosing()bool

func (cComment) HTMLStartTag_getAttrName(attrIdxuint32)string

func (cComment) HTMLStartTag_getAttrValue(attrIdxuint32)string

func (cComment) HTMLStartTag_getNumAttrs()uint32

func (cComment) HTMLTagComment_getAsString()string

func (cComment) HTMLTagComment_getTagName()string

func (cComment) InlineCommandComment_getArgText(argIdxuint32)string

func (cComment) InlineCommandComment_getCommandName()string

func (cComment) InlineCommandComment_getNumArgs()uint32

func (cComment) InlineCommandComment_getRenderKind()CommentInlineCommandRenderKind

func (cComment) InlineContentComment_HasTrailingNewline()bool

func (cComment) IsWhitespace()bool

func (cComment) Kind()CommentKind

func (cComment) NumChildren()uint32

func (cComment) ParamCommandComment_IsDirectionExplicit()bool

func (cComment) ParamCommandComment_IsParamIndexValid()bool

func (cComment) ParamCommandComment_getDirection()CommentParamPassDirection

func (cComment) ParamCommandComment_getParamIndex()uint32

func (cComment) ParamCommandComment_getParamName()string

func (cComment) TParamCommandComment_IsParamPositionValid()bool

func (cComment) TParamCommandComment_getDepth()uint32

func (cComment) TParamCommandComment_getIndex(depthuint32)uint32

func (cComment) TParamCommandComment_getParamName()string

func (cComment) TextComment_getText()string

func (cComment) TranslationUnit()TranslationUnit

func (cComment) VerbatimBlockLineComment_getText()string

func (cComment) VerbatimLineComment_getText()string

typeCommentInlineCommandRenderKind¶

type CommentInlineCommandRenderKinduint32

The most appropriate rendering mode for an inline command, chosen on command semantics in Doxygen.

func (cicrkCommentInlineCommandRenderKind) Spelling()string

func (cicrkCommentInlineCommandRenderKind) String()string

typeCommentKind¶

type CommentKinduint32

Describes the type of the comment AST node (CXComment). A comment node can be considered block content (e. g., paragraph), inline content (plain text) or neither (the root AST node).

func (ckCommentKind) Spelling()string

func (ckCommentKind) String()string

typeCommentParamPassDirection¶

type CommentParamPassDirectionuint32

Describes parameter passing direction for \Parameter or \\arg command.

func (cppdCommentParamPassDirection) Spelling()string

func (cppdCommentParamPassDirection) String()string

typeCompilationDatabase¶

type CompilationDatabase struct {// contains filtered or unexported fields}

A compilation database holds all information used to compile files in aproject. For each file in the database, it can be queried for the workingdirectory or the command line used for the compiler invocation.

Must be freed by clang_CompilationDatabase_dispose

func (cdCompilationDatabase) AllCompileCommands()CompileCommands

func (cdCompilationDatabase) CompileCommands(completeFileNamestring)CompileCommands

func (cdCompilationDatabase) Dispose()

typeCompilationDatabase_Error¶

type CompilationDatabase_Errorint32

Error codes for Compilation Database

const (CompilationDatabase_NoErrorCompilationDatabase_Error =C.CXCompilationDatabase_NoErrorCompilationDatabase_CanNotLoadDatabase                           =C.CXCompilationDatabase_CanNotLoadDatabase)

func (cdeCompilationDatabase_Error) Error()string

func (cdeCompilationDatabase_Error) Spelling()string

func (cdeCompilationDatabase_Error) String()string

typeCompileCommand¶

type CompileCommand struct {// contains filtered or unexported fields}

Represents the command line invocation to compile a specific file.

func (ccCompileCommand) Arg(iuint32)string

func (ccCompileCommand) Directory()string

func (ccCompileCommand) Filename()string

func (ccCompileCommand) NumArgs()uint32

typeCompileCommands¶

type CompileCommands struct {// contains filtered or unexported fields}

Contains the results of a search in the compilation database

When searching for the compile command for a file, the compilation db canreturn several commands, as the file may have been compiled withdifferent options in different places of the project. This choice of compilecommands is wrapped in this opaque data structure. It must be freed byclang_CompileCommands_dispose.

func (ccCompileCommands) Command(iuint32)CompileCommand

func (ccCompileCommands) Dispose()

func (ccCompileCommands) Size()uint32

typeCompletionChunkKind¶

type CompletionChunkKinduint32

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

Each "chunk" within a code-completion string (CXCompletionString) iseither a piece of text with a specific "kind" that describes how that textshould be interpreted by the client or is another completion string.

func (cckCompletionChunkKind) Spelling()string

func (cckCompletionChunkKind) String()string

typeCompletionContext¶

type CompletionContextuint32

Bits that represent the context under which completion is occurring.

The enumerators in this enumeration may be bitwise-OR'd together if multiplecontexts are occurring simultaneously.

func (ccCompletionContext) Spelling()string

func (ccCompletionContext) String()string

typeCompletionResult¶

type CompletionResult struct {// contains filtered or unexported fields}

A single result of code completion.

func (crCompletionResult) CompletionString()CompletionString

func (crCompletionResult) CursorKind()CursorKind

typeCompletionString¶

type CompletionString struct {// contains filtered or unexported fields}

A semantic string that describes a code-completion result.

A semantic string that describes the formatting of a code-completionresult as a single "template" of text that should be inserted into thesource buffer when a particular code-completion result is selected.Each semantic string is made up of some number of "chunks", each of whichcontains some text along with a description of what that text means, e.g.,the name of the entity being referenced, whether the text chunk is part ofthe template, or whether it is a "placeholder" that the user should replacewith actual code,of a specific kind. See CXCompletionChunkKind for adescription of the different kinds of chunks.

func (csCompletionString) Annotation(annotationNumberuint32)string

func (csCompletionString) Availability()AvailabilityKind

func (csCompletionString) BriefComment()string

func (csCompletionString) ChunkCompletionString(chunkNumberuint32)CompletionString

func (csCompletionString) ChunkKind(chunkNumberuint32)CompletionChunkKind

func (csCompletionString) ChunkText(chunkNumberuint32)string

func (csCompletionString) NumAnnotations()uint32

func (csCompletionString) NumChunks()uint32

func (csCompletionString) Parent(kind *CursorKind)string

func (csCompletionString) Priority()uint32

typeCursor¶

type Cursor struct {// contains filtered or unexported fields}

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

The cursor abstraction unifies the different kinds of entities in aprogram--declaration, statements, expressions, references to declarations,etc.--under a single "cursor" abstraction with a common set of operations.Common operation for a cursor include: getting the physical location ina source file where the cursor points, getting the name associated with acursor, and retrieving cursors for any child nodes of a particular cursor.

Cursors can be produced in two specific ways.clang_getTranslationUnitCursor() produces a cursor for a translation unit,from which one can use clang_visitChildren() to explore the rest of thetranslation unit. clang_getCursor() maps from a physical source locationto the entity that resides at that location, allowing one to map from thesource code into the AST.

func NewNullCursor()Cursor

func (cCursor) AccessSpecifier()AccessSpecifier

func (cCursor) Argument(iuint32)Cursor

func (cCursor) Availability()AvailabilityKind

func (cCursor) BriefCommentText()string

func (cCursor) CXXConstructor_IsConvertingConstructor()bool

func (cCursor) CXXConstructor_IsCopyConstructor()bool

func (cCursor) CXXConstructor_IsDefaultConstructor()bool

func (cCursor) CXXConstructor_IsMoveConstructor()bool

func (cCursor) CXXField_IsMutable()bool

func (cCursor) CXXManglings() *StringSet

func (cCursor) CXXMethod_IsConst()bool

func (cCursor) CXXMethod_IsDefaulted()bool

func (cCursor) CXXMethod_IsPureVirtual()bool

func (cCursor) CXXMethod_IsStatic()bool

func (cCursor) CXXMethod_IsVirtual()bool

func (cCursor) CXXRecord_IsAbstract()bool

func (cCursor) CanonicalCursor()Cursor

func (cCursor) CommentRange()SourceRange

func (cCursor) CompletionString()CompletionString

func (cCursor) DeclObjCTypeEncoding()string

func (cCursor) DeclQualifiers()uint32

func (cCursor) Definition()Cursor

func (cCursor) DefinitionSpellingAndExtent() (string,string,uint32,uint32,uint32,uint32)

func (cCursor) DisplayName()string

func (cCursor) EnumConstantDeclUnsignedValue()uint64

func (cCursor) EnumConstantDeclValue()int64

func (cCursor) EnumDeclIntegerType()Type

func (cCursor) EnumDecl_IsScoped()bool

func (cCursor) Equal(c2Cursor)bool

func (cCursor) Evaluate()EvalResult

func (cCursor) ExceptionSpecificationType()int32

func (cCursor) Extent()SourceRange

func (cCursor) FieldDeclBitWidth()int32

func (cCursor) FindReferencesInFile(fileFile, visitorCursorAndRangeVisitor)Result

func (cCursor) HasAttrs()bool

func (cCursor) HasVarDeclExternalStorage()bool

func (cCursor) HasVarDeclGlobalStorage()bool

func (cCursor) HashCursor()uint32

func (cCursor) IBOutletCollectionType()Type

func (cCursor) IncludedFile()File

func (cCursor) IsAnonymous()bool

func (cCursor) IsAnonymousRecordDecl()bool

func (cCursor) IsBitField()bool

func (cCursor) IsCursorDefinition()bool

func (cCursor) IsDynamicCall()bool

func (cCursor) IsExternalSymbol() (string,string,uint32,bool)

func (cCursor) IsFunctionInlined()bool

func (cCursor) IsInlineNamespace()bool

func (cCursor) IsInvalidDeclaration()bool

func (cCursor) IsMacroBuiltin()bool

func (cCursor) IsMacroFunctionLike()bool

func (cCursor) IsNull()bool

func (cCursor) IsObjCOptional()bool

func (cCursor) IsVariadic()bool

func (cCursor) IsVirtualBase()bool

func (cCursor) Kind()CursorKind

func (cCursor) Language()LanguageKind

func (cCursor) LexicalParent()Cursor

func (cCursor) Linkage()LinkageKind

func (cCursor) Location()SourceLocation

func (cCursor) Mangling()string

func (cCursor) Module()Module

func (cCursor) NumArguments()int32

func (cCursor) NumOverloadedDecls()uint32

func (cCursor) NumTemplateArguments()int32

func (cCursor) ObjCManglings() *StringSet

func (cCursor) OffsetOfField()int64

func (cCursor) OverloadedDecl(indexuint32)Cursor

func (cCursor) OverriddenCursors() []Cursor

func (cCursor) ParsedComment()Comment

func (cCursor) PlatformAvailability(availabilitySizeint) (alwaysDeprecatedbool, deprecated_msgstring, always_unavailablebool, unavailable_msgstring, availability []PlatformAvailability)

func (cCursor) PrettyPrinted(policyPrintingPolicy)string

func (cCursor) PrintingPolicy()PrintingPolicy

func (cCursor) PropertyAttributes(reserveduint32)uint32

func (cCursor) PropertyGetterName()string

func (cCursor) PropertySetterName()string

func (cCursor) RawCommentText()string

func (cCursor) ReceiverType()Type

func (cCursor) ReferenceNameRange(nameFlagsuint32, pieceIndexuint32)SourceRange

func (cCursor) Referenced()Cursor

func (cCursor) ResultType()Type

func (cCursor) SelectorIndex()int32

func (cCursor) SemanticParent()Cursor

func (cCursor) SpecializedCursorTemplate()Cursor

func (cCursor) Spelling()string

func (cCursor) SpellingNameRange(pieceIndexuint32, optionsuint32)SourceRange

func (cCursor) StorageClass()StorageClass

func (cCursor) TLSKind()TLSKind

func (cCursor) TemplateArgumentKind(iuint32)TemplateArgumentKind

func (cCursor) TemplateArgumentType(iuint32)Type

func (cCursor) TemplateArgumentUnsignedValue(iuint32)uint64

func (cCursor) TemplateArgumentValue(iuint32)int64

func (cCursor) TemplateCursorKind()CursorKind

func (cCursor) TranslationUnit()TranslationUnit

func (cCursor) Type()Type

func (cCursor) TypedefDeclUnderlyingType()Type

func (cCursor) USR()string

func (cCursor) VarDeclInitializer()Cursor

func (cCursor) Visibility()VisibilityKind

func (cCursor) Visit(visitorCursorVisitor)bool

func (cCursor) Xdata()int32

typeCursorAndRangeVisitor¶

type CursorAndRangeVisitor struct {// contains filtered or unexported fields}

typeCursorKind¶

type CursorKinduint32

Describes the kind of entity that a cursor refers to.

func (ckCursorKind) IsAttribute()bool

func (ckCursorKind) IsDeclaration()bool

func (ckCursorKind) IsExpression()bool

func (ckCursorKind) IsInvalid()bool

func (ckCursorKind) IsPreprocessing()bool

func (ckCursorKind) IsReference()bool

func (ckCursorKind) IsStatement()bool

func (ckCursorKind) IsTranslationUnit()bool

func (ckCursorKind) IsUnexposed()bool

func (ckCursorKind) Spelling()string

func (ckCursorKind) String()string

typeCursorSet¶

type CursorSet struct {// contains filtered or unexported fields}

A fast container representing a set of CXCursors.

func NewCursorSet()CursorSet

func (csCursorSet) Contains(cursorCursor)uint32

func (csCursorSet) Dispose()

func (csCursorSet) Insert(cursorCursor)uint32

typeCursorVisitor¶

type CursorVisitor func(cursor, parentCursor) (statusChildVisitResult)

CursorVisitor invoked for each cursor found by a traversal.

This visitor function will be invoked for each cursor found byclang_visitCursorChildren(). Its first argument is the cursor beingvisited, its second argument is the parent visitor for that cursor,and its third argument is the client data provided toclang_visitCursorChildren().

The visitor should return one of the ChildVisitResult valuesto direct clang_visitCursorChildren().

typeCursor_ExceptionSpecificationKind¶

type Cursor_ExceptionSpecificationKinduint32

Describes the exception specification of a cursor.

A negative value indicates that the cursor is not a function declaration.

func (ceskCursor_ExceptionSpecificationKind) Spelling()string

func (ceskCursor_ExceptionSpecificationKind) String()string

typeDeclQualifierKind¶

type DeclQualifierKinduint32

'Qualifiers' written next to the return and parameter types in Objective-C method declarations.

func (dqkDeclQualifierKind) Spelling()string

func (dqkDeclQualifierKind) String()string

typeDiagnostic¶

type Diagnostic struct {// contains filtered or unexported fields}

A single diagnostic, containing the diagnostic's severity, location, text, source ranges, and fix-it hints.

func (dDiagnostic) Category()uint32

func (dDiagnostic) CategoryText()string

func (dDiagnostic) ChildDiagnostics()DiagnosticSet

func (dDiagnostic) Dispose()

func (dDiagnostic) FixIt(fixItuint32) (SourceRange,string)

func (dDiagnostic) FormatDiagnostic(optionsuint32)string

func (dDiagnostic) Location()SourceLocation

func (dDiagnostic) NumFixIts()uint32

func (dDiagnostic) NumRanges()uint32

func (dDiagnostic) Option() (string,string)

func (dDiagnostic) Range(ruint32)SourceRange

func (dDiagnostic) Severity()DiagnosticSeverity

func (dDiagnostic) Spelling()string

typeDiagnosticDisplayOptions¶

type DiagnosticDisplayOptionsuint32

Options to control the display of diagnostics.

The values in this enum are meant to be combined to customize thebehavior of clang_formatDiagnostic().