Unit Neslib.Clang

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

Enable/disable crash recovery.

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

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

Returns a default set of code-completion options that can be passed to ITranslationUnit.CodeCompleteAt.

Construct a USR for a specified Objective-C class.

Construct a USR for a specified Objective-C category.

Construct a USR for a specified Objective-C protocol.

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

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

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

Converts a clang-string to a Delphi string. Used internally.

Parameters

ASource

the source clang-string.

ADispose

(optional) whether to dispose the original clang-string. Defaults to True.

Returns

The corresponding Delphi string.

Error codes returned by libclang routines. TError.Success is the only error code indicating success. Other error codes, including not yet assigned non-zero values, indicate errors.

Values

• Success = CXError_Success: No error
• Failure = CXError_Failure: A generic error code, no further details are available.

  Errors of this kind can get their own specific error codes in future libclang versions.

• Crashed = CXError_Crashed: libclang crashed while performing the requested operation.
• InvalidArguments = CXError_InvalidArguments: The function detected that the arguments violate the function contract.
• AstReadError = CXError_ASTReadError: An AST deserialization error has occurred.

Values

• ThreadBackgroundPriorityForIndexing: Used to indicate that threads that libclang creates for indexing purposes should use background priority.
• ThreadBackgroundPriorityForEditing: Used to indicate that threads that libclang creates for editing purposes should use background priority.

Flags that control the creation of translation units.

Values

• DetailedPreprocessingRecord: 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 memory and time to parse, since the information contained in the record is usually not retained. However, it can be useful for applications that require more detailed information about the behavior of the preprocessor.

• Incomplete: Used to indicate that the translation unit is incomplete.

  When a translation unit is considered "incomplete", semantic analysis that is typically performed at the end of the translation unit will be suppressed. For example, this suppresses the completion of tentative declarations in C and of instantiation of implicitly-instantiation function templates in C++. This option is typically used when parsing a header with the intent of producing a precompiled header.

• PrecompiledPreamble: Used to indicate that the translation unit should be built with an implicit precompiled header for the preamble.

  An implicit precompiled header is used as an optimization when a particular translation unit is likely to be reparsed many times when the sources aren't changing that often. In this case, an implicit precompiled header will be built containing all of the initial includes at the top of the main file (what we refer to as the "preamble" of the file). In subsequent parses, if the preamble or the files in it have not changed, ITranslationUnit.Reparse will re-use the implicit precompiled header to improve parsing performance.

• CacheCompletionResults: Used to indicate that the translation unit should cache some code-completion results with each reparse of the source file.

  Caching of code-completion results is a performance optimization that introduces some overhead to reparsing but improves the performance of code-completion operations.

• ForSerialization: Used to indicate that the translation unit will be serialized with ITranslationUnit.Save.

  This option is typically used when parsing a header with the intent of producing a precompiled header.

• CXXChainedPCH: DEPRECATED: Enabled chained precompiled preambles in C++.

  Note: this is a *temporary* option that is available only while we are testing C++ precompiled preamble support. It is deprecated.

• SkipFunctionBodies: Used to indicate that function/method bodies should be skipped while parsing.

  This option can be used to search for declarations/definitions while ignoring the usages.

• IncludeBriefCommentsInCodeCompletion: Used to indicate that brief documentation comments should be included into the set of code completions returned from this translation unit.
• CreatePreambleOnFirstParse: 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).
• KeepGoing: 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 common source for fatal errors are unresolvable include files. For the purposes of an IDE, this is undesirable behavior and as much information as possible should be reported. Use this flag to enable this behavior.

• SingleFileParse: Sets the preprocessor in a mode for parsing a single file only.

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

Values

• OK = CXSaveError_None: Indicates that no error occurred while saving a translation unit.
• Unknown = CXSaveError_Unknown: Indicates that an unknown error occurred while attempting to save the file.

  This error typically indicates that file I/O failed when attempting to write the file.

• TranslationErrors = CXSaveError_TranslationErrors: Indicates that errors during translation prevented this attempt to save the translation unit.

  Errors that prevent the translation unit from being saved can be extracted ITranslationUnit.Diagnostics.

• InvalidTranslationUnit = CXSaveError_InvalidTU: Indicates that the translation unit to be saved was somehow invalid.

Flags that can be passed to ITranslationUnit.CodeCompleteAt to modify its behavior.

Values

• IncludeMacros: Whether to include macros within the set of code completions returned.
• IncludeCodePatterns: Whether to include code patterns for language constructs within the set of code completions, e.g., for loops.
• IncludeBriefComments: Whether to include brief documentation within the set of code completions returned.

Visitors must return one of these values.

Values

• Break = CXVisit_Break: Stop the visitor process.
• Continue = CXVisit_Continue: Continue the visitor process.

Result of a visitor function.

Values

• Success = CXResult_Success: Function returned successfully.
• Invalid = CXResult_Invalid: One of the parameters was invalid for the function.
• VisitBreak = CXResult_VisitBreak: The function was terminated by a callback (e.g. it returned TVisitorResult.Break).

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

A value of this enumeration type should be returned by each TCursorVisitor to indicate how TCursor.VisitChildren proceeds.

Values

• Break = CXChildVisit_Break: Terminates the cursor traversal.
• Continue = CXChildVisit_Continue: Continues the cursor traversal with the next sibling of the cursor just visited, without visiting its children.
• Recurse = CXChildVisit_Recurse: Recursively traverse the children of this cursor, using the same visitor.

Describes the kind of entity that a cursor refers to.

Values

• UnexposedDecl = CXCursor_UnexposedDecl: A declaration whose specific kind is not exposed via this interface.

  Unexposed declarations have the same operations as any other kind of declaration; one can extract their location information, spelling, find their definitions, etc. However, the specific kind of the declaration is not reported.

