2777 lines
71 KiB
Go
2777 lines
71 KiB
Go
/*
|
|
* Copyright (c) 2024 The GoPlus Authors (goplus.org). All rights reserved.
|
|
*
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
|
* you may not use this file except in compliance with the License.
|
|
* You may obtain a copy of the License at
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
* See the License for the specific language governing permissions and
|
|
* limitations under the License.
|
|
*/
|
|
|
|
package clang
|
|
|
|
import (
|
|
"unsafe"
|
|
|
|
"github.com/goplus/llgo/c"
|
|
)
|
|
|
|
const (
|
|
LLGoFiles = "$(llvm-config --cflags): _wrap/cursor.cpp"
|
|
LLGoPackage = "link: -L$(llvm-config --libdir) -lclang; -lclang"
|
|
)
|
|
|
|
const (
|
|
/* Declarations */
|
|
/**
|
|
* 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.
|
|
*/
|
|
CursorUnexposedDecl CursorKind = iota + 1
|
|
|
|
/** A C or C++ struct. */
|
|
CursorStructDecl
|
|
|
|
/** A C or C++ union. */
|
|
CursorUnionDecl
|
|
|
|
/** A C++ class. */
|
|
CursorClassDecl
|
|
|
|
/** An enumeration. */
|
|
CursorEnumDecl
|
|
|
|
/**
|
|
* A field (in C) or non-static data member (in C++) in a
|
|
* struct, union, or C++ class.
|
|
*/
|
|
CursorFieldDecl
|
|
|
|
/** An enumerator constant. */
|
|
CursorEnumConstantDecl
|
|
|
|
/** A function. */
|
|
CursorFunctionDecl
|
|
|
|
/** A variable. */
|
|
CursorVarDecl
|
|
|
|
/** A function or method parameter. */
|
|
CursorParmDecl
|
|
|
|
/** An Objective-C \@interface. */
|
|
CursorObjCInterfaceDecl
|
|
|
|
/** An Objective-C \@interface for a category. */
|
|
CursorObjCCategoryDecl
|
|
|
|
/** An Objective-C \@protocol declaration. */
|
|
CursorObjCProtocolDecl
|
|
|
|
/** An Objective-C \@property declaration. */
|
|
CursorObjCPropertyDecl
|
|
|
|
/** An Objective-C instance variable. */
|
|
CursorObjCIvarDecl
|
|
|
|
/** An Objective-C instance method. */
|
|
CursorObjCInstanceMethodDecl
|
|
|
|
/** An Objective-C class method. */
|
|
CursorObjCClassMethodDecl
|
|
|
|
/** An Objective-C \@implementation. */
|
|
CursorObjCImplementationDecl
|
|
|
|
/** An Objective-C \@implementation for a category. */
|
|
CursorObjCCategoryImplDecl
|
|
|
|
/** A typedef. */
|
|
CursorTypedefDecl
|
|
|
|
/** A C++ class method. */
|
|
CursorCXXMethod
|
|
|
|
/** A C++ namespace. */
|
|
CursorNamespace
|
|
|
|
/** A linkage specification, e.g. 'extern "C"'. */
|
|
CursorLinkageSpec
|
|
|
|
/** A C++ constructor. */
|
|
CursorConstructor
|
|
|
|
/** A C++ destructor. */
|
|
CursorDestructor
|
|
|
|
/** A C++ conversion function. */
|
|
CursorConversionFunction
|
|
|
|
/** A C++ template type parameter. */
|
|
CursorTemplateTypeParameter
|
|
|
|
/** A C++ non-type template parameter. */
|
|
CursorNonTypeTemplateParameter
|
|
|
|
/** A C++ template template parameter. */
|
|
CursorTemplateTemplateParameter
|
|
|
|
/** A C++ function template. */
|
|
CursorFunctionTemplate
|
|
|
|
/** A C++ class template. */
|
|
CursorClassTemplate
|
|
|
|
/** A C++ class template partial specialization. */
|
|
CursorClassTemplatePartialSpecialization
|
|
|
|
/** A C++ namespace alias declaration. */
|
|
CursorNamespaceAlias
|
|
|
|
/** A C++ using directive. */
|
|
CursorUsingDirective
|
|
|
|
/** A C++ using declaration. */
|
|
CursorUsingDeclaration
|
|
|
|
/** A C++ alias declaration */
|
|
CursorTypeAliasDecl
|
|
|
|
/** An Objective-C \@synthesize definition. */
|
|
CursorObjCSynthesizeDecl
|
|
|
|
/** An Objective-C \@dynamic definition. */
|
|
CursorObjCDynamicDecl
|
|
|
|
/** An access specifier. */
|
|
CursorCXXAccessSpecifier
|
|
|
|
CursorFirstDecl = CursorUnexposedDecl
|
|
CursorLastDecl = CursorCXXAccessSpecifier
|
|
|
|
/* References */
|
|
CursorFirstRef = 40
|
|
CursorObjCSuperClassRef = iota - 2 //40
|
|
CursorObjCProtocolRef
|
|
CursorObjCClassRef
|
|
|
|
/**
|
|
* A reference to a type declaration.
|
|
*
|
|
* A type reference occurs anywhere where a type is named but not
|
|
* declared. For example, given:
|
|
*
|
|
* \code
|
|
* typedef unsigned size_type;
|
|
* size_type size;
|
|
* \endcode
|
|
*
|
|
* The typedef is a declaration of size_type (CXCursor_TypedefDecl),
|
|
* while the type of the variable "size" is referenced. The cursor
|
|
* referenced by the type of size is the typedef for size_type.
|
|
*/
|
|
CursorTypeRef
|
|
|
|
CursorCXXBaseSpecifier
|
|
|
|
/**
|
|
* A reference to a class template, function template, template
|
|
* template parameter, or class template partial specialization.
|
|
*/
|
|
CursorTemplateRef
|
|
|
|
/**
|
|
* A reference to a namespace or namespace alias.
|
|
*/
|
|
CursorNamespaceRef
|
|
|
|
/**
|
|
* A reference to a member of a struct, union, or class that occurs in
|
|
* some non-expression context, e.g., a designated initializer.
|
|
*/
|
|
CursorMemberRef
|
|
|
|
/**
|
|
* 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:
|
|
*
|
|
* \code
|
|
* start_over:
|
|
* ++counter;
|
|
*
|
|
* goto start_over;
|
|
* \endcode
|
|
*
|
|
* A label reference cursor refers to a label statement.
|
|
*/
|
|
CursorLabelRef
|
|
|
|
/**
|
|
* 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:
|
|
*
|
|
* \code
|
|
* 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&);
|
|
* \endcode
|
|
*
|
|
* 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 functions \c clang_getNumOverloadedDecls() and
|
|
* \c clang_getOverloadedDecl() can be used to retrieve the definitions
|
|
* referenced by this cursor.
|
|
*/
|
|
CursorOverloadedDeclRef
|
|
|
|
/**
|
|
* A reference to a variable that occurs in some non-expression
|
|
* context, e.g., a C++ lambda capture list.
|
|
*/
|
|
CursorVariableRef
|
|
|
|
CursorLastRef = CursorVariableRef
|
|
|
|
/* Error conditions */
|
|
CursorFirstInvalid = 70
|
|
CursorInvalidFile = iota + 15 //70
|
|
CursorNoDeclFound
|
|
CursorNotImplemented
|
|
CursorInvalidCode
|
|
CursorLastInvalid = CursorInvalidCode
|
|
|
|
/* Expressions */
|
|
CursorFirstExpr = 100
|
|
|
|
/**
|
|
* 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.
|
|
*/
|
|
CursorUnexposedExpr = iota + 39 //100
|
|
|
|
/**
|
|
* An expression that refers to some value declaration, such
|
|
* as a function, variable, or enumerator.
|
|
*/
|
|
CursorDeclRefExpr
|
|
|
|
/**
|
|
* An expression that refers to a member of a struct, union,
|
|
* class, Objective-C class, etc.
|
|
*/
|
|
CursorMemberRefExpr
|
|
|
|
/** An expression that calls a function. */
|
|
CursorCallExpr
|
|
|
|
/** An expression that sends a message to an Objective-C
|
|
object or class. */
|
|
CursorObjCMessageExpr
|
|
|
|
/** An expression that represents a block literal. */
|
|
CursorBlockExpr
|
|
|
|
/** An integer literal.
|
|
*/
|
|
CursorIntegerLiteral
|
|
|
|
/** A floating point number literal.
|
|
*/
|
|
CursorFloatingLiteral
|
|
|
|
/** An imaginary number literal.
|
|
*/
|
|
CursorImaginaryLiteral
|
|
|
|
/** A string literal.
|
|
*/
|
|
CursorStringLiteral
|
|
|
|
/** A character literal.
|
|
*/
|
|
CursorCharacterLiteral
|
|
|
|
/** A parenthesized expression, e.g. "(1)".
|
|
*
|
|
* This AST node is only formed if full location information is requested.
|
|
*/
|
|
CursorParenExpr
|
|
|
|
/** This represents the unary-expression's (except sizeof and
|
|
* alignof).
|
|
*/
|
|
CursorUnaryOperator
|
|
|
|
/** [C99 6.5.2.1] Array Subscripting.
|
|
*/
|
|
CursorArraySubscriptExpr
|
|
|
|
/** A builtin binary operation expression such as "x + y" or
|
|
* "x <= y".
|
|
*/
|
|
CursorBinaryOperator
|
|
|
|
/** Compound assignment such as "+=".
|
|
*/
|
|
CursorCompoundAssignOperator
|
|
|
|
/** The ?: ternary operator.
|
|
*/
|
|
CursorConditionalOperator
|
|
|
|
/** 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.
|
|
*/
|
|
CursorCStyleCastExpr
|
|
|
|
/** [C99 6.5.2.5]
|
|
*/
|
|
CursorCompoundLiteralExpr
|
|
|
|
/** Describes an C or C++ initializer list.
|
|
*/
|
|
CursorInitListExpr
|
|
|
|
/** The GNU address of label extension, representing &&label.
|
|
*/
|
|
CursorAddrLabelExpr
|
|
|
|
/** This is the GNU Statement Expression extension: ({int X=4; X;})
|
|
*/
|
|
CursorStmtExpr
|
|
|
|
/** Represents a C11 generic selection.
|
|
*/
|
|
CursorGenericSelectionExpr
|
|
|
|
/** 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).
|
|
*/
|
|
CursorGNUNullExpr
|
|
|
|
/** C++'s static_cast<> expression.
|
|
*/
|
|
CursorCXXStaticCastExpr
|
|
|
|
/** C++'s dynamic_cast<> expression.
|
|
*/
|
|
CursorCXXDynamicCastExpr
|
|
|
|
/** C++'s reinterpret_cast<> expression.
|
|
*/
|
|
CursorCXXReinterpretCastExpr
|
|
|
|
/** C++'s const_cast<> expression.
|
|
*/
|
|
CursorCXXConstCastExpr
|
|
|
|
/** Represents an explicit C++ type conversion that uses "functional"
|
|
* notion (C++ [expr.type.conv]).
|
|
*
|
|
* Example:
|
|
* \code
|
|
* x = int(0.5);
|
|
* \endcode
|
|
*/
|
|
CursorCXXFunctionalCastExpr
|
|
|
|
/** A C++ typeid expression (C++ [expr.typeid]).
|
|
*/
|
|
CursorCXXTypeidExpr
|
|
|
|
/** [C++ 2.13.5] C++ Boolean Literal.
|
|
*/
|
|
CursorCXXBoolLiteralExpr
|
|
|
|
/** [C++0x 2.14.7] C++ Pointer Literal.
|
|
*/
|
|
CursorCXXNullPtrLiteralExpr
|
|
|
|
/** Represents the "this" expression in C++
|
|
*/
|
|
CursorCXXThisExpr
|
|
|
|
/** [C++ 15] C++ Throw Expression.
|
|
*
|
|
* This handles 'throw' and 'throw' assignment-expression. When
|
|
* assignment-expression isn't present, Op will be null.
|
|
*/
|
|
CursorCXXThrowExpr
|
|
|
|
/** A new expression for memory allocation and constructor calls, e.g:
|
|
* "new CXXNewExpr(foo)".
|
|
*/
|
|
CursorCXXNewExpr
|
|
|
|
/** A delete expression for memory deallocation and destructor calls,
|
|
* e.g. "delete[] pArray".
|
|
*/
|
|
CursorCXXDeleteExpr
|
|
|
|
/** A unary expression. (noexcept, sizeof, or other traits)
|
|
*/
|
|
CursorUnaryExpr
|
|
|
|
/** An Objective-C string literal i.e. @"foo".
|
|
*/
|
|
CursorObjCStringLiteral
|
|
|
|
/** An Objective-C \@encode expression.
|
|
*/
|
|
CursorObjCEncodeExpr
|
|
|
|
/** An Objective-C \@selector expression.
|
|
*/
|
|
CursorObjCSelectorExpr
|
|
|
|
/** An Objective-C \@protocol expression.
|
|
*/
|
|
CursorObjCProtocolExpr
|
|
|
|
/** An Objective-C "bridged" cast expression, which casts between
|
|
* Objective-C pointers and C pointers, transferring ownership in the process.
|
|
*
|
|
* \code
|
|
* NSString *str = (__bridge_transfer NSString *)CFCreateString();
|
|
* \endcode
|
|
*/
|
|
CursorObjCBridgedCastExpr
|
|
|
|
/** 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:
|
|
*
|
|
* \code
|
|
* template<typename F, typename ...Types>
|
|
* void forward(F f, Types &&...args) {
|
|
* f(static_cast<Types&&>(args)...);
|
|
* }
|
|
* \endcode
|
|
*/
|
|
CursorPackExpansionExpr
|
|
|
|
/** Represents an expression that computes the length of a parameter
|
|
* pack.
|
|
*
|
|
* \code
|
|
* template<typename ...Types>
|
|
* struct count {
|
|
* static const unsigned value = sizeof...(Types);
|
|
* };
|
|
* \endcode
|
|
*/
|
|
CursorSizeOfPackExpr
|
|
/* Represents a C++ lambda expression that produces a local function
|
|
* object.
|
|
*
|
|
* \code
|
|
* void abssort(float *x, unsigned N) {
|
|
* std::sort(x, x + N,
|
|
* [](float a, float b) {
|
|
* return std::abs(a) < std::abs(b);
|
|
* });
|
|
* }
|
|
* \endcode
|
|
*/
|
|
CursorLambdaExpr
|
|
|
|
/** Objective-c Boolean Literal.
|
|
*/
|
|
CursorObjCBoolLiteralExpr
|
|
|
|
/** Represents the "self" expression in an Objective-C method.
|
|
*/
|
|
CursorObjCSelfExpr
|
|
|
|
/** OpenMP 5.0 [2.1.5, Array Section].
|
|
*/
|
|
CursorOMPArraySectionExpr
|
|
|
|
/** Represents an @available(...) check.
|
|
*/
|
|
CursorObjCAvailabilityCheckExpr
|
|
|
|
/**
|
|
* Fixed point literal
|
|
*/
|
|
CursorFixedPointLiteral
|
|
|
|
/** OpenMP 5.0 [2.1.4, Array Shaping].
|
|
*/
|
|
CursorOMPArrayShapingExpr
|
|
|
|
/**
|
|
* OpenMP 5.0 [2.1.6 Iterators]
|
|
*/
|
|
CursorOMPIteratorExpr
|
|
|
|
/** OpenCL's addrspace_cast<> expression.
|
|
*/
|
|
CursorCXXAddrspaceCastExpr
|
|
|
|
/**
|
|
* Expression that references a C++20 concept.
|
|
*/
|
|
CursorConceptSpecializationExpr
|
|
|
|
/**
|
|
* Expression that references a C++20 concept.
|
|
*/
|
|
CursorRequiresExpr
|
|
|
|
/**
|
|
* Expression that references a C++20 parenthesized list aggregate
|
|
* initializer.
|
|
*/
|
|
CursorCXXParenListInitExpr
|
|
|
|
CursorLastExpr = CursorCXXParenListInitExpr
|
|
|
|
/* Statements */
|
|
CursorFirstStmt = 200
|
|
/**
|
|
* 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.
|
|
*/
|
|
CursorUnexposedStmt = iota + 81 //200
|
|
|
|
/** A labelled statement in a function.
|
|
*
|
|
* This cursor kind is used to describe the "start_over:" label statement in
|
|
* the following example:
|
|
*
|
|
* \code
|
|
* start_over:
|
|
* ++counter;
|
|
* \endcode
|
|
*
|
|
*/
|
|
CursorLabelStmt
|
|
|
|
/** A group of statements like { stmt stmt }.
|
|
*
|
|
* This cursor kind is used to describe compound statements, e.g. function
|
|
* bodies.
|
|
*/
|
|
CursorCompoundStmt
|
|
|
|
/** A case statement.
|
|
*/
|
|
CursorCaseStmt
|
|
|
|
/** A default statement.
|
|
*/
|
|
CursorDefaultStmt
|
|
|
|
/** An if statement
|
|
*/
|
|
CursorIfStmt
|
|
|
|
/** A switch statement.
|
|
*/
|
|
CursorSwitchStmt
|
|
|
|
/** A while statement.
|
|
*/
|
|
CursorWhileStmt
|
|
|
|
/** A do statement.
|
|
*/
|
|
CursorDoStmt
|
|
|
|
/** A for statement.
|
|
*/
|
|
CursorForStmt
|
|
|
|
/** A goto statement.
|
|
*/
|
|
CursorGotoStmt
|
|
|
|
/** An indirect goto statement.
|
|
*/
|
|
CursorIndirectGotoStmt
|
|
|
|
/** A continue statement.
|
|
*/
|
|
CursorContinueStmt
|
|
|
|
/** A break statement.
|
|
*/
|
|
CursorBreakStmt
|
|
|
|
/** A return statement.
|
|
*/
|
|
CursorReturnStmt
|
|
|
|
/** A GCC inline assembly statement extension.
|
|
*/
|
|
CursorGCCAsmStmt
|
|
CursorAsmStmt = CursorGCCAsmStmt
|
|
|
|
/** Objective-C's overall \@try-\@catch-\@finally statement.
|
|
*/
|
|
CursorObjCAtTryStmt = iota + 80 //216
|
|
|
|
/** Objective-C's \@catch statement.
|
|
*/
|
|
CursorObjCAtCatchStmt
|
|
|
|
/** Objective-C's \@finally statement.
|
|
*/
|
|
CursorObjCAtFinallyStmt
|
|
|
|
/** Objective-C's \@throw statement.
|
|
*/
|
|
CursorObjCAtThrowStmt
|
|
|
|
/** Objective-C's \@synchronized statement.
|
|
*/
|
|
CursorObjCAtSynchronizedStmt
|
|
|
|
/** Objective-C's autorelease pool statement.
|
|
*/
|
|
CursorObjCAutoreleasePoolStmt
|
|
|
|
/** Objective-C's collection statement.
|
|
*/
|
|
CursorObjCForCollectionStmt
|
|
|
|
/** C++'s catch statement.
|
|
*/
|
|
CursorCXXCatchStmt
|
|
|
|
/** C++'s try statement.
|
|
*/
|
|
CursorCXXTryStmt
|
|
|
|
/** C++'s for (* : *) statement.
|
|
*/
|
|
CursorCXXForRangeStmt
|
|
|
|
/** Windows Structured Exception Handling's try statement.
|
|
*/
|
|
CursorSEHTryStmt
|
|
|
|
/** Windows Structured Exception Handling's except statement.
|
|
*/
|
|
CursorSEHExceptStmt
|
|
|
|
/** Windows Structured Exception Handling's finally statement.
|
|
*/
|
|
CursorSEHFinallyStmt
|
|
|
|
/** A MS inline assembly statement extension.
|
|
*/
|
|
CursorMSAsmStmt
|
|
|
|
/** The null statement ";": C99 6.8.3p3.
|
|
*
|
|
* This cursor kind is used to describe the null statement.
|
|
*/
|
|
CursorNullStmt
|
|
|
|
/** Adaptor class for mixing declarations with statements and
|
|
* expressions.
|
|
*/
|
|
CursorDeclStmt
|
|
|
|
/** OpenMP parallel directive.
|
|
*/
|
|
CursorOMPParallelDirective
|
|
|
|
/** OpenMP SIMD directive.
|
|
*/
|
|
CursorOMPSimdDirective
|
|
|
|
/** OpenMP for directive.
|
|
*/
|
|
CursorOMPForDirective
|
|
|
|
/** OpenMP sections directive.
|
|
*/
|
|
CursorOMPSectionsDirective
|
|
|
|
/** OpenMP section directive.
|
|
*/
|
|
CursorOMPSectionDirective
|
|
|
|
/** OpenMP single directive.
|
|
*/
|
|
CursorOMPSingleDirective
|
|
|
|
/** OpenMP parallel for directive.
|
|
*/
|
|
CursorOMPParallelForDirective
|
|
|
|
/** OpenMP parallel sections directive.
|
|
*/
|
|
CursorOMPParallelSectionsDirective
|
|
|
|
/** OpenMP task directive.
|
|
*/
|
|
CursorOMPTaskDirective
|
|
|
|
/** OpenMP master directive.
|
|
*/
|
|
CursorOMPMasterDirective
|
|
|
|
/** OpenMP critical directive.
|
|
*/
|
|
CursorOMPCriticalDirective
|
|
|
|
/** OpenMP taskyield directive.
|
|
*/
|
|
CursorOMPTaskyieldDirective
|
|
|
|
/** OpenMP barrier directive.
|
|
*/
|
|
CursorOMPBarrierDirective
|
|
|
|
/** OpenMP taskwait directive.
|
|
*/
|
|
CursorOMPTaskwaitDirective
|
|
|
|
/** OpenMP flush directive.
|
|
*/
|
|
CursorOMPFlushDirective
|
|
|
|
/** Windows Structured Exception Handling's leave statement.
|
|
*/
|
|
CursorSEHLeaveStmt
|
|
|
|
/** OpenMP ordered directive.
|
|
*/
|
|
CursorOMPOrderedDirective
|
|
|
|
/** OpenMP atomic directive.
|
|
*/
|
|
CursorOMPAtomicDirective
|
|
|
|
/** OpenMP for SIMD directive.
|
|
*/
|
|
CursorOMPForSimdDirective
|
|
|
|
/** OpenMP parallel for SIMD directive.
|
|
*/
|
|
CursorOMPParallelForSimdDirective
|
|
|
|
/** OpenMP target directive.
|
|
*/
|
|
CursorOMPTargetDirective
|
|
|
|
/** OpenMP teams directive.
|
|
*/
|
|
CursorOMPTeamsDirective
|
|
|
|
/** OpenMP taskgroup directive.
|
|
*/
|
|
CursorOMPTaskgroupDirective
|
|
|
|
/** OpenMP cancellation point directive.
|
|
*/
|
|
CursorOMPCancellationPointDirective
|
|
|
|
/** OpenMP cancel directive.
|
|
*/
|
|
CursorOMPCancelDirective
|
|
|
|
/** OpenMP target data directive.
|
|
*/
|
|
CursorOMPTargetDataDirective
|
|
|
|
/** OpenMP taskloop directive.
|
|
*/
|
|
CursorOMPTaskLoopDirective
|
|
|
|
/** OpenMP taskloop simd directive.
|
|
*/
|
|
CursorOMPTaskLoopSimdDirective
|
|
|
|
/** OpenMP distribute directive.
|
|
*/
|
|
CursorOMPDistributeDirective
|
|
|
|
/** OpenMP target enter data directive.
|
|
*/
|
|
CursorOMPTargetEnterDataDirective
|
|
|
|
/** OpenMP target exit data directive.
|
|
*/
|
|
CursorOMPTargetExitDataDirective
|
|
|
|
/** OpenMP target parallel directive.
|
|
*/
|
|
CursorOMPTargetParallelDirective
|
|
|
|
/** OpenMP target parallel for directive.
|
|
*/
|
|
CursorOMPTargetParallelForDirective
|
|
|
|
/** OpenMP target update directive.
|
|
*/
|
|
CursorOMPTargetUpdateDirective
|
|
|
|
/** OpenMP distribute parallel for directive.
|
|
*/
|
|
CursorOMPDistributeParallelForDirective
|
|
|
|
/** OpenMP distribute parallel for simd directive.
|
|
*/
|
|
CursorOMPDistributeParallelForSimdDirective
|
|
|
|
/** OpenMP distribute simd directive.
|
|
*/
|
|
CursorOMPDistributeSimdDirective
|
|
|
|
/** OpenMP target parallel for simd directive.
|
|
*/
|
|
CursorOMPTargetParallelForSimdDirective
|
|
|
|
/** OpenMP target simd directive.
|
|
*/
|
|
CursorOMPTargetSimdDirective
|
|
|
|
/** OpenMP teams distribute directive.
|
|
*/
|
|
CursorOMPTeamsDistributeDirective
|
|
|
|
/** OpenMP teams distribute simd directive.
|
|
*/
|
|
CursorOMPTeamsDistributeSimdDirective
|
|
|
|
/** OpenMP teams distribute parallel for simd directive.
|
|
*/
|
|
CursorOMPTeamsDistributeParallelForSimdDirective
|
|
|
|
/** OpenMP teams distribute parallel for directive.
|
|
*/
|
|
CursorOMPTeamsDistributeParallelForDirective
|
|
|
|
/** OpenMP target teams directive.
|
|
*/
|
|
CursorOMPTargetTeamsDirective
|
|
|
|
/** OpenMP target teams distribute directive.
|
|
*/
|
|
CursorOMPTargetTeamsDistributeDirective
|
|
|
|
/** OpenMP target teams distribute parallel for directive.
|
|
*/
|
|
CursorOMPTargetTeamsDistributeParallelForDirective
|
|
|
|
/** OpenMP target teams distribute parallel for simd directive.
|
|
*/
|
|
CursorOMPTargetTeamsDistributeParallelForSimdDirective
|
|
|
|
/** OpenMP target teams distribute simd directive.
|
|
*/
|
|
CursorOMPTargetTeamsDistributeSimdDirective
|
|
|
|
/** C++2a std::bit_cast expression.
|
|
*/
|
|
CursorBuiltinBitCastExpr
|
|
|
|
/** OpenMP master taskloop directive.
|
|
*/
|
|
CursorOMPMasterTaskLoopDirective
|
|
|
|
/** OpenMP parallel master taskloop directive.
|
|
*/
|
|
CursorOMPParallelMasterTaskLoopDirective
|
|
|
|
/** OpenMP master taskloop simd directive.
|
|
*/
|
|
CursorOMPMasterTaskLoopSimdDirective
|
|
|
|
/** OpenMP parallel master taskloop simd directive.
|
|
*/
|
|
CursorOMPParallelMasterTaskLoopSimdDirective
|
|
|
|
/** OpenMP parallel master directive.
|
|
*/
|
|
CursorOMPParallelMasterDirective
|
|
|
|
/** OpenMP depobj directive.
|
|
*/
|
|
CursorOMPDepobjDirective
|
|
|
|
/** OpenMP scan directive.
|
|
*/
|
|
CursorOMPScanDirective
|
|
|
|
/** OpenMP tile directive.
|
|
*/
|
|
CursorOMPTileDirective
|
|
|
|
/** OpenMP canonical loop.
|
|
*/
|
|
CursorOMPCanonicalLoop
|
|
|
|
/** OpenMP interop directive.
|
|
*/
|
|
CursorOMPInteropDirective
|
|
|
|
/** OpenMP dispatch directive.
|
|
*/
|
|
CursorOMPDispatchDirective
|
|
|
|
/** OpenMP masked directive.
|
|
*/
|
|
CursorOMPMaskedDirective
|
|
|
|
/** OpenMP unroll directive.
|
|
*/
|
|
CursorOMPUnrollDirective
|
|
|
|
/** OpenMP metadirective directive.
|
|
*/
|
|
CursorOMPMetaDirective
|
|
|
|
/** OpenMP loop directive.
|
|
*/
|
|
CursorOMPGenericLoopDirective
|
|
|
|
/** OpenMP teams loop directive.
|
|
*/
|
|
CursorOMPTeamsGenericLoopDirective
|
|
|
|
/** OpenMP target teams loop directive.
|
|
*/
|
|
CursorOMPTargetTeamsGenericLoopDirective
|
|
|
|
/** OpenMP parallel loop directive.
|
|
*/
|
|
CursorOMPParallelGenericLoopDirective
|
|
|
|
/** OpenMP target parallel loop directive.
|
|
*/
|
|
CursorOMPTargetParallelGenericLoopDirective
|
|
|
|
/** OpenMP parallel masked directive.
|
|
*/
|
|
CursorOMPParallelMaskedDirective
|
|
|
|
/** OpenMP masked taskloop directive.
|
|
*/
|
|
CursorOMPMaskedTaskLoopDirective
|
|
|
|
/** OpenMP masked taskloop simd directive.
|
|
*/
|
|
CursorOMPMaskedTaskLoopSimdDirective
|
|
|
|
/** OpenMP parallel masked taskloop directive.
|
|
*/
|
|
CursorOMPParallelMaskedTaskLoopDirective
|
|
|
|
/** OpenMP parallel masked taskloop simd directive.
|
|
*/
|
|
CursorOMPParallelMaskedTaskLoopSimdDirective
|
|
|
|
/** OpenMP error directive.
|
|
*/
|
|
CursorOMPErrorDirective
|
|
|
|
/** OpenMP scope directive.
|
|
*/
|
|
CursorOMPScopeDirective
|
|
|
|
CursorLastStmt = CursorOMPScopeDirective
|
|
|
|
/**
|
|
* 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.
|
|
*/
|
|
CursorTranslationUnit = 350
|
|
|
|
/* Attributes */
|
|
CursorFirstAttr = 400
|
|
/**
|
|
* An attribute whose specific kind is not exposed via this
|
|
* interface.
|
|
*/
|
|
CursorUnexposedAttr = iota + 170
|
|
|
|
CursorIBActionAttr
|
|
CursorIBOutletAttr
|
|
CursorIBOutletCollectionAttr
|
|
CursorCXXFinalAttr
|
|
CursorCXXOverrideAttr
|
|
CursorAnnotateAttr
|
|
CursorAsmLabelAttr
|
|
CursorPackedAttr
|
|
CursorPureAttr
|
|
CursorConstAttr
|
|
CursorNoDuplicateAttr
|
|
CursorCUDAConstantAttr
|
|
CursorCUDADeviceAttr
|
|
CursorCUDAGlobalAttr
|
|
CursorCUDAHostAttr
|
|
CursorCUDASharedAttr
|
|
CursorVisibilityAttr
|
|
CursorDLLExport
|
|
CursorDLLImport
|
|
CursorNSReturnsRetained
|
|
CursorNSReturnsNotRetained
|
|
CursorNSReturnsAutoreleased
|
|
CursorNSConsumesSelf
|
|
CursorNSConsumed
|
|
CursorObjCException
|
|
CursorObjCNSObject
|
|
CursorObjCIndependentClass
|
|
CursorObjCPreciseLifetime
|
|
CursorObjCReturnsInnerPointer
|
|
CursorObjCRequiresSuper
|
|
CursorObjCRootClass
|
|
CursorObjCSubclassingRestricted
|
|
CursorObjCExplicitProtocolImpl
|
|
CursorObjCDesignatedInitializer
|
|
CursorObjCRuntimeVisible
|
|
CursorObjCBoxable
|
|
CursorFlagEnum
|
|
CursorConvergentAttr
|
|
CursorWarnUnusedAttr
|
|
CursorWarnUnusedResultAttr
|
|
CursorAlignedAttr
|
|
CursorLastAttr = CursorAlignedAttr
|
|
|
|
/* Preprocessing */
|
|
CursorPreprocessingDirective = iota + 227 //500
|
|
CursorMacroDefinition
|
|
CursorMacroExpansion
|
|
CursorMacroInstantiation = CursorMacroExpansion
|
|
CursorInclusionDirective = 503
|
|
CursorFirstPreprocessing = CursorPreprocessingDirective
|
|
CursorLastPreprocessing = CursorInclusionDirective
|
|
|
|
/* Extra Declarations */
|
|
/**
|
|
* A module import declaration.
|
|
*/
|
|
CursorModuleImportDecl = iota + 320 //600
|
|
CursorTypeAliasTemplateDecl
|
|
/**
|
|
* A static_assert or _Static_assert node
|
|
*/
|
|
CursorStaticAssert
|
|
/**
|
|
* a friend declaration.
|
|
*/
|
|
CursorFriendDecl
|
|
/**
|
|
* a concept declaration.
|
|
*/
|
|
CursorConceptDecl
|
|
|
|
CursorFirstExtraDecl = CursorModuleImportDecl
|
|
CursorLastExtraDecl = CursorConceptDecl
|
|
|
|
/**
|
|
* A code completion overload candidate.
|
|
*/
|
|
CursorOverloadCandidate = 700
|
|
)
|
|
|
|
/**
|
|
* Opaque pointer representing client data that will be passed through
|
|
* to various callbacks and visitors.
|
|
*/
|
|
type ClientData = c.Pointer
|
|
|
|
/**
|
|
* Provides the contents of a file that has not yet been saved to disk.
|
|
*
|
|
* Each CXUnsavedFile instance provides the name of a file on the
|
|
* system along with the current contents of that file that have not
|
|
* yet been saved to disk.
|
|
*/
|
|
type UnsavedFile struct {
|
|
/**
|
|
* The file whose contents have not yet been saved.
|
|
*
|
|
* This file must already exist in the file system.
|
|
*/
|
|
Filename *c.Char
|
|
|
|
/**
|
|
* A buffer containing the unsaved contents of this file.
|
|
*/
|
|
Contents *c.Char
|
|
|
|
/**
|
|
* The length of the unsaved contents of this buffer.
|
|
*/
|
|
Length c.Ulong
|
|
}
|
|
|
|
/**
|
|
* An "index" that consists of a set of translation units that would
|
|
* typically be linked together into an executable or library.
|
|
*/
|
|
type Index struct {
|
|
Unused [0]byte
|
|
}
|
|
|
|
/**
|
|
* Provides a shared context for creating translation units.
|
|
*
|
|
* It provides two options:
|
|
*
|
|
* - excludeDeclarationsFromPCH: When non-zero, allows enumeration of "local"
|
|
* declarations (when loading any new translation units). A "local" declaration
|
|
* is one that belongs in the translation unit itself and not in a precompiled
|
|
* header that was used by the translation unit. If zero, all declarations
|
|
* will be enumerated.
|
|
*
|
|
* Here is an example:
|
|
*
|
|
* \code
|
|
* // excludeDeclsFromPCH = 1, displayDiagnostics=1
|
|
* Idx = clang_createIndex(1, 1);
|
|
*
|
|
* // IndexTest.pch was produced with the following command:
|
|
* // "clang -x c IndexTest.h -emit-ast -o IndexTest.pch"
|
|
* TU = clang_createTranslationUnit(Idx, "IndexTest.pch");
|
|
*
|
|
* // This will load all the symbols from 'IndexTest.pch'
|
|
* clang_visitChildren(clang_getTranslationUnitCursor(TU),
|
|
* TranslationUnitVisitor, 0);
|
|
* clang_disposeTranslationUnit(TU);
|
|
*
|
|
* // This will load all the symbols from 'IndexTest.c', excluding symbols
|
|
* // from 'IndexTest.pch'.
|
|
* char *args[] = { "-Xclang", "-include-pch=IndexTest.pch" };
|
|
* TU = clang_createTranslationUnitFromSourceFile(Idx, "IndexTest.c", 2, args,
|
|
* 0, 0);
|
|
* clang_visitChildren(clang_getTranslationUnitCursor(TU),
|
|
* TranslationUnitVisitor, 0);
|
|
* clang_disposeTranslationUnit(TU);
|
|
* \endcode
|
|
*
|
|
* This process of creating the 'pch', loading it separately, and using it (via
|
|
* -include-pch) allows 'excludeDeclsFromPCH' to remove redundant callbacks
|
|
* (which gives the indexer the same performance benefit as the compiler).
|
|
*/
|
|
//go:linkname CreateIndex C.clang_createIndex
|
|
func CreateIndex(excludeDeclarationsFromPCH, displayDiagnostics c.Int) *Index
|
|
|
|
/**
|
|
* Destroy the given index.
|
|
*
|
|
* The index must not be destroyed until all of the translation units created
|
|
* within that index have been destroyed.
|
|
*/
|
|
// llgo:link (*Index).Dispose C.clang_disposeIndex
|
|
func (*Index) Dispose() {}
|
|
|
|
/**
|
|
* Flags that control the creation of translation units.
|
|
*
|
|
* The enumerators in this enumeration type are meant to be bitwise
|
|
* ORed together to specify which options should be used when
|
|
* constructing the translation unit.
|
|
*/
|
|
const (
|
|
/**
|
|
* Used to indicate that no special translation-unit options are
|
|
* needed.
|
|
*/
|
|
TranslationUnit_None = 0x0
|
|
/**
|
|
* 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.
|
|
*/
|
|
DetailedPreprocessingRecord = 0x01
|
|
)
|
|
|
|
/**
|
|
* Same as \c clang_parseTranslationUnit2, but returns
|
|
* the \c CXTranslationUnit instead of an error code. In case of an error this
|
|
* routine returns a \c NULL \c CXTranslationUnit, without further detailed
|
|
* error codes.
|
|
*/
|
|
// llgo:link (*Index).ParseTranslationUnit C.clang_parseTranslationUnit
|
|
func (*Index) ParseTranslationUnit(
|
|
sourceFilename *c.Char, commandLineArgs **c.Char, numCommandLineArgs c.Int,
|
|
unsavedFiles *UnsavedFile, numUnsavedFiles c.Uint, options c.Uint) *TranslationUnit {
|
|
return nil
|
|
}
|
|
|
|
/**
|
|
* A single translation unit, which resides in an index.
|
|
*/
|
|
type TranslationUnit struct {
|
|
Unused [0]byte
|
|
}
|
|
|
|
/**
|
|
* Destroy the specified CXTranslationUnit object.
|
|
*/
|
|
// llgo:link (*TranslationUnit).Dispose C.clang_disposeTranslationUnit
|
|
func (*TranslationUnit) Dispose() {}
|
|
|
|
/**
|
|
* Retrieve the cursor that represents the given translation unit.
|
|
*
|
|
* The translation unit cursor can be used to start traversing the
|
|
* various declarations within the given translation unit.
|
|
*/
|
|
|
|
//llgo:link (*TranslationUnit).wrapCursor C.wrap_clang_getTranslationUnitCursor
|
|
func (t *TranslationUnit) wrapCursor(cursor *Cursor) {}
|
|
|
|
func (t *TranslationUnit) Cursor() (ret Cursor) {
|
|
t.wrapCursor(&ret)
|
|
return
|
|
}
|
|
|
|
/**
|
|
* Describes the kind of entity that a cursor refers to.
|
|
*/
|
|
type CursorKind c.Int
|
|
|
|
/* for debug/testing */
|
|
// llgo:link CursorKind.String C.clang_getCursorKindSpelling
|
|
func (CursorKind) String() (ret String) {
|
|
return
|
|
}
|
|
|
|
/**
|
|
* A cursor representing some element in the abstract syntax tree for
|
|
* a translation unit.
|
|
*
|
|
* The cursor abstraction unifies the different kinds of entities in a
|
|
* program--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 in
|
|
* a source file where the cursor points, getting the name associated with a
|
|
* cursor, 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 the
|
|
* translation unit. clang_getCursor() maps from a physical source location
|
|
* to the entity that resides at that location, allowing one to map from the
|
|
* source code into the AST.
|
|
*/
|
|
type Cursor struct {
|
|
Kind CursorKind
|
|
xdata c.Int
|
|
data [3]c.Pointer
|
|
}
|
|
|
|
type TypeKind c.Int
|
|
|
|
/**
|
|
* Describes the kind of type
|
|
*/
|
|
const (
|
|
/**
|
|
* Represents an invalid type (e.g., where no type is available).
|
|
*/
|
|
TypeInvalid TypeKind = iota
|
|
|
|
/**
|
|
* A type whose specific kind is not exposed via this
|
|
* interface.
|
|
*/
|
|
TypeUnexposed
|
|
|
|
/* Builtin types */
|
|
TypeVoid
|
|
TypeBool
|
|
TypeCharU
|
|
TypeUChar
|
|
TypeChar16
|
|
TypeChar32
|
|
TypeUShort
|
|
TypeUInt
|
|
TypeULong
|
|
TypeULongLong
|
|
TypeUInt128
|
|
TypeCharS
|
|
TypeSChar
|
|
TypeWChar
|
|
TypeShort
|
|
TypeInt
|
|
TypeLong
|
|
TypeLongLong
|
|
TypeInt128
|
|
TypeFloat
|
|
TypeDouble
|
|
TypeLongDouble
|
|
TypeNullPtr
|
|
TypeOverload
|
|
TypeDependent
|
|
TypeObjCId
|
|
TypeObjCClass
|
|
TypeObjCSel
|
|
TypeFloat128
|
|
TypeHalf
|
|
TypeFloat16
|
|
TypeShortAccum
|
|
TypeAccum
|
|
TypeLongAccum
|
|
TypeUShortAccum
|
|
TypeUAccum
|
|
TypeULongAccum
|
|
TypeBFloat16
|
|
TypeIbm128
|
|
|
|
TypeFirstBuiltin = TypeVoid
|
|
TypeLastBuiltin = TypeIbm128
|
|
|
|
TypeComplex TypeKind = iota + 57 // 100
|
|
TypePointer
|
|
TypeBlockPointer
|
|
TypeLValueReference
|
|
TypeRValueReference
|
|
TypeRecord
|
|
TypeEnum
|
|
TypeTypedef
|
|
TypeObjCInterface
|
|
TypeObjCObjectPointer
|
|
TypeFunctionNoProto
|
|
TypeFunctionProto
|
|
TypeConstantArray
|
|
TypeVector
|
|
TypeIncompleteArray
|
|
TypeVariableArray
|
|
TypeDependentSizedArray
|
|
TypeMemberPointer
|
|
TypeAuto
|
|
|
|
/**
|
|
* 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.
|
|
*/
|
|
TypeElaborated
|
|
|
|
/* OpenCL PipeType. */
|
|
TypePipe
|
|
|
|
/* OpenCL builtin types. */
|
|
TypeOCLImage1dRO
|
|
TypeOCLImage1dArrayRO
|
|
TypeOCLImage1dBufferRO
|
|
TypeOCLImage2dRO
|
|
TypeOCLImage2dArrayRO
|
|
TypeOCLImage2dDepthRO
|
|
TypeOCLImage2dArrayDepthRO
|
|
TypeOCLImage2dMSAARO
|
|
TypeOCLImage2dArrayMSAARO
|
|
TypeOCLImage2dMSAADepthRO
|
|
TypeOCLImage2dArrayMSAADepthRO
|
|
TypeOCLImage3dRO
|
|
TypeOCLImage1dWO
|
|
TypeOCLImage1dArrayWO
|
|
TypeOCLImage1dBufferWO
|
|
TypeOCLImage2dWO
|
|
TypeOCLImage2dArrayWO
|
|
TypeOCLImage2dDepthWO
|
|
TypeOCLImage2dArrayDepthWO
|
|
TypeOCLImage2dMSAAWO
|
|
TypeOCLImage2dArrayMSAAWO
|
|
TypeOCLImage2dMSAADepthWO
|
|
TypeOCLImage2dArrayMSAADepthWO
|
|
TypeOCLImage3dWO
|
|
TypeOCLImage1dRW
|
|
TypeOCLImage1dArrayRW
|
|
TypeOCLImage1dBufferRW
|
|
TypeOCLImage2dRW
|
|
TypeOCLImage2dArrayRW
|
|
TypeOCLImage2dDepthRW
|
|
TypeOCLImage2dArrayDepthRW
|
|
TypeOCLImage2dMSAARW
|
|
TypeOCLImage2dArrayMSAARW
|
|
TypeOCLImage2dMSAADepthRW
|
|
TypeOCLImage2dArrayMSAADepthRW
|
|
TypeOCLImage3dRW
|
|
TypeOCLSampler
|
|
TypeOCLEvent
|
|
TypeOCLQueue
|
|
TypeOCLReserveID
|
|
|
|
TypeObjCObject
|
|
TypeObjCTypeParam
|
|
TypeAttributed
|
|
|
|
TypeOCLIntelSubgroupAVCMcePayload
|
|
TypeOCLIntelSubgroupAVCImePayload
|
|
TypeOCLIntelSubgroupAVCRefPayload
|
|
TypeOCLIntelSubgroupAVCSicPayload
|
|
TypeOCLIntelSubgroupAVCMceResult
|
|
TypeOCLIntelSubgroupAVCImeResult
|
|
TypeOCLIntelSubgroupAVCRefResult
|
|
TypeOCLIntelSubgroupAVCSicResult
|
|
TypeOCLIntelSubgroupAVCImeResultSingleReferenceStreamout
|
|
TypeOCLIntelSubgroupAVCImeResultDualReferenceStreamout
|
|
TypeOCLIntelSubgroupAVCImeSingleReferenceStreamin
|
|
TypeOCLIntelSubgroupAVCImeDualReferenceStreamin
|
|
|
|
/* Old aliases for AVC OpenCL extension types. */
|
|
TypeOCLIntelSubgroupAVCImeResultSingleRefStreamout = TypeOCLIntelSubgroupAVCImeResultSingleReferenceStreamout
|
|
TypeOCLIntelSubgroupAVCImeResultDualRefStreamout = TypeOCLIntelSubgroupAVCImeResultDualReferenceStreamout
|
|
TypeOCLIntelSubgroupAVCImeSingleRefStreamin = TypeOCLIntelSubgroupAVCImeSingleReferenceStreamin
|
|
TypeOCLIntelSubgroupAVCImeDualRefStreamin = TypeOCLIntelSubgroupAVCImeDualReferenceStreamin
|
|
|
|
TypeExtVector = iota + 53 // 176
|
|
TypeAtomic
|
|
TypeBTFTagAttributed
|
|
)
|
|
|
|
/**
|
|
* The type of an element in the abstract syntax tree.
|
|
*
|
|
*/
|
|
type Type struct {
|
|
Kind TypeKind
|
|
data [2]c.Pointer
|
|
}
|
|
|
|
/**
|
|
* A particular source file that is part of a translation unit.
|
|
*/
|
|
type File uintptr
|
|
|
|
/**
|
|
* Identifies a specific source location within a translation
|
|
* unit.
|
|
*
|
|
* Use clang_getExpansionLocation() or clang_getSpellingLocation()
|
|
* to map a source location to a particular file, line, and column.
|
|
*/
|
|
type SourceLocation struct {
|
|
ptrData [2]c.Pointer
|
|
intData c.Uint
|
|
}
|
|
|
|
/**
|
|
* Identifies a half-open character range in the source code.
|
|
*
|
|
* Use clang_getRangeStart() and clang_getRangeEnd() to retrieve the
|
|
* starting and end locations from a source range, respectively.
|
|
*/
|
|
type SourceRange struct {
|
|
ptrData [2]c.Pointer
|
|
beginIntData c.Uint
|
|
endIntData c.Uint
|
|
}
|
|
|
|
/**
|
|
* Describes a kind of token.
|
|
*/
|
|
type TokenKind c.Int
|
|
|
|
const (
|
|
/**
|
|
* A token that contains some kind of punctuation.
|
|
*/
|
|
Punctuation TokenKind = iota
|
|
/**
|
|
* A language keyword.
|
|
*/
|
|
Keyword
|
|
|
|
/**
|
|
* An identifier (that is not a keyword).
|
|
*/
|
|
Identifier
|
|
/**
|
|
* A numeric, string, or character literal.
|
|
*/
|
|
Literal
|
|
/**
|
|
* A comment.
|
|
*/
|
|
Comment
|
|
)
|
|
|
|
type Token struct {
|
|
intData [4]c.Uint
|
|
ptrData c.Pointer
|
|
}
|
|
|
|
/**
|
|
* Determine whether two cursors are equivalent.
|
|
*/
|
|
// llgo:link (*Cursor).wrapEqual C.wrap_clang_equalCursors
|
|
func (*Cursor) wrapEqual(cursor *Cursor) c.Uint { return 0 }
|
|
|
|
func (c Cursor) Equal(cursor Cursor) c.Uint {
|
|
return c.wrapEqual(&cursor)
|
|
}
|
|
|
|
/**
|
|
* Returns non-zero if \p cursor is null.
|
|
*/
|
|
// llgo:link (*Cursor).wrapIsNull C.wrap_clang_Cursor_isNull
|
|
func (*Cursor) wrapIsNull() c.Int { return 0 }
|
|
|
|
func (c Cursor) IsNull() c.Int { return c.wrapIsNull() }
|
|
|
|
/**
|
|
* Determine the semantic parent of the given cursor.
|
|
*
|
|
* The semantic parent of a cursor is the cursor that semantically contains
|
|
* the given \p cursor. For many declarations, the lexical and semantic parents
|
|
* are equivalent (the lexical parent is returned by
|
|
* \c clang_getCursorLexicalParent()). They diverge when declarations or
|
|
* definitions are provided out-of-line. For example:
|
|
*
|
|
* \code
|
|
* class C {
|
|
* void f();
|
|
* };
|
|
*
|
|
* void C::f() { }
|
|
* \endcode
|
|
*
|
|
* In the out-of-line definition of \c C::f, the semantic parent is
|
|
* the class \c C, of which this function is a member. The lexical parent is
|
|
* the place where the declaration actually occurs in the source code; in this
|
|
* case, the definition occurs in the translation unit. In general, the
|
|
* lexical parent for a given entity can change without affecting the semantics
|
|
* of the program, and the lexical parent of different declarations of the
|
|
* same entity may be different. Changing the semantic parent of a declaration,
|
|
* on the other hand, can have a major impact on semantics, and redeclarations
|
|
* of a particular entity should all have the same semantic context.
|
|
*
|
|
* In the example above, both declarations of \c C::f have \c C as their
|
|
* semantic context, while the lexical context of the first \c C::f is \c C
|
|
* and the lexical context of the second \c C::f is the translation unit.
|
|
*
|
|
* For global declarations, the semantic parent is the translation unit.
|
|
*/
|
|
// llgo:link (*Cursor).wrapSemanticParent C.wrap_clang_getCursorSemanticParent
|
|
func (*Cursor) wrapSemanticParent(parent *Cursor) {}
|
|
|
|
func (c Cursor) SemanticParent() (parent Cursor) {
|
|
c.wrapSemanticParent(&parent)
|
|
return
|
|
}
|
|
|
|
/**
|
|
* Determine the lexical parent of the given cursor.
|
|
*
|
|
* The lexical parent of a cursor is the cursor in which the given \p cursor
|
|
* was actually written. For many declarations, the lexical and semantic parents
|
|
* are equivalent (the semantic parent is returned by
|
|
* \c clang_getCursorSemanticParent()). They diverge when declarations or
|
|
* definitions are provided out-of-line. For example:
|
|
*
|
|
* \code
|
|
* class C {
|
|
* void f();
|
|
* };
|
|
*
|
|
* void C::f() { }
|
|
* \endcode
|
|
*
|
|
* In the out-of-line definition of \c C::f, the semantic parent is
|
|
* the class \c C, of which this function is a member. The lexical parent is
|
|
* the place where the declaration actually occurs in the source code; in this
|
|
* case, the definition occurs in the translation unit. In general, the
|
|
* lexical parent for a given entity can change without affecting the semantics
|
|
* of the program, and the lexical parent of different declarations of the
|
|
* same entity may be different. Changing the semantic parent of a declaration,
|
|
* on the other hand, can have a major impact on semantics, and redeclarations
|
|
* of a particular entity should all have the same semantic context.
|
|
*
|
|
* In the example above, both declarations of \c C::f have \c C as their
|
|
* semantic context, while the lexical context of the first \c C::f is \c C
|
|
* and the lexical context of the second \c C::f is the translation unit.
|
|
*
|
|
* For declarations written in the global scope, the lexical parent is
|
|
* the translation unit.
|
|
*/
|
|
// llgo:link (*Cursor).wrapLexicalParent C.wrap_clang_getCursorLexicalParent
|
|
func (*Cursor) wrapLexicalParent(parent *Cursor) {}
|
|
|
|
func (c Cursor) LexicalParent() (parent Cursor) {
|
|
c.wrapLexicalParent(&parent)
|
|
return
|
|
}
|
|
|
|
/**
|
|
* Determine the set of methods that are overridden by the given
|
|
* method.
|
|
*
|
|
* In both Objective-C and C++, a method (aka virtual member function,
|
|
* in C++) can override a virtual method in a base class. For
|
|
* Objective-C, a method is said to override any method in the class's
|
|
* base class, its protocols, or its categories' protocols, that has the same
|
|
* selector and is of the same kind (class or instance).
|
|
* If no such method exists, the search continues to the class's superclass,
|
|
* its protocols, and its categories, and so on. A method from an Objective-C
|
|
* implementation is considered to override the same methods as its
|
|
* corresponding method in the interface.
|
|
*
|
|
* For C++, a virtual member function overrides any virtual member
|
|
* function with the same signature that occurs in its base
|
|
* classes. With multiple inheritance, a virtual member function can
|
|
* override several virtual member functions coming from different
|
|
* base classes.
|
|
*
|
|
* In all cases, this function determines the immediate overridden
|
|
* method, rather than all of the overridden methods. For example, if
|
|
* a method is originally declared in a class A, then overridden in B
|
|
* (which in inherits from A) and also in C (which inherited from B),
|
|
* then the only overridden method returned from this function when
|
|
* invoked on C's method will be B's method. The client may then
|
|
* invoke this function again, given the previously-found overridden
|
|
* methods, to map out the complete method-override set.
|
|
*
|
|
* \param cursor A cursor representing an Objective-C or C++
|
|
* method. This routine will compute the set of methods that this
|
|
* method overrides.
|
|
*
|
|
* \param overridden A pointer whose pointee will be replaced with a
|
|
* pointer to an array of cursors, representing the set of overridden
|
|
* methods. If there are no overridden methods, the pointee will be
|
|
* set to NULL. The pointee must be freed via a call to
|
|
* \c clang_disposeOverriddenCursors().
|
|
*
|
|
* \param num_overridden A pointer to the number of overridden
|
|
* functions, will be set to the number of overridden functions in the
|
|
* array pointed to by \p overridden.
|
|
*/
|
|
// llgo:link (*Cursor).wrapOverriddenCursors C.wrap_clang_getOverriddenCursors
|
|
func (c *Cursor) wrapOverriddenCursors(overridden **Cursor, numOverridden *c.Uint) {}
|
|
|
|
func (c Cursor) OverriddenCursors(overridden **Cursor, numOverridden *c.Uint) {
|
|
c.wrapOverriddenCursors(overridden, numOverridden)
|
|
}
|
|
|
|
/**
|
|
* Free the set of overridden cursors returned by \c
|
|
* clang_getOverriddenCursors().
|
|
*/
|
|
// llgo:link (*Cursor).DisposeOverriddenCursors C.clang_disposeOverriddenCursors
|
|
func (c *Cursor) DisposeOverriddenCursors() {}
|
|
|
|
/**
|
|
* Map a source location to the cursor that describes the entity at that
|
|
* location in the source code.
|
|
*
|
|
* clang_getCursor() maps an arbitrary source location within a translation
|
|
* unit down to the most specific cursor that describes the entity at that
|
|
* location. For example, given an expression \c x + y, invoking
|
|
* clang_getCursor() with a source location pointing to "x" will return the
|
|
* cursor for "x"; similarly for "y". If the cursor points anywhere between
|
|
* "x" or "y" (e.g., on the + or the whitespace around it), clang_getCursor()
|
|
* will return a cursor referring to the "+" expression.
|
|
*
|
|
* \returns a cursor representing the entity at the given source location, or
|
|
* a NULL cursor if no such entity can be found.
|
|
*/
|
|
|
|
// llgo:link (*TranslationUnit).wrapGetCursor C.wrap_clang_getCursor
|
|
func (l *TranslationUnit) wrapGetCursor(loc *SourceLocation, cur *Cursor) {}
|
|
|
|
func (l *TranslationUnit) GetCursor(loc *SourceLocation) (cur Cursor) {
|
|
l.wrapGetCursor(loc, &cur)
|
|
return
|
|
}
|
|
|
|
/**
|
|
* Retrieve the physical location of the source constructor referenced
|
|
* by the given cursor.
|
|
*
|
|
* The location of a declaration is typically the location of the name of that
|
|
* declaration, where the name of that declaration would occur if it is
|
|
* unnamed, or some keyword that introduces that particular declaration.
|
|
* The location of a reference is where that reference occurs within the
|
|
* source code.
|
|
*/
|
|
// llgo:link (*Cursor).wrapLocation C.wrap_clang_getCursorLocation
|
|
func (c *Cursor) wrapLocation(loc *SourceLocation) {}
|
|
|
|
func (c Cursor) Location() (loc SourceLocation) {
|
|
c.wrapLocation(&loc)
|
|
return
|
|
}
|
|
|
|
/**
|
|
* Retrieve the physical extent of the source construct referenced by
|
|
* the given cursor.
|
|
*
|
|
* The extent of a cursor starts with the file/line/column pointing at the
|
|
* first character within the source construct that the cursor refers to and
|
|
* ends with the last character within that source construct. For a
|
|
* declaration, the extent covers the declaration itself. For a reference,
|
|
* the extent covers the location of the reference (e.g., where the referenced
|
|
* entity was actually used).
|
|
*/
|
|
// llgo:link (*Cursor).wrapExtent C.wrap_clang_getCursorExtent
|
|
func (c *Cursor) wrapExtent(loc *SourceRange) {}
|
|
|
|
func (c Cursor) Extent() (loc SourceRange) {
|
|
c.wrapExtent(&loc)
|
|
return
|
|
}
|
|
|
|
/**
|
|
* Retrieve the type of a CXCursor (if any).
|
|
*/
|
|
// llgo:link (*Cursor).wrapType C.wrap_clang_getCursorType
|
|
func (c *Cursor) wrapType(ret *Type) {}
|
|
|
|
func (c Cursor) Type() (ret Type) {
|
|
c.wrapType(&ret)
|
|
return
|
|
}
|
|
|
|
/**
|
|
* Pretty-print the underlying type using the rules of the
|
|
* language of the translation unit from which it came.
|
|
*
|
|
* If the type is invalid, an empty string is returned.
|
|
*/
|
|
// llgo:link (*Type).wrapString C.wrap_clang_getTypeSpelling
|
|
func (t *Type) wrapString() (ret String) {
|
|
return
|
|
}
|
|
|
|
func (t Type) String() (ret String) {
|
|
return t.wrapString()
|
|
}
|
|
|
|
/**
|
|
* Retrieve the underlying type of a typedef declaration.
|
|
*
|
|
* If the cursor does not reference a typedef declaration, an invalid type is
|
|
* returned.
|
|
*/
|
|
// llgo:link (*Cursor).wrapTypedefDeclUnderlyingType C.wrap_clang_getTypedefDeclUnderlyingType
|
|
func (c *Cursor) wrapTypedefDeclUnderlyingType(ret *Type) { return }
|
|
|
|
func (c Cursor) TypedefDeclUnderlyingType() (ret Type) {
|
|
c.wrapTypedefDeclUnderlyingType(&ret)
|
|
return
|
|
}
|
|
|
|
/**
|
|
* Retrieve the integer value of an enum constant declaration as a signed
|
|
* long long.
|
|
*
|
|
* If the cursor does not reference an enum constant declaration, LLONG_MIN is
|
|
* returned. Since this is also potentially a valid constant value, the kind of
|
|
* the cursor must be verified before calling this function.
|
|
*/
|
|
// llgo:link (*Cursor).wrapEnumConstantDeclValue C.wrap_clang_getEnumConstantDeclValue
|
|
func (*Cursor) wrapEnumConstantDeclValue() (ret c.LongLong) {
|
|
return 0
|
|
}
|
|
func (c Cursor) EnumConstantDeclValue() (ret c.LongLong) {
|
|
return c.wrapEnumConstantDeclValue()
|
|
}
|
|
|
|
/**
|
|
* Retrieve the number of non-variadic arguments associated with a given
|
|
* cursor.
|
|
*
|
|
* The number of arguments can be determined for calls as well as for
|
|
* declarations of functions or methods. For other cursors -1 is returned.
|
|
*/
|
|
// llgo:link (*Cursor).wrapNumArguments C.wrap_clang_Cursor_getNumArguments
|
|
func (*Cursor) wrapNumArguments() (num c.Int) {
|
|
return 0
|
|
}
|
|
|
|
func (c Cursor) NumArguments() (num c.Int) {
|
|
return c.wrapNumArguments()
|
|
}
|
|
|
|
/**
|
|
* Retrieve the argument cursor of a function or method.
|
|
*
|
|
* The argument cursor can be determined for calls as well as for declarations
|
|
* of functions or methods. For other cursors and for invalid indices, an
|
|
* invalid cursor is returned.
|
|
*/
|
|
// llgo:link (*Cursor).wrapArgument C.wrap_clang_Cursor_getArgument
|
|
func (*Cursor) wrapArgument(index c.Uint, arg *Cursor) {}
|
|
|
|
func (c Cursor) Argument(index c.Uint) (arg Cursor) {
|
|
c.wrapArgument(index, &arg)
|
|
return
|
|
}
|
|
|
|
/**
|
|
* Return the canonical type for a CXType.
|
|
*
|
|
* Clang's type system explicitly models typedefs and all the ways
|
|
* a specific type can be represented. The canonical type is the underlying
|
|
* type with all the "sugar" removed. For example, if 'T' is a typedef
|
|
* for 'int', the canonical type for 'T' would be 'int'.
|
|
*/
|
|
// llgo:link (*Type).wrapCanonicalType C.wrap_clang_getCanonicalType
|
|
func (t *Type) wrapCanonicalType(ret *Type) { return }
|
|
|
|
func (t Type) CanonicalType() (ret Type) {
|
|
t.wrapCanonicalType(&ret)
|
|
return
|
|
}
|
|
|
|
/**
|
|
* Determine whether a CXType has the "const" qualifier set,
|
|
* without looking through typedefs that may have added "const" at a
|
|
* different level.
|
|
*/
|
|
// llgo:link (*Type).wrapIsConstQualifiedType C.wrap_clang_isConstQualifiedType
|
|
func (t *Type) wrapIsConstQualifiedType() (ret c.Uint) { return 0 }
|
|
|
|
func (t Type) IsConstQualifiedType() (ret c.Uint) {
|
|
return t.wrapIsConstQualifiedType()
|
|
}
|
|
|
|
/**
|
|
* Determine whether a CXCursor that is a macro, is
|
|
* function like.
|
|
*/
|
|
// llgo:link (*Cursor).wrapIsMacroFunctionLike C.wrap_clang_Cursor_isMacroFunctionLike
|
|
func (c *Cursor) wrapIsMacroFunctionLike() (ret c.Uint) { return 0 }
|
|
|
|
func (c Cursor) IsMacroFunctionLike() (ret c.Uint) {
|
|
return c.wrapIsMacroFunctionLike()
|
|
}
|
|
|
|
/**
|
|
* Determine whether a CXCursor that is a macro, is a
|
|
* builtin one.
|
|
*/
|
|
// llgo:link (*Cursor).wrapIsMacroBuiltin C.wrap_clang_Cursor_isMacroBuiltin
|
|
func (c *Cursor) wrapIsMacroBuiltin() (ret c.Uint) { return 0 }
|
|
|
|
func (c Cursor) IsMacroBuiltin() (ret c.Uint) {
|
|
return c.wrapIsMacroBuiltin()
|
|
}
|
|
|
|
/**
|
|
* Determine whether a CXCursor that is a function declaration, is an
|
|
* inline declaration.
|
|
*/
|
|
// llgo:link (*Cursor).wrapIsFunctionInlined C.wrap_clang_Cursor_isFunctionInlined
|
|
func (c *Cursor) wrapIsFunctionInlined() (ret c.Uint) { return 0 }
|
|
|
|
func (c Cursor) IsFunctionInlined() (ret c.Uint) {
|
|
return c.wrapIsFunctionInlined()
|
|
}
|
|
|
|
/**
|
|
* Determine whether a CXType has the "volatile" qualifier set,
|
|
* without looking through typedefs that may have added "volatile" at
|
|
* a different level.
|
|
*/
|
|
// llgo:link (*Type).wrapIsVolatileQualifiedType C.wrap_clang_isVolatileQualifiedType
|
|
func (t *Type) wrapIsVolatileQualifiedType() (ret c.Uint) { return 0 }
|
|
|
|
func (t Type) IsVolatileQualifiedType() (ret c.Uint) {
|
|
return t.wrapIsVolatileQualifiedType()
|
|
}
|
|
|
|
/**
|
|
* Determine whether a CXType has the "restrict" qualifier set,
|
|
* without looking through typedefs that may have added "restrict" at a
|
|
* different level.
|
|
*/
|
|
// llgo:link (*Type).wrapIsRestrictQualifiedType C.wrap_clang_isRestrictQualifiedType
|
|
func (t *Type) wrapIsRestrictQualifiedType() (ret c.Uint) { return 0 }
|
|
|
|
func (t Type) IsRestrictQualifiedType() (ret c.Uint) {
|
|
return t.wrapIsRestrictQualifiedType()
|
|
}
|
|
|
|
/**
|
|
* For pointer types, returns the type of the pointee.
|
|
*/
|
|
// llgo:link (*Type).wrapPointeeType C.wrap_clang_getPointeeType
|
|
func (t *Type) wrapPointeeType(ret *Type) { return }
|
|
|
|
func (t Type) PointeeType() (ret Type) {
|
|
t.wrapPointeeType(&ret)
|
|
return
|
|
}
|
|
|
|
/**
|
|
* For reference types (e.g., "const int&"), returns the type that the
|
|
* reference refers to (e.g "const int").
|
|
*
|
|
* Otherwise, returns the type itself.
|
|
*
|
|
* A type that has kind \c CXType_LValueReference or
|
|
* \c CXType_RValueReference is a reference type.
|
|
*/
|
|
// llgo:link (*Type).wrapNonReferenceType C.wrap_clang_getNonReferenceType
|
|
func (t *Type) wrapNonReferenceType(ret *Type) { return }
|
|
|
|
func (t Type) NonReferenceType() (ret Type) {
|
|
t.wrapNonReferenceType(&ret)
|
|
return
|
|
}
|
|
|
|
/**
|
|
* Return the cursor for the declaration of the given type.
|
|
*/
|
|
// llgo:link (*Type).wrapTypeDeclaration C.wrap_clang_getTypeDeclaration
|
|
func (t *Type) wrapTypeDeclaration(ret *Cursor) { return }
|
|
|
|
func (t Type) TypeDeclaration() (ret Cursor) {
|
|
t.wrapTypeDeclaration(&ret)
|
|
return
|
|
}
|
|
|
|
/**
|
|
* Retrieve the spelling of a given CXTypeKind.
|
|
*/
|
|
// llgo:link TypeKind.String C.clang_getTypeKindSpelling
|
|
func (TypeKind) String() (ret String) {
|
|
return
|
|
}
|
|
|
|
/**
|
|
* Retrieve the return type associated with a function type.
|
|
*
|
|
* If a non-function type is passed in, an invalid type is returned.
|
|
*/
|
|
// llgo:link (*Type).wrapResultType C.wrap_clang_getResultType
|
|
func (t *Type) wrapResultType(ret *Type) { return }
|
|
|
|
func (t Type) ResultType() (ret Type) {
|
|
t.wrapResultType(&ret)
|
|
return
|
|
}
|
|
|
|
/**
|
|
* Retrieve the number of non-variadic parameters associated with a
|
|
* function type.
|
|
*
|
|
* If a non-function type is passed in, -1 is returned.
|
|
*/
|
|
// llgo:link (*Type).wrapNumArgTypes C.wrap_clang_getNumArgTypes
|
|
func (t *Type) wrapNumArgTypes() (num c.Int) { return 0 }
|
|
|
|
func (t Type) NumArgTypes() (num c.Int) {
|
|
return t.wrapNumArgTypes()
|
|
}
|
|
|
|
/**
|
|
* Retrieve the type of a parameter of a function type.
|
|
*
|
|
* If a non-function type is passed in or the function does not have enough
|
|
* parameters, an invalid type is returned.
|
|
*/
|
|
// llgo:link (*Type).wrapArgType C.wrap_clang_getArgType
|
|
func (t *Type) wrapArgType(index c.Uint, argTyp *Type) { return }
|
|
|
|
func (t Type) ArgType(index c.Uint) (ret Type) {
|
|
t.wrapArgType(index, &ret)
|
|
return
|
|
}
|
|
|
|
/**
|
|
* Return 1 if the CXType is a variadic function type, and 0 otherwise.
|
|
*/
|
|
// llgo:link (*Type).wrapIsFunctionTypeVariadic C.wrap_clang_isFunctionTypeVariadic
|
|
func (t *Type) wrapIsFunctionTypeVariadic() (ret c.Uint) { return 0 }
|
|
|
|
func (t Type) IsFunctionTypeVariadic() (ret c.Uint) { return t.wrapIsFunctionTypeVariadic() }
|
|
|
|
/**
|
|
* Retrieve the return type associated with a given cursor.
|
|
*
|
|
* This only returns a valid type if the cursor refers to a function or method.
|
|
*/
|
|
// llgo:link (*Cursor).wrapResultType C.wrap_clang_getCursorResultType
|
|
func (c *Cursor) wrapResultType(ret *Type) {}
|
|
|
|
func (c Cursor) ResultType() (ret Type) {
|
|
c.wrapResultType(&ret)
|
|
return
|
|
}
|
|
|
|
/**
|
|
* Return the element type of an array, complex, or vector type.
|
|
*
|
|
* If a type is passed in that is not an array, complex, or vector type,
|
|
* an invalid type is returned.
|
|
*/
|
|
// llgo:link (*Type).wrapElementType C.wrap_clang_getElementType
|
|
func (t *Type) wrapElementType(ret *Type) { return }
|
|
|
|
func (t Type) ElementType() (ret Type) {
|
|
t.wrapElementType(&ret)
|
|
return
|
|
}
|
|
|
|
/**
|
|
* Return the element type of an array type.
|
|
*
|
|
* If a non-array type is passed in, an invalid type is returned.
|
|
*/
|
|
// llgo:link (*Type).wrapArrayElementType C.wrap_clang_getArrayElementType
|
|
func (t *Type) wrapArrayElementType(ret *Type) { return }
|
|
|
|
func (t Type) ArrayElementType() (ret Type) {
|
|
t.wrapArrayElementType(&ret)
|
|
return
|
|
}
|
|
|
|
/**
|
|
* Return the array size of a constant array.
|
|
*
|
|
* If a non-array type is passed in, -1 is returned.
|
|
*/
|
|
// llgo:link (*Type).wrapArraySize C.wrap_clang_getArraySize
|
|
func (t *Type) wrapArraySize() (ret c.LongLong) { return 0 }
|
|
|
|
func (t Type) ArraySize() (ret c.LongLong) {
|
|
return t.wrapArraySize()
|
|
}
|
|
|
|
/**
|
|
* Retrieve the type named by the qualified-id.
|
|
*
|
|
* If a non-elaborated type is passed in, an invalid type is returned.
|
|
*/
|
|
// llgo:link (*Type).wrapNamedType C.wrap_clang_Type_getNamedType
|
|
func (t *Type) wrapNamedType(ret *Type) { return }
|
|
|
|
func (t Type) NamedType() (ret Type) {
|
|
t.wrapNamedType(&ret)
|
|
return
|
|
}
|
|
|
|
/**
|
|
* Determine whether the given cursor represents an anonymous
|
|
* tag or namespace
|
|
*/
|
|
// llgo:link (*Cursor).wrapIsAnonymous C.wrap_clang_Cursor_isAnonymous
|
|
func (c *Cursor) wrapIsAnonymous() (ret c.Uint) {
|
|
return 0
|
|
}
|
|
|
|
func (c Cursor) IsAnonymous() (ret c.Uint) {
|
|
return c.wrapIsAnonymous()
|
|
}
|
|
|
|
/**
|
|
* Determine whether the given cursor represents an anonymous record
|
|
* declaration.
|
|
*/
|
|
// llgo:link (*Cursor).wrapIsAnonymousRecordDecl C.wrap_clang_Cursor_isAnonymousRecordDecl
|
|
func (c *Cursor) wrapIsAnonymousRecordDecl() (ret c.Uint) {
|
|
return 0
|
|
}
|
|
|
|
func (c Cursor) IsAnonymousRecordDecl() (ret c.Uint) {
|
|
return c.wrapIsAnonymousRecordDecl()
|
|
}
|
|
|
|
/**
|
|
* Represents the C++ access control level to a base class for a
|
|
* cursor with kind CX_CXXBaseSpecifier.
|
|
*/
|
|
type CXXAccessSpecifier c.Int
|
|
|
|
const (
|
|
CXXInvalidAccessSpecifier CXXAccessSpecifier = iota
|
|
CXXPublic
|
|
CXXProtected
|
|
CXXPrivate
|
|
)
|
|
|
|
/**
|
|
* Returns the access control level for the referenced object.
|
|
*
|
|
* If the cursor refers to a C++ declaration, its access control level within
|
|
* its parent scope is returned. Otherwise, if the cursor refers to a base
|
|
* specifier or access specifier, the specifier itself is returned.
|
|
*/
|
|
// llgo:link (*Cursor).wrapCXXAccessSpecifier C.wrap_clang_getCXXAccessSpecifier
|
|
func (*Cursor) wrapCXXAccessSpecifier() (spec CXXAccessSpecifier) {
|
|
return 0
|
|
}
|
|
|
|
func (c Cursor) CXXAccessSpecifier() CXXAccessSpecifier {
|
|
return c.wrapCXXAccessSpecifier()
|
|
}
|
|
|
|
type StorageClass c.Int
|
|
|
|
/**
|
|
* Represents the storage classes as declared in the source. CX_SC_Invalid
|
|
* was added for the case that the passed cursor in not a declaration.
|
|
*/
|
|
const (
|
|
SCInvalid StorageClass = iota
|
|
SCNone
|
|
SCExtern
|
|
SCStatic
|
|
SCPrivateExtern
|
|
SCOpenCLWorkGroupLocal
|
|
SCAuto
|
|
SCRegister
|
|
)
|
|
|
|
/**
|
|
* Returns the storage class for a function or variable declaration.
|
|
*
|
|
* If the passed in Cursor is not a function or variable declaration,
|
|
* CX_SC_Invalid is returned else the storage class.
|
|
*/
|
|
// llgo:link (*Cursor).wrapStorageClass C.wrap_clang_Cursor_getStorageClass
|
|
func (*Cursor) wrapStorageClass() (ret StorageClass) {
|
|
return 0
|
|
}
|
|
|
|
func (c Cursor) StorageClass() (ret StorageClass) {
|
|
return c.wrapStorageClass()
|
|
}
|
|
|
|
/**
|
|
* Retrieve a Unified Symbol Resolution (USR) for the entity referenced
|
|
* by the given cursor.
|
|
*
|
|
* A Unified Symbol Resolution (USR) is a string that identifies a particular
|
|
* entity (function, class, variable, etc.) within a program. USRs can be
|
|
* compared across translation units to determine, e.g., when references in
|
|
* one translation refer to an entity defined in another translation unit.
|
|
*/
|
|
// llgo:link (*Cursor).wrapUSR C.wrap_clang_getCursorUSR
|
|
func (*Cursor) wrapUSR() (ret String) {
|
|
return
|
|
}
|
|
|
|
func (c Cursor) USR() (ret String) {
|
|
return c.wrapUSR()
|
|
}
|
|
|
|
/**
|
|
* Retrieve a name for the entity referenced by this cursor.
|
|
*/
|
|
// llgo:link (*Cursor).wrapString C.wrap_clang_getCursorSpelling
|
|
func (*Cursor) wrapString() (ret String) {
|
|
return
|
|
}
|
|
|
|
func (c Cursor) String() (ret String) {
|
|
return c.wrapString()
|
|
}
|
|
|
|
/**
|
|
* Retrieve the display name for the entity referenced by this cursor.
|
|
*
|
|
* The display name contains extra information that helps identify the cursor,
|
|
* such as the parameters of a function or template or the arguments of a
|
|
* class template specialization.
|
|
*/
|
|
// llgo:link (*Cursor).wrapDisplayName C.wrap_clang_getCursorDisplayName
|
|
func (*Cursor) wrapDisplayName() (ret String) {
|
|
return
|
|
}
|
|
func (c Cursor) DisplayName() (ret String) {
|
|
return c.wrapDisplayName()
|
|
}
|
|
|
|
/** For a cursor that is a reference, retrieve a cursor representing the
|
|
* entity that it references.
|
|
*
|
|
* Reference cursors refer to other entities in the AST. For example, an
|
|
* Objective-C superclass reference cursor refers to an Objective-C class.
|
|
* This function produces the cursor for the Objective-C class from the
|
|
* cursor for the superclass reference. If the input cursor is a declaration or
|
|
* definition, it returns that declaration or definition unchanged.
|
|
* Otherwise, returns the NULL cursor.
|
|
*/
|
|
// llgo:link (*Cursor).wrapReferenced C.wrap_clang_getCursorReferenced
|
|
func (*Cursor) wrapReferenced(referenced *Cursor) {}
|
|
|
|
func (c Cursor) Referenced() (referenced Cursor) {
|
|
c.wrapReferenced(&referenced)
|
|
return
|
|
}
|
|
|
|
/**
|
|
* Returns non-zero if the given cursor is a variadic function or method.
|
|
*/
|
|
// llgo:link (*Cursor).wrapIsVariadic C.wrap_clang_Cursor_isVariadic
|
|
func (*Cursor) wrapIsVariadic() (ret c.Uint) { return 0 }
|
|
|
|
func (c Cursor) IsVariadic() (ret c.Uint) { return c.wrapIsVariadic() }
|
|
|
|
/**
|
|
* Given a cursor that represents a declaration, return the associated
|
|
* comment's source range. The range may include multiple consecutive comments
|
|
* with whitespace in between.
|
|
*/
|
|
// llgo:link (*Cursor).wrapCommentRange C.wrap_clang_Cursor_getCommentRange
|
|
func (c *Cursor) wrapCommentRange(ret *SourceRange) {}
|
|
|
|
func (c Cursor) CommentRange() (loc SourceRange) {
|
|
c.wrapCommentRange(&loc)
|
|
return
|
|
}
|
|
|
|
/**
|
|
* Given a cursor that represents a declaration, return the associated
|
|
* comment text, including comment markers.
|
|
*/
|
|
// llgo:link (*Cursor).wrapRawCommentText C.wrap_clang_Cursor_getRawCommentText
|
|
func (c *Cursor) wrapRawCommentText() (ret String) {
|
|
return
|
|
}
|
|
|
|
func (c Cursor) RawCommentText() (ret String) {
|
|
return c.wrapRawCommentText()
|
|
}
|
|
|
|
/**
|
|
* Retrieve a name for the entity referenced by this cursor.
|
|
*/
|
|
// llgo:link (*Cursor).wrapMangling C.wrap_clang_Cursor_getMangling
|
|
func (*Cursor) wrapMangling() (ret String) {
|
|
return
|
|
}
|
|
|
|
func (c Cursor) Mangling() (ret String) {
|
|
return c.wrapMangling()
|
|
}
|
|
|
|
/**
|
|
* Determine if a C++ constructor is a converting constructor.
|
|
*/
|
|
// llgo:link (*Cursor).wrapIsConvertingConstructor C.wrap_clang_CXXConstructor_isConvertingConstructor
|
|
func (c *Cursor) wrapIsConvertingConstructor() (ret c.Uint) {
|
|
return 0
|
|
}
|
|
|
|
func (c Cursor) IsConvertingConstructor() (ret c.Uint) {
|
|
return c.wrapIsConvertingConstructor()
|
|
}
|
|
|
|
/**
|
|
* Determine if a C++ constructor is a copy constructor.
|
|
*/
|
|
// llgo:link (*Cursor).wrapIsCopyConstructor C.wrap_clang_CXXConstructor_isCopyConstructor
|
|
func (c *Cursor) wrapIsCopyConstructor() (ret c.Uint) {
|
|
return 0
|
|
}
|
|
func (c Cursor) IsCopyConstructor() (ret c.Uint) {
|
|
return c.wrapIsCopyConstructor()
|
|
}
|
|
|
|
/**
|
|
* Determine if a C++ constructor is the default constructor.
|
|
*/
|
|
// llgo:link (*Cursor).wrapIsDefaultConstructor C.wrap_clang_CXXConstructor_isDefaultConstructor
|
|
func (c *Cursor) wrapIsDefaultConstructor() (ret c.Uint) {
|
|
return 0
|
|
}
|
|
func (c Cursor) IsDefaultConstructor() (ret c.Uint) {
|
|
return c.wrapIsDefaultConstructor()
|
|
}
|
|
|
|
/**
|
|
* Determine if a C++ constructor is a move constructor.
|
|
*/
|
|
// llgo:link (*Cursor).wrapIsMoveConstructor C.wrap_clang_CXXConstructor_isMoveConstructor
|
|
func (c *Cursor) wrapIsMoveConstructor() (ret c.Uint) {
|
|
return 0
|
|
}
|
|
func (c Cursor) IsMoveConstructor() (ret c.Uint) {
|
|
return c.wrapIsMoveConstructor()
|
|
}
|
|
|
|
/**
|
|
* Determine if a C++ field is declared 'mutable'.
|
|
*/
|
|
// llgo:link (*Cursor).wrapIsMutable C.wrap_clang_CXXField_isMutable
|
|
func (c *Cursor) wrapIsMutable() (ret c.Uint) {
|
|
return 0
|
|
}
|
|
func (c Cursor) IsMutable() (ret c.Uint) {
|
|
return c.wrapIsMutable()
|
|
}
|
|
|
|
/**
|
|
* Determine if a C++ method is declared '= default'.
|
|
*/
|
|
// llgo:link (*Cursor).wrapIsDefaulted C.wrap_clang_CXXMethod_isDefaulted
|
|
func (c *Cursor) wrapIsDefaulted() (ret c.Uint) {
|
|
return 0
|
|
}
|
|
func (c Cursor) IsDefaulted() (ret c.Uint) {
|
|
return c.wrapIsDefaulted()
|
|
}
|
|
|
|
/**
|
|
* Determine if a C++ method is declared '= delete'.
|
|
*/
|
|
// llgo:link (*Cursor).wrapIsDeleted C.wrap_clang_CXXMethod_isDeleted
|
|
func (c *Cursor) wrapIsDeleted() (ret c.Uint) {
|
|
return 0
|
|
}
|
|
func (c Cursor) IsDeleted() (ret c.Uint) {
|
|
return c.wrapIsDeleted()
|
|
}
|
|
|
|
/**
|
|
* Determine if a C++ member function or member function template is
|
|
* pure virtual.
|
|
*/
|
|
// llgo:link (*Cursor).wrapIsPureVirtual C.wrap_clang_CXXMethod_isPureVirtual
|
|
func (c *Cursor) wrapIsPureVirtual() (ret c.Uint) {
|
|
return 0
|
|
}
|
|
func (c Cursor) IsPureVirtual() (ret c.Uint) {
|
|
return c.wrapIsPureVirtual()
|
|
}
|
|
|
|
/**
|
|
* Determine if a C++ member function or member function template is
|
|
* declared 'static'.
|
|
*/
|
|
// llgo:link (*Cursor).wrapIsStatic C.wrap_clang_CXXMethod_isStatic
|
|
func (c *Cursor) wrapIsStatic() (ret c.Uint) {
|
|
return 0
|
|
}
|
|
func (c Cursor) IsStatic() (ret c.Uint) {
|
|
return c.wrapIsStatic()
|
|
}
|
|
|
|
/**
|
|
* Determine if a C++ member function or member function template is
|
|
* explicitly declared 'virtual' or if it overrides a virtual method from
|
|
* one of the base classes.
|
|
*/
|
|
// llgo:link (*Cursor).wrapIsVirtual C.wrap_clang_CXXMethod_isVirtual
|
|
func (c *Cursor) wrapIsVirtual() (ret c.Uint) {
|
|
return 0
|
|
}
|
|
func (c Cursor) IsVirtual() (ret c.Uint) {
|
|
return c.wrapIsVirtual()
|
|
}
|
|
|
|
/**
|
|
* Determine if a C++ member function is a copy-assignment operator,
|
|
* returning 1 if such is the case and 0 otherwise.
|
|
*
|
|
* > A copy-assignment operator `X::operator=` is a non-static,
|
|
* > non-template member function of _class_ `X` with exactly one
|
|
* > parameter of type `X`, `X&`, `const X&`, `volatile X&` or `const
|
|
* > volatile X&`.
|
|
*
|
|
* That is, for example, the `operator=` in:
|
|
*
|
|
* class Foo {
|
|
* bool operator=(const volatile Foo&);
|
|
* };
|
|
*
|
|
* Is a copy-assignment operator, while the `operator=` in:
|
|
*
|
|
* class Bar {
|
|
* bool operator=(const int&);
|
|
* };
|
|
*
|
|
* Is not.
|
|
*/
|
|
// llgo:link (*Cursor).wrapIsCopyAssignmentOperator C.wrap_clang_CXXMethod_isCopyAssignmentOperator
|
|
func (c *Cursor) wrapIsCopyAssignmentOperator() (ret c.Uint) {
|
|
return 0
|
|
}
|
|
func (c Cursor) IsCopyAssignmentOperator() (ret c.Uint) {
|
|
return c.wrapIsCopyAssignmentOperator()
|
|
}
|
|
|
|
/**
|
|
* Determine if a C++ member function is a move-assignment operator,
|
|
* returning 1 if such is the case and 0 otherwise.
|
|
*
|
|
* > A move-assignment operator `X::operator=` is a non-static,
|
|
* > non-template member function of _class_ `X` with exactly one
|
|
* > parameter of type `X&&`, `const X&&`, `volatile X&&` or `const
|
|
* > volatile X&&`.
|
|
*
|
|
* That is, for example, the `operator=` in:
|
|
*
|
|
* class Foo {
|
|
* bool operator=(const volatile Foo&&);
|
|
* };
|
|
*
|
|
* Is a move-assignment operator, while the `operator=` in:
|
|
*
|
|
* class Bar {
|
|
* bool operator=(const int&&);
|
|
* };
|
|
*
|
|
* Is not.
|
|
*/
|
|
// llgo:link (*Cursor).wrapIsMoveAssignmentOperator C.wrap_clang_CXXMethod_isMoveAssignmentOperator
|
|
func (c *Cursor) wrapIsMoveAssignmentOperator() (ret c.Uint) {
|
|
return 0
|
|
}
|
|
func (c Cursor) IsMoveAssignmentOperator() (ret c.Uint) {
|
|
return c.wrapIsMoveAssignmentOperator()
|
|
}
|
|
|
|
/**
|
|
* Determines if a C++ constructor or conversion function was declared
|
|
* explicit, returning 1 if such is the case and 0 otherwise.
|
|
*
|
|
* Constructors or conversion functions are declared explicit through
|
|
* the use of the explicit specifier.
|
|
*
|
|
* For example, the following constructor and conversion function are
|
|
* not explicit as they lack the explicit specifier:
|
|
*
|
|
* class Foo {
|
|
* Foo();
|
|
* operator int();
|
|
* };
|
|
*
|
|
* While the following constructor and conversion function are
|
|
* explicit as they are declared with the explicit specifier.
|
|
*
|
|
* class Foo {
|
|
* explicit Foo();
|
|
* explicit operator int();
|
|
* };
|
|
*
|
|
* This function will return 0 when given a cursor pointing to one of
|
|
* the former declarations and it will return 1 for a cursor pointing
|
|
* to the latter declarations.
|
|
*
|
|
* The explicit specifier allows the user to specify a
|
|
* conditional compile-time expression whose value decides
|
|
* whether the marked element is explicit or not.
|
|
*
|
|
* For example:
|
|
*
|
|
* constexpr bool foo(int i) { return i % 2 == 0; }
|
|
*
|
|
* class Foo {
|
|
* explicit(foo(1)) Foo();
|
|
* explicit(foo(2)) operator int();
|
|
* }
|
|
*
|
|
* This function will return 0 for the constructor and 1 for
|
|
* the conversion function.
|
|
*/
|
|
// llgo:link (*Cursor).wrapIsExplicit C.wrap_clang_CXXMethod_isExplicit
|
|
func (c *Cursor) wrapIsExplicit() (ret c.Uint) {
|
|
return 0
|
|
}
|
|
func (c Cursor) IsExplicit() (ret c.Uint) {
|
|
return c.wrapIsExplicit()
|
|
}
|
|
|
|
/**
|
|
* Determine if a C++ record is abstract, i.e. whether a class or struct
|
|
* has a pure virtual member function.
|
|
*/
|
|
// llgo:link (*Cursor).wrapIsAbstract C.wrap_clang_CXXRecord_isAbstract
|
|
func (c *Cursor) wrapIsAbstract() (ret c.Uint) {
|
|
return 0
|
|
}
|
|
func (c Cursor) IsAbstract() (ret c.Uint) {
|
|
return c.wrapIsAbstract()
|
|
}
|
|
|
|
/**
|
|
* Determine if an enum declaration refers to a scoped enum.
|
|
*/
|
|
// llgo:link (*Cursor).wrapIsScoped C.wrap_clang_EnumDecl_isScoped
|
|
func (c *Cursor) wrapIsScoped() (ret c.Uint) {
|
|
return 0
|
|
}
|
|
func (c Cursor) IsScoped() (ret c.Uint) {
|
|
return c.wrapIsScoped()
|
|
}
|
|
|
|
/**
|
|
* Determine if a C++ member function or member function template is
|
|
* declared 'const'.
|
|
*/
|
|
// llgo:link (*Cursor).wrapIsConst C.wrap_clang_CXXMethod_isConst
|
|
func (c *Cursor) wrapIsConst() (ret c.Uint) {
|
|
return 0
|
|
}
|
|
func (c Cursor) IsConst() (ret c.Uint) {
|
|
return c.wrapIsConst()
|
|
}
|
|
|
|
/**
|
|
* Determine the kind of the given token.
|
|
*/
|
|
// llgo:link (*Token).wrapKind C.wrap_clang_getTokenKind
|
|
func (c *Token) wrapKind() (ret TokenKind) {
|
|
return
|
|
}
|
|
|
|
func (c Token) Kind() (ret TokenKind) {
|
|
return c.wrapKind()
|
|
}
|
|
|
|
/**
|
|
* Determine the spelling of the given token.
|
|
*
|
|
* The spelling of a token is the textual representation of that token, e.g.,
|
|
* the text of an identifier or keyword.
|
|
*/
|
|
// llgo:link (*TranslationUnit).wrapToken C.wrap_clang_getTokenSpelling
|
|
func (*TranslationUnit) wrapToken(token *Token) (ret String) {
|
|
return
|
|
}
|
|
|
|
func (c *TranslationUnit) Token(token Token) (ret String) {
|
|
return c.wrapToken(&token)
|
|
}
|
|
|
|
/**
|
|
* 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
|
|
* \c CXCursorVisitor to indicate how clang_visitChildren() proceed.
|
|
*/
|
|
type ChildVisitResult c.Int
|
|
|
|
const (
|
|
/**
|
|
* Terminates the cursor traversal.
|
|
*/
|
|
ChildVisit_Break ChildVisitResult = iota
|
|
/**
|
|
* Continues the cursor traversal with the next sibling of
|
|
* the cursor just visited, without visiting its children.
|
|
*/
|
|
ChildVisit_Continue
|
|
/**
|
|
* Recursively traverse the children of this cursor, using
|
|
* the same visitor and client data.
|
|
*/
|
|
ChildVisit_Recurse
|
|
)
|
|
|
|
/**
|
|
* Visit the children of a particular cursor.
|
|
*
|
|
* This function visits all the direct children of the given cursor,
|
|
* invoking the given \p visitor function with the cursors of each
|
|
* visited child. The traversal may be recursive, if the visitor returns
|
|
* \c CXChildVisit_Recurse. The traversal may also be ended prematurely, if
|
|
* the visitor returns \c CXChildVisit_Break.
|
|
*
|
|
* \param parent the cursor whose child may be visited. All kinds of
|
|
* cursors can be visited, including invalid cursors (which, by
|
|
* definition, have no children).
|
|
*
|
|
* \param visitor the visitor function that will be invoked for each
|
|
* child of \p parent.
|
|
*
|
|
* \param client_data pointer data supplied by the client, which will
|
|
* be passed to the visitor each time it is invoked.
|
|
*
|
|
* \returns a non-zero value if the traversal was terminated
|
|
* prematurely by the visitor returning \c CXChildVisit_Break.
|
|
*/
|
|
//go:linkname wrapVisitChildren C.wrap_clang_visitChildren
|
|
func wrapVisitChildren(
|
|
cusor *Cursor,
|
|
fn wrapVisitor,
|
|
clientData ClientData) c.Uint {
|
|
return 0
|
|
}
|
|
|
|
//llgo:type C
|
|
type wrapVisitor func(cursor, parent *Cursor, clientData ClientData) ChildVisitResult
|
|
|
|
type wrapData struct {
|
|
data ClientData
|
|
fn Visitor
|
|
}
|
|
|
|
func VisitChildren(
|
|
root Cursor,
|
|
fn Visitor,
|
|
clientData ClientData) c.Uint {
|
|
return wrapVisitChildren(&root, func(cursor, parent *Cursor, data ClientData) ChildVisitResult {
|
|
p := (*wrapData)(data)
|
|
return p.fn(*cursor, *parent, p.data)
|
|
}, unsafe.Pointer(&wrapData{clientData, fn}))
|
|
}
|
|
|
|
//llgo:type C
|
|
type Visitor func(cursor, parent Cursor, clientData ClientData) ChildVisitResult
|
|
|
|
/**
|
|
* Visitor invoked for each file in a translation unit
|
|
* (used with clang_getInclusions()).
|
|
*
|
|
* This visitor function will be invoked by clang_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'.
|
|
*/
|
|
//llgo:type C
|
|
type InclusionVisitor func(included_file File, inclusion_stack *SourceLocation, include_len c.Uint, client_data ClientData)
|
|
|
|
/**
|
|
* Visit the set of preprocessor inclusions in a translation unit.
|
|
* The visitor function is called with the provided data for every included
|
|
* file. This does not include headers included by the PCH file (unless one
|
|
* is inspecting the inclusions in the PCH file itself).
|
|
*/
|
|
//go:linkname GetInclusions C.clang_getInclusions
|
|
func GetInclusions(tu *TranslationUnit, visitor InclusionVisitor, client_data ClientData)
|
|
|
|
/**
|
|
* Tokenize the source code described by the given range into raw
|
|
* lexical tokens.
|
|
*
|
|
* \param TU the translation unit whose text is being tokenized.
|
|
*
|
|
* \param Range the source range in which text should be tokenized. All of the
|
|
* tokens produced by tokenization will fall within this source range,
|
|
*
|
|
* \param Tokens this pointer will be set to point to the array of tokens
|
|
* that occur within the given source range. The returned pointer must be
|
|
* freed with clang_disposeTokens() before the translation unit is destroyed.
|
|
*
|
|
* \param NumTokens will be set to the number of tokens in the \c *Tokens
|
|
* array.
|
|
*
|
|
*/
|
|
// llgo:link (*TranslationUnit).wrapTokenize C.wrap_clang_tokenize
|
|
func (t *TranslationUnit) wrapTokenize(ran *SourceRange, tokens **Token, numTokens *c.Uint) {}
|
|
|
|
func (t *TranslationUnit) Tokenize(ran SourceRange, tokens **Token, numTokens *c.Uint) {
|
|
t.wrapTokenize(&ran, tokens, numTokens)
|
|
}
|
|
|
|
/**
|
|
* Free the given set of tokens.
|
|
*/
|
|
// llgo:link (*TranslationUnit).DisposeTokens C.clang_disposeTokens
|
|
func (t *TranslationUnit) DisposeTokens(tokens *Token, numTokens c.Uint) {}
|
|
|
|
/**
|
|
* Retrieve the file, line, column, and offset represented by
|
|
* the given source location.
|
|
*
|
|
* If the location refers into a macro instantiation, return where the
|
|
* location was originally spelled in the source file.
|
|
*
|
|
* \param location the location within a source file that will be decomposed
|
|
* into its parts.
|
|
*
|
|
* \param file [out] if non-NULL, will be set to the file to which the given
|
|
* source location points.
|
|
*
|
|
* \param line [out] if non-NULL, will be set to the line to which the given
|
|
* source location points.
|
|
*
|
|
* \param column [out] if non-NULL, will be set to the column to which the given
|
|
* source location points.
|
|
*
|
|
* \param offset [out] if non-NULL, will be set to the offset into the
|
|
* buffer to which the given source location points.
|
|
*/
|
|
// llgo:link (*SourceLocation).wrapSpellingLocation C.wrap_clang_getSpellingLocation
|
|
func (l *SourceLocation) wrapSpellingLocation(file *File, line, column, offset *c.Uint) {}
|
|
|
|
func (l SourceLocation) SpellingLocation(file *File, line, column, offset *c.Uint) {
|
|
l.wrapSpellingLocation(file, line, column, offset)
|
|
}
|
|
|
|
/**
|
|
* Retrieve a source location representing the first character within a
|
|
* source range.
|
|
*/
|
|
// llgo:link (*SourceRange).wrapRangeStart C.wrap_clang_getRangeStart
|
|
func (r *SourceRange) wrapRangeStart(loc *SourceLocation) { return }
|
|
|
|
func (r SourceRange) RangeStart() (loc SourceLocation) {
|
|
r.wrapRangeStart(&loc)
|
|
return
|
|
}
|
|
|
|
/**
|
|
* Retrieve a source location representing the last character within a
|
|
* source range.
|
|
*/
|
|
// llgo:link (*SourceRange).wrapRangeEnd C.wrap_clang_getRangeEnd
|
|
func (r *SourceRange) wrapRangeEnd(loc *SourceLocation) { return }
|
|
|
|
func (r SourceRange) RangeEnd() (loc SourceLocation) {
|
|
r.wrapRangeEnd(&loc)
|
|
return
|
|
}
|
|
|
|
//llgo:link File.FileName C.clang_getFileName
|
|
func (File) FileName() (ret String) { return }
|