• StructDecl = CXCursor_StructDecl: A C or C++ struct.
• UnionDecl = CXCursor_UnionDecl: A C or C++ union.
• ClassDecl = CXCursor_ClassDecl: A C++ class.
• EnumDecl = CXCursor_EnumDecl: An enumeration.
• FieldDecl = CXCursor_FieldDecl: A field (in C) or non-static data member (in C++) in a struct, union, or C++ class.
• EnumConstantDecl = CXCursor_EnumConstantDecl: An enumerator constant.
• FunctionDecl = CXCursor_FunctionDecl: A function.
• VarDecl = CXCursor_VarDecl: A variable.
• ParmDecl = CXCursor_ParmDecl: A function or method parameter.
• ObjCInterfaceDecl = CXCursor_ObjCInterfaceDecl: An Objective-C @interface.
• ObjCCategoryDecl = CXCursor_ObjCCategoryDecl: An Objective-C @interface for a category.
• ObjCProtocolDecl = CXCursor_ObjCProtocolDecl: An Objective-C @protocol declaration.
• ObjCPropertyDecl = CXCursor_ObjCPropertyDecl: An Objective-C @property declaration.
• ObjCIvarDecl = CXCursor_ObjCIvarDecl: An Objective-C instance variable.
• ObjCInstanceMethodDecl = CXCursor_ObjCInstanceMethodDecl: An Objective-C instance method.
• ObjCClassMethodDecl = CXCursor_ObjCClassMethodDecl: An Objective-C class method.
• ObjCImplementationDecl = CXCursor_ObjCImplementationDecl: An Objective-C @implementation.
• ObjCCategoryImplDecl = CXCursor_ObjCCategoryImplDecl: An Objective-C @implementation for a category.
• TypedefDecl = CXCursor_TypedefDecl: A typedef.
• CXXMethod = CXCursor_CXXMethod: A C++ class method.
• Namespace = CXCursor_Namespace: A C++ namespace.
• LinkageSpec = CXCursor_LinkageSpec: A linkage specification, e.g. 'extern "C"'.
• Cor = CXCursor_Constructor: A C++ constructor.
• Dtor = CXCursor_Destructor: A C++ destructor.
• ConversionFunction = CXCursor_ConversionFunction: A C++ conversion function.
• TemplateTypeParameter = CXCursor_TemplateTypeParameter: A C++ template type parameter.
• NonTypeTemplateParameter = CXCursor_NonTypeTemplateParameter: A C++ non-type template parameter.
• TemplateTemplateParameter = CXCursor_TemplateTemplateParameter: A C++ template template parameter.
• FunctionTemplate = CXCursor_FunctionTemplate: A C++ function template.
• ClassTemplate = CXCursor_ClassTemplate: A C++ class template.
• ClassTemplatePartialSpecialization = CXCursor_ClassTemplatePartialSpecialization: A C++ class template partial specialization.
• NamespaceAlias = CXCursor_NamespaceAlias: A C++ namespace alias declaration.
• UsingDirective = CXCursor_UsingDirective: A C++ using directive.
• UsingDeclaration = CXCursor_UsingDeclaration: A C++ using declaration.
• TypeAliasDecl = CXCursor_TypeAliasDecl: A C++ alias declaration
• ObjCSynthesizeDecl = CXCursor_ObjCSynthesizeDecl: An Objective-C @synthesize definition.
• ObjCDynamicDecl = CXCursor_ObjCDynamicDecl: An Objective-C @dynamic definition.
• CXXAccessSpecifier = CXCursor_CXXAccessSpecifier: An access specifier.
• FirstDecl = CXCursor_FirstDecl:  
• LastDecl = CXCursor_LastDecl:  
• FirstRef = CXCursor_FirstRef: References
• ObjCSuperClassRef = CXCursor_ObjCSuperClassRef:  
• ObjCProtocolRef = CXCursor_ObjCProtocolRef:  
• ObjCClassRef = CXCursor_ObjCClassRef:  
• TypeRef = CXCursor_TypeRef: A reference to a type declaration.

  A type reference occurs anywhere where a type is named but not declared. For example, given:

          typedef unsigned size_type;
          size_type size;
        

  The typedef is a declaration of size_type (TypedefDecl), while the type of the variable "size" is referenced. The cursor referenced by the type of size is the typedef for size_type.

• CXXBaseSpecifier = CXCursor_CXXBaseSpecifier:  
• TemplateRef = CXCursor_TemplateRef: A reference to a class template, function template, template parameter, or class template partial specialization.
• NamespaceRef = CXCursor_NamespaceRef: A reference to a namespace or namespace alias.
• MemberRef = CXCursor_MemberRef: A reference to a member of a struct, union, or class that occurs in some non-expression context, e.g., a designated initializer.
• LabelRef = CXCursor_LabelRef: A reference to a labeled statement.

  This cursor kind is used to describe the jump to "start_over" in the goto statement in the following example:

          start_over:
            ++counter;
  
            goto start_over;
        

  A label reference cursor refers to a label statement.

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

  An overloaded declaration reference cursor occurs in C++ templates where a dependent name refers to a function. For example:

          template<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&);
        

  Here, the identifier "swap" is associated with an overloaded declaration reference. In the template definition, "swap" refers to either of the two "swap" functions declared above, so both results will be available. At instantiation time, "swap" may also refer to other functions found via argument-dependent lookup (e.g., the "swap" function at the end of the example).

  The property TCursor.OverloadedDecls can be used to retrieve the definitions referenced by this cursor.

• VariableRef = CXCursor_VariableRef: A reference to a variable that occurs in some non-expression context, e.g., a C++ lambda capture list.
• LastRef = CXCursor_LastRef:  
• FirstInvalid = CXCursor_FirstInvalid: Error conditions
• InvalidFile = CXCursor_InvalidFile:  
• NoDeclFound = CXCursor_NoDeclFound:  
• NotImplemented = CXCursor_NotImplemented:  
• InvalidCode = CXCursor_InvalidCode:  
• LastInvalid = CXCursor_LastInvalid:  
• FirstExpr = CXCursor_FirstExpr: Expressions
• UnexposedExpr = CXCursor_UnexposedExpr: An expression whose specific kind is not exposed via this interface.

  Unexposed expressions have the same operations as any other kind of expression; one can extract their location information, spelling, children, etc. However, the specific kind of the expression is not reported.

• DeclRefExpr = CXCursor_DeclRefExpr: An expression that refers to some value declaration, such as a function, variable, or enumerator.
• MemberRefExpr = CXCursor_MemberRefExpr: An expression that refers to a member of a struct, union, class, Objective-C class, etc.
• CallExpr = CXCursor_CallExpr: An expression that calls a function.
• ObjCMessageExpr = CXCursor_ObjCMessageExpr: An expression that sends a message to an Objective-C object or class.
• BlockExpr = CXCursor_BlockExpr: An expression that represents a block literal.
• IntegerLiteral = CXCursor_IntegerLiteral: An integer literal.
• FloatingLiteral = CXCursor_FloatingLiteral: A floating point number literal.
• ImaginaryLiteral = CXCursor_ImaginaryLiteral: An imaginary number literal.
• StringLiteral = CXCursor_StringLiteral: A string literal.
• CharacterLiteral = CXCursor_CharacterLiteral: A character literal.
• ParenExpr = CXCursor_ParenExpr: A parenthesized expression, e.g. "(1)". This AST node is only formed if full location information is requested.
• UnaryOperator = CXCursor_UnaryOperator: This represents the unary-expression's (except sizeof and alignof).
• ArraySubscriptExpr = CXCursor_ArraySubscriptExpr: [C99 6.5.2.1] Array Subscripting.
• BinaryOperator = CXCursor_BinaryOperator: A builtin binary operation expression such as "x + y" or "x <= y".
• CompoundAssignOperator = CXCursor_CompoundAssignOperator: Compound assignment such as "+=".
• ConditionalOperator = CXCursor_ConditionalOperator: The ?: ternary operator.
• CStyleCastExpr = CXCursor_CStyleCastExpr: An explicit cast in C (C99 6.5.4) or a C-style cast in C++ (C++ [expr.cast]), which uses the syntax (Type)expr. For example: (int)f.
• CompoundLiteralExpr = CXCursor_CompoundLiteralExpr: [C99 6.5.2.5]
• InitListExpr = CXCursor_InitListExpr: Describes an C or C++ initializer list.
• AddrLabelExpr = CXCursor_AddrLabelExpr: The GNU address of label extension, representing &&label.
• StmtExpr = CXCursor_StmtExpr: This is the GNU Statement Expression extension: ({int X=4; X;})
• GenericSelectionExpr = CXCursor_GenericSelectionExpr: Represents a C11 generic selection.
• GNUNullExpr = CXCursor_GNUNullExpr: Implements the GNU __null extension, which is a name for a null pointer constant that has integral type (e.g., int or long) and is the same size and alignment as a pointer.

  The __null extension is typically only used by system headers, which define NULL as __null in C++ rather than using 0 (which is an integer that may not match the size of a pointer).

• CXXStaticCastExpr = CXCursor_CXXStaticCastExpr: C++'s static_cast<> expression.
• CXXDynamicCastExpr = CXCursor_CXXDynamicCastExpr: C++'s dynamic_cast<> expression.
• CXXReinterpretCastExpr = CXCursor_CXXReinterpretCastExpr: C++'s reinterpret_cast<> expression.
• CXXConstCastExpr = CXCursor_CXXConstCastExpr: C++'s const_cast<> expression.
• CXXFunctionalCastExpr = CXCursor_CXXFunctionalCastExpr: Represents an explicit C++ type conversion that uses "functional" notion (C++ [expr.type.conv]). Example: x = int(0.5);
• CXXTypeidExpr = CXCursor_CXXTypeidExpr: A C++ typeid expression (C++ [expr.typeid]).
• CXXBoolLiteralExpr = CXCursor_CXXBoolLiteralExpr: [C++ 2.13.5] C++ Boolean Literal.
• CXXNullPtrLiteralExpr = CXCursor_CXXNullPtrLiteralExpr: [C++0x 2.14.7] C++ Pointer Literal.
• CXXThisExpr = CXCursor_CXXThisExpr: Represents the "this" expression in C++
• CXXThrowExpr = CXCursor_CXXThrowExpr: [C++ 15] C++ Throw Expression. This handles 'throw' and 'throw' assignment-expression. When assignment-expression isn't present, Op will be null.
• CXXNewExpr = CXCursor_CXXNewExpr: A new expression for memory allocation and constructor calls, e.g: "new CXXNewExpr(foo)".
• CXXDeleteExpr = CXCursor_CXXDeleteExpr: A delete expression for memory deallocation and destructor calls, e.g. "delete[] pArray".
• UnaryExpr = CXCursor_UnaryExpr: A unary expression. (noexcept, sizeof, or other traits)
• ObjCStringLiteral = CXCursor_ObjCStringLiteral: An Objective-C string literal i.e. @"foo".
• ObjCEncodeExpr = CXCursor_ObjCEncodeExpr: An Objective-C @encode expression.
• ObjCSelectorExpr = CXCursor_ObjCSelectorExpr: An Objective-C @selector expression.
• ObjCProtocolExpr = CXCursor_ObjCProtocolExpr: An Objective-C @protocol expression.
• ObjCBridgedCastExpr = CXCursor_ObjCBridgedCastExpr: An Objective-C "bridged" cast expression, which casts between Objective-C pointers and C pointers, transferring ownership in the process. NSString *str = (__bridge_transfer NSString *)CFCreateString();
• PackExpansionExpr = CXCursor_PackExpansionExpr: Represents a C++0x pack expansion that produces a sequence of expressions.

  A pack expansion expression contains a pattern (which itself is an expression) followed by an ellipsis. For example:

          template<typename F, typename ...Types>
          void forward(F f, Types &&...args) {
            f(static_cast<Types&&>(args)...);
          };
        

• SizeOfPackExpr = CXCursor_SizeOfPackExpr: Represents an expression that computes the length of a parameter pack.

  template<typename ...Types> struct count { static const unsigned value = sizeof...(Types); };

• LambdaExpr = CXCursor_LambdaExpr: Represents a C++ lambda expression that produces a local function object.

  void abssort(float *x, unsigned N) { std::sort(x, x + N, [](float a, float b) { return std::abs(a) < std::abs(b); }); }

• ObjCBoolLiteralExpr = CXCursor_ObjCBoolLiteralExpr: Objective-c Boolean Literal.
• ObjCSelfExpr = CXCursor_ObjCSelfExpr: Represents the "self" expression in an Objective-C method.
• OMPArraySectionExpr = CXCursor_OMPArraySectionExpr: OpenMP 4.0 [2.4, Array Section].
• ObjCAvailabilityCheckExpr = CXCursor_ObjCAvailabilityCheckExpr: Represents an @available(...) check.
• LastExpr = CXCursor_LastExpr:  
• FirstStmt = CXCursor_FirstStmt: Statements
• UnexposedStmt = CXCursor_UnexposedStmt: A statement whose specific kind is not exposed via this interface.

  Unexposed statements have the same operations as any other kind of statement; one can extract their location information, spelling, children, etc. However, the specific kind of the statement is not reported.

• LabelStmt = CXCursor_LabelStmt: A labelled statement in a function.

  This cursor kind is used to describe the "start_over:" label statement in the following example:

          start_over:
            ++counter;
        

• CompoundStmt = CXCursor_CompoundStmt: A group of statements like { stmt stmt }.

  This cursor kind is used to describe compound statements, e.g. function bodies.

• CaseStmt = CXCursor_CaseStmt: A case statement.
• DefaultStmt = CXCursor_DefaultStmt: A default statement.
• IfStmt = CXCursor_IfStmt: An if statement
• SwitchStmt = CXCursor_SwitchStmt: A switch statement.
• WhileStmt = CXCursor_WhileStmt: A while statement.
• DoStmt = CXCursor_DoStmt: A do statement.
• ForStmt = CXCursor_ForStmt: A for statement.
• GotoStmt = CXCursor_GotoStmt: A goto statement.
• IndirectGotoStmt = CXCursor_IndirectGotoStmt: An indirect goto statement.
• ContinueStmt = CXCursor_ContinueStmt: A continue statement.
• BreakStmt = CXCursor_BreakStmt: A break statement.
• ReturnStmt = CXCursor_ReturnStmt: A return statement.
• GCCAsmStmt = CXCursor_GCCAsmStmt: A GCC inline assembly statement extension.
• AsmStmt = CXCursor_AsmStmt:  
• ObjCAtTryStmt = CXCursor_ObjCAtTryStmt: Objective-C's overall @try-@catch-@finally statement.
• ObjCAtCatchStmt = CXCursor_ObjCAtCatchStmt: Objective-C's @catch statement.
• ObjCAtFinallyStmt = CXCursor_ObjCAtFinallyStmt: Objective-C's @finally statement.
• ObjCAtThrowStmt = CXCursor_ObjCAtThrowStmt: Objective-C's @throw statement.
• ObjCAtSynchronizedStmt = CXCursor_ObjCAtSynchronizedStmt: Objective-C's @synchronized statement.
• ObjCAutoreleasePoolStmt = CXCursor_ObjCAutoreleasePoolStmt: Objective-C's autorelease pool statement.
• ObjCForCollectionStmt = CXCursor_ObjCForCollectionStmt: Objective-C's collection statement.
• CXXCatchStmt = CXCursor_CXXCatchStmt: C++'s catch statement.
• CXXTryStmt = CXCursor_CXXTryStmt: C++'s try statement.
• CXXForRangeStmt = CXCursor_CXXForRangeStmt: C++'s for (* : *) statement.
• SEHTryStmt = CXCursor_SEHTryStmt: Windows Structured Exception Handling's try statement.
• SEHExceptStmt = CXCursor_SEHExceptStmt: Windows Structured Exception Handling's except statement.
• SEHFinallyStmt = CXCursor_SEHFinallyStmt: Windows Structured Exception Handling's finally statement.
• MSAsmStmt = CXCursor_MSAsmStmt: A MS inline assembly statement extension.
• NullStmt = CXCursor_NullStmt: The null statement ";": C99 6.8.3p3. This cursor kind is used to describe the null statement.
• DeclStmt = CXCursor_DeclStmt: Adaptor class for mixing declarations with statements and expressions.
• OMPParallelDirective = CXCursor_OMPParallelDirective: OpenMP parallel directive.
• OMPSimdDirective = CXCursor_OMPSimdDirective: OpenMP SIMD directive.
• OMPForDirective = CXCursor_OMPForDirective: OpenMP for directive.
• OMPSectionsDirective = CXCursor_OMPSectionsDirective: OpenMP sections directive.
• OMPSectionDirective = CXCursor_OMPSectionDirective: OpenMP section directive.
• OMPSingleDirective = CXCursor_OMPSingleDirective: OpenMP single directive.
• OMPParallelForDirective = CXCursor_OMPParallelForDirective: OpenMP parallel for directive.
• OMPParallelSectionsDirective = CXCursor_OMPParallelSectionsDirective: OpenMP parallel sections directive.
• OMPTaskDirective = CXCursor_OMPTaskDirective: OpenMP task directive.
• OMPMasterDirective = CXCursor_OMPMasterDirective: OpenMP master directive.
• OMPCriticalDirective = CXCursor_OMPCriticalDirective: OpenMP critical directive.
• OMPTaskyieldDirective = CXCursor_OMPTaskyieldDirective: OpenMP taskyield directive.
• OMPBarrierDirective = CXCursor_OMPBarrierDirective: OpenMP barrier directive.
• OMPTaskwaitDirective = CXCursor_OMPTaskwaitDirective: OpenMP taskwait directive.
• OMPFlushDirective = CXCursor_OMPFlushDirective: OpenMP flush directive.
• SEHLeaveStmt = CXCursor_SEHLeaveStmt: Windows Structured Exception Handling's leave statement.
• OMPOrderedDirective = CXCursor_OMPOrderedDirective: OpenMP ordered directive.
• OMPAtomicDirective = CXCursor_OMPAtomicDirective: OpenMP atomic directive.
• OMPForSimdDirective = CXCursor_OMPForSimdDirective: OpenMP for SIMD directive.
• OMPParallelForSimdDirective = CXCursor_OMPParallelForSimdDirective: OpenMP parallel for SIMD directive.
• OMPTargetDirective = CXCursor_OMPTargetDirective: OpenMP target directive.
• OMPTeamsDirective = CXCursor_OMPTeamsDirective: OpenMP teams directive.
• OMPTaskgroupDirective = CXCursor_OMPTaskgroupDirective: OpenMP taskgroup directive.
• OMPCancellationPointDirective = CXCursor_OMPCancellationPointDirective: OpenMP cancellation point directive.
• OMPCancelDirective = CXCursor_OMPCancelDirective: OpenMP cancel directive.
• OMPTargetDataDirective = CXCursor_OMPTargetDataDirective: OpenMP target data directive.
• OMPTaskLoopDirective = CXCursor_OMPTaskLoopDirective: OpenMP taskloop directive.
• OMPTaskLoopSimdDirective = CXCursor_OMPTaskLoopSimdDirective: OpenMP taskloop simd directive.
• OMPDistributeDirective = CXCursor_OMPDistributeDirective: OpenMP distribute directive.
• OMPTargetEnterDataDirective = CXCursor_OMPTargetEnterDataDirective: OpenMP target enter data directive.
• OMPTargetExitDataDirective = CXCursor_OMPTargetExitDataDirective: OpenMP target exit data directive.
• OMPTargetParallelDirective = CXCursor_OMPTargetParallelDirective: OpenMP target parallel directive.
• OMPTargetParallelForDirective = CXCursor_OMPTargetParallelForDirective: OpenMP target parallel for directive.
• OMPTargetUpdateDirective = CXCursor_OMPTargetUpdateDirective: OpenMP target update directive.
• OMPDistributeParallelForDirective = CXCursor_OMPDistributeParallelForDirective: OpenMP distribute parallel for directive.
• OMPDistributeParallelForSimdDirective = CXCursor_OMPDistributeParallelForSimdDirective: OpenMP distribute parallel for simd directive.
• OMPDistributeSimdDirective = CXCursor_OMPDistributeSimdDirective: OpenMP distribute simd directive.
• OMPTargetParallelForSimdDirective = CXCursor_OMPTargetParallelForSimdDirective: OpenMP target parallel for simd directive.
• OMPTargetSimdDirective = CXCursor_OMPTargetSimdDirective: OpenMP target simd directive.
• OMPTeamsDistributeDirective = CXCursor_OMPTeamsDistributeDirective: OpenMP teams distribute directive.
• OMPTeamsDistributeSimdDirective = CXCursor_OMPTeamsDistributeSimdDirective: OpenMP teams distribute simd directive.
• OMPTeamsDistributeParallelForSimdDirective = CXCursor_OMPTeamsDistributeParallelForSimdDirective: OpenMP teams distribute parallel for simd directive.
• OMPTeamsDistributeParallelForDirective = CXCursor_OMPTeamsDistributeParallelForDirective: OpenMP teams distribute parallel for directive.
• OMPTargetTeamsDirective = CXCursor_OMPTargetTeamsDirective: OpenMP target teams directive.
• OMPTargetTeamsDistributeDirective = CXCursor_OMPTargetTeamsDistributeDirective: OpenMP target teams distribute directive.
• OMPTargetTeamsDistributeParallelForDirective = CXCursor_OMPTargetTeamsDistributeParallelForDirective: OpenMP target teams distribute parallel for directive.
• OMPTargetTeamsDistributeParallelForSimdDirective = CXCursor_OMPTargetTeamsDistributeParallelForSimdDirective: OpenMP target teams distribute parallel for simd directive.
• OMPTargetTeamsDistributeSimdDirective = CXCursor_OMPTargetTeamsDistributeSimdDirective: OpenMP target teams distribute simd directive.
• LastStmt = CXCursor_LastStmt:  
• TranslationUnit = CXCursor_TranslationUnit: Cursor that represents the translation unit itself.

  The translation unit cursor exists primarily to act as the root cursor for traversing the contents of a translation unit.

• FirstAttr = CXCursor_FirstAttr: Attributes
• UnexposedAttr = CXCursor_UnexposedAttr: An attribute whose specific kind is not exposed via this interface.
• IBActionAttr = CXCursor_IBActionAttr:  
• IBOutletAttr = CXCursor_IBOutletAttr:  
• IBOutletCollectionAttr = CXCursor_IBOutletCollectionAttr:  
• CXXFinalAttr = CXCursor_CXXFinalAttr:  
• CXXOverrideAttr = CXCursor_CXXOverrideAttr:  
• AnnotateAttr = CXCursor_AnnotateAttr:  
• AsmLabelAttr = CXCursor_AsmLabelAttr:  
• PackedAttr = CXCursor_PackedAttr:  
• PureAttr = CXCursor_PureAttr:  
• ConstAttr = CXCursor_ConstAttr:  
• NoDuplicateAttr = CXCursor_NoDuplicateAttr:  
• CUDAConstantAttr = CXCursor_CUDAConstantAttr:  
• CUDADeviceAttr = CXCursor_CUDADeviceAttr:  
• CUDAGlobalAttr = CXCursor_CUDAGlobalAttr:  
• CUDAHostAttr = CXCursor_CUDAHostAttr:  
• CUDASharedAttr = CXCursor_CUDASharedAttr:  
• VisibilityAttr = CXCursor_VisibilityAttr:  
• DLLExport = CXCursor_DLLExport:  
• DLLImport = CXCursor_DLLImport:  
• LastAttr = CXCursor_LastAttr:  
• PreprocessingDirective = CXCursor_PreprocessingDirective: Preprocessing
• MacroDefinition = CXCursor_MacroDefinition:  
• MacroExpansion = CXCursor_MacroExpansion:  
• MacroInstantiation = CXCursor_MacroInstantiation:  
• InclusionDirective = CXCursor_InclusionDirective:  
• FirstPreprocessing = CXCursor_FirstPreprocessing:  
• LastPreprocessing = CXCursor_LastPreprocessing:  
• ModuleImportDecl = CXCursor_ModuleImportDecl: A module import declaration.
• TypeAliasTemplateDecl = CXCursor_TypeAliasTemplateDecl:  
• StaticAssert = CXCursor_StaticAssert: A static_assert or _Static_assert node
• FriendDecl = CXCursor_FriendDecl: A friend declaration.
• FirstExtraDecl = CXCursor_FirstExtraDecl:  
• LastExtraDecl = CXCursor_LastExtraDecl:  
• OverloadCandidate = CXCursor_OverloadCandidate: A code completion overload candidate.

Describes the kind of a type

Values

• Invalid = CXType_Invalid: Represents an invalid type (e.g., where no type is available).
• Unexposed = CXType_Unexposed: A type whose specific kind is not exposed via this interface.
• Void = CXType_Void: Builtin types
• Bool = CXType_Bool:  
• Char_U = CXType_Char_U:  
• UChar = CXType_UChar:  
• Char16 = CXType_Char16:  
• Char32 = CXType_Char32:  
• UShort = CXType_UShort:  
• UInt = CXType_UInt:  
• ULong = CXType_ULong:  
• ULongLong = CXType_ULongLong:  
• UInt128 = CXType_UInt128:  
• Char_S = CXType_Char_S:  
• SChar = CXType_SChar:  
• WChar = CXType_WChar:  
• Short = CXType_Short:  
• Int = CXType_Int:  
• Long = CXType_Long:  
• LongLong = CXType_LongLong:  
• Int128 = CXType_Int128:  
• Float = CXType_Float:  
• Double = CXType_Double:  
• LongDouble = CXType_LongDouble:  
• NullPtr = CXType_NullPtr:  
• Overload = CXType_Overload:  
• Dependent = CXType_Dependent:  
• ObjCId = CXType_ObjCId:  
• ObjCClass = CXType_ObjCClass:  
• ObjCSel = CXType_ObjCSel:  
• Float128 = CXType_Float128:  
• Half = CXType_Half:  
• Float16 = CXType_Float16:  
• FirstBuiltin = CXType_FirstBuiltin:  
• LastBuiltin = CXType_LastBuiltin:  
• Complex = CXType_Complex:  
• Pointer = CXType_Pointer:  
• BlockPointer = CXType_BlockPointer:  
• LValueReference = CXType_LValueReference:  
• RValueReference = CXType_RValueReference:  
• Rec = CXType_Record:  
• Enum = CXType_Enum:  
• Typedef = CXType_Typedef:  
• ObjCInterface = CXType_ObjCInterface:  
• ObjCObjectPointer = CXType_ObjCObjectPointer:  
• FunctionNoProto = CXType_FunctionNoProto:  
• FunctionProto = CXType_FunctionProto:  
• ConstantArray = CXType_ConstantArray:  
• Vector = CXType_Vector:  
• IncompleteArray = CXType_IncompleteArray:  
• VariableArray = CXType_VariableArray:  
• DependentSizedArray = CXType_DependentSizedArray:  
• MemberPointer = CXType_MemberPointer:  
• Auto = CXType_Auto:  
• Elaborated = 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.
• Pipe = CXType_Pipe: OpenCL PipeType.
• OCLImage1dRO = CXType_OCLImage1dRO: OpenCL builtin types.
• OCLImage1dArrayRO = CXType_OCLImage1dArrayRO:  
• OCLImage1dBufferRO = CXType_OCLImage1dBufferRO:  
• OCLImage2dRO = CXType_OCLImage2dRO:  
• OCLImage2dArrayRO = CXType_OCLImage2dArrayRO:  
• OCLImage2dDepthRO = CXType_OCLImage2dDepthRO:  
• OCLImage2dArrayDepthRO = CXType_OCLImage2dArrayDepthRO:  
• OCLImage2dMSAARO = CXType_OCLImage2dMSAARO:  
• OCLImage2dArrayMSAARO = CXType_OCLImage2dArrayMSAARO:  
• OCLImage2dMSAADepthRO = CXType_OCLImage2dMSAADepthRO:  
• OCLImage2dArrayMSAADepthRO = CXType_OCLImage2dArrayMSAADepthRO:  
• OCLImage3dRO = CXType_OCLImage3dRO:  
• OCLImage1dWO = CXType_OCLImage1dWO:  
• OCLImage1dArrayWO = CXType_OCLImage1dArrayWO:  
• OCLImage1dBufferWO = CXType_OCLImage1dBufferWO:  
• OCLImage2dWO = CXType_OCLImage2dWO:  
• OCLImage2dArrayWO = CXType_OCLImage2dArrayWO:  
• OCLImage2dDepthWO = CXType_OCLImage2dDepthWO:  
• OCLImage2dArrayDepthWO = CXType_OCLImage2dArrayDepthWO:  
• OCLImage2dMSAAWO = CXType_OCLImage2dMSAAWO:  
• OCLImage2dArrayMSAAWO = CXType_OCLImage2dArrayMSAAWO:  
• OCLImage2dMSAADepthWO = CXType_OCLImage2dMSAADepthWO:  
• OCLImage2dArrayMSAADepthWO = CXType_OCLImage2dArrayMSAADepthWO:  
• OCLImage3dWO = CXType_OCLImage3dWO:  
• OCLImage1dRW = CXType_OCLImage1dRW:  
• OCLImage1dArrayRW = CXType_OCLImage1dArrayRW:  
• OCLImage1dBufferRW = CXType_OCLImage1dBufferRW:  
• OCLImage2dRW = CXType_OCLImage2dRW:  
• OCLImage2dArrayRW = CXType_OCLImage2dArrayRW:  
• OCLImage2dDepthRW = CXType_OCLImage2dDepthRW:  
• OCLImage2dArrayDepthRW = CXType_OCLImage2dArrayDepthRW:  
• OCLImage2dMSAARW = CXType_OCLImage2dMSAARW:  
• OCLImage2dArrayMSAARW = CXType_OCLImage2dArrayMSAARW:  
• OCLImage2dMSAADepthRW = CXType_OCLImage2dMSAADepthRW:  
• OCLImage2dArrayMSAADepthRW = CXType_OCLImage2dArrayMSAADepthRW:  
• OCLImage3dRW = CXType_OCLImage3dRW:  
• OCLSampler = CXType_OCLSampler:  
• OCLEvent = CXType_OCLEvent:  
• OCLQueue = CXType_OCLQueue:  
• OCLReserveID = CXType_OCLReserveID:  

Describes the kind of a template argument.

Values

• Null = CXTemplateArgumentKind_Null:  
• Typ = CXTemplateArgumentKind_Type:  
• Declaration = CXTemplateArgumentKind_Declaration:  
• NullPtr = CXTemplateArgumentKind_NullPtr:  
• Integral = CXTemplateArgumentKind_Integral:  
• Template = CXTemplateArgumentKind_Template:  
• TemplateExpansion = CXTemplateArgumentKind_TemplateExpansion:  
• Expression = CXTemplateArgumentKind_Expression:  
• Pack = CXTemplateArgumentKind_Pack:  
• Invalid = CXTemplateArgumentKind_Invalid: Indicates an error case, preventing the kind from being deduced.

The linkage of the entity referred to by a cursor.

Values

• Invalid = CXLinkage_Invalid: This value indicates that no linkage information is available for a provided TCursor.
• NoLinkage = CXLinkage_NoLinkage: This is the linkage for variables, parameters, and so on that have automatic storage. This covers normal (non-extern) local variables.
• Internal = CXLinkage_Internal: This is the linkage for static variables and static functions.
• UniqueExternal = CXLinkage_UniqueExternal: This is the linkage for entities with external linkage that live in C++ anonymous namespaces.
• External = CXLinkage_External: This is the linkage for entities with true, external linkage.

The visibility of an entity referenced by a cursor.

Values

• Invalid = CXVisibility_Invalid: This value indicates that no visibility information is available for a provided TCursor.
• Hidden = CXVisibility_Hidden: Symbol not seen by the linker.
• Protected = CXVisibility_Protected: Symbol seen by the linker but resolves to a symbol inside this object.
• Default = CXVisibility_Default: Symbol seen by the linker and acts like a normal symbol.

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.

Values

• Available = CXAvailability_Available: The entity is available.
• Deprecated = CXAvailability_Deprecated: The entity is available, but has been deprecated (and its use is not recommended).
• NotAvailable = CXAvailability_NotAvailable: The entity is not available; any use of it will be an error.
• NotAccessible = CXAvailability_NotAccessible: The entity is available, but not accessible; any use of it will be an error.

The "language" of the entity referred to by a cursor

Values

• Invalid = CXLanguage_Invalid:  
• C = CXLanguage_C:  
• ObjC = CXLanguage_ObjC:  
• CPlusPlus = CXLanguage_CPlusPlus:  

The C++ access control level to a base class for a cursor with kind CXXBaseSpecifier.

Values

• Invalid = CX_CXXInvalidAccessSpecifier:  
• Public = CX_CXXPublic:  
• Protected = CX_CXXProtected:  
• Private = CX_CXXPrivate:  

The storage classes as declared in the source. Option Invalid was added for the case that the passed cursor in not a declaration.

Values

• Invalid = CX_SC_Invalid:  
• None = CX_SC_None:  
• Extern = CX_SC_Extern:  
• Static = CX_SC_Static:  
• PrivateExtern = CX_SC_PrivateExtern:  
• OpenCLWorkGroupLocal = CX_SC_OpenCLWorkGroupLocal:  
• Auto = CX_SC_Auto:  
• Register = CX_SC_Register:  

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

Values

• None = CXTLS_None:  
• Dynamic = CXTLS_Dynamic:  
• Static = CXTLS_Static:  

Property attributes for a ObjCPropertyDecl cursors.

Values

• ReadOnly:  
• Getter:  
• Assign:  
• ReadWrite:  
• Retain:  
• Copy:  
• NonAtomic:  
• Setter:  
• Atomic:  
• Weak:  
• Strong:  
• UnsafeRetained:  
• Clas:  

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

Values

• Input:  
• InOut:  
• Output:  
• ByCopy:  
• ByRef:  
• OneWay:  

Name reference flags

Values

• WantQualifier: Include the nested-name-specifier, e.g. Foo:: in x.Foo::y, in the range.
• WantTemplateArgs: Include the explicit template arguments, e.g. <int> in x.f<int>, in the range.
• WantSinglePiece: If the name is non-contiguous, return the full spanning range. Non-contiguous names occur in Objective-C when a selector with two or more parameters is used, or in C++ when using an operator:

  [object doSomething:here withValue:there]; // Objective-C return some_vector[1]; // C++

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

Values

• None = CXLoadDiag_None: Indicates that no error occurred.
• Unknown = CXLoadDiag_Unknown: Indicates that an unknown error occurred while attempting to deserialize diagnostics.
• CannotLoad = CXLoadDiag_CannotLoad: Indicates that the file containing the serialized diagnostics could not be opened.
• InvalidFile = CXLoadDiag_InvalidFile: Indicates that the serialized diagnostics file is invalid or corrupt.

Options to control the display of diagnostics.

Values

• DisplaySourceLocation: Display the source-location information where the diagnostic was located.

  When set, diagnostics will be prefixed by the file, line, and (optionally) column to which the diagnostic refers. For example,

          test.c:28: warning: extra tokens at end of #endif directive
        

  This option corresponds to the clang flag -fshow-source-location.

• DisplayColumn: If displaying the source-location information of the diagnostic, also include the column number.

  This option corresponds to the clang flag -fshow-column.

• DisplaySourceRanges: If displaying the source-location information of the diagnostic, also include information about source ranges in a machine-parsable format.

  This option corresponds to the clang flag -fdiagnostics-print-source-range-info.

• DisplayOption: Display the option name associated with this diagnostic, if any.

  The option name displayed (e.g., -Wconversion) will be placed in brackets after the diagnostic text. This option corresponds to the clang flag -fdiagnostics-show-option.

• DisplayCategoryId: 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.

• DisplayCategoryName: 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.

The severity of a particular diagnostic.

Values

• Ignored = CXDiagnostic_Ignored: A diagnostic that has been suppressed, e.g., by a command-line option.
• Note = CXDiagnostic_Note: This diagnostic is a note that should be attached to the previous (non-note) diagnostic.
• Warning = CXDiagnostic_Warning: This diagnostic indicates suspicious code that may not be wrong.
• Error = CXDiagnostic_Error: This diagnostic indicates that the code is ill-formed.
• Fatal = CXDiagnostic_Fatal: This diagnostic indicates that the code is ill-formed such that future parser recovery is unlikely to produce useful results.

Categorizes how memory is being used by a translation unit.

Values

• AST = CXTUResourceUsage_AST:  
• Identifiers = CXTUResourceUsage_Identifiers:  
• Selectors = CXTUResourceUsage_Selectors:  
• GlobalCompletionResults = CXTUResourceUsage_GlobalCompletionResults:  
• SourceManagerContentCache = CXTUResourceUsage_SourceManagerContentCache:  
• AST_SideTables = CXTUResourceUsage_AST_SideTables:  
• SourceManager_Membuffer_Malloc = CXTUResourceUsage_SourceManager_Membuffer_Malloc:  
• SourceManager_Membuffer_MMap = CXTUResourceUsage_SourceManager_Membuffer_MMap:  
• ExternalASTSource_Membuffer_Malloc = CXTUResourceUsage_ExternalASTSource_Membuffer_Malloc:  
• ExternalASTSource_Membuffer_MMap = CXTUResourceUsage_ExternalASTSource_Membuffer_MMap:  
• Preprocessor = CXTUResourceUsage_Preprocessor:  
• PreprocessingRecord = CXTUResourceUsage_PreprocessingRecord:  
• SourceManager_DataStructures = CXTUResourceUsage_SourceManager_DataStructures:  
• Preprocessor_HeaderSearch = CXTUResourceUsage_Preprocessor_HeaderSearch:  

Describes the calling convention of a function type

Values

• Default = CXCallingConv_Default:  
• C = CXCallingConv_C:  
• X86StdCall = CXCallingConv_X86StdCall:  
• X86FastCall = CXCallingConv_X86FastCall:  
• X86ThisCall = CXCallingConv_X86ThisCall:  
• X86Pascal = CXCallingConv_X86Pascal:  
• AAPCS = CXCallingConv_AAPCS:  
• AAPCS_VFP = CXCallingConv_AAPCS_VFP:  
• X86RegCall = CXCallingConv_X86RegCall:  
• IntelOclBicc = CXCallingConv_IntelOclBicc:  
• Win64 = CXCallingConv_Win64:  
• X86_64Win64 = CXCallingConv_X86_64Win64:  
• X86_64SysV = CXCallingConv_X86_64SysV:  
• X86VectorCall = CXCallingConv_X86VectorCall:  
• Swift = CXCallingConv_Swift:  
• PreserveMost = CXCallingConv_PreserveMost:  
• PreserveAll = CXCallingConv_PreserveAll:  
• Invalid = CXCallingConv_Invalid:  
• Unexposed = CXCallingConv_Unexposed:  

Kinds of reference qualifiers

Values

• None = CXRefQualifier_None: No ref-qualifier was provided.
• LValue = CXRefQualifier_LValue: An lvalue ref-qualifier was provided (&).
• RValue = CXRefQualifier_RValue: An rvalue ref-qualifier was provided (&&).

A kind of token.

Values

• Punctuation = CXToken_Punctuation: A token that contains some kind of punctuation.
• Keyword = CXToken_Keyword: A language keyword.
• Identifier = CXToken_Identifier: An identifier (that is not a keyword).
• Literal = CXToken_Literal: A numeric, string, or character literal.
• Comment = CXToken_Comment: A comment.

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

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

Values

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

  The Optional chunk is the only kind of chunk that has a code-completion string for its representation, which is accessible via TCompletionString.ChunkCompletionString. The code-completion string describes an additional part of the template that is completely optional. For example, optional chunks can be used to describe the placeholders for arguments that match up with defaulted function parameters, e.g. given:

          void f(int x, float y = 3.14, double z = 2.71828);
        

  The 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 the
          function "f" would only include the first parameter ("int x").
        - Fully expand all optional chunks, in which case the template for the
          function "f" would have all of the parameters.
        

• TypedText = CXCompletionChunk_TypedText: Text that a user would be expected to type to get this code-completion result.

  There will be exactly one "typed text" chunk in a semantic string, which will typically provide the spelling of a keyword or the name of a declaration that could be used at the current code point. Clients are expected to filter the code-completion results based on the text in this chunk.

• Text = CXCompletionChunk_Text: Text that should be inserted as part of a code-completion result.

  A "text" chunk represents text that is part of the template to be inserted into user code should this particular code-completion result be selected.

• Placeholder = CXCompletionChunk_Placeholder: Placeholder text that should be replaced by the user.

  A "placeholder" chunk marks a place where the user should insert text into the code-completion template. For example, placeholders might mark the function parameters for a function declaration, to indicate that the user should provide arguments for each of those parameters. The actual text in a placeholder is a suggestion for the text to display before the user replaces the placeholder with real code.

• Informative = CXCompletionChunk_Informative: Informative text that should be displayed but never inserted as part of the template.

  An "informative" chunk contains annotations that can be displayed to help the user decide whether a particular code-completion result is the right option, but which is not part of the actual template to be inserted by code completion.

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

  A "current parameter" chunk occurs when code-completion is providing information about a parameter corresponding to the argument at the code-completion point. For example, given a function

        int add(int x, int y);
      

  and the source code add(, where the code-completion point is after the "(", the code-completion string will contain a "current parameter" chunk for "int x", indicating that the current argument will initialize that parameter. After typing further, to add(17, (where the code-completion point is after the ","), the code-completion string will contain a "current paremeter" chunk to "int y".

• LeftParen = CXCompletionChunk_LeftParen: A left parenthesis ('('), used to initiate a function call or signal the beginning of a function parameter list.
• RightParent = CXCompletionChunk_RightParen: A right parenthesis (')'), used to finish a function call or signal the end of a function parameter list.
• LeftBracket = CXCompletionChunk_LeftBracket: A left bracket ('[').
• RightBracket = CXCompletionChunk_RightBracket: A right bracket (']').
• LeftBrace = CXCompletionChunk_LeftBrace: A left brace ('{').
• RightBrace = CXCompletionChunk_RightBrace: A right brace ('}').
• LeftAngle = CXCompletionChunk_LeftAngle: A left angle bracket ('<').
• RightAngle = CXCompletionChunk_RightAngle: A right angle bracket ('>').
• Comma = CXCompletionChunk_Comma: A comma separator (',').
• ResultType = CXCompletionChunk_ResultType: Text that specifies the result type of a given result.

  This special kind of informative chunk is not meant to be inserted into the text buffer. Rather, it is meant to illustrate the type that an expression using the given completion string would have.

• Colon = CXCompletionChunk_Colon: A colon (':').
• SemiColon = CXCompletionChunk_SemiColon: A semicolon (';').
• Equal = CXCompletionChunk_Equal: An '=' sign.
• HorizontalSpace = CXCompletionChunk_HorizontalSpace: Horizontal space (' ').
• VerticalSpace = CXCompletionChunk_VerticalSpace: Vertical space (#10), after which it is generally a good idea to perform indentation.

Kinds of evaluation results

Values

• Unexposed = CXEval_UnExposed:  
• Int = CXEval_Int:  
• Float = CXEval_Float:  
• ObjCStrLiteral = CXEval_ObjCStrLiteral:  
• StrLiteral = CXEval_StrLiteral:  
• CFStr = CXEval_CFStr:  
• Other = CXEval_Other:  

Indexer options used by IIndexAction

Values

• SuppressRedundantRefs: Used to indicate that IIndexerListener.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.
• IndexFunctionLocalSymbols: Function-local symbols should be indexed. If this is not set function-local symbols will be ignored.
• IndexImplicitTemplateInstantiations: Implicit function/class template instantiations should be indexed. If this is not set, implicit instantiations will be ignored.
• SuppressWarnings: Suppress all compiler warnings when parsing for indexing.
• SkipParsedBodiesInSession: Skip a function/method body that was already parsed during an indexing session associated with an IIndexAction object. Bodies in system headers are always skipped.

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

Values

• Null = CXComment_Null: Null comment. No AST node is constructed at the requested location because there is no text or a syntax error.
• Text = CXComment_Text: Plain text. Inline content.
• InlineCommand = CXComment_InlineCommand: A command with word-like arguments that is considered inline content.

  For example: \c command.

• HtmlStartTag = CXComment_HTMLStartTag: HTML start tag with attributes (name-value pairs). Considered inline content. For example:

          @br <br /> <a href="http://example.org/">
        

• HtmlEndTag = CXComment_HTMLEndTag: HTML end tag. Considered inline content. For example:

          </a>
        

• Paragraph = CXComment_Paragraph: A paragraph, contains inline comment. The paragraph itself is block content.
• BlockCommand = CXComment_BlockCommand: A command that has zero or more word-like arguments (number of word-like arguments depends on command name) and a paragraph as an argument. Block command is block content.

  Paragraph argument is also a child of the block command.

  For example: \brief has 0 word-like arguments and a paragraph argument.

  AST nodes of special kinds that parser knows about (e.g., \param command) have their own node kinds.

• ParamCommand = CXComment_ParamCommand: A \param or \arg command that describes the function parameter (name, passing direction, description).

  For example: \param [in] ParamName description.

• TParamCommand = CXComment_TParamCommand: A \tparam command that describes a template parameter (name and description).

  For example: \tparam T description.

• VerbatimBlockCommand = CXComment_VerbatimBlockCommand: A verbatim block command (e. g., preformatted code). Verbatim block has an opening and a closing command and contains multiple lines of text (VerbatimBlockLine child nodes).

  For example:

          \verbatim
          aaa
          \endverbatim
        

• VerbatimBlockLine = CXComment_VerbatimBlockLine: A line of text that is contained within a VerbatimBlockCommand node.
• VerbatimLine = CXComment_VerbatimLine: 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.
• FullComment = CXComment_FullComment: A full comment attached to a declaration, contains block content.

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

Values

• Normal = CXCommentInlineCommandRenderKind_Normal: Command argument should be rendered in a normal font.
• Bold = CXCommentInlineCommandRenderKind_Bold: Command argument should be rendered in a bold font.
• Monospaced = CXCommentInlineCommandRenderKind_Monospaced: Command argument should be rendered in a monospaced font.
• Emphasized = CXCommentInlineCommandRenderKind_Emphasized: Command argument should be rendered emphasized (typically italic font).

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

Values

• Input = CXCommentParamPassDirection_In: The parameter is an input parameter.
• Ouput = CXCommentParamPassDirection_Out: The parameter is an output parameter.
• InOut = CXCommentParamPassDirection_InOut: The parameter is an input and output parameter.

Visitor invoked for each cursor found by a traversal.

This visitor function will be invoked for each cursor found by TCursor.VisitChildren. Its first argument is the cursor being visited, its second argument is the parent visitor for that cursor.

The visitor should return one of the TChildVisitResult values to direct TCursor.VisitChildren.

Visitor that receives a cursor and source range

Visitor invoked for each field found by a traversal.

This visitor will be invoked for each field found by TType.VisitFields. Its argument is the cursor being visited.

The visitor should return one of the TVisitorResult values to direct TType.VisitFields.

Visitor invoked for each file in a translation unit (used with ITranslationUnit.GetInclusions).

This visitor (anonymous) method will be invoked by ITranslationUnit.GetInclusions for each file included (either at the top-level or by #include directives) within a translation unit. The first argument is the file being included, and the second and third arguments provide the inclusion stack. The array is sorted in order of immediate inclusion. For example, the first element refers to the location that included 'included_file'.

The client's data object that is associated with a TFile.

The client's data object that is associated with a semantic container of entities.

The client's data object that is associated with a semantic entity.

Values

• Unexposed = CXIdxEntity_Unexposed:  
• Typedef = CXIdxEntity_Typedef:  
• Func = CXIdxEntity_Function:  
• Variable = CXIdxEntity_Variable:  
• Field = CXIdxEntity_Field:  
• EnumConstant = CXIdxEntity_EnumConstant:  
• ObjCClass = CXIdxEntity_ObjCClass:  
• ObjCProtocol = CXIdxEntity_ObjCProtocol:  
• ObjCCategory = CXIdxEntity_ObjCCategory:  
• ObjCInstanceMethod = CXIdxEntity_ObjCInstanceMethod:  
• ObjCClassMethod = CXIdxEntity_ObjCClassMethod:  
• ObjCProperty = CXIdxEntity_ObjCProperty:  
• ObjCIvar = CXIdxEntity_ObjCIvar:  
• Enum = CXIdxEntity_Enum:  
• Struct = CXIdxEntity_Struct:  
• Union = CXIdxEntity_Union:  
• CXXClass = CXIdxEntity_CXXClass:  
• CXXNamespace = CXIdxEntity_CXXNamespace:  
• CXXNamespaceAlias = CXIdxEntity_CXXNamespaceAlias:  
• CXXStaticVariable = CXIdxEntity_CXXStaticVariable:  
• CXXStaticMethod = CXIdxEntity_CXXStaticMethod:  
• CXXInstanceMethod = CXIdxEntity_CXXInstanceMethod:  
• CXXConstructor = CXIdxEntity_CXXConstructor:  
• CXXDestructor = CXIdxEntity_CXXDestructor:  
• CXXConversionFunction = CXIdxEntity_CXXConversionFunction:  
• CXXTypeAlias = CXIdxEntity_CXXTypeAlias:  
• CXXInterface = CXIdxEntity_CXXInterface:  

Values

• NonTemplate = CXIdxEntity_NonTemplate:  
• Template = CXIdxEntity_Template:  
• TemplatePartialSpecialization = CXIdxEntity_TemplatePartialSpecialization:  
• TemplateSpecialization = CXIdxEntity_TemplateSpecialization:  

Values

• None = CXIdxEntityLang_None:  
• C = CXIdxEntityLang_C:  
• ObjC = CXIdxEntityLang_ObjC:  
• CXX = CXIdxEntityLang_CXX:  
• Swift = CXIdxEntityLang_Swift:  

Values

• Unexposed = CXIdxAttr_Unexposed:  
• IBAction = CXIdxAttr_IBAction:  
• IBOutlet = CXIdxAttr_IBOutlet:  
• IBOutletCollection = CXIdxAttr_IBOutletCollection:  

Values

• ForwardRef = CXIdxObjCContainer_ForwardRef:  
• Interf = CXIdxObjCContainer_Interface:  
• Impl = CXIdxObjCContainer_Implementation:  

Data for IIndexerListener.IndexEntityReference.

Values

• Direct = CXIdxEntityRef_Direct: The entity is referenced directly in user's code.
• Implicit = CXIdxEntityRef_Implicit: An implicit reference, e.g. a reference of an Objective-C method via the dot syntax.

Type is of kind TTypeKind.Invalid.

The type is an incomplete Type

The type is a dependent Type.

The type is not a constant size type.

The Field name is not valid for this record.