cc

package module
Version: v3.36.1 Latest Latest
Warning

This package is not in the latest version of its module.

Go to latest
Published: Jul 31, 2022 License: BSD-3-Clause Imports: 30 Imported by: 11

README

cc/v3

Package CC is a C99 compiler front end.

Most of the functionality is now working.

Installation

$ go get -u modernc.org/cc/v3

Documentation: godoc.org/modernc.org/cc/v3

Documentation

Overview

Package cc is a C99 compiler front end (Work in progress).

Installation

To install/update cc/v3 invoke:

$ go get [-u] modernc.org/cc/v3

Online documentation

See https://godoc.org/modernc.org/cc/v3.

Status

Most of the functionality is now working.

Supported platforms

The code is known to work on Darwin, Linux and Windows, but the supported features may vary.

Index

Examples

Constants

View Source
const (
	ACCUM                  // _Accum
	ADDASSIGN              // +=
	ALIGNAS                // _Alignas
	ALIGNOF                // _Alignof
	ANDAND                 // &&
	ANDASSIGN              // &=
	ARROW                  // ->
	ASM                    // __asm__
	ATOMIC                 // _Atomic
	ATTRIBUTE              // __attribute__
	AUTO                   // auto
	BOOL                   // _Bool
	BREAK                  // break
	BUILTINCHOOSEEXPR      // __builtin_choose_expr
	BUILTINTYPESCOMPATIBLE // __builtin_types_compatible_p
	CASE                   // case
	CHAR                   // char
	CHARCONST              // 'a'
	COMPLEX                // _Complex
	CONST                  // const
	CONTINUE               // continue
	DDD                    // ...
	DEC                    // --
	DECIMAL128             // _Decimal128
	DECIMAL32              // _Decimal32
	DECIMAL64              // _Decimal64
	DEFAULT                // default
	DIVASSIGN              // /=
	DO                     // do
	DOUBLE                 // double
	ELSE                   // else
	ENUM                   // enum
	ENUMCONST              // foo in enum x { foo, bar };
	EQ                     // ==
	EXTERN                 // extern
	FLOAT                  // float
	FLOAT128               // _Float128
	FLOAT16                // __fp16
	FLOAT32                // _Float32
	FLOAT32X               // _Float32x
	FLOAT64                // _Float64
	FLOAT64X               // _Float64x
	FLOAT80                // __float80
	FLOATCONST             // 1.23
	FOR                    // for
	FRACT                  // _Fract
	GEQ                    // >=
	GOTO                   // goto
	IDENTIFIER             // foo
	IF                     // if
	IMAG                   // __imag__
	INC                    // ++
	INLINE                 // inline
	INT                    // int
	INT8                   // __int8
	INT16                  // __int16
	INT32                  // __int32
	INT64                  // __int64
	INT128                 // __int128
	INTCONST               // 42
	LABEL                  // __label__
	LEQ                    // <=
	LONG                   // long
	LONGCHARCONST          // L'a'
	LONGSTRINGLITERAL      // L"foo"
	LSH                    // <<
	LSHASSIGN              // <<=
	MODASSIGN              // %=
	MULASSIGN              // *=
	NEQ                    // !=
	NORETURN               // _Noreturn
	ORASSIGN               // |=
	OROR                   // ||
	PPNUMBER               // .32e.
	PPPASTE                // ##
	PRAGMASTDC             // __pragma_stdc
	REAL                   // __real__
	REGISTER               // register
	RESTRICT               // restrict
	RETURN                 // return
	RSH                    // >>
	RSHASSIGN              // >>=
	SAT                    // _Sat
	SHORT                  // short
	SIGNED                 // signed
	SIZEOF                 // sizeof
	STATIC                 // static
	STRINGLITERAL          // "foo"
	STRUCT                 // struct
	SUBASSIGN              // -=
	SWITCH                 // switch
	THREADLOCAL            // _Thread_local
	TYPEDEF                // typedef
	TYPEDEFNAME            // int_t in typedef int int_t;
	TYPEOF                 // typeof
	UNION                  // union
	UNSIGNED               // unsigned
	VOID                   // void
	VOLATILE               // volatile
	WHILE                  // while
	XORASSIGN              // ^=

)

Values of Token.Rune for lexemes.

Variables

This section is empty.

Functions

func HostConfig

func HostConfig(cpp string, opts ...string) (predefined string, includePaths, sysIncludePaths []string, err error)

HostConfig returns the system C preprocessor/compiler configuration, or an error, if any. The configuration is obtained by running the command named by the cpp argumnent or "cpp" when it's empty. For the predefined macros list the '-dM' options is added. For the include paths lists, the option '-v' is added and the output is parsed to extract the "..." include and <...> include paths. To add any other options to cpp, list them in opts.

The function relies on a POSIX/GCC compatible C preprocessor installed. Execution of HostConfig is not free, so caching of the results is recommended.

func Inspect

func Inspect(n Node, f func(Node, bool) bool)

Inspect inspects AST node trees.

If n is a non-terminal node, f(n, true) is called first. Next, f is called recursively for each of n's non-nil non-terminal children nodes, if any, in alphabetical order. Next, all n's terminal nodes, if any, are visited in the numeric order of their suffixes (Token, Token2, Token3, ...). Finally, f(n, false) is invoked.

If n a terminal node, of type *Token, f(n, <unspecified boolean value> is called once.

Inspect stops when any invocation of f returns false.

func Preprocess

func Preprocess(cfg *Config, includePaths, sysIncludePaths []string, sources []Source, w io.Writer) error

Preprocess preprocesses a translation unit and outputs the result to w.

Please see Parse for the documentation of the other parameters.

func PrettyString

func PrettyString(v interface{}) string

PrettyString returns a formatted representation of things produced by this package.

Types

type ABI

type ABI struct {
	ByteOrder binary.ByteOrder
	Types     map[Kind]ABIType

	SignedChar bool
	// contains filtered or unexported fields
}

ABI describes selected parts of the Application Binary Interface.

func NewABI

func NewABI(os, arch string) (ABI, error)

NewABI creates an ABI for a given OS and architecture. The OS and architecture values are the same as used in Go. The ABI type map may miss advanced types like complex numbers, etc. If the os/arch pair is not recognized, a *ErrUnsupportedOSArch is returned.

func NewABIFromEnv

func NewABIFromEnv() (ABI, error)

NewABIFromEnv uses GOOS and GOARCH values to create a corresponding ABI. If those environment variables are not set, an OS/arch of a Go runtime is used. It returns a *ErrUnsupportedOSArch if OS/arch pair is not supported.

func (*ABI) Ptr

func (a *ABI) Ptr(n Node, t Type) Type

func (*ABI) Type

func (a *ABI) Type(k Kind) Type

type ABIType

type ABIType struct {
	Size       uintptr
	Align      int
	FieldAlign int
}

ABIType describes properties of a non-aggregate type.

type AST

type AST struct {
	Enums       map[StringID]Operand // Enumeration constants declared in file scope.
	Macros      map[StringID]*Macro  // Macros as defined after parsing.
	PtrdiffType Type
	Scope       Scope // File scope.
	SizeType    Type
	StructTypes map[StringID]Type // Tagged struct/union types declared in file scope.
	// Alignment and size of every struct/union defined in the translation
	// unit. Valid only after Translate.
	Structs map[StructInfo]struct{}
	// TLD contains pruned file scope declarators, ie. either the first one
	// or the first one that has an initializer.
	TLD               map[*Declarator]struct{}
	TrailingSeperator StringID // White space and/or comments preceding EOF.
	TranslationUnit   *TranslationUnit
	WideCharType      Type
	// contains filtered or unexported fields
}

AST represents a translation unit and its related data.

func Parse

func Parse(cfg *Config, includePaths, sysIncludePaths []string, sources []Source) (*AST, error)

Parse preprocesses and parses a translation unit and returns an *AST or error, if any.

Search paths listed in includePaths and sysIncludePaths are used to resolve #include "foo.h" and #include <foo.h> preprocessing directives respectively. A special search path "@" is interpreted as 'the same directory as where the file with the #include directive is'.

The sources should typically provide, usually in this particular order:

- predefined macros, eg.

#define __SIZE_TYPE__ long unsigned int

- built-in declarations, eg.

int __builtin_printf(char *__format, ...);

- command-line provided directives, eg.

#define FOO
#define BAR 42
#undef QUX

- normal C sources, eg.

int main() {}

All search and file paths should be absolute paths.

If the preprocessed translation unit is empty, the function may return (nil, nil).

The parser does only the minimum declarations/identifier resolving necessary for correct parsing. Redeclarations are not checked.

Declarators (*Declarator) and StructDeclarators (*StructDeclarator) are inserted in the appropriate scopes.

Tagged struct/union specifier definitions (*StructOrUnionSpecifier) are inserted in the appropriate scopes.

Tagged enum specifier definitions (*EnumSpecifier) and enumeration constants (*Enumerator) are inserted in the appropriate scopes.

Labels (*LabeledStatement) are inserted in the appropriate scopes.

func Translate

func Translate(cfg *Config, includePaths, sysIncludePaths []string, sources []Source) (*AST, error)

Translate parses and typechecks a translation unit and returns an *AST or error, if any.

Please see Parse for the documentation of the parameters.

func (*AST) Eval

func (n *AST) Eval(m *Macro) (o Operand, err error)

Eval returns the operand that represents the value of m, if it expands to a valid constant expression other than an identifier, or an error, if any.

func (*AST) Typecheck

func (n *AST) Typecheck() error

Typecheck determines types of objects and expressions and verifies types are valid in the context they are used.

type AbstractDeclarator

type AbstractDeclarator struct {
	Case                     AbstractDeclaratorCase `PrettyPrint:"stringer,zero"`
	DirectAbstractDeclarator *DirectAbstractDeclarator
	Pointer                  *Pointer
	// contains filtered or unexported fields
}

AbstractDeclarator represents data reduced by productions:

AbstractDeclarator:
        Pointer                           // Case AbstractDeclaratorPtr
|       Pointer DirectAbstractDeclarator  // Case AbstractDeclaratorDecl
Example (Decl)
fmt.Println(exampleAST(194, "void f(int());"))
Output:

&cc.AbstractDeclarator{
· Case: AbstractDeclaratorDecl,
· DirectAbstractDeclarator: &cc.DirectAbstractDeclarator{
· · Case: DirectAbstractDeclaratorFunc,
· · Token: example.c:1:11: '(' "(",
· · Token2: example.c:1:12: ')' ")",
· },
}
Example (Ptr)
fmt.Println(exampleAST(193, "void f(int*);"))
Output:

&cc.AbstractDeclarator{
· Case: AbstractDeclaratorPtr,
· Pointer: &cc.Pointer{
· · Case: PointerTypeQual,
· · Token: example.c:1:11: '*' "*",
· },
}

func (*AbstractDeclarator) Position

func (n *AbstractDeclarator) Position() (r token.Position)

Position reports the position of the first component of n, if available.

func (*AbstractDeclarator) String

func (n *AbstractDeclarator) String() string

String implements fmt.Stringer.

type AbstractDeclaratorCase

type AbstractDeclaratorCase int

AbstractDeclaratorCase represents case numbers of production AbstractDeclarator

const (
	AbstractDeclaratorPtr AbstractDeclaratorCase = iota
	AbstractDeclaratorDecl
)

Values of type AbstractDeclaratorCase

func (AbstractDeclaratorCase) String

func (n AbstractDeclaratorCase) String() string

String implements fmt.Stringer

type AdditiveExpression

type AdditiveExpression struct {
	Operand Operand

	IsSideEffectsFree        bool
	AdditiveExpression       *AdditiveExpression
	Case                     AdditiveExpressionCase `PrettyPrint:"stringer,zero"`
	MultiplicativeExpression *MultiplicativeExpression
	Token                    Token
	// contains filtered or unexported fields
}

AdditiveExpression represents data reduced by productions:

AdditiveExpression:
        MultiplicativeExpression                         // Case AdditiveExpressionMul
|       AdditiveExpression '+' MultiplicativeExpression  // Case AdditiveExpressionAdd
|       AdditiveExpression '-' MultiplicativeExpression  // Case AdditiveExpressionSub
Example (Add)
fmt.Println(exampleAST(46, "int i = x+y;"))
Output:

&cc.AdditiveExpression{
· AdditiveExpression: &cc.AdditiveExpression{
· · Case: AdditiveExpressionMul,
· · MultiplicativeExpression: &cc.MultiplicativeExpression{
· · · Case: MultiplicativeExpressionCast,
· · · CastExpression: &cc.CastExpression{
· · · · Case: CastExpressionUnary,
· · · · UnaryExpression: &cc.UnaryExpression{
· · · · · Case: UnaryExpressionPostfix,
· · · · · PostfixExpression: &cc.PostfixExpression{
· · · · · · Case: PostfixExpressionPrimary,
· · · · · · PrimaryExpression: &cc.PrimaryExpression{
· · · · · · · Case: PrimaryExpressionIdent,
· · · · · · · Token: example.c:1:9: IDENTIFIER "x",
· · · · · · },
· · · · · },
· · · · },
· · · },
· · },
· },
· Case: AdditiveExpressionAdd,
· MultiplicativeExpression: &cc.MultiplicativeExpression{
· · Case: MultiplicativeExpressionCast,
· · CastExpression: &cc.CastExpression{
· · · Case: CastExpressionUnary,
· · · UnaryExpression: &cc.UnaryExpression{
· · · · Case: UnaryExpressionPostfix,
· · · · PostfixExpression: &cc.PostfixExpression{
· · · · · Case: PostfixExpressionPrimary,
· · · · · PrimaryExpression: &cc.PrimaryExpression{
· · · · · · Case: PrimaryExpressionIdent,
· · · · · · Token: example.c:1:11: IDENTIFIER "y",
· · · · · },
· · · · },
· · · },
· · },
· },
· Token: example.c:1:10: '+' "+",
}
Example (Mul)
fmt.Println(exampleAST(45, "int i = x;"))
Output:

&cc.AdditiveExpression{
· Case: AdditiveExpressionMul,
· MultiplicativeExpression: &cc.MultiplicativeExpression{
· · Case: MultiplicativeExpressionCast,
· · CastExpression: &cc.CastExpression{
· · · Case: CastExpressionUnary,
· · · UnaryExpression: &cc.UnaryExpression{
· · · · Case: UnaryExpressionPostfix,
· · · · PostfixExpression: &cc.PostfixExpression{
· · · · · Case: PostfixExpressionPrimary,
· · · · · PrimaryExpression: &cc.PrimaryExpression{
· · · · · · Case: PrimaryExpressionIdent,
· · · · · · Token: example.c:1:9: IDENTIFIER "x",
· · · · · },
· · · · },
· · · },
· · },
· },
}
Example (Sub)
fmt.Println(exampleAST(47, "int i = x-y;"))
Output:

&cc.AdditiveExpression{
· AdditiveExpression: &cc.AdditiveExpression{
· · Case: AdditiveExpressionMul,
· · MultiplicativeExpression: &cc.MultiplicativeExpression{
· · · Case: MultiplicativeExpressionCast,
· · · CastExpression: &cc.CastExpression{
· · · · Case: CastExpressionUnary,
· · · · UnaryExpression: &cc.UnaryExpression{
· · · · · Case: UnaryExpressionPostfix,
· · · · · PostfixExpression: &cc.PostfixExpression{
· · · · · · Case: PostfixExpressionPrimary,
· · · · · · PrimaryExpression: &cc.PrimaryExpression{
· · · · · · · Case: PrimaryExpressionIdent,
· · · · · · · Token: example.c:1:9: IDENTIFIER "x",
· · · · · · },
· · · · · },
· · · · },
· · · },
· · },
· },
· Case: AdditiveExpressionSub,
· MultiplicativeExpression: &cc.MultiplicativeExpression{
· · Case: MultiplicativeExpressionCast,
· · CastExpression: &cc.CastExpression{
· · · Case: CastExpressionUnary,
· · · UnaryExpression: &cc.UnaryExpression{
· · · · Case: UnaryExpressionPostfix,
· · · · PostfixExpression: &cc.PostfixExpression{
· · · · · Case: PostfixExpressionPrimary,
· · · · · PrimaryExpression: &cc.PrimaryExpression{
· · · · · · Case: PrimaryExpressionIdent,
· · · · · · Token: example.c:1:11: IDENTIFIER "y",
· · · · · },
· · · · },
· · · },
· · },
· },
· Token: example.c:1:10: '-' "-",
}

func (*AdditiveExpression) Declarator

func (n *AdditiveExpression) Declarator() *Declarator

func (*AdditiveExpression) Position

func (n *AdditiveExpression) Position() (r token.Position)

Position reports the position of the first component of n, if available.

func (*AdditiveExpression) Promote

func (n *AdditiveExpression) Promote() Type

Promote returns the type the operands of the binary operation are promoted to.

func (*AdditiveExpression) String

func (n *AdditiveExpression) String() string

String implements fmt.Stringer.

type AdditiveExpressionCase

type AdditiveExpressionCase int

AdditiveExpressionCase represents case numbers of production AdditiveExpression

const (
	AdditiveExpressionMul AdditiveExpressionCase = iota
	AdditiveExpressionAdd
	AdditiveExpressionSub
)

Values of type AdditiveExpressionCase

func (AdditiveExpressionCase) String

func (n AdditiveExpressionCase) String() string

String implements fmt.Stringer

type AlignmentSpecifier

type AlignmentSpecifier struct {
	Case               AlignmentSpecifierCase `PrettyPrint:"stringer,zero"`
	ConstantExpression *ConstantExpression
	Token              Token
	Token2             Token
	Token3             Token
	TypeName           *TypeName
}

AlignmentSpecifier represents data reduced by productions:

AlignmentSpecifier:
        "_Alignas" '(' TypeName ')'            // Case AlignmentSpecifierAlignasType
|       "_Alignas" '(' ConstantExpression ')'  // Case AlignmentSpecifierAlignasExpr
Example (AlignasExpr)
fmt.Println(exampleAST(168, "_Alignas(0ll) char c;"))
Output:

&cc.AlignmentSpecifier{
· Case: AlignmentSpecifierAlignasExpr,
· ConstantExpression: &cc.ConstantExpression{
· · ConditionalExpression: &cc.ConditionalExpression{
· · · Case: ConditionalExpressionLOr,
· · · LogicalOrExpression: &cc.LogicalOrExpression{
· · · · Case: LogicalOrExpressionLAnd,
· · · · LogicalAndExpression: &cc.LogicalAndExpression{
· · · · · Case: LogicalAndExpressionOr,
· · · · · InclusiveOrExpression: &cc.InclusiveOrExpression{
· · · · · · Case: InclusiveOrExpressionXor,
· · · · · · ExclusiveOrExpression: &cc.ExclusiveOrExpression{
· · · · · · · AndExpression: &cc.AndExpression{
· · · · · · · · Case: AndExpressionEq,
· · · · · · · · EqualityExpression: &cc.EqualityExpression{
· · · · · · · · · Case: EqualityExpressionRel,
· · · · · · · · · RelationalExpression: &cc.RelationalExpression{
· · · · · · · · · · Case: RelationalExpressionShift,
· · · · · · · · · · ShiftExpression: &cc.ShiftExpression{
· · · · · · · · · · · AdditiveExpression: &cc.AdditiveExpression{
· · · · · · · · · · · · Case: AdditiveExpressionMul,
· · · · · · · · · · · · MultiplicativeExpression: &cc.MultiplicativeExpression{
· · · · · · · · · · · · · Case: MultiplicativeExpressionCast,
· · · · · · · · · · · · · CastExpression: &cc.CastExpression{
· · · · · · · · · · · · · · Case: CastExpressionUnary,
· · · · · · · · · · · · · · UnaryExpression: &cc.UnaryExpression{
· · · · · · · · · · · · · · · Case: UnaryExpressionPostfix,
· · · · · · · · · · · · · · · PostfixExpression: &cc.PostfixExpression{
· · · · · · · · · · · · · · · · Case: PostfixExpressionPrimary,
· · · · · · · · · · · · · · · · PrimaryExpression: &cc.PrimaryExpression{
· · · · · · · · · · · · · · · · · Case: PrimaryExpressionInt,
· · · · · · · · · · · · · · · · · Token: example.c:1:10: INTCONST "0ll",
· · · · · · · · · · · · · · · · },
· · · · · · · · · · · · · · · },
· · · · · · · · · · · · · · },
· · · · · · · · · · · · · },
· · · · · · · · · · · · },
· · · · · · · · · · · },
· · · · · · · · · · · Case: ShiftExpressionAdd,
· · · · · · · · · · },
· · · · · · · · · },
· · · · · · · · },
· · · · · · · },
· · · · · · · Case: ExclusiveOrExpressionAnd,
· · · · · · },
· · · · · },
· · · · },
· · · },
· · },
· },
· Token: example.c:1:1: ALIGNAS "_Alignas",
· Token2: example.c:1:9: '(' "(",
· Token3: example.c:1:13: ')' ")",
}
Example (AlignasType)
fmt.Println(exampleAST(167, "_Alignas(double) char c;"))
Output:

&cc.AlignmentSpecifier{
· Case: AlignmentSpecifierAlignasType,
· Token: example.c:1:1: ALIGNAS "_Alignas",
· Token2: example.c:1:9: '(' "(",
· Token3: example.c:1:16: ')' ")",
· TypeName: &cc.TypeName{
· · SpecifierQualifierList: &cc.SpecifierQualifierList{
· · · Case: SpecifierQualifierListTypeSpec,
· · · TypeSpecifier: &cc.TypeSpecifier{
· · · · Case: TypeSpecifierDouble,
· · · · Token: example.c:1:10: DOUBLE "double",
· · · },
· · },
· },
}

func (*AlignmentSpecifier) Position

func (n *AlignmentSpecifier) Position() (r token.Position)

Position reports the position of the first component of n, if available.

func (*AlignmentSpecifier) String

func (n *AlignmentSpecifier) String() string

String implements fmt.Stringer.

type AlignmentSpecifierCase

type AlignmentSpecifierCase int

AlignmentSpecifierCase represents case numbers of production AlignmentSpecifier

const (
	AlignmentSpecifierAlignasType AlignmentSpecifierCase = iota
	AlignmentSpecifierAlignasExpr
)

Values of type AlignmentSpecifierCase

func (AlignmentSpecifierCase) String

func (n AlignmentSpecifierCase) String() string

String implements fmt.Stringer

type AndExpression

type AndExpression struct {
	Operand Operand

	IsSideEffectsFree  bool
	AndExpression      *AndExpression
	Case               AndExpressionCase `PrettyPrint:"stringer,zero"`
	EqualityExpression *EqualityExpression
	Token              Token
	// contains filtered or unexported fields
}

AndExpression represents data reduced by productions:

AndExpression:
        EqualityExpression                    // Case AndExpressionEq
|       AndExpression '&' EqualityExpression  // Case AndExpressionAnd
Example (And)
fmt.Println(exampleAST(60, "int i = x & y;"))
Output:

&cc.AndExpression{
· AndExpression: &cc.AndExpression{
· · Case: AndExpressionEq,
· · EqualityExpression: &cc.EqualityExpression{
· · · Case: EqualityExpressionRel,
· · · RelationalExpression: &cc.RelationalExpression{
· · · · Case: RelationalExpressionShift,
· · · · ShiftExpression: &cc.ShiftExpression{
· · · · · AdditiveExpression: &cc.AdditiveExpression{
· · · · · · Case: AdditiveExpressionMul,
· · · · · · MultiplicativeExpression: &cc.MultiplicativeExpression{
· · · · · · · Case: MultiplicativeExpressionCast,
· · · · · · · CastExpression: &cc.CastExpression{
· · · · · · · · Case: CastExpressionUnary,
· · · · · · · · UnaryExpression: &cc.UnaryExpression{
· · · · · · · · · Case: UnaryExpressionPostfix,
· · · · · · · · · PostfixExpression: &cc.PostfixExpression{
· · · · · · · · · · Case: PostfixExpressionPrimary,
· · · · · · · · · · PrimaryExpression: &cc.PrimaryExpression{
· · · · · · · · · · · Case: PrimaryExpressionIdent,
· · · · · · · · · · · Token: example.c:1:9: IDENTIFIER "x",
· · · · · · · · · · },
· · · · · · · · · },
· · · · · · · · },
· · · · · · · },
· · · · · · },
· · · · · },
· · · · · Case: ShiftExpressionAdd,
· · · · },
· · · },
· · },
· },
· Case: AndExpressionAnd,
· EqualityExpression: &cc.EqualityExpression{
· · Case: EqualityExpressionRel,
· · RelationalExpression: &cc.RelationalExpression{
· · · Case: RelationalExpressionShift,
· · · ShiftExpression: &cc.ShiftExpression{
· · · · AdditiveExpression: &cc.AdditiveExpression{
· · · · · Case: AdditiveExpressionMul,
· · · · · MultiplicativeExpression: &cc.MultiplicativeExpression{
· · · · · · Case: MultiplicativeExpressionCast,
· · · · · · CastExpression: &cc.CastExpression{
· · · · · · · Case: CastExpressionUnary,
· · · · · · · UnaryExpression: &cc.UnaryExpression{
· · · · · · · · Case: UnaryExpressionPostfix,
· · · · · · · · PostfixExpression: &cc.PostfixExpression{
· · · · · · · · · Case: PostfixExpressionPrimary,
· · · · · · · · · PrimaryExpression: &cc.PrimaryExpression{
· · · · · · · · · · Case: PrimaryExpressionIdent,
· · · · · · · · · · Token: example.c:1:13: IDENTIFIER "y",
· · · · · · · · · },
· · · · · · · · },
· · · · · · · },
· · · · · · },
· · · · · },
· · · · },
· · · · Case: ShiftExpressionAdd,
· · · },
· · },
· },
· Token: example.c:1:11: '&' "&",
}
Example (Eq)
fmt.Println(exampleAST(59, "int i = x;"))
Output:

&cc.AndExpression{
· Case: AndExpressionEq,
· EqualityExpression: &cc.EqualityExpression{
· · Case: EqualityExpressionRel,
· · RelationalExpression: &cc.RelationalExpression{
· · · Case: RelationalExpressionShift,
· · · ShiftExpression: &cc.ShiftExpression{
· · · · AdditiveExpression: &cc.AdditiveExpression{
· · · · · Case: AdditiveExpressionMul,
· · · · · MultiplicativeExpression: &cc.MultiplicativeExpression{
· · · · · · Case: MultiplicativeExpressionCast,
· · · · · · CastExpression: &cc.CastExpression{
· · · · · · · Case: CastExpressionUnary,
· · · · · · · UnaryExpression: &cc.UnaryExpression{
· · · · · · · · Case: UnaryExpressionPostfix,
· · · · · · · · PostfixExpression: &cc.PostfixExpression{
· · · · · · · · · Case: PostfixExpressionPrimary,
· · · · · · · · · PrimaryExpression: &cc.PrimaryExpression{
· · · · · · · · · · Case: PrimaryExpressionIdent,
· · · · · · · · · · Token: example.c:1:9: IDENTIFIER "x",
· · · · · · · · · },
· · · · · · · · },
· · · · · · · },
· · · · · · },
· · · · · },
· · · · },
· · · · Case: ShiftExpressionAdd,
· · · },
· · },
· },
}

func (*AndExpression) Declarator

func (n *AndExpression) Declarator() *Declarator

func (*AndExpression) Position

func (n *AndExpression) Position() (r token.Position)

Position reports the position of the first component of n, if available.

func (*AndExpression) Promote added in v3.25.2

func (n *AndExpression) Promote() Type

Promote returns the type the operands of the binary operation are promoted to.

func (*AndExpression) String

func (n *AndExpression) String() string

String implements fmt.Stringer.

type AndExpressionCase

type AndExpressionCase int

AndExpressionCase represents case numbers of production AndExpression

const (
	AndExpressionEq AndExpressionCase = iota
	AndExpressionAnd
)

Values of type AndExpressionCase

func (AndExpressionCase) String

func (n AndExpressionCase) String() string

String implements fmt.Stringer

type ArgumentExpressionList

type ArgumentExpressionList struct {
	ArgumentExpressionList *ArgumentExpressionList
	AssignmentExpression   *AssignmentExpression
	Token                  Token
}

ArgumentExpressionList represents data reduced by productions:

ArgumentExpressionList:
        AssignmentExpression
|       ArgumentExpressionList ',' AssignmentExpression
Example (Case0)
fmt.Println(exampleAST(21, "int i = f(x);"))
Output:

&cc.ArgumentExpressionList{
· AssignmentExpression: &cc.AssignmentExpression{
· · Case: AssignmentExpressionCond,
· · ConditionalExpression: &cc.ConditionalExpression{
· · · Case: ConditionalExpressionLOr,
· · · LogicalOrExpression: &cc.LogicalOrExpression{
· · · · Case: LogicalOrExpressionLAnd,
· · · · LogicalAndExpression: &cc.LogicalAndExpression{
· · · · · Case: LogicalAndExpressionOr,
· · · · · InclusiveOrExpression: &cc.InclusiveOrExpression{
· · · · · · Case: InclusiveOrExpressionXor,
· · · · · · ExclusiveOrExpression: &cc.ExclusiveOrExpression{
· · · · · · · AndExpression: &cc.AndExpression{
· · · · · · · · Case: AndExpressionEq,
· · · · · · · · EqualityExpression: &cc.EqualityExpression{
· · · · · · · · · Case: EqualityExpressionRel,
· · · · · · · · · RelationalExpression: &cc.RelationalExpression{
· · · · · · · · · · Case: RelationalExpressionShift,
· · · · · · · · · · ShiftExpression: &cc.ShiftExpression{
· · · · · · · · · · · AdditiveExpression: &cc.AdditiveExpression{
· · · · · · · · · · · · Case: AdditiveExpressionMul,
· · · · · · · · · · · · MultiplicativeExpression: &cc.MultiplicativeExpression{
· · · · · · · · · · · · · Case: MultiplicativeExpressionCast,
· · · · · · · · · · · · · CastExpression: &cc.CastExpression{
· · · · · · · · · · · · · · Case: CastExpressionUnary,
· · · · · · · · · · · · · · UnaryExpression: &cc.UnaryExpression{
· · · · · · · · · · · · · · · Case: UnaryExpressionPostfix,
· · · · · · · · · · · · · · · PostfixExpression: &cc.PostfixExpression{
· · · · · · · · · · · · · · · · Case: PostfixExpressionPrimary,
· · · · · · · · · · · · · · · · PrimaryExpression: &cc.PrimaryExpression{
· · · · · · · · · · · · · · · · · Case: PrimaryExpressionIdent,
· · · · · · · · · · · · · · · · · Token: example.c:1:11: IDENTIFIER "x",
· · · · · · · · · · · · · · · · },
· · · · · · · · · · · · · · · },
· · · · · · · · · · · · · · },
· · · · · · · · · · · · · },
· · · · · · · · · · · · },
· · · · · · · · · · · },
· · · · · · · · · · · Case: ShiftExpressionAdd,
· · · · · · · · · · },
· · · · · · · · · },
· · · · · · · · },
· · · · · · · },
· · · · · · · Case: ExclusiveOrExpressionAnd,
· · · · · · },
· · · · · },
· · · · },
· · · },
· · },
· },
}
Example (Case1)
fmt.Println(exampleAST(22, "int i = f(x, y);"))
Output:

&cc.ArgumentExpressionList{
· ArgumentExpressionList: &cc.ArgumentExpressionList{
· · AssignmentExpression: &cc.AssignmentExpression{
· · · Case: AssignmentExpressionCond,
· · · ConditionalExpression: &cc.ConditionalExpression{
· · · · Case: ConditionalExpressionLOr,
· · · · LogicalOrExpression: &cc.LogicalOrExpression{
· · · · · Case: LogicalOrExpressionLAnd,
· · · · · LogicalAndExpression: &cc.LogicalAndExpression{
· · · · · · Case: LogicalAndExpressionOr,
· · · · · · InclusiveOrExpression: &cc.InclusiveOrExpression{
· · · · · · · Case: InclusiveOrExpressionXor,
· · · · · · · ExclusiveOrExpression: &cc.ExclusiveOrExpression{
· · · · · · · · AndExpression: &cc.AndExpression{
· · · · · · · · · Case: AndExpressionEq,
· · · · · · · · · EqualityExpression: &cc.EqualityExpression{
· · · · · · · · · · Case: EqualityExpressionRel,
· · · · · · · · · · RelationalExpression: &cc.RelationalExpression{
· · · · · · · · · · · Case: RelationalExpressionShift,
· · · · · · · · · · · ShiftExpression: &cc.ShiftExpression{
· · · · · · · · · · · · AdditiveExpression: &cc.AdditiveExpression{
· · · · · · · · · · · · · Case: AdditiveExpressionMul,
· · · · · · · · · · · · · MultiplicativeExpression: &cc.MultiplicativeExpression{
· · · · · · · · · · · · · · Case: MultiplicativeExpressionCast,
· · · · · · · · · · · · · · CastExpression: &cc.CastExpression{
· · · · · · · · · · · · · · · Case: CastExpressionUnary,
· · · · · · · · · · · · · · · UnaryExpression: &cc.UnaryExpression{
· · · · · · · · · · · · · · · · Case: UnaryExpressionPostfix,
· · · · · · · · · · · · · · · · PostfixExpression: &cc.PostfixExpression{
· · · · · · · · · · · · · · · · · Case: PostfixExpressionPrimary,
· · · · · · · · · · · · · · · · · PrimaryExpression: &cc.PrimaryExpression{
· · · · · · · · · · · · · · · · · · Case: PrimaryExpressionIdent,
· · · · · · · · · · · · · · · · · · Token: example.c:1:14: IDENTIFIER "y",
· · · · · · · · · · · · · · · · · },
· · · · · · · · · · · · · · · · },
· · · · · · · · · · · · · · · },
· · · · · · · · · · · · · · },
· · · · · · · · · · · · · },
· · · · · · · · · · · · },
· · · · · · · · · · · · Case: ShiftExpressionAdd,
· · · · · · · · · · · },
· · · · · · · · · · },
· · · · · · · · · },
· · · · · · · · },
· · · · · · · · Case: ExclusiveOrExpressionAnd,
· · · · · · · },
· · · · · · },
· · · · · },
· · · · },
· · · },
· · },
· · Token: example.c:1:12: ',' ",",
· },
· AssignmentExpression: &cc.AssignmentExpression{
· · Case: AssignmentExpressionCond,
· · ConditionalExpression: &cc.ConditionalExpression{
· · · Case: ConditionalExpressionLOr,
· · · LogicalOrExpression: &cc.LogicalOrExpression{
· · · · Case: LogicalOrExpressionLAnd,
· · · · LogicalAndExpression: &cc.LogicalAndExpression{
· · · · · Case: LogicalAndExpressionOr,
· · · · · InclusiveOrExpression: &cc.InclusiveOrExpression{
· · · · · · Case: InclusiveOrExpressionXor,
· · · · · · ExclusiveOrExpression: &cc.ExclusiveOrExpression{
· · · · · · · AndExpression: &cc.AndExpression{
· · · · · · · · Case: AndExpressionEq,
· · · · · · · · EqualityExpression: &cc.EqualityExpression{
· · · · · · · · · Case: EqualityExpressionRel,
· · · · · · · · · RelationalExpression: &cc.RelationalExpression{
· · · · · · · · · · Case: RelationalExpressionShift,
· · · · · · · · · · ShiftExpression: &cc.ShiftExpression{
· · · · · · · · · · · AdditiveExpression: &cc.AdditiveExpression{
· · · · · · · · · · · · Case: AdditiveExpressionMul,
· · · · · · · · · · · · MultiplicativeExpression: &cc.MultiplicativeExpression{
· · · · · · · · · · · · · Case: MultiplicativeExpressionCast,
· · · · · · · · · · · · · CastExpression: &cc.CastExpression{
· · · · · · · · · · · · · · Case: CastExpressionUnary,
· · · · · · · · · · · · · · UnaryExpression: &cc.UnaryExpression{
· · · · · · · · · · · · · · · Case: UnaryExpressionPostfix,
· · · · · · · · · · · · · · · PostfixExpression: &cc.PostfixExpression{
· · · · · · · · · · · · · · · · Case: PostfixExpressionPrimary,
· · · · · · · · · · · · · · · · PrimaryExpression: &cc.PrimaryExpression{
· · · · · · · · · · · · · · · · · Case: PrimaryExpressionIdent,
· · · · · · · · · · · · · · · · · Token: example.c:1:11: IDENTIFIER "x",
· · · · · · · · · · · · · · · · },
· · · · · · · · · · · · · · · },
· · · · · · · · · · · · · · },
· · · · · · · · · · · · · },
· · · · · · · · · · · · },
· · · · · · · · · · · },
· · · · · · · · · · · Case: ShiftExpressionAdd,
· · · · · · · · · · },
· · · · · · · · · },
· · · · · · · · },
· · · · · · · },
· · · · · · · Case: ExclusiveOrExpressionAnd,
· · · · · · },
· · · · · },
· · · · },
· · · },
· · },
· },
}

func (*ArgumentExpressionList) Position

func (n *ArgumentExpressionList) Position() (r token.Position)

Position reports the position of the first component of n, if available.

func (*ArgumentExpressionList) String

func (n *ArgumentExpressionList) String() string

String implements fmt.Stringer.

type Asm

type Asm struct {
	AsmArgList       *AsmArgList
	AsmQualifierList *AsmQualifierList
	Token            Token
	Token2           Token
	Token3           Token
	Token4           Token
}

Asm represents data reduced by production:

Asm:
        "__asm__" AsmQualifierList '(' STRINGLITERAL AsmArgList ')'
Example (Case0)
fmt.Println(exampleAST(259, "__asm__(\"nop\");"))
Output:

&cc.Asm{
· Token: example.c:1:1: ASM "__asm__",
· Token2: example.c:1:8: '(' "(",
· Token3: example.c:1:9: STRINGLITERAL "nop",
· Token4: example.c:1:14: ')' ")",
}

func (*Asm) Position

func (n *Asm) Position() (r token.Position)

Position reports the position of the first component of n, if available.

func (*Asm) String

func (n *Asm) String() string

String implements fmt.Stringer.

type AsmArgList

type AsmArgList struct {
	AsmArgList        *AsmArgList
	AsmExpressionList *AsmExpressionList
	Token             Token
}

AsmArgList represents data reduced by productions:

AsmArgList:
        ':' AsmExpressionList
|       AsmArgList ':' AsmExpressionList
Example (Case0)
fmt.Println(exampleAST(257, "__asm__(\"nop\": a);"))
Output:

&cc.AsmArgList{
· AsmExpressionList: &cc.AsmExpressionList{
· · AssignmentExpression: &cc.AssignmentExpression{
· · · Case: AssignmentExpressionCond,
· · · ConditionalExpression: &cc.ConditionalExpression{
· · · · Case: ConditionalExpressionLOr,
· · · · LogicalOrExpression: &cc.LogicalOrExpression{
· · · · · Case: LogicalOrExpressionLAnd,
· · · · · LogicalAndExpression: &cc.LogicalAndExpression{
· · · · · · Case: LogicalAndExpressionOr,
· · · · · · InclusiveOrExpression: &cc.InclusiveOrExpression{
· · · · · · · Case: InclusiveOrExpressionXor,
· · · · · · · ExclusiveOrExpression: &cc.ExclusiveOrExpression{
· · · · · · · · AndExpression: &cc.AndExpression{
· · · · · · · · · Case: AndExpressionEq,
· · · · · · · · · EqualityExpression: &cc.EqualityExpression{
· · · · · · · · · · Case: EqualityExpressionRel,
· · · · · · · · · · RelationalExpression: &cc.RelationalExpression{
· · · · · · · · · · · Case: RelationalExpressionShift,
· · · · · · · · · · · ShiftExpression: &cc.ShiftExpression{
· · · · · · · · · · · · AdditiveExpression: &cc.AdditiveExpression{
· · · · · · · · · · · · · Case: AdditiveExpressionMul,
· · · · · · · · · · · · · MultiplicativeExpression: &cc.MultiplicativeExpression{
· · · · · · · · · · · · · · Case: MultiplicativeExpressionCast,
· · · · · · · · · · · · · · CastExpression: &cc.CastExpression{
· · · · · · · · · · · · · · · Case: CastExpressionUnary,
· · · · · · · · · · · · · · · UnaryExpression: &cc.UnaryExpression{
· · · · · · · · · · · · · · · · Case: UnaryExpressionPostfix,
· · · · · · · · · · · · · · · · PostfixExpression: &cc.PostfixExpression{
· · · · · · · · · · · · · · · · · Case: PostfixExpressionPrimary,
· · · · · · · · · · · · · · · · · PrimaryExpression: &cc.PrimaryExpression{
· · · · · · · · · · · · · · · · · · Case: PrimaryExpressionIdent,
· · · · · · · · · · · · · · · · · · Token: example.c:1:16: IDENTIFIER "a",
· · · · · · · · · · · · · · · · · },
· · · · · · · · · · · · · · · · },
· · · · · · · · · · · · · · · },
· · · · · · · · · · · · · · },
· · · · · · · · · · · · · },
· · · · · · · · · · · · },
· · · · · · · · · · · · Case: ShiftExpressionAdd,
· · · · · · · · · · · },
· · · · · · · · · · },
· · · · · · · · · },
· · · · · · · · },
· · · · · · · · Case: ExclusiveOrExpressionAnd,
· · · · · · · },
· · · · · · },
· · · · · },
· · · · },
· · · },
· · },
· },
· Token: example.c:1:14: ':' ":",
}
Example (Case1)
fmt.Println(exampleAST(258, "__asm__(\"nop\": a : b);"))
Output:

&cc.AsmArgList{
· AsmArgList: &cc.AsmArgList{
· · AsmExpressionList: &cc.AsmExpressionList{
· · · AssignmentExpression: &cc.AssignmentExpression{
· · · · Case: AssignmentExpressionCond,
· · · · ConditionalExpression: &cc.ConditionalExpression{
· · · · · Case: ConditionalExpressionLOr,
· · · · · LogicalOrExpression: &cc.LogicalOrExpression{
· · · · · · Case: LogicalOrExpressionLAnd,
· · · · · · LogicalAndExpression: &cc.LogicalAndExpression{
· · · · · · · Case: LogicalAndExpressionOr,
· · · · · · · InclusiveOrExpression: &cc.InclusiveOrExpression{
· · · · · · · · Case: InclusiveOrExpressionXor,
· · · · · · · · ExclusiveOrExpression: &cc.ExclusiveOrExpression{
· · · · · · · · · AndExpression: &cc.AndExpression{
· · · · · · · · · · Case: AndExpressionEq,
· · · · · · · · · · EqualityExpression: &cc.EqualityExpression{
· · · · · · · · · · · Case: EqualityExpressionRel,
· · · · · · · · · · · RelationalExpression: &cc.RelationalExpression{
· · · · · · · · · · · · Case: RelationalExpressionShift,
· · · · · · · · · · · · ShiftExpression: &cc.ShiftExpression{
· · · · · · · · · · · · · AdditiveExpression: &cc.AdditiveExpression{
· · · · · · · · · · · · · · Case: AdditiveExpressionMul,
· · · · · · · · · · · · · · MultiplicativeExpression: &cc.MultiplicativeExpression{
· · · · · · · · · · · · · · · Case: MultiplicativeExpressionCast,
· · · · · · · · · · · · · · · CastExpression: &cc.CastExpression{
· · · · · · · · · · · · · · · · Case: CastExpressionUnary,
· · · · · · · · · · · · · · · · UnaryExpression: &cc.UnaryExpression{
· · · · · · · · · · · · · · · · · Case: UnaryExpressionPostfix,
· · · · · · · · · · · · · · · · · PostfixExpression: &cc.PostfixExpression{
· · · · · · · · · · · · · · · · · · Case: PostfixExpressionPrimary,
· · · · · · · · · · · · · · · · · · PrimaryExpression: &cc.PrimaryExpression{
· · · · · · · · · · · · · · · · · · · Case: PrimaryExpressionIdent,
· · · · · · · · · · · · · · · · · · · Token: example.c:1:20: IDENTIFIER "b",
· · · · · · · · · · · · · · · · · · },
· · · · · · · · · · · · · · · · · },
· · · · · · · · · · · · · · · · },
· · · · · · · · · · · · · · · },
· · · · · · · · · · · · · · },
· · · · · · · · · · · · · },
· · · · · · · · · · · · · Case: ShiftExpressionAdd,
· · · · · · · · · · · · },
· · · · · · · · · · · },
· · · · · · · · · · },
· · · · · · · · · },
· · · · · · · · · Case: ExclusiveOrExpressionAnd,
· · · · · · · · },
· · · · · · · },
· · · · · · },
· · · · · },
· · · · },
· · · },
· · },
· · Token: example.c:1:18: ':' ":",
· },
· AsmExpressionList: &cc.AsmExpressionList{
· · AssignmentExpression: &cc.AssignmentExpression{
· · · Case: AssignmentExpressionCond,
· · · ConditionalExpression: &cc.ConditionalExpression{
· · · · Case: ConditionalExpressionLOr,
· · · · LogicalOrExpression: &cc.LogicalOrExpression{
· · · · · Case: LogicalOrExpressionLAnd,
· · · · · LogicalAndExpression: &cc.LogicalAndExpression{
· · · · · · Case: LogicalAndExpressionOr,
· · · · · · InclusiveOrExpression: &cc.InclusiveOrExpression{
· · · · · · · Case: InclusiveOrExpressionXor,
· · · · · · · ExclusiveOrExpression: &cc.ExclusiveOrExpression{
· · · · · · · · AndExpression: &cc.AndExpression{
· · · · · · · · · Case: AndExpressionEq,
· · · · · · · · · EqualityExpression: &cc.EqualityExpression{
· · · · · · · · · · Case: EqualityExpressionRel,
· · · · · · · · · · RelationalExpression: &cc.RelationalExpression{
· · · · · · · · · · · Case: RelationalExpressionShift,
· · · · · · · · · · · ShiftExpression: &cc.ShiftExpression{
· · · · · · · · · · · · AdditiveExpression: &cc.AdditiveExpression{
· · · · · · · · · · · · · Case: AdditiveExpressionMul,
· · · · · · · · · · · · · MultiplicativeExpression: &cc.MultiplicativeExpression{
· · · · · · · · · · · · · · Case: MultiplicativeExpressionCast,
· · · · · · · · · · · · · · CastExpression: &cc.CastExpression{
· · · · · · · · · · · · · · · Case: CastExpressionUnary,
· · · · · · · · · · · · · · · UnaryExpression: &cc.UnaryExpression{
· · · · · · · · · · · · · · · · Case: UnaryExpressionPostfix,
· · · · · · · · · · · · · · · · PostfixExpression: &cc.PostfixExpression{
· · · · · · · · · · · · · · · · · Case: PostfixExpressionPrimary,
· · · · · · · · · · · · · · · · · PrimaryExpression: &cc.PrimaryExpression{
· · · · · · · · · · · · · · · · · · Case: PrimaryExpressionIdent,
· · · · · · · · · · · · · · · · · · Token: example.c:1:16: IDENTIFIER "a",
· · · · · · · · · · · · · · · · · },
· · · · · · · · · · · · · · · · },
· · · · · · · · · · · · · · · },
· · · · · · · · · · · · · · },
· · · · · · · · · · · · · },
· · · · · · · · · · · · },
· · · · · · · · · · · · Case: ShiftExpressionAdd,
· · · · · · · · · · · },
· · · · · · · · · · },
· · · · · · · · · },
· · · · · · · · },
· · · · · · · · Case: ExclusiveOrExpressionAnd,
· · · · · · · },
· · · · · · },
· · · · · },
· · · · },
· · · },
· · },
· },
· Token: example.c:1:14: ':' ":",
}

func (*AsmArgList) Position

func (n *AsmArgList) Position() (r token.Position)

Position reports the position of the first component of n, if available.

func (*AsmArgList) String

func (n *AsmArgList) String() string

String implements fmt.Stringer.

type AsmExpressionList

type AsmExpressionList struct {
	AsmExpressionList    *AsmExpressionList
	AsmIndex             *AsmIndex
	AssignmentExpression *AssignmentExpression
	Token                Token
}

AsmExpressionList represents data reduced by productions:

AsmExpressionList:
        AsmIndex AssignmentExpression
|       AsmExpressionList ',' AsmIndex AssignmentExpression
Example (Case0)
fmt.Println(exampleAST(255, "__asm__(\"nop\": a);"))
Output:

&cc.AsmExpressionList{
· AssignmentExpression: &cc.AssignmentExpression{
· · Case: AssignmentExpressionCond,
· · ConditionalExpression: &cc.ConditionalExpression{
· · · Case: ConditionalExpressionLOr,
· · · LogicalOrExpression: &cc.LogicalOrExpression{
· · · · Case: LogicalOrExpressionLAnd,
· · · · LogicalAndExpression: &cc.LogicalAndExpression{
· · · · · Case: LogicalAndExpressionOr,
· · · · · InclusiveOrExpression: &cc.InclusiveOrExpression{
· · · · · · Case: InclusiveOrExpressionXor,
· · · · · · ExclusiveOrExpression: &cc.ExclusiveOrExpression{
· · · · · · · AndExpression: &cc.AndExpression{
· · · · · · · · Case: AndExpressionEq,
· · · · · · · · EqualityExpression: &cc.EqualityExpression{
· · · · · · · · · Case: EqualityExpressionRel,
· · · · · · · · · RelationalExpression: &cc.RelationalExpression{
· · · · · · · · · · Case: RelationalExpressionShift,
· · · · · · · · · · ShiftExpression: &cc.ShiftExpression{
· · · · · · · · · · · AdditiveExpression: &cc.AdditiveExpression{
· · · · · · · · · · · · Case: AdditiveExpressionMul,
· · · · · · · · · · · · MultiplicativeExpression: &cc.MultiplicativeExpression{
· · · · · · · · · · · · · Case: MultiplicativeExpressionCast,
· · · · · · · · · · · · · CastExpression: &cc.CastExpression{
· · · · · · · · · · · · · · Case: CastExpressionUnary,
· · · · · · · · · · · · · · UnaryExpression: &cc.UnaryExpression{
· · · · · · · · · · · · · · · Case: UnaryExpressionPostfix,
· · · · · · · · · · · · · · · PostfixExpression: &cc.PostfixExpression{
· · · · · · · · · · · · · · · · Case: PostfixExpressionPrimary,
· · · · · · · · · · · · · · · · PrimaryExpression: &cc.PrimaryExpression{
· · · · · · · · · · · · · · · · · Case: PrimaryExpressionIdent,
· · · · · · · · · · · · · · · · · Token: example.c:1:16: IDENTIFIER "a",
· · · · · · · · · · · · · · · · },
· · · · · · · · · · · · · · · },
· · · · · · · · · · · · · · },
· · · · · · · · · · · · · },
· · · · · · · · · · · · },
· · · · · · · · · · · },
· · · · · · · · · · · Case: ShiftExpressionAdd,
· · · · · · · · · · },
· · · · · · · · · },
· · · · · · · · },
· · · · · · · },
· · · · · · · Case: ExclusiveOrExpressionAnd,
· · · · · · },
· · · · · },
· · · · },
· · · },
· · },
· },
}
Example (Case1)
fmt.Println(exampleAST(256, "__asm__(\"nop\": a, b);"))
Output:

&cc.AsmExpressionList{
· AsmExpressionList: &cc.AsmExpressionList{
· · AssignmentExpression: &cc.AssignmentExpression{
· · · Case: AssignmentExpressionCond,
· · · ConditionalExpression: &cc.ConditionalExpression{
· · · · Case: ConditionalExpressionLOr,
· · · · LogicalOrExpression: &cc.LogicalOrExpression{
· · · · · Case: LogicalOrExpressionLAnd,
· · · · · LogicalAndExpression: &cc.LogicalAndExpression{
· · · · · · Case: LogicalAndExpressionOr,
· · · · · · InclusiveOrExpression: &cc.InclusiveOrExpression{
· · · · · · · Case: InclusiveOrExpressionXor,
· · · · · · · ExclusiveOrExpression: &cc.ExclusiveOrExpression{
· · · · · · · · AndExpression: &cc.AndExpression{
· · · · · · · · · Case: AndExpressionEq,
· · · · · · · · · EqualityExpression: &cc.EqualityExpression{
· · · · · · · · · · Case: EqualityExpressionRel,
· · · · · · · · · · RelationalExpression: &cc.RelationalExpression{
· · · · · · · · · · · Case: RelationalExpressionShift,
· · · · · · · · · · · ShiftExpression: &cc.ShiftExpression{
· · · · · · · · · · · · AdditiveExpression: &cc.AdditiveExpression{
· · · · · · · · · · · · · Case: AdditiveExpressionMul,
· · · · · · · · · · · · · MultiplicativeExpression: &cc.MultiplicativeExpression{
· · · · · · · · · · · · · · Case: MultiplicativeExpressionCast,
· · · · · · · · · · · · · · CastExpression: &cc.CastExpression{
· · · · · · · · · · · · · · · Case: CastExpressionUnary,
· · · · · · · · · · · · · · · UnaryExpression: &cc.UnaryExpression{
· · · · · · · · · · · · · · · · Case: UnaryExpressionPostfix,
· · · · · · · · · · · · · · · · PostfixExpression: &cc.PostfixExpression{
· · · · · · · · · · · · · · · · · Case: PostfixExpressionPrimary,
· · · · · · · · · · · · · · · · · PrimaryExpression: &cc.PrimaryExpression{
· · · · · · · · · · · · · · · · · · Case: PrimaryExpressionIdent,
· · · · · · · · · · · · · · · · · · Token: example.c:1:19: IDENTIFIER "b",
· · · · · · · · · · · · · · · · · },
· · · · · · · · · · · · · · · · },
· · · · · · · · · · · · · · · },
· · · · · · · · · · · · · · },
· · · · · · · · · · · · · },
· · · · · · · · · · · · },
· · · · · · · · · · · · Case: ShiftExpressionAdd,
· · · · · · · · · · · },
· · · · · · · · · · },
· · · · · · · · · },
· · · · · · · · },
· · · · · · · · Case: ExclusiveOrExpressionAnd,
· · · · · · · },
· · · · · · },
· · · · · },
· · · · },
· · · },
· · },
· · Token: example.c:1:17: ',' ",",
· },
· AssignmentExpression: &cc.AssignmentExpression{
· · Case: AssignmentExpressionCond,
· · ConditionalExpression: &cc.ConditionalExpression{
· · · Case: ConditionalExpressionLOr,
· · · LogicalOrExpression: &cc.LogicalOrExpression{
· · · · Case: LogicalOrExpressionLAnd,
· · · · LogicalAndExpression: &cc.LogicalAndExpression{
· · · · · Case: LogicalAndExpressionOr,
· · · · · InclusiveOrExpression: &cc.InclusiveOrExpression{
· · · · · · Case: InclusiveOrExpressionXor,
· · · · · · ExclusiveOrExpression: &cc.ExclusiveOrExpression{
· · · · · · · AndExpression: &cc.AndExpression{
· · · · · · · · Case: AndExpressionEq,
· · · · · · · · EqualityExpression: &cc.EqualityExpression{
· · · · · · · · · Case: EqualityExpressionRel,
· · · · · · · · · RelationalExpression: &cc.RelationalExpression{
· · · · · · · · · · Case: RelationalExpressionShift,
· · · · · · · · · · ShiftExpression: &cc.ShiftExpression{
· · · · · · · · · · · AdditiveExpression: &cc.AdditiveExpression{
· · · · · · · · · · · · Case: AdditiveExpressionMul,
· · · · · · · · · · · · MultiplicativeExpression: &cc.MultiplicativeExpression{
· · · · · · · · · · · · · Case: MultiplicativeExpressionCast,
· · · · · · · · · · · · · CastExpression: &cc.CastExpression{
· · · · · · · · · · · · · · Case: CastExpressionUnary,
· · · · · · · · · · · · · · UnaryExpression: &cc.UnaryExpression{
· · · · · · · · · · · · · · · Case: UnaryExpressionPostfix,
· · · · · · · · · · · · · · · PostfixExpression: &cc.PostfixExpression{
· · · · · · · · · · · · · · · · Case: PostfixExpressionPrimary,
· · · · · · · · · · · · · · · · PrimaryExpression: &cc.PrimaryExpression{
· · · · · · · · · · · · · · · · · Case: PrimaryExpressionIdent,
· · · · · · · · · · · · · · · · · Token: example.c:1:16: IDENTIFIER "a",
· · · · · · · · · · · · · · · · },
· · · · · · · · · · · · · · · },
· · · · · · · · · · · · · · },
· · · · · · · · · · · · · },
· · · · · · · · · · · · },
· · · · · · · · · · · },
· · · · · · · · · · · Case: ShiftExpressionAdd,
· · · · · · · · · · },
· · · · · · · · · },
· · · · · · · · },
· · · · · · · },
· · · · · · · Case: ExclusiveOrExpressionAnd,
· · · · · · },
· · · · · },
· · · · },
· · · },
· · },
· },
}

func (*AsmExpressionList) Position

func (n *AsmExpressionList) Position() (r token.Position)

Position reports the position of the first component of n, if available.

func (*AsmExpressionList) String

func (n *AsmExpressionList) String() string

String implements fmt.Stringer.

type AsmFunctionDefinition

type AsmFunctionDefinition struct {
	AsmStatement          *AsmStatement
	DeclarationSpecifiers *DeclarationSpecifiers
	Declarator            *Declarator
}

AsmFunctionDefinition represents data reduced by production:

AsmFunctionDefinition:
        DeclarationSpecifiers Declarator AsmStatement
Example (Case0)
fmt.Println(exampleAST(261, "int f() __asm__(\"nop\");"))
Output:

&cc.AsmFunctionDefinition{
· AsmStatement: &cc.AsmStatement{
· · Asm: &cc.Asm{
· · · Token: example.c:1:9: ASM "__asm__",
· · · Token2: example.c:1:16: '(' "(",
· · · Token3: example.c:1:17: STRINGLITERAL "nop",
· · · Token4: example.c:1:22: ')' ")",
· · },
· · Token: example.c:1:23: ';' ";",
· },
· DeclarationSpecifiers: &cc.DeclarationSpecifiers{
· · Case: DeclarationSpecifiersTypeSpec,
· · TypeSpecifier: &cc.TypeSpecifier{
· · · Case: TypeSpecifierInt,
· · · Token: example.c:1:1: INT "int",
· · },
· },
· Declarator: &cc.Declarator{
· · DirectDeclarator: &cc.DirectDeclarator{
· · · Case: DirectDeclaratorFuncIdent,
· · · DirectDeclarator: &cc.DirectDeclarator{
· · · · Case: DirectDeclaratorIdent,
· · · · Token: example.c:1:5: IDENTIFIER "f",
· · · },
· · · Token: example.c:1:6: '(' "(",
· · · Token2: example.c:1:7: ')' ")",
· · },
· },
}

func (*AsmFunctionDefinition) Position

func (n *AsmFunctionDefinition) Position() (r token.Position)

Position reports the position of the first component of n, if available.

func (*AsmFunctionDefinition) String

func (n *AsmFunctionDefinition) String() string

String implements fmt.Stringer.

type AsmIndex

type AsmIndex struct {
	Expression *Expression
	Token      Token
	Token2     Token
}

AsmIndex represents data reduced by production:

AsmIndex:
        '[' Expression ']'
Example (Case0)
fmt.Println(exampleAST(254, "__asm__(\"nop\": [a] b);"))
Output:

&cc.AsmIndex{
· Expression: &cc.Expression{
· · AssignmentExpression: &cc.AssignmentExpression{
· · · Case: AssignmentExpressionCond,
· · · ConditionalExpression: &cc.ConditionalExpression{
· · · · Case: ConditionalExpressionLOr,
· · · · LogicalOrExpression: &cc.LogicalOrExpression{
· · · · · Case: LogicalOrExpressionLAnd,
· · · · · LogicalAndExpression: &cc.LogicalAndExpression{
· · · · · · Case: LogicalAndExpressionOr,
· · · · · · InclusiveOrExpression: &cc.InclusiveOrExpression{
· · · · · · · Case: InclusiveOrExpressionXor,
· · · · · · · ExclusiveOrExpression: &cc.ExclusiveOrExpression{
· · · · · · · · AndExpression: &cc.AndExpression{
· · · · · · · · · Case: AndExpressionEq,
· · · · · · · · · EqualityExpression: &cc.EqualityExpression{
· · · · · · · · · · Case: EqualityExpressionRel,
· · · · · · · · · · RelationalExpression: &cc.RelationalExpression{
· · · · · · · · · · · Case: RelationalExpressionShift,
· · · · · · · · · · · ShiftExpression: &cc.ShiftExpression{
· · · · · · · · · · · · AdditiveExpression: &cc.AdditiveExpression{
· · · · · · · · · · · · · Case: AdditiveExpressionMul,
· · · · · · · · · · · · · MultiplicativeExpression: &cc.MultiplicativeExpression{
· · · · · · · · · · · · · · Case: MultiplicativeExpressionCast,
· · · · · · · · · · · · · · CastExpression: &cc.CastExpression{
· · · · · · · · · · · · · · · Case: CastExpressionUnary,
· · · · · · · · · · · · · · · UnaryExpression: &cc.UnaryExpression{
· · · · · · · · · · · · · · · · Case: UnaryExpressionPostfix,
· · · · · · · · · · · · · · · · PostfixExpression: &cc.PostfixExpression{
· · · · · · · · · · · · · · · · · Case: PostfixExpressionPrimary,
· · · · · · · · · · · · · · · · · PrimaryExpression: &cc.PrimaryExpression{
· · · · · · · · · · · · · · · · · · Case: PrimaryExpressionIdent,
· · · · · · · · · · · · · · · · · · Token: example.c:1:17: IDENTIFIER "a",
· · · · · · · · · · · · · · · · · },
· · · · · · · · · · · · · · · · },
· · · · · · · · · · · · · · · },
· · · · · · · · · · · · · · },
· · · · · · · · · · · · · },
· · · · · · · · · · · · },
· · · · · · · · · · · · Case: ShiftExpressionAdd,
· · · · · · · · · · · },
· · · · · · · · · · },
· · · · · · · · · },
· · · · · · · · },
· · · · · · · · Case: ExclusiveOrExpressionAnd,
· · · · · · · },
· · · · · · },
· · · · · },
· · · · },
· · · },
· · },
· · Case: ExpressionAssign,
· },
· Token: example.c:1:16: '[' "[",
· Token2: example.c:1:18: ']' "]",
}

func (*AsmIndex) Position

func (n *AsmIndex) Position() (r token.Position)

Position reports the position of the first component of n, if available.

func (*AsmIndex) String

func (n *AsmIndex) String() string

String implements fmt.Stringer.

type AsmQualifier

type AsmQualifier struct {
	Case  AsmQualifierCase `PrettyPrint:"stringer,zero"`
	Token Token
}

AsmQualifier represents data reduced by productions:

AsmQualifier:
        "volatile"  // Case AsmQualifierVolatile
|       "inline"    // Case AsmQualifierInline
|       "goto"      // Case AsmQualifierGoto
Example (Goto)
fmt.Println(exampleAST(264, "__asm__ goto (\"nop\");"))
Output:

&cc.AsmQualifier{
· Case: AsmQualifierGoto,
· Token: example.c:1:9: GOTO "goto",
}
Example (Inline)
fmt.Println(exampleAST(263, "__asm__ inline (\"nop\");"))
Output:

&cc.AsmQualifier{
· Case: AsmQualifierInline,
· Token: example.c:1:9: INLINE "inline",
}
Example (Volatile)
fmt.Println(exampleAST(262, "__asm__ volatile (\"nop\");"))
Output:

&cc.AsmQualifier{
· Case: AsmQualifierVolatile,
· Token: example.c:1:9: VOLATILE "volatile",
}

func (*AsmQualifier) Position

func (n *AsmQualifier) Position() (r token.Position)

Position reports the position of the first component of n, if available.

func (*AsmQualifier) String

func (n *AsmQualifier) String() string

String implements fmt.Stringer.

type AsmQualifierCase

type AsmQualifierCase int

AsmQualifierCase represents case numbers of production AsmQualifier

const (
	AsmQualifierVolatile AsmQualifierCase = iota
	AsmQualifierInline
	AsmQualifierGoto
)

Values of type AsmQualifierCase

func (AsmQualifierCase) String

func (n AsmQualifierCase) String() string

String implements fmt.Stringer

type AsmQualifierList

type AsmQualifierList struct {
	AsmQualifier     *AsmQualifier
	AsmQualifierList *AsmQualifierList
}

AsmQualifierList represents data reduced by productions:

AsmQualifierList:
        AsmQualifier
|       AsmQualifierList AsmQualifier
Example (Case0)
fmt.Println(exampleAST(265, "__asm__ inline (\"nop\");"))
Output:

&cc.AsmQualifierList{
· AsmQualifier: &cc.AsmQualifier{
· · Case: AsmQualifierInline,
· · Token: example.c:1:9: INLINE "inline",
· },
}
Example (Case1)
fmt.Println(exampleAST(266, "__asm__ inline volatile (\"nop\");"))
Output:

&cc.AsmQualifierList{
· AsmQualifier: &cc.AsmQualifier{
· · Case: AsmQualifierInline,
· · Token: example.c:1:9: INLINE "inline",
· },
· AsmQualifierList: &cc.AsmQualifierList{
· · AsmQualifier: &cc.AsmQualifier{
· · · Case: AsmQualifierVolatile,
· · · Token: example.c:1:16: VOLATILE "volatile",
· · },
· },
}

func (*AsmQualifierList) Position

func (n *AsmQualifierList) Position() (r token.Position)

Position reports the position of the first component of n, if available.

func (*AsmQualifierList) String

func (n *AsmQualifierList) String() string

String implements fmt.Stringer.

type AsmStatement

type AsmStatement struct {
	Asm                    *Asm
	AttributeSpecifierList *AttributeSpecifierList
	Token                  Token
}

AsmStatement represents data reduced by production:

AsmStatement:
        Asm AttributeSpecifierList ';'
Example (Case0)
fmt.Println(exampleAST(260, "void f() { __asm__(\"nop\"); }"))
Output:

&cc.AsmStatement{
· Asm: &cc.Asm{
· · Token: example.c:1:12: ASM "__asm__",
· · Token2: example.c:1:19: '(' "(",
· · Token3: example.c:1:20: STRINGLITERAL "nop",
· · Token4: example.c:1:25: ')' ")",
· },
· Token: example.c:1:26: ';' ";",
}

func (*AsmStatement) Position

func (n *AsmStatement) Position() (r token.Position)

Position reports the position of the first component of n, if available.

func (*AsmStatement) String

func (n *AsmStatement) String() string

String implements fmt.Stringer.

type AssignmentExpression

type AssignmentExpression struct {
	Operand            Operand
	InitializerOperand Operand // When the expression is used in an initializer

	IsSideEffectsFree     bool
	AssignmentExpression  *AssignmentExpression
	Case                  AssignmentExpressionCase `PrettyPrint:"stringer,zero"`
	ConditionalExpression *ConditionalExpression
	Token                 Token
	UnaryExpression       *UnaryExpression
	// contains filtered or unexported fields
}

AssignmentExpression represents data reduced by productions:

AssignmentExpression:
        ConditionalExpression                       // Case AssignmentExpressionCond
|       UnaryExpression '=' AssignmentExpression    // Case AssignmentExpressionAssign
|       UnaryExpression "*=" AssignmentExpression   // Case AssignmentExpressionMul
|       UnaryExpression "/=" AssignmentExpression   // Case AssignmentExpressionDiv
|       UnaryExpression "%=" AssignmentExpression   // Case AssignmentExpressionMod
|       UnaryExpression "+=" AssignmentExpression   // Case AssignmentExpressionAdd
|       UnaryExpression "-=" AssignmentExpression   // Case AssignmentExpressionSub
|       UnaryExpression "<<=" AssignmentExpression  // Case AssignmentExpressionLsh
|       UnaryExpression ">>=" AssignmentExpression  // Case AssignmentExpressionRsh
|       UnaryExpression "&=" AssignmentExpression   // Case AssignmentExpressionAnd
|       UnaryExpression "^=" AssignmentExpression   // Case AssignmentExpressionXor
|       UnaryExpression "|=" AssignmentExpression   // Case AssignmentExpressionOr
Example (Add)
fmt.Println(exampleAST(76, "int f() { x += y; }"))
Output:

&cc.AssignmentExpression{
· AssignmentExpression: &cc.AssignmentExpression{
· · Case: AssignmentExpressionCond,
· · ConditionalExpression: &cc.ConditionalExpression{
· · · Case: ConditionalExpressionLOr,
· · · LogicalOrExpression: &cc.LogicalOrExpression{
· · · · Case: LogicalOrExpressionLAnd,
· · · · LogicalAndExpression: &cc.LogicalAndExpression{
· · · · · Case: LogicalAndExpressionOr,
· · · · · InclusiveOrExpression: &cc.InclusiveOrExpression{
· · · · · · Case: InclusiveOrExpressionXor,
· · · · · · ExclusiveOrExpression: &cc.ExclusiveOrExpression{
· · · · · · · AndExpression: &cc.AndExpression{
· · · · · · · · Case: AndExpressionEq,
· · · · · · · · EqualityExpression: &cc.EqualityExpression{
· · · · · · · · · Case: EqualityExpressionRel,
· · · · · · · · · RelationalExpression: &cc.RelationalExpression{
· · · · · · · · · · Case: RelationalExpressionShift,
· · · · · · · · · · ShiftExpression: &cc.ShiftExpression{
· · · · · · · · · · · AdditiveExpression: &cc.AdditiveExpression{
· · · · · · · · · · · · Case: AdditiveExpressionMul,
· · · · · · · · · · · · MultiplicativeExpression: &cc.MultiplicativeExpression{
· · · · · · · · · · · · · Case: MultiplicativeExpressionCast,
· · · · · · · · · · · · · CastExpression: &cc.CastExpression{
· · · · · · · · · · · · · · Case: CastExpressionUnary,
· · · · · · · · · · · · · · UnaryExpression: &cc.UnaryExpression{
· · · · · · · · · · · · · · · Case: UnaryExpressionPostfix,
· · · · · · · · · · · · · · · PostfixExpression: &cc.PostfixExpression{
· · · · · · · · · · · · · · · · Case: PostfixExpressionPrimary,
· · · · · · · · · · · · · · · · PrimaryExpression: &cc.PrimaryExpression{
· · · · · · · · · · · · · · · · · Case: PrimaryExpressionIdent,
· · · · · · · · · · · · · · · · · Token: example.c:1:16: IDENTIFIER "y",
· · · · · · · · · · · · · · · · },
· · · · · · · · · · · · · · · },
· · · · · · · · · · · · · · },
· · · · · · · · · · · · · },
· · · · · · · · · · · · },
· · · · · · · · · · · },
· · · · · · · · · · · Case: ShiftExpressionAdd,
· · · · · · · · · · },
· · · · · · · · · },
· · · · · · · · },
· · · · · · · },
· · · · · · · Case: ExclusiveOrExpressionAnd,
· · · · · · },
· · · · · },
· · · · },
· · · },
· · },
· },
· Case: AssignmentExpressionAdd,
· Token: example.c:1:13: ADDASSIGN "+=",
· UnaryExpression: &cc.UnaryExpression{
· · Case: UnaryExpressionPostfix,
· · PostfixExpression: &cc.PostfixExpression{
· · · Case: PostfixExpressionPrimary,
· · · PrimaryExpression: &cc.PrimaryExpression{
· · · · Case: PrimaryExpressionIdent,
· · · · Token: example.c:1:11: IDENTIFIER "x",
· · · },
· · },
· },
}
Example (And)
fmt.Println(exampleAST(80, "int f() { x &= y; }"))
Output:

&cc.AssignmentExpression{
· AssignmentExpression: &cc.AssignmentExpression{
· · Case: AssignmentExpressionCond,
· · ConditionalExpression: &cc.ConditionalExpression{
· · · Case: ConditionalExpressionLOr,
· · · LogicalOrExpression: &cc.LogicalOrExpression{
· · · · Case: LogicalOrExpressionLAnd,
· · · · LogicalAndExpression: &cc.LogicalAndExpression{
· · · · · Case: LogicalAndExpressionOr,
· · · · · InclusiveOrExpression: &cc.InclusiveOrExpression{
· · · · · · Case: InclusiveOrExpressionXor,
· · · · · · ExclusiveOrExpression: &cc.ExclusiveOrExpression{
· · · · · · · AndExpression: &cc.AndExpression{
· · · · · · · · Case: AndExpressionEq,
· · · · · · · · EqualityExpression: &cc.EqualityExpression{
· · · · · · · · · Case: EqualityExpressionRel,
· · · · · · · · · RelationalExpression: &cc.RelationalExpression{
· · · · · · · · · · Case: RelationalExpressionShift,
· · · · · · · · · · ShiftExpression: &cc.ShiftExpression{
· · · · · · · · · · · AdditiveExpression: &cc.AdditiveExpression{
· · · · · · · · · · · · Case: AdditiveExpressionMul,
· · · · · · · · · · · · MultiplicativeExpression: &cc.MultiplicativeExpression{
· · · · · · · · · · · · · Case: MultiplicativeExpressionCast,
· · · · · · · · · · · · · CastExpression: &cc.CastExpression{
· · · · · · · · · · · · · · Case: CastExpressionUnary,
· · · · · · · · · · · · · · UnaryExpression: &cc.UnaryExpression{
· · · · · · · · · · · · · · · Case: UnaryExpressionPostfix,
· · · · · · · · · · · · · · · PostfixExpression: &cc.PostfixExpression{
· · · · · · · · · · · · · · · · Case: PostfixExpressionPrimary,
· · · · · · · · · · · · · · · · PrimaryExpression: &cc.PrimaryExpression{
· · · · · · · · · · · · · · · · · Case: PrimaryExpressionIdent,
· · · · · · · · · · · · · · · · · Token: example.c:1:16: IDENTIFIER "y",
· · · · · · · · · · · · · · · · },
· · · · · · · · · · · · · · · },
· · · · · · · · · · · · · · },
· · · · · · · · · · · · · },
· · · · · · · · · · · · },
· · · · · · · · · · · },
· · · · · · · · · · · Case: ShiftExpressionAdd,
· · · · · · · · · · },
· · · · · · · · · },
· · · · · · · · },
· · · · · · · },
· · · · · · · Case: ExclusiveOrExpressionAnd,
· · · · · · },
· · · · · },
· · · · },
· · · },
· · },
· },
· Case: AssignmentExpressionAnd,
· Token: example.c:1:13: ANDASSIGN "&=",
· UnaryExpression: &cc.UnaryExpression{
· · Case: UnaryExpressionPostfix,
· · PostfixExpression: &cc.PostfixExpression{
· · · Case: PostfixExpressionPrimary,
· · · PrimaryExpression: &cc.PrimaryExpression{
· · · · Case: PrimaryExpressionIdent,
· · · · Token: example.c:1:11: IDENTIFIER "x",
· · · },
· · },
· },
}
Example (Assign)
fmt.Println(exampleAST(72, "int f() { x = y; }"))
Output:

&cc.AssignmentExpression{
· AssignmentExpression: &cc.AssignmentExpression{
· · Case: AssignmentExpressionCond,
· · ConditionalExpression: &cc.ConditionalExpression{
· · · Case: ConditionalExpressionLOr,
· · · LogicalOrExpression: &cc.LogicalOrExpression{
· · · · Case: LogicalOrExpressionLAnd,
· · · · LogicalAndExpression: &cc.LogicalAndExpression{
· · · · · Case: LogicalAndExpressionOr,
· · · · · InclusiveOrExpression: &cc.InclusiveOrExpression{
· · · · · · Case: InclusiveOrExpressionXor,
· · · · · · ExclusiveOrExpression: &cc.ExclusiveOrExpression{
· · · · · · · AndExpression: &cc.AndExpression{
· · · · · · · · Case: AndExpressionEq,
· · · · · · · · EqualityExpression: &cc.EqualityExpression{
· · · · · · · · · Case: EqualityExpressionRel,
· · · · · · · · · RelationalExpression: &cc.RelationalExpression{
· · · · · · · · · · Case: RelationalExpressionShift,
· · · · · · · · · · ShiftExpression: &cc.ShiftExpression{
· · · · · · · · · · · AdditiveExpression: &cc.AdditiveExpression{
· · · · · · · · · · · · Case: AdditiveExpressionMul,
· · · · · · · · · · · · MultiplicativeExpression: &cc.MultiplicativeExpression{
· · · · · · · · · · · · · Case: MultiplicativeExpressionCast,
· · · · · · · · · · · · · CastExpression: &cc.CastExpression{
· · · · · · · · · · · · · · Case: CastExpressionUnary,
· · · · · · · · · · · · · · UnaryExpression: &cc.UnaryExpression{
· · · · · · · · · · · · · · · Case: UnaryExpressionPostfix,
· · · · · · · · · · · · · · · PostfixExpression: &cc.PostfixExpression{
· · · · · · · · · · · · · · · · Case: PostfixExpressionPrimary,
· · · · · · · · · · · · · · · · PrimaryExpression: &cc.PrimaryExpression{
· · · · · · · · · · · · · · · · · Case: PrimaryExpressionIdent,
· · · · · · · · · · · · · · · · · Token: example.c:1:15: IDENTIFIER "y",
· · · · · · · · · · · · · · · · },
· · · · · · · · · · · · · · · },
· · · · · · · · · · · · · · },
· · · · · · · · · · · · · },
· · · · · · · · · · · · },
· · · · · · · · · · · },
· · · · · · · · · · · Case: ShiftExpressionAdd,
· · · · · · · · · · },
· · · · · · · · · },
· · · · · · · · },
· · · · · · · },
· · · · · · · Case: ExclusiveOrExpressionAnd,
· · · · · · },
· · · · · },
· · · · },
· · · },
· · },
· },
· Case: AssignmentExpressionAssign,
· Token: example.c:1:13: '=' "=",
· UnaryExpression: &cc.UnaryExpression{
· · Case: UnaryExpressionPostfix,
· · PostfixExpression: &cc.PostfixExpression{
· · · Case: PostfixExpressionPrimary,
· · · PrimaryExpression: &cc.PrimaryExpression{
· · · · Case: PrimaryExpressionIdent,
· · · · Token: example.c:1:11: IDENTIFIER "x",
· · · },
· · },
· },
}
Example (Cond)
fmt.Println(exampleAST(71, "int i = x; }"))
Output:

&cc.AssignmentExpression{
· Case: AssignmentExpressionCond,
· ConditionalExpression: &cc.ConditionalExpression{
· · Case: ConditionalExpressionLOr,
· · LogicalOrExpression: &cc.LogicalOrExpression{
· · · Case: LogicalOrExpressionLAnd,
· · · LogicalAndExpression: &cc.LogicalAndExpression{
· · · · Case: LogicalAndExpressionOr,
· · · · InclusiveOrExpression: &cc.InclusiveOrExpression{
· · · · · Case: InclusiveOrExpressionXor,
· · · · · ExclusiveOrExpression: &cc.ExclusiveOrExpression{
· · · · · · AndExpression: &cc.AndExpression{
· · · · · · · Case: AndExpressionEq,
· · · · · · · EqualityExpression: &cc.EqualityExpression{
· · · · · · · · Case: EqualityExpressionRel,
· · · · · · · · RelationalExpression: &cc.RelationalExpression{
· · · · · · · · · Case: RelationalExpressionShift,
· · · · · · · · · ShiftExpression: &cc.ShiftExpression{
· · · · · · · · · · AdditiveExpression: &cc.AdditiveExpression{
· · · · · · · · · · · Case: AdditiveExpressionMul,
· · · · · · · · · · · MultiplicativeExpression: &cc.MultiplicativeExpression{
· · · · · · · · · · · · Case: MultiplicativeExpressionCast,
· · · · · · · · · · · · CastExpression: &cc.CastExpression{
· · · · · · · · · · · · · Case: CastExpressionUnary,
· · · · · · · · · · · · · UnaryExpression: &cc.UnaryExpression{
· · · · · · · · · · · · · · Case: UnaryExpressionPostfix,
· · · · · · · · · · · · · · PostfixExpression: &cc.PostfixExpression{
· · · · · · · · · · · · · · · Case: PostfixExpressionPrimary,
· · · · · · · · · · · · · · · PrimaryExpression: &cc.PrimaryExpression{
· · · · · · · · · · · · · · · · Case: PrimaryExpressionIdent,
· · · · · · · · · · · · · · · · Token: example.c:1:9: IDENTIFIER "x",
· · · · · · · · · · · · · · · },
· · · · · · · · · · · · · · },
· · · · · · · · · · · · · },
· · · · · · · · · · · · },
· · · · · · · · · · · },
· · · · · · · · · · },
· · · · · · · · · · Case: ShiftExpressionAdd,
· · · · · · · · · },
· · · · · · · · },
· · · · · · · },
· · · · · · },
· · · · · · Case: ExclusiveOrExpressionAnd,
· · · · · },
· · · · },
· · · },
· · },
· },
}
Example (Div)
fmt.Println(exampleAST(74, "int f() { x /= y; }"))
Output:

&cc.AssignmentExpression{
· AssignmentExpression: &cc.AssignmentExpression{
· · Case: AssignmentExpressionCond,
· · ConditionalExpression: &cc.ConditionalExpression{
· · · Case: ConditionalExpressionLOr,
· · · LogicalOrExpression: &cc.LogicalOrExpression{
· · · · Case: LogicalOrExpressionLAnd,
· · · · LogicalAndExpression: &cc.LogicalAndExpression{
· · · · · Case: LogicalAndExpressionOr,
· · · · · InclusiveOrExpression: &cc.InclusiveOrExpression{
· · · · · · Case: InclusiveOrExpressionXor,
· · · · · · ExclusiveOrExpression: &cc.ExclusiveOrExpression{
· · · · · · · AndExpression: &cc.AndExpression{
· · · · · · · · Case: AndExpressionEq,
· · · · · · · · EqualityExpression: &cc.EqualityExpression{
· · · · · · · · · Case: EqualityExpressionRel,
· · · · · · · · · RelationalExpression: &cc.RelationalExpression{
· · · · · · · · · · Case: RelationalExpressionShift,
· · · · · · · · · · ShiftExpression: &cc.ShiftExpression{
· · · · · · · · · · · AdditiveExpression: &cc.AdditiveExpression{
· · · · · · · · · · · · Case: AdditiveExpressionMul,
· · · · · · · · · · · · MultiplicativeExpression: &cc.MultiplicativeExpression{
· · · · · · · · · · · · · Case: MultiplicativeExpressionCast,
· · · · · · · · · · · · · CastExpression: &cc.CastExpression{
· · · · · · · · · · · · · · Case: CastExpressionUnary,
· · · · · · · · · · · · · · UnaryExpression: &cc.UnaryExpression{
· · · · · · · · · · · · · · · Case: UnaryExpressionPostfix,
· · · · · · · · · · · · · · · PostfixExpression: &cc.PostfixExpression{
· · · · · · · · · · · · · · · · Case: PostfixExpressionPrimary,
· · · · · · · · · · · · · · · · PrimaryExpression: &cc.PrimaryExpression{
· · · · · · · · · · · · · · · · · Case: PrimaryExpressionIdent,
· · · · · · · · · · · · · · · · · Token: example.c:1:16: IDENTIFIER "y",
· · · · · · · · · · · · · · · · },
· · · · · · · · · · · · · · · },
· · · · · · · · · · · · · · },
· · · · · · · · · · · · · },
· · · · · · · · · · · · },
· · · · · · · · · · · },
· · · · · · · · · · · Case: ShiftExpressionAdd,
· · · · · · · · · · },
· · · · · · · · · },
· · · · · · · · },
· · · · · · · },
· · · · · · · Case: ExclusiveOrExpressionAnd,
· · · · · · },
· · · · · },
· · · · },
· · · },
· · },
· },
· Case: AssignmentExpressionDiv,
· Token: example.c:1:13: DIVASSIGN "/=",
· UnaryExpression: &cc.UnaryExpression{
· · Case: UnaryExpressionPostfix,
· · PostfixExpression: &cc.PostfixExpression{
· · · Case: PostfixExpressionPrimary,
· · · PrimaryExpression: &cc.PrimaryExpression{
· · · · Case: PrimaryExpressionIdent,
· · · · Token: example.c:1:11: IDENTIFIER "x",
· · · },
· · },
· },
}
Example (Lsh)
fmt.Println(exampleAST(78, "int f() { x <<= y; }"))
Output:

&cc.AssignmentExpression{
· AssignmentExpression: &cc.AssignmentExpression{
· · Case: AssignmentExpressionCond,
· · ConditionalExpression: &cc.ConditionalExpression{
· · · Case: ConditionalExpressionLOr,
· · · LogicalOrExpression: &cc.LogicalOrExpression{
· · · · Case: LogicalOrExpressionLAnd,
· · · · LogicalAndExpression: &cc.LogicalAndExpression{
· · · · · Case: LogicalAndExpressionOr,
· · · · · InclusiveOrExpression: &cc.InclusiveOrExpression{
· · · · · · Case: InclusiveOrExpressionXor,
· · · · · · ExclusiveOrExpression: &cc.ExclusiveOrExpression{
· · · · · · · AndExpression: &cc.AndExpression{
· · · · · · · · Case: AndExpressionEq,
· · · · · · · · EqualityExpression: &cc.EqualityExpression{
· · · · · · · · · Case: EqualityExpressionRel,
· · · · · · · · · RelationalExpression: &cc.RelationalExpression{
· · · · · · · · · · Case: RelationalExpressionShift,
· · · · · · · · · · ShiftExpression: &cc.ShiftExpression{
· · · · · · · · · · · AdditiveExpression: &cc.AdditiveExpression{
· · · · · · · · · · · · Case: AdditiveExpressionMul,
· · · · · · · · · · · · MultiplicativeExpression: &cc.MultiplicativeExpression{
· · · · · · · · · · · · · Case: MultiplicativeExpressionCast,
· · · · · · · · · · · · · CastExpression: &cc.CastExpression{
· · · · · · · · · · · · · · Case: CastExpressionUnary,
· · · · · · · · · · · · · · UnaryExpression: &cc.UnaryExpression{
· · · · · · · · · · · · · · · Case: UnaryExpressionPostfix,
· · · · · · · · · · · · · · · PostfixExpression: &cc.PostfixExpression{
· · · · · · · · · · · · · · · · Case: PostfixExpressionPrimary,
· · · · · · · · · · · · · · · · PrimaryExpression: &cc.PrimaryExpression{
· · · · · · · · · · · · · · · · · Case: PrimaryExpressionIdent,
· · · · · · · · · · · · · · · · · Token: example.c:1:17: IDENTIFIER "y",
· · · · · · · · · · · · · · · · },
· · · · · · · · · · · · · · · },
· · · · · · · · · · · · · · },
· · · · · · · · · · · · · },
· · · · · · · · · · · · },
· · · · · · · · · · · },
· · · · · · · · · · · Case: ShiftExpressionAdd,
· · · · · · · · · · },
· · · · · · · · · },
· · · · · · · · },
· · · · · · · },
· · · · · · · Case: ExclusiveOrExpressionAnd,
· · · · · · },
· · · · · },
· · · · },
· · · },
· · },
· },
· Case: AssignmentExpressionLsh,
· Token: example.c:1:13: LSHASSIGN "<<=",
· UnaryExpression: &cc.UnaryExpression{
· · Case: UnaryExpressionPostfix,
· · PostfixExpression: &cc.PostfixExpression{
· · · Case: PostfixExpressionPrimary,
· · · PrimaryExpression: &cc.PrimaryExpression{
· · · · Case: PrimaryExpressionIdent,
· · · · Token: example.c:1:11: IDENTIFIER "x",
· · · },
· · },
· },
}
Example (Mod)
fmt.Println(exampleAST(75, "int f() { x %= y; }"))
Output:

&cc.AssignmentExpression{
· AssignmentExpression: &cc.AssignmentExpression{
· · Case: AssignmentExpressionCond,
· · ConditionalExpression: &cc.ConditionalExpression{
· · · Case: ConditionalExpressionLOr,
· · · LogicalOrExpression: &cc.LogicalOrExpression{
· · · · Case: LogicalOrExpressionLAnd,
· · · · LogicalAndExpression: &cc.LogicalAndExpression{
· · · · · Case: LogicalAndExpressionOr,
· · · · · InclusiveOrExpression: &cc.InclusiveOrExpression{
· · · · · · Case: InclusiveOrExpressionXor,
· · · · · · ExclusiveOrExpression: &cc.ExclusiveOrExpression{
· · · · · · · AndExpression: &cc.AndExpression{
· · · · · · · · Case: AndExpressionEq,
· · · · · · · · EqualityExpression: &cc.EqualityExpression{
· · · · · · · · · Case: EqualityExpressionRel,
· · · · · · · · · RelationalExpression: &cc.RelationalExpression{
· · · · · · · · · · Case: RelationalExpressionShift,
· · · · · · · · · · ShiftExpression: &cc.ShiftExpression{
· · · · · · · · · · · AdditiveExpression: &cc.AdditiveExpression{
· · · · · · · · · · · · Case: AdditiveExpressionMul,
· · · · · · · · · · · · MultiplicativeExpression: &cc.MultiplicativeExpression{
· · · · · · · · · · · · · Case: MultiplicativeExpressionCast,
· · · · · · · · · · · · · CastExpression: &cc.CastExpression{
· · · · · · · · · · · · · · Case: CastExpressionUnary,
· · · · · · · · · · · · · · UnaryExpression: &cc.UnaryExpression{
· · · · · · · · · · · · · · · Case: UnaryExpressionPostfix,
· · · · · · · · · · · · · · · PostfixExpression: &cc.PostfixExpression{
· · · · · · · · · · · · · · · · Case: PostfixExpressionPrimary,
· · · · · · · · · · · · · · · · PrimaryExpression: &cc.PrimaryExpression{
· · · · · · · · · · · · · · · · · Case: PrimaryExpressionIdent,
· · · · · · · · · · · · · · · · · Token: example.c:1:16: IDENTIFIER "y",
· · · · · · · · · · · · · · · · },
· · · · · · · · · · · · · · · },
· · · · · · · · · · · · · · },
· · · · · · · · · · · · · },
· · · · · · · · · · · · },
· · · · · · · · · · · },
· · · · · · · · · · · Case: ShiftExpressionAdd,
· · · · · · · · · · },
· · · · · · · · · },
· · · · · · · · },
· · · · · · · },
· · · · · · · Case: ExclusiveOrExpressionAnd,
· · · · · · },
· · · · · },
· · · · },
· · · },
· · },
· },
· Case: AssignmentExpressionMod,
· Token: example.c:1:13: MODASSIGN "%=",
· UnaryExpression: &cc.UnaryExpression{
· · Case: UnaryExpressionPostfix,
· · PostfixExpression: &cc.PostfixExpression{
· · · Case: PostfixExpressionPrimary,
· · · PrimaryExpression: &cc.PrimaryExpression{
· · · · Case: PrimaryExpressionIdent,
· · · · Token: example.c:1:11: IDENTIFIER "x",
· · · },
· · },
· },
}
Example (Mul)
fmt.Println(exampleAST(73, "int f() { x *= y; }"))
Output:

&cc.AssignmentExpression{
· AssignmentExpression: &cc.AssignmentExpression{
· · Case: AssignmentExpressionCond,
· · ConditionalExpression: &cc.ConditionalExpression{
· · · Case: ConditionalExpressionLOr,
· · · LogicalOrExpression: &cc.LogicalOrExpression{
· · · · Case: LogicalOrExpressionLAnd,
· · · · LogicalAndExpression: &cc.LogicalAndExpression{
· · · · · Case: LogicalAndExpressionOr,
· · · · · InclusiveOrExpression: &cc.InclusiveOrExpression{
· · · · · · Case: InclusiveOrExpressionXor,
· · · · · · ExclusiveOrExpression: &cc.ExclusiveOrExpression{
· · · · · · · AndExpression: &cc.AndExpression{
· · · · · · · · Case: AndExpressionEq,
· · · · · · · · EqualityExpression: &cc.EqualityExpression{
· · · · · · · · · Case: EqualityExpressionRel,
· · · · · · · · · RelationalExpression: &cc.RelationalExpression{
· · · · · · · · · · Case: RelationalExpressionShift,
· · · · · · · · · · ShiftExpression: &cc.ShiftExpression{
· · · · · · · · · · · AdditiveExpression: &cc.AdditiveExpression{
· · · · · · · · · · · · Case: AdditiveExpressionMul,
· · · · · · · · · · · · MultiplicativeExpression: &cc.MultiplicativeExpression{
· · · · · · · · · · · · · Case: MultiplicativeExpressionCast,
· · · · · · · · · · · · · CastExpression: &cc.CastExpression{
· · · · · · · · · · · · · · Case: CastExpressionUnary,
· · · · · · · · · · · · · · UnaryExpression: &cc.UnaryExpression{
· · · · · · · · · · · · · · · Case: UnaryExpressionPostfix,
· · · · · · · · · · · · · · · PostfixExpression: &cc.PostfixExpression{
· · · · · · · · · · · · · · · · Case: PostfixExpressionPrimary,
· · · · · · · · · · · · · · · · PrimaryExpression: &cc.PrimaryExpression{
· · · · · · · · · · · · · · · · · Case: PrimaryExpressionIdent,
· · · · · · · · · · · · · · · · · Token: example.c:1:16: IDENTIFIER "y",
· · · · · · · · · · · · · · · · },
· · · · · · · · · · · · · · · },
· · · · · · · · · · · · · · },
· · · · · · · · · · · · · },
· · · · · · · · · · · · },
· · · · · · · · · · · },
· · · · · · · · · · · Case: ShiftExpressionAdd,
· · · · · · · · · · },
· · · · · · · · · },
· · · · · · · · },
· · · · · · · },
· · · · · · · Case: ExclusiveOrExpressionAnd,
· · · · · · },
· · · · · },
· · · · },
· · · },
· · },
· },
· Case: AssignmentExpressionMul,
· Token: example.c:1:13: MULASSIGN "*=",
· UnaryExpression: &cc.UnaryExpression{
· · Case: UnaryExpressionPostfix,
· · PostfixExpression: &cc.PostfixExpression{
· · · Case: PostfixExpressionPrimary,
· · · PrimaryExpression: &cc.PrimaryExpression{
· · · · Case: PrimaryExpressionIdent,
· · · · Token: example.c:1:11: IDENTIFIER "x",
· · · },
· · },
· },
}
Example (Or)
fmt.Println(exampleAST(82, "int f() { x |= y; }"))
Output:

&cc.AssignmentExpression{
· AssignmentExpression: &cc.AssignmentExpression{
· · Case: AssignmentExpressionCond,
· · ConditionalExpression: &cc.ConditionalExpression{
· · · Case: ConditionalExpressionLOr,
· · · LogicalOrExpression: &cc.LogicalOrExpression{
· · · · Case: LogicalOrExpressionLAnd,
· · · · LogicalAndExpression: &cc.LogicalAndExpression{
· · · · · Case: LogicalAndExpressionOr,
· · · · · InclusiveOrExpression: &cc.InclusiveOrExpression{
· · · · · · Case: InclusiveOrExpressionXor,
· · · · · · ExclusiveOrExpression: &cc.ExclusiveOrExpression{
· · · · · · · AndExpression: &cc.AndExpression{
· · · · · · · · Case: AndExpressionEq,
· · · · · · · · EqualityExpression: &cc.EqualityExpression{
· · · · · · · · · Case: EqualityExpressionRel,
· · · · · · · · · RelationalExpression: &cc.RelationalExpression{
· · · · · · · · · · Case: RelationalExpressionShift,
· · · · · · · · · · ShiftExpression: &cc.ShiftExpression{
· · · · · · · · · · · AdditiveExpression: &cc.AdditiveExpression{
· · · · · · · · · · · · Case: AdditiveExpressionMul,
· · · · · · · · · · · · MultiplicativeExpression: &cc.MultiplicativeExpression{
· · · · · · · · · · · · · Case: MultiplicativeExpressionCast,
· · · · · · · · · · · · · CastExpression: &cc.CastExpression{
· · · · · · · · · · · · · · Case: CastExpressionUnary,
· · · · · · · · · · · · · · UnaryExpression: &cc.UnaryExpression{
· · · · · · · · · · · · · · · Case: UnaryExpressionPostfix,
· · · · · · · · · · · · · · · PostfixExpression: &cc.PostfixExpression{
· · · · · · · · · · · · · · · · Case: PostfixExpressionPrimary,
· · · · · · · · · · · · · · · · PrimaryExpression: &cc.PrimaryExpression{
· · · · · · · · · · · · · · · · · Case: PrimaryExpressionIdent,
· · · · · · · · · · · · · · · · · Token: example.c:1:16: IDENTIFIER "y",
· · · · · · · · · · · · · · · · },
· · · · · · · · · · · · · · · },
· · · · · · · · · · · · · · },
· · · · · · · · · · · · · },
· · · · · · · · · · · · },
· · · · · · · · · · · },
· · · · · · · · · · · Case: ShiftExpressionAdd,
· · · · · · · · · · },
· · · · · · · · · },
· · · · · · · · },
· · · · · · · },
· · · · · · · Case: ExclusiveOrExpressionAnd,
· · · · · · },
· · · · · },
· · · · },
· · · },
· · },
· },
· Case: AssignmentExpressionOr,
· Token: example.c:1:13: ORASSIGN "|=",
· UnaryExpression: &cc.UnaryExpression{
· · Case: UnaryExpressionPostfix,
· · PostfixExpression: &cc.PostfixExpression{
· · · Case: PostfixExpressionPrimary,
· · · PrimaryExpression: &cc.PrimaryExpression{
· · · · Case: PrimaryExpressionIdent,
· · · · Token: example.c:1:11: IDENTIFIER "x",
· · · },
· · },
· },
}
Example (Rsh)
fmt.Println(exampleAST(79, "int f() { x >>= y; }"))
Output:

&cc.AssignmentExpression{
· AssignmentExpression: &cc.AssignmentExpression{
· · Case: AssignmentExpressionCond,
· · ConditionalExpression: &cc.ConditionalExpression{
· · · Case: ConditionalExpressionLOr,
· · · LogicalOrExpression: &cc.LogicalOrExpression{
· · · · Case: LogicalOrExpressionLAnd,
· · · · LogicalAndExpression: &cc.LogicalAndExpression{
· · · · · Case: LogicalAndExpressionOr,
· · · · · InclusiveOrExpression: &cc.InclusiveOrExpression{
· · · · · · Case: InclusiveOrExpressionXor,
· · · · · · ExclusiveOrExpression: &cc.ExclusiveOrExpression{
· · · · · · · AndExpression: &cc.AndExpression{
· · · · · · · · Case: AndExpressionEq,
· · · · · · · · EqualityExpression: &cc.EqualityExpression{
· · · · · · · · · Case: EqualityExpressionRel,
· · · · · · · · · RelationalExpression: &cc.RelationalExpression{
· · · · · · · · · · Case: RelationalExpressionShift,
· · · · · · · · · · ShiftExpression: &cc.ShiftExpression{
· · · · · · · · · · · AdditiveExpression: &cc.AdditiveExpression{
· · · · · · · · · · · · Case: AdditiveExpressionMul,
· · · · · · · · · · · · MultiplicativeExpression: &cc.MultiplicativeExpression{
· · · · · · · · · · · · · Case: MultiplicativeExpressionCast,
· · · · · · · · · · · · · CastExpression: &cc.CastExpression{
· · · · · · · · · · · · · · Case: CastExpressionUnary,
· · · · · · · · · · · · · · UnaryExpression: &cc.UnaryExpression{
· · · · · · · · · · · · · · · Case: UnaryExpressionPostfix,
· · · · · · · · · · · · · · · PostfixExpression: &cc.PostfixExpression{
· · · · · · · · · · · · · · · · Case: PostfixExpressionPrimary,
· · · · · · · · · · · · · · · · PrimaryExpression: &cc.PrimaryExpression{
· · · · · · · · · · · · · · · · · Case: PrimaryExpressionIdent,
· · · · · · · · · · · · · · · · · Token: example.c:1:17: IDENTIFIER "y",
· · · · · · · · · · · · · · · · },
· · · · · · · · · · · · · · · },
· · · · · · · · · · · · · · },
· · · · · · · · · · · · · },
· · · · · · · · · · · · },
· · · · · · · · · · · },
· · · · · · · · · · · Case: ShiftExpressionAdd,
· · · · · · · · · · },
· · · · · · · · · },
· · · · · · · · },
· · · · · · · },
· · · · · · · Case: ExclusiveOrExpressionAnd,
· · · · · · },
· · · · · },
· · · · },
· · · },
· · },
· },
· Case: AssignmentExpressionRsh,
· Token: example.c:1:13: RSHASSIGN ">>=",
· UnaryExpression: &cc.UnaryExpression{
· · Case: UnaryExpressionPostfix,
· · PostfixExpression: &cc.PostfixExpression{
· · · Case: PostfixExpressionPrimary,
· · · PrimaryExpression: &cc.PrimaryExpression{
· · · · Case: PrimaryExpressionIdent,
· · · · Token: example.c:1:11: IDENTIFIER "x",
· · · },
· · },
· },
}
Example (Sub)
fmt.Println(exampleAST(77, "int f() { x -= y; }"))
Output:

&cc.AssignmentExpression{
· AssignmentExpression: &cc.AssignmentExpression{
· · Case: AssignmentExpressionCond,
· · ConditionalExpression: &cc.ConditionalExpression{
· · · Case: ConditionalExpressionLOr,
· · · LogicalOrExpression: &cc.LogicalOrExpression{
· · · · Case: LogicalOrExpressionLAnd,
· · · · LogicalAndExpression: &cc.LogicalAndExpression{
· · · · · Case: LogicalAndExpressionOr,
· · · · · InclusiveOrExpression: &cc.InclusiveOrExpression{
· · · · · · Case: InclusiveOrExpressionXor,
· · · · · · ExclusiveOrExpression: &cc.ExclusiveOrExpression{
· · · · · · · AndExpression: &cc.AndExpression{
· · · · · · · · Case: AndExpressionEq,
· · · · · · · · EqualityExpression: &cc.EqualityExpression{
· · · · · · · · · Case: EqualityExpressionRel,
· · · · · · · · · RelationalExpression: &cc.RelationalExpression{
· · · · · · · · · · Case: RelationalExpressionShift,
· · · · · · · · · · ShiftExpression: &cc.ShiftExpression{
· · · · · · · · · · · AdditiveExpression: &cc.AdditiveExpression{
· · · · · · · · · · · · Case: AdditiveExpressionMul,
· · · · · · · · · · · · MultiplicativeExpression: &cc.MultiplicativeExpression{
· · · · · · · · · · · · · Case: MultiplicativeExpressionCast,
· · · · · · · · · · · · · CastExpression: &cc.CastExpression{
· · · · · · · · · · · · · · Case: CastExpressionUnary,
· · · · · · · · · · · · · · UnaryExpression: &cc.UnaryExpression{
· · · · · · · · · · · · · · · Case: UnaryExpressionPostfix,
· · · · · · · · · · · · · · · PostfixExpression: &cc.PostfixExpression{
· · · · · · · · · · · · · · · · Case: PostfixExpressionPrimary,
· · · · · · · · · · · · · · · · PrimaryExpression: &cc.PrimaryExpression{
· · · · · · · · · · · · · · · · · Case: PrimaryExpressionIdent,
· · · · · · · · · · · · · · · · · Token: example.c:1:16: IDENTIFIER "y",
· · · · · · · · · · · · · · · · },
· · · · · · · · · · · · · · · },
· · · · · · · · · · · · · · },
· · · · · · · · · · · · · },
· · · · · · · · · · · · },
· · · · · · · · · · · },
· · · · · · · · · · · Case: ShiftExpressionAdd,
· · · · · · · · · · },
· · · · · · · · · },
· · · · · · · · },
· · · · · · · },
· · · · · · · Case: ExclusiveOrExpressionAnd,
· · · · · · },
· · · · · },
· · · · },
· · · },
· · },
· },
· Case: AssignmentExpressionSub,
· Token: example.c:1:13: SUBASSIGN "-=",
· UnaryExpression: &cc.UnaryExpression{
· · Case: UnaryExpressionPostfix,
· · PostfixExpression: &cc.PostfixExpression{
· · · Case: PostfixExpressionPrimary,
· · · PrimaryExpression: &cc.PrimaryExpression{
· · · · Case: PrimaryExpressionIdent,
· · · · Token: example.c:1:11: IDENTIFIER "x",
· · · },
· · },
· },
}
Example (Xor)
fmt.Println(exampleAST(81, "int f() { x ^= y; }"))
Output:

&cc.AssignmentExpression{
· AssignmentExpression: &cc.AssignmentExpression{
· · Case: AssignmentExpressionCond,
· · ConditionalExpression: &cc.ConditionalExpression{
· · · Case: ConditionalExpressionLOr,
· · · LogicalOrExpression: &cc.LogicalOrExpression{
· · · · Case: LogicalOrExpressionLAnd,
· · · · LogicalAndExpression: &cc.LogicalAndExpression{
· · · · · Case: LogicalAndExpressionOr,
· · · · · InclusiveOrExpression: &cc.InclusiveOrExpression{
· · · · · · Case: InclusiveOrExpressionXor,
· · · · · · ExclusiveOrExpression: &cc.ExclusiveOrExpression{
· · · · · · · AndExpression: &cc.AndExpression{
· · · · · · · · Case: AndExpressionEq,
· · · · · · · · EqualityExpression: &cc.EqualityExpression{
· · · · · · · · · Case: EqualityExpressionRel,
· · · · · · · · · RelationalExpression: &cc.RelationalExpression{
· · · · · · · · · · Case: RelationalExpressionShift,
· · · · · · · · · · ShiftExpression: &cc.ShiftExpression{
· · · · · · · · · · · AdditiveExpression: &cc.AdditiveExpression{
· · · · · · · · · · · · Case: AdditiveExpressionMul,
· · · · · · · · · · · · MultiplicativeExpression: &cc.MultiplicativeExpression{
· · · · · · · · · · · · · Case: MultiplicativeExpressionCast,
· · · · · · · · · · · · · CastExpression: &cc.CastExpression{
· · · · · · · · · · · · · · Case: CastExpressionUnary,
· · · · · · · · · · · · · · UnaryExpression: &cc.UnaryExpression{
· · · · · · · · · · · · · · · Case: UnaryExpressionPostfix,
· · · · · · · · · · · · · · · PostfixExpression: &cc.PostfixExpression{
· · · · · · · · · · · · · · · · Case: PostfixExpressionPrimary,
· · · · · · · · · · · · · · · · PrimaryExpression: &cc.PrimaryExpression{
· · · · · · · · · · · · · · · · · Case: PrimaryExpressionIdent,
· · · · · · · · · · · · · · · · · Token: example.c:1:16: IDENTIFIER "y",
· · · · · · · · · · · · · · · · },
· · · · · · · · · · · · · · · },
· · · · · · · · · · · · · · },
· · · · · · · · · · · · · },
· · · · · · · · · · · · },
· · · · · · · · · · · },
· · · · · · · · · · · Case: ShiftExpressionAdd,
· · · · · · · · · · },
· · · · · · · · · },
· · · · · · · · },
· · · · · · · },
· · · · · · · Case: ExclusiveOrExpressionAnd,
· · · · · · },
· · · · · },
· · · · },
· · · },
· · },
· },
· Case: AssignmentExpressionXor,
· Token: example.c:1:13: XORASSIGN "^=",
· UnaryExpression: &cc.UnaryExpression{
· · Case: UnaryExpressionPostfix,
· · PostfixExpression: &cc.PostfixExpression{
· · · Case: PostfixExpressionPrimary,
· · · PrimaryExpression: &cc.PrimaryExpression{
· · · · Case: PrimaryExpressionIdent,
· · · · Token: example.c:1:11: IDENTIFIER "x",
· · · },
· · },
· },
}

func (*AssignmentExpression) Declarator

func (n *AssignmentExpression) Declarator() *Declarator

func (*AssignmentExpression) Position

func (n *AssignmentExpression) Position() (r token.Position)

Position reports the position of the first component of n, if available.

func (*AssignmentExpression) Promote

func (n *AssignmentExpression) Promote() Type

Promote returns the type the operands of a binary operation are promoted to or the type and argument passed in a function call is promoted.

func (*AssignmentExpression) String

func (n *AssignmentExpression) String() string

String implements fmt.Stringer.

type AssignmentExpressionCase

type AssignmentExpressionCase int

AssignmentExpressionCase represents case numbers of production AssignmentExpression

const (
	AssignmentExpressionCond AssignmentExpressionCase = iota
	AssignmentExpressionAssign
	AssignmentExpressionMul
	AssignmentExpressionDiv
	AssignmentExpressionMod
	AssignmentExpressionAdd
	AssignmentExpressionSub
	AssignmentExpressionLsh
	AssignmentExpressionRsh
	AssignmentExpressionAnd
	AssignmentExpressionXor
	AssignmentExpressionOr
)

Values of type AssignmentExpressionCase

func (AssignmentExpressionCase) String

func (n AssignmentExpressionCase) String() string

String implements fmt.Stringer

type AtomicTypeSpecifier

type AtomicTypeSpecifier struct {
	Token    Token
	Token2   Token
	Token3   Token
	TypeName *TypeName
	// contains filtered or unexported fields
}

AtomicTypeSpecifier represents data reduced by production:

AtomicTypeSpecifier:
        "_Atomic" '(' TypeName ')'
Example (Case0)
fmt.Println(exampleAST(159, "_Atomic(int) i;"))
Output:

&cc.AtomicTypeSpecifier{
· Token: example.c:1:1: ATOMIC "_Atomic",
· Token2: example.c:1:8: '(' "(",
· Token3: example.c:1:12: ')' ")",
· TypeName: &cc.TypeName{
· · SpecifierQualifierList: &cc.SpecifierQualifierList{
· · · Case: SpecifierQualifierListTypeSpec,
· · · TypeSpecifier: &cc.TypeSpecifier{
· · · · Case: TypeSpecifierInt,
· · · · Token: example.c:1:9: INT "int",
· · · },
· · },
· },
}

func (*AtomicTypeSpecifier) Position

func (n *AtomicTypeSpecifier) Position() (r token.Position)

Position reports the position of the first component of n, if available.

func (*AtomicTypeSpecifier) String

func (n *AtomicTypeSpecifier) String() string

String implements fmt.Stringer.

type AttributeSpecifier

type AttributeSpecifier struct {
	AttributeValueList *AttributeValueList
	Token              Token
	Token2             Token
	Token3             Token
	Token4             Token
	Token5             Token
}

AttributeSpecifier represents data reduced by production:

AttributeSpecifier:
        "__attribute__" '(' '(' AttributeValueList ')' ')'
Example (Case0)
fmt.Println(exampleAST(274, "int i __attribute__((a));"))
Output:

&cc.AttributeSpecifier{
· AttributeValueList: &cc.AttributeValueList{
· · AttributeValue: &cc.AttributeValue{
· · · Case: AttributeValueIdent,
· · · Token: example.c:1:22: IDENTIFIER "a",
· · },
· },
· Token: example.c:1:7: ATTRIBUTE "__attribute__",
· Token2: example.c:1:20: '(' "(",
· Token3: example.c:1:21: '(' "(",
· Token4: example.c:1:23: ')' ")",
· Token5: example.c:1:24: ')' ")",
}

func (*AttributeSpecifier) Has added in v3.33.0

func (n *AttributeSpecifier) Has(key ...StringID) (*ExpressionList, bool)

Has reports whether n has any of attributes in key.

func (*AttributeSpecifier) Position

func (n *AttributeSpecifier) Position() (r token.Position)

Position reports the position of the first component of n, if available.

func (*AttributeSpecifier) String

func (n *AttributeSpecifier) String() string

String implements fmt.Stringer.

type AttributeSpecifierList

type AttributeSpecifierList struct {
	AttributeSpecifier     *AttributeSpecifier
	AttributeSpecifierList *AttributeSpecifierList
}

AttributeSpecifierList represents data reduced by productions:

AttributeSpecifierList:
        AttributeSpecifier
|       AttributeSpecifierList AttributeSpecifier
Example (Case0)
fmt.Println(exampleAST(275, "int i __attribute__((a));"))
Output:

&cc.AttributeSpecifierList{
· AttributeSpecifier: &cc.AttributeSpecifier{
· · AttributeValueList: &cc.AttributeValueList{
· · · AttributeValue: &cc.AttributeValue{
· · · · Case: AttributeValueIdent,
· · · · Token: example.c:1:22: IDENTIFIER "a",
· · · },
· · },
· · Token: example.c:1:7: ATTRIBUTE "__attribute__",
· · Token2: example.c:1:20: '(' "(",
· · Token3: example.c:1:21: '(' "(",
· · Token4: example.c:1:23: ')' ")",
· · Token5: example.c:1:24: ')' ")",
· },
}
Example (Case1)
fmt.Println(exampleAST(276, "int i __attribute__((a)) __attribute((b));"))
Output:

&cc.AttributeSpecifierList{
· AttributeSpecifier: &cc.AttributeSpecifier{
· · AttributeValueList: &cc.AttributeValueList{
· · · AttributeValue: &cc.AttributeValue{
· · · · Case: AttributeValueIdent,
· · · · Token: example.c:1:22: IDENTIFIER "a",
· · · },
· · },
· · Token: example.c:1:7: ATTRIBUTE "__attribute__",
· · Token2: example.c:1:20: '(' "(",
· · Token3: example.c:1:21: '(' "(",
· · Token4: example.c:1:23: ')' ")",
· · Token5: example.c:1:24: ')' ")",
· },
· AttributeSpecifierList: &cc.AttributeSpecifierList{
· · AttributeSpecifier: &cc.AttributeSpecifier{
· · · AttributeValueList: &cc.AttributeValueList{
· · · · AttributeValue: &cc.AttributeValue{
· · · · · Case: AttributeValueIdent,
· · · · · Token: example.c:1:39: IDENTIFIER "b",
· · · · },
· · · },
· · · Token: example.c:1:26: ATTRIBUTE "__attribute",
· · · Token2: example.c:1:37: '(' "(",
· · · Token3: example.c:1:38: '(' "(",
· · · Token4: example.c:1:40: ')' ")",
· · · Token5: example.c:1:41: ')' ")",
· · },
· },
}

func (*AttributeSpecifierList) Has added in v3.33.0

Has reports whether n has any of attributes in key.

func (*AttributeSpecifierList) Position

func (n *AttributeSpecifierList) Position() (r token.Position)

Position reports the position of the first component of n, if available.

func (*AttributeSpecifierList) String

func (n *AttributeSpecifierList) String() string

String implements fmt.Stringer.

type AttributeValue

type AttributeValue struct {
	Case           AttributeValueCase `PrettyPrint:"stringer,zero"`
	ExpressionList *ExpressionList
	Token          Token
	Token2         Token
	Token3         Token
	// contains filtered or unexported fields
}

AttributeValue represents data reduced by productions:

AttributeValue:
        IDENTIFIER                         // Case AttributeValueIdent
|       IDENTIFIER '(' ExpressionList ')'  // Case AttributeValueExpr
Example (Expr)
fmt.Println(exampleAST(271, "int i __attribute__((a(b)));"))
Output:

&cc.AttributeValue{
· Case: AttributeValueExpr,
· ExpressionList: &cc.ExpressionList{
· · AssignmentExpression: &cc.AssignmentExpression{
· · · Case: AssignmentExpressionCond,
· · · ConditionalExpression: &cc.ConditionalExpression{
· · · · Case: ConditionalExpressionLOr,
· · · · LogicalOrExpression: &cc.LogicalOrExpression{
· · · · · Case: LogicalOrExpressionLAnd,
· · · · · LogicalAndExpression: &cc.LogicalAndExpression{
· · · · · · Case: LogicalAndExpressionOr,
· · · · · · InclusiveOrExpression: &cc.InclusiveOrExpression{
· · · · · · · Case: InclusiveOrExpressionXor,
· · · · · · · ExclusiveOrExpression: &cc.ExclusiveOrExpression{
· · · · · · · · AndExpression: &cc.AndExpression{
· · · · · · · · · Case: AndExpressionEq,
· · · · · · · · · EqualityExpression: &cc.EqualityExpression{
· · · · · · · · · · Case: EqualityExpressionRel,
· · · · · · · · · · RelationalExpression: &cc.RelationalExpression{
· · · · · · · · · · · Case: RelationalExpressionShift,
· · · · · · · · · · · ShiftExpression: &cc.ShiftExpression{
· · · · · · · · · · · · AdditiveExpression: &cc.AdditiveExpression{
· · · · · · · · · · · · · Case: AdditiveExpressionMul,
· · · · · · · · · · · · · MultiplicativeExpression: &cc.MultiplicativeExpression{
· · · · · · · · · · · · · · Case: MultiplicativeExpressionCast,
· · · · · · · · · · · · · · CastExpression: &cc.CastExpression{
· · · · · · · · · · · · · · · Case: CastExpressionUnary,
· · · · · · · · · · · · · · · UnaryExpression: &cc.UnaryExpression{
· · · · · · · · · · · · · · · · Case: UnaryExpressionPostfix,
· · · · · · · · · · · · · · · · PostfixExpression: &cc.PostfixExpression{
· · · · · · · · · · · · · · · · · Case: PostfixExpressionPrimary,
· · · · · · · · · · · · · · · · · PrimaryExpression: &cc.PrimaryExpression{
· · · · · · · · · · · · · · · · · · Case: PrimaryExpressionIdent,
· · · · · · · · · · · · · · · · · · Token: example.c:1:24: IDENTIFIER "b",
· · · · · · · · · · · · · · · · · },
· · · · · · · · · · · · · · · · },
· · · · · · · · · · · · · · · },
· · · · · · · · · · · · · · },
· · · · · · · · · · · · · },
· · · · · · · · · · · · },
· · · · · · · · · · · · Case: ShiftExpressionAdd,
· · · · · · · · · · · },
· · · · · · · · · · },
· · · · · · · · · },
· · · · · · · · },
· · · · · · · · Case: ExclusiveOrExpressionAnd,
· · · · · · · },
· · · · · · },
· · · · · },
· · · · },
· · · },
· · },
· },
· Token: example.c:1:22: IDENTIFIER "a",
· Token2: example.c:1:23: '(' "(",
· Token3: example.c:1:25: ')' ")",
}
Example (Ident)
fmt.Println(exampleAST(270, "int i __attribute__((a));"))
Output:

&cc.AttributeValue{
· Case: AttributeValueIdent,
· Token: example.c:1:22: IDENTIFIER "a",
}

func (*AttributeValue) Position

func (n *AttributeValue) Position() (r token.Position)

Position reports the position of the first component of n, if available.

func (*AttributeValue) String

func (n *AttributeValue) String() string

String implements fmt.Stringer.

type AttributeValueCase

type AttributeValueCase int

AttributeValueCase represents case numbers of production AttributeValue

const (
	AttributeValueIdent AttributeValueCase = iota
	AttributeValueExpr
)

Values of type AttributeValueCase

func (AttributeValueCase) String

func (n AttributeValueCase) String() string

String implements fmt.Stringer

type AttributeValueList

type AttributeValueList struct {
	AttributeValue     *AttributeValue
	AttributeValueList *AttributeValueList
	Token              Token
}

AttributeValueList represents data reduced by productions:

AttributeValueList:
        AttributeValue
|       AttributeValueList ',' AttributeValue
Example (Case0)
fmt.Println(exampleAST(272, "int i __attribute__((a));"))
Output:

&cc.AttributeValueList{
· AttributeValue: &cc.AttributeValue{
· · Case: AttributeValueIdent,
· · Token: example.c:1:22: IDENTIFIER "a",
· },
}
Example (Case1)
fmt.Println(exampleAST(273, "int i __attribute__((a, b));"))
Output:

&cc.AttributeValueList{
· AttributeValue: &cc.AttributeValue{
· · Case: AttributeValueIdent,
· · Token: example.c:1:22: IDENTIFIER "a",
· },
· AttributeValueList: &cc.AttributeValueList{
· · AttributeValue: &cc.AttributeValue{
· · · Case: AttributeValueIdent,
· · · Token: example.c:1:25: IDENTIFIER "b",
· · },
· · Token: example.c:1:23: ',' ",",
· },
}

func (*AttributeValueList) Position

func (n *AttributeValueList) Position() (r token.Position)

Position reports the position of the first component of n, if available.

func (*AttributeValueList) String

func (n *AttributeValueList) String() string

String implements fmt.Stringer.

type BlockItem

type BlockItem struct {
	Last                  bool
	Case                  BlockItemCase `PrettyPrint:"stringer,zero"`
	CompoundStatement     *CompoundStatement
	Declaration           *Declaration
	DeclarationSpecifiers *DeclarationSpecifiers
	Declarator            *Declarator
	LabelDeclaration      *LabelDeclaration
	PragmaSTDC            *PragmaSTDC
	Statement             *Statement
	// contains filtered or unexported fields
}

BlockItem represents data reduced by productions:

BlockItem:
        Declaration                                         // Case BlockItemDecl
|       Statement                                           // Case BlockItemStmt
|       LabelDeclaration                                    // Case BlockItemLabel
|       DeclarationSpecifiers Declarator CompoundStatement  // Case BlockItemFuncDef
|       PragmaSTDC                                          // Case BlockItemPragma
Example (Decl)
fmt.Println(exampleAST(225, "int f() { int i; }"))
Output:

&cc.BlockItem{
· Case: BlockItemDecl,
· Declaration: &cc.Declaration{
· · DeclarationSpecifiers: &cc.DeclarationSpecifiers{
· · · Case: DeclarationSpecifiersTypeSpec,
· · · TypeSpecifier: &cc.TypeSpecifier{
· · · · Case: TypeSpecifierInt,
· · · · Token: example.c:1:11: INT "int",
· · · },
· · },
· · InitDeclaratorList: &cc.InitDeclaratorList{
· · · InitDeclarator: &cc.InitDeclarator{
· · · · Case: InitDeclaratorDecl,
· · · · Declarator: &cc.Declarator{
· · · · · DirectDeclarator: &cc.DirectDeclarator{
· · · · · · Case: DirectDeclaratorIdent,
· · · · · · Token: example.c:1:15: IDENTIFIER "i",
· · · · · },
· · · · },
· · · },
· · },
· · Token: example.c:1:16: ';' ";",
· },
}
Example (FuncDef)
fmt.Println(exampleAST(228, "int f() { int g() {} }"))
Output:

&cc.BlockItem{
· Case: BlockItemFuncDef,
· CompoundStatement: &cc.CompoundStatement{
· · Token: example.c:1:19: '{' "{",
· · Token2: example.c:1:20: '}' "}",
· },
· DeclarationSpecifiers: &cc.DeclarationSpecifiers{
· · Case: DeclarationSpecifiersTypeSpec,
· · TypeSpecifier: &cc.TypeSpecifier{
· · · Case: TypeSpecifierInt,
· · · Token: example.c:1:11: INT "int",
· · },
· },
· Declarator: &cc.Declarator{
· · DirectDeclarator: &cc.DirectDeclarator{
· · · Case: DirectDeclaratorFuncIdent,
· · · DirectDeclarator: &cc.DirectDeclarator{
· · · · Case: DirectDeclaratorIdent,
· · · · Token: example.c:1:15: IDENTIFIER "g",
· · · },
· · · Token: example.c:1:16: '(' "(",
· · · Token2: example.c:1:17: ')' ")",
· · },
· },
}
Example (Label)
fmt.Println(exampleAST(227, "int f() { __label__ L; }"))
Output:

&cc.BlockItem{
· Case: BlockItemLabel,
· LabelDeclaration: &cc.LabelDeclaration{
· · IdentifierList: &cc.IdentifierList{
· · · Token: example.c:1:21: IDENTIFIER "L",
· · },
· · Token: example.c:1:11: LABEL "__label__",
· · Token2: example.c:1:22: ';' ";",
· },
}
Example (Pragma)
fmt.Println(exampleAST(229, "int f() {\\n#pragma STDC FENV_ACCESS OFF\\n}"))
Output:

&cc.BlockItem{
· Case: BlockItemPragma,
· PragmaSTDC: &cc.PragmaSTDC{
· · Token: example.c:2:9: PPPRAGMASTDC "__pragma_stdc",
· · Token2: example.c:2:9: IDENTIFIER "STDC",
· · Token3: example.c:2:14: IDENTIFIER "FENV_ACCESS",
· · Token4: example.c:2:26: IDENTIFIER "OFF",
· },
}
Example (Stmt)
fmt.Println(exampleAST(226, "int f() { g(); }"))
Output:

&cc.BlockItem{
· Case: BlockItemStmt,
· Statement: &cc.Statement{
· · Case: StatementExpr,
· · ExpressionStatement: &cc.ExpressionStatement{
· · · Expression: &cc.Expression{
· · · · AssignmentExpression: &cc.AssignmentExpression{
· · · · · Case: AssignmentExpressionCond,
· · · · · ConditionalExpression: &cc.ConditionalExpression{
· · · · · · Case: ConditionalExpressionLOr,
· · · · · · LogicalOrExpression: &cc.LogicalOrExpression{
· · · · · · · Case: LogicalOrExpressionLAnd,
· · · · · · · LogicalAndExpression: &cc.LogicalAndExpression{
· · · · · · · · Case: LogicalAndExpressionOr,
· · · · · · · · InclusiveOrExpression: &cc.InclusiveOrExpression{
· · · · · · · · · Case: InclusiveOrExpressionXor,
· · · · · · · · · ExclusiveOrExpression: &cc.ExclusiveOrExpression{
· · · · · · · · · · AndExpression: &cc.AndExpression{
· · · · · · · · · · · Case: AndExpressionEq,
· · · · · · · · · · · EqualityExpression: &cc.EqualityExpression{
· · · · · · · · · · · · Case: EqualityExpressionRel,
· · · · · · · · · · · · RelationalExpression: &cc.RelationalExpression{
· · · · · · · · · · · · · Case: RelationalExpressionShift,
· · · · · · · · · · · · · ShiftExpression: &cc.ShiftExpression{
· · · · · · · · · · · · · · AdditiveExpression: &cc.AdditiveExpression{
· · · · · · · · · · · · · · · Case: AdditiveExpressionMul,
· · · · · · · · · · · · · · · MultiplicativeExpression: &cc.MultiplicativeExpression{
· · · · · · · · · · · · · · · · Case: MultiplicativeExpressionCast,
· · · · · · · · · · · · · · · · CastExpression: &cc.CastExpression{
· · · · · · · · · · · · · · · · · Case: CastExpressionUnary,
· · · · · · · · · · · · · · · · · UnaryExpression: &cc.UnaryExpression{
· · · · · · · · · · · · · · · · · · Case: UnaryExpressionPostfix,
· · · · · · · · · · · · · · · · · · PostfixExpression: &cc.PostfixExpression{
· · · · · · · · · · · · · · · · · · · Case: PostfixExpressionCall,
· · · · · · · · · · · · · · · · · · · PostfixExpression: &cc.PostfixExpression{
· · · · · · · · · · · · · · · · · · · · Case: PostfixExpressionPrimary,
· · · · · · · · · · · · · · · · · · · · PrimaryExpression: &cc.PrimaryExpression{
· · · · · · · · · · · · · · · · · · · · · Case: PrimaryExpressionIdent,
· · · · · · · · · · · · · · · · · · · · · Token: example.c:1:11: IDENTIFIER "g",
· · · · · · · · · · · · · · · · · · · · },
· · · · · · · · · · · · · · · · · · · },
· · · · · · · · · · · · · · · · · · · Token: example.c:1:12: '(' "(",
· · · · · · · · · · · · · · · · · · · Token2: example.c:1:13: ')' ")",
· · · · · · · · · · · · · · · · · · },
· · · · · · · · · · · · · · · · · },
· · · · · · · · · · · · · · · · },
· · · · · · · · · · · · · · · },
· · · · · · · · · · · · · · },
· · · · · · · · · · · · · · Case: ShiftExpressionAdd,
· · · · · · · · · · · · · },
· · · · · · · · · · · · },
· · · · · · · · · · · },
· · · · · · · · · · },
· · · · · · · · · · Case: ExclusiveOrExpressionAnd,
· · · · · · · · · },
· · · · · · · · },
· · · · · · · },
· · · · · · },
· · · · · },
· · · · },
· · · · Case: ExpressionAssign,
· · · },
· · · Token: example.c:1:14: ';' ";",
· · },
· },
}

func (*BlockItem) Closure

func (n *BlockItem) Closure() map[StringID]struct{}

Closure reports the variables closed over by a nested function (case BlockItemFuncDef).

func (*BlockItem) FunctionDefinition

func (n *BlockItem) FunctionDefinition() *FunctionDefinition

FunctionDefinition returns the nested function (case BlockItemFuncDef).

func (*BlockItem) Position

func (n *BlockItem) Position() (r token.Position)

Position reports the position of the first component of n, if available.

func (*BlockItem) String

func (n *BlockItem) String() string

String implements fmt.Stringer.

type BlockItemCase

type BlockItemCase int

BlockItemCase represents case numbers of production BlockItem

const (
	BlockItemDecl BlockItemCase = iota
	BlockItemStmt
	BlockItemLabel
	BlockItemFuncDef
	BlockItemPragma
)

Values of type BlockItemCase

func (BlockItemCase) String

func (n BlockItemCase) String() string

String implements fmt.Stringer

type BlockItemList

type BlockItemList struct {
	BlockItem     *BlockItem
	BlockItemList *BlockItemList
}

BlockItemList represents data reduced by productions:

BlockItemList:
        BlockItem
|       BlockItemList BlockItem
Example (Case0)
fmt.Println(exampleAST(223, "int f() { int i; }"))
Output:

&cc.BlockItemList{
· BlockItem: &cc.BlockItem{
· · Case: BlockItemDecl,
· · Declaration: &cc.Declaration{
· · · DeclarationSpecifiers: &cc.DeclarationSpecifiers{
· · · · Case: DeclarationSpecifiersTypeSpec,
· · · · TypeSpecifier: &cc.TypeSpecifier{
· · · · · Case: TypeSpecifierInt,
· · · · · Token: example.c:1:11: INT "int",
· · · · },
· · · },
· · · InitDeclaratorList: &cc.InitDeclaratorList{
· · · · InitDeclarator: &cc.InitDeclarator{
· · · · · Case: InitDeclaratorDecl,
· · · · · Declarator: &cc.Declarator{
· · · · · · DirectDeclarator: &cc.DirectDeclarator{
· · · · · · · Case: DirectDeclaratorIdent,
· · · · · · · Token: example.c:1:15: IDENTIFIER "i",
· · · · · · },
· · · · · },
· · · · },
· · · },
· · · Token: example.c:1:16: ';' ";",
· · },
· },
}
Example (Case1)
fmt.Println(exampleAST(224, "int f() { int i; double j; }"))
Output:

&cc.BlockItemList{
· BlockItem: &cc.BlockItem{
· · Case: BlockItemDecl,
· · Declaration: &cc.Declaration{
· · · DeclarationSpecifiers: &cc.DeclarationSpecifiers{
· · · · Case: DeclarationSpecifiersTypeSpec,
· · · · TypeSpecifier: &cc.TypeSpecifier{
· · · · · Case: TypeSpecifierInt,
· · · · · Token: example.c:1:11: INT "int",
· · · · },
· · · },
· · · InitDeclaratorList: &cc.InitDeclaratorList{
· · · · InitDeclarator: &cc.InitDeclarator{
· · · · · Case: InitDeclaratorDecl,
· · · · · Declarator: &cc.Declarator{
· · · · · · DirectDeclarator: &cc.DirectDeclarator{
· · · · · · · Case: DirectDeclaratorIdent,
· · · · · · · Token: example.c:1:15: IDENTIFIER "i",
· · · · · · },
· · · · · },
· · · · },
· · · },
· · · Token: example.c:1:16: ';' ";",
· · },
· },
· BlockItemList: &cc.BlockItemList{
· · BlockItem: &cc.BlockItem{
· · · Case: BlockItemDecl,
· · · Declaration: &cc.Declaration{
· · · · DeclarationSpecifiers: &cc.DeclarationSpecifiers{
· · · · · Case: DeclarationSpecifiersTypeSpec,
· · · · · TypeSpecifier: &cc.TypeSpecifier{
· · · · · · Case: TypeSpecifierDouble,
· · · · · · Token: example.c:1:18: DOUBLE "double",
· · · · · },
· · · · },
· · · · InitDeclaratorList: &cc.InitDeclaratorList{
· · · · · InitDeclarator: &cc.InitDeclarator{
· · · · · · Case: InitDeclaratorDecl,
· · · · · · Declarator: &cc.Declarator{
· · · · · · · DirectDeclarator: &cc.DirectDeclarator{
· · · · · · · · Case: DirectDeclaratorIdent,
· · · · · · · · Token: example.c:1:25: IDENTIFIER "j",
· · · · · · · },
· · · · · · },
· · · · · },
· · · · },
· · · · Token: example.c:1:26: ';' ";",
· · · },
· · },
· },
}

func (*BlockItemList) Position

func (n *BlockItemList) Position() (r token.Position)

Position reports the position of the first component of n, if available.

func (*BlockItemList) String

func (n *BlockItemList) String() string

String implements fmt.Stringer.

type CastExpression

type CastExpression struct {
	Operand           Operand
	IsSideEffectsFree bool
	Case              CastExpressionCase `PrettyPrint:"stringer,zero"`
	CastExpression    *CastExpression
	Token             Token
	Token2            Token
	TypeName          *TypeName
	UnaryExpression   *UnaryExpression
}

CastExpression represents data reduced by productions:

CastExpression:
        UnaryExpression                  // Case CastExpressionUnary
|       '(' TypeName ')' CastExpression  // Case CastExpressionCast
Example (Cast)
fmt.Println(exampleAST(40, "int i = (int)3.14;"))
Output:

&cc.CastExpression{
· Case: CastExpressionCast,
· CastExpression: &cc.CastExpression{
· · Case: CastExpressionUnary,
· · UnaryExpression: &cc.UnaryExpression{
· · · Case: UnaryExpressionPostfix,
· · · PostfixExpression: &cc.PostfixExpression{
· · · · Case: PostfixExpressionPrimary,
· · · · PrimaryExpression: &cc.PrimaryExpression{
· · · · · Case: PrimaryExpressionFloat,
· · · · · Token: example.c:1:14: FLOATCONST "3.14",
· · · · },
· · · },
· · },
· },
· Token: example.c:1:9: '(' "(",
· Token2: example.c:1:13: ')' ")",
· TypeName: &cc.TypeName{
· · SpecifierQualifierList: &cc.SpecifierQualifierList{
· · · Case: SpecifierQualifierListTypeSpec,
· · · TypeSpecifier: &cc.TypeSpecifier{
· · · · Case: TypeSpecifierInt,
· · · · Token: example.c:1:10: INT "int",
· · · },
· · },
· },
}
Example (Unary)
fmt.Println(exampleAST(39, "int i = 42;"))
Output:

&cc.CastExpression{
· Case: CastExpressionUnary,
· UnaryExpression: &cc.UnaryExpression{
· · Case: UnaryExpressionPostfix,
· · PostfixExpression: &cc.PostfixExpression{
· · · Case: PostfixExpressionPrimary,
· · · PrimaryExpression: &cc.PrimaryExpression{
· · · · Case: PrimaryExpressionInt,
· · · · Token: example.c:1:9: INTCONST "42",
· · · },
· · },
· },
}

func (*CastExpression) Declarator

func (n *CastExpression) Declarator() *Declarator

func (*CastExpression) Position

func (n *CastExpression) Position() (r token.Position)

Position reports the position of the first component of n, if available.

func (*CastExpression) String

func (n *CastExpression) String() string

String implements fmt.Stringer.

type CastExpressionCase

type CastExpressionCase int

CastExpressionCase represents case numbers of production CastExpression

const (
	CastExpressionUnary CastExpressionCase = iota
	CastExpressionCast
)

Values of type CastExpressionCase

func (CastExpressionCase) String

func (n CastExpressionCase) String() string

String implements fmt.Stringer

type Complex128Value

type Complex128Value complex128

func (Complex128Value) IsConst added in v3.33.6

func (v Complex128Value) IsConst() bool

func (Complex128Value) IsNonZero added in v3.33.6

func (v Complex128Value) IsNonZero() bool

func (Complex128Value) IsZero added in v3.33.6

func (v Complex128Value) IsZero() bool

type Complex256Value

type Complex256Value struct {
	Re, Im *Float128Value
}

func (Complex256Value) IsConst added in v3.33.6

func (v Complex256Value) IsConst() bool

func (Complex256Value) IsNonZero added in v3.33.6

func (v Complex256Value) IsNonZero() bool

func (Complex256Value) IsZero added in v3.33.6

func (v Complex256Value) IsZero() bool

type Complex64Value

type Complex64Value complex64

func (Complex64Value) IsConst added in v3.33.6

func (v Complex64Value) IsConst() bool

func (Complex64Value) IsNonZero added in v3.33.6

func (v Complex64Value) IsNonZero() bool

func (Complex64Value) IsZero added in v3.33.6

func (v Complex64Value) IsZero() bool

type CompoundStatement

type CompoundStatement struct {
	Operand Operand

	BlockItemList *BlockItemList
	Token         Token
	Token2        Token
	// contains filtered or unexported fields
}

CompoundStatement represents data reduced by production:

CompoundStatement:
        '{' BlockItemList '}'
Example (Case0)
fmt.Println(exampleAST(222, "int f() { int i; }"))
Output:

&cc.CompoundStatement{
· BlockItemList: &cc.BlockItemList{
· · BlockItem: &cc.BlockItem{
· · · Case: BlockItemDecl,
· · · Declaration: &cc.Declaration{
· · · · DeclarationSpecifiers: &cc.DeclarationSpecifiers{
· · · · · Case: DeclarationSpecifiersTypeSpec,
· · · · · TypeSpecifier: &cc.TypeSpecifier{
· · · · · · Case: TypeSpecifierInt,
· · · · · · Token: example.c:1:11: INT "int",
· · · · · },
· · · · },
· · · · InitDeclaratorList: &cc.InitDeclaratorList{
· · · · · InitDeclarator: &cc.InitDeclarator{
· · · · · · Case: InitDeclaratorDecl,
· · · · · · Declarator: &cc.Declarator{
· · · · · · · DirectDeclarator: &cc.DirectDeclarator{
· · · · · · · · Case: DirectDeclaratorIdent,
· · · · · · · · Token: example.c:1:15: IDENTIFIER "i",
· · · · · · · },
· · · · · · },
· · · · · },
· · · · },
· · · · Token: example.c:1:16: ';' ";",
· · · },
· · },
· },
· Token: example.c:1:9: '{' "{",
· Token2: example.c:1:18: '}' "}",
}

func (*CompoundStatement) Children

func (n *CompoundStatement) Children() []*CompoundStatement

Children returns the list of n's children.

func (*CompoundStatement) Declarations

func (n *CompoundStatement) Declarations() []*Declaration

Declarations returns the list of declarations in n.

func (*CompoundStatement) IsJumpTarget

func (n *CompoundStatement) IsJumpTarget() bool

IsJumpTarget returns whether n or any of its children contain a named labeled statement.

func (*CompoundStatement) LabeledStatements

func (n *CompoundStatement) LabeledStatements() []*LabeledStatement

LabeledStatements returns labeled statements of n.

func (*CompoundStatement) Parent

func (n *CompoundStatement) Parent() *CompoundStatement

Parent returns the CompoundStatement that contains n, if any.

func (*CompoundStatement) Position

func (n *CompoundStatement) Position() (r token.Position)

Position reports the position of the first component of n, if available.

func (*CompoundStatement) String

func (n *CompoundStatement) String() string

String implements fmt.Stringer.

type ConditionalExpression

type ConditionalExpression struct {
	Operand               Operand
	IsSideEffectsFree     bool
	Case                  ConditionalExpressionCase `PrettyPrint:"stringer,zero"`
	ConditionalExpression *ConditionalExpression
	Expression            *Expression
	LogicalOrExpression   *LogicalOrExpression
	Token                 Token
	Token2                Token
}

ConditionalExpression represents data reduced by productions:

ConditionalExpression:
        LogicalOrExpression                                           // Case ConditionalExpressionLOr
|       LogicalOrExpression '?' Expression ':' ConditionalExpression  // Case ConditionalExpressionCond
Example (Cond)
fmt.Println(exampleAST(70, "int i = x ? y : z;"))
Output:

&cc.ConditionalExpression{
· Case: ConditionalExpressionCond,
· ConditionalExpression: &cc.ConditionalExpression{
· · Case: ConditionalExpressionLOr,
· · LogicalOrExpression: &cc.LogicalOrExpression{
· · · Case: LogicalOrExpressionLAnd,
· · · LogicalAndExpression: &cc.LogicalAndExpression{
· · · · Case: LogicalAndExpressionOr,
· · · · InclusiveOrExpression: &cc.InclusiveOrExpression{
· · · · · Case: InclusiveOrExpressionXor,
· · · · · ExclusiveOrExpression: &cc.ExclusiveOrExpression{
· · · · · · AndExpression: &cc.AndExpression{
· · · · · · · Case: AndExpressionEq,
· · · · · · · EqualityExpression: &cc.EqualityExpression{
· · · · · · · · Case: EqualityExpressionRel,
· · · · · · · · RelationalExpression: &cc.RelationalExpression{
· · · · · · · · · Case: RelationalExpressionShift,
· · · · · · · · · ShiftExpression: &cc.ShiftExpression{
· · · · · · · · · · AdditiveExpression: &cc.AdditiveExpression{
· · · · · · · · · · · Case: AdditiveExpressionMul,
· · · · · · · · · · · MultiplicativeExpression: &cc.MultiplicativeExpression{
· · · · · · · · · · · · Case: MultiplicativeExpressionCast,
· · · · · · · · · · · · CastExpression: &cc.CastExpression{
· · · · · · · · · · · · · Case: CastExpressionUnary,
· · · · · · · · · · · · · UnaryExpression: &cc.UnaryExpression{
· · · · · · · · · · · · · · Case: UnaryExpressionPostfix,
· · · · · · · · · · · · · · PostfixExpression: &cc.PostfixExpression{
· · · · · · · · · · · · · · · Case: PostfixExpressionPrimary,
· · · · · · · · · · · · · · · PrimaryExpression: &cc.PrimaryExpression{
· · · · · · · · · · · · · · · · Case: PrimaryExpressionIdent,
· · · · · · · · · · · · · · · · Token: example.c:1:17: IDENTIFIER "z",
· · · · · · · · · · · · · · · },
· · · · · · · · · · · · · · },
· · · · · · · · · · · · · },
· · · · · · · · · · · · },
· · · · · · · · · · · },
· · · · · · · · · · },
· · · · · · · · · · Case: ShiftExpressionAdd,
· · · · · · · · · },
· · · · · · · · },
· · · · · · · },
· · · · · · },
· · · · · · Case: ExclusiveOrExpressionAnd,
· · · · · },
· · · · },
· · · },
· · },
· },
· Expression: &cc.Expression{
· · AssignmentExpression: &cc.AssignmentExpression{
· · · Case: AssignmentExpressionCond,
· · · ConditionalExpression: &cc.ConditionalExpression{
· · · · Case: ConditionalExpressionLOr,
· · · · LogicalOrExpression: &cc.LogicalOrExpression{
· · · · · Case: LogicalOrExpressionLAnd,
· · · · · LogicalAndExpression: &cc.LogicalAndExpression{
· · · · · · Case: LogicalAndExpressionOr,
· · · · · · InclusiveOrExpression: &cc.InclusiveOrExpression{
· · · · · · · Case: InclusiveOrExpressionXor,
· · · · · · · ExclusiveOrExpression: &cc.ExclusiveOrExpression{
· · · · · · · · AndExpression: &cc.AndExpression{
· · · · · · · · · Case: AndExpressionEq,
· · · · · · · · · EqualityExpression: &cc.EqualityExpression{
· · · · · · · · · · Case: EqualityExpressionRel,
· · · · · · · · · · RelationalExpression: &cc.RelationalExpression{
· · · · · · · · · · · Case: RelationalExpressionShift,
· · · · · · · · · · · ShiftExpression: &cc.ShiftExpression{
· · · · · · · · · · · · AdditiveExpression: &cc.AdditiveExpression{
· · · · · · · · · · · · · Case: AdditiveExpressionMul,
· · · · · · · · · · · · · MultiplicativeExpression: &cc.MultiplicativeExpression{
· · · · · · · · · · · · · · Case: MultiplicativeExpressionCast,
· · · · · · · · · · · · · · CastExpression: &cc.CastExpression{
· · · · · · · · · · · · · · · Case: CastExpressionUnary,
· · · · · · · · · · · · · · · UnaryExpression: &cc.UnaryExpression{
· · · · · · · · · · · · · · · · Case: UnaryExpressionPostfix,
· · · · · · · · · · · · · · · · PostfixExpression: &cc.PostfixExpression{
· · · · · · · · · · · · · · · · · Case: PostfixExpressionPrimary,
· · · · · · · · · · · · · · · · · PrimaryExpression: &cc.PrimaryExpression{
· · · · · · · · · · · · · · · · · · Case: PrimaryExpressionIdent,
· · · · · · · · · · · · · · · · · · Token: example.c:1:13: IDENTIFIER "y",
· · · · · · · · · · · · · · · · · },
· · · · · · · · · · · · · · · · },
· · · · · · · · · · · · · · · },
· · · · · · · · · · · · · · },
· · · · · · · · · · · · · },
· · · · · · · · · · · · },
· · · · · · · · · · · · Case: ShiftExpressionAdd,
· · · · · · · · · · · },
· · · · · · · · · · },
· · · · · · · · · },
· · · · · · · · },
· · · · · · · · Case: ExclusiveOrExpressionAnd,
· · · · · · · },
· · · · · · },
· · · · · },
· · · · },
· · · },
· · },
· · Case: ExpressionAssign,
· },
· LogicalOrExpression: &cc.LogicalOrExpression{
· · Case: LogicalOrExpressionLAnd,
· · LogicalAndExpression: &cc.LogicalAndExpression{
· · · Case: LogicalAndExpressionOr,
· · · InclusiveOrExpression: &cc.InclusiveOrExpression{
· · · · Case: InclusiveOrExpressionXor,
· · · · ExclusiveOrExpression: &cc.ExclusiveOrExpression{
· · · · · AndExpression: &cc.AndExpression{
· · · · · · Case: AndExpressionEq,
· · · · · · EqualityExpression: &cc.EqualityExpression{
· · · · · · · Case: EqualityExpressionRel,
· · · · · · · RelationalExpression: &cc.RelationalExpression{
· · · · · · · · Case: RelationalExpressionShift,
· · · · · · · · ShiftExpression: &cc.ShiftExpression{
· · · · · · · · · AdditiveExpression: &cc.AdditiveExpression{
· · · · · · · · · · Case: AdditiveExpressionMul,
· · · · · · · · · · MultiplicativeExpression: &cc.MultiplicativeExpression{
· · · · · · · · · · · Case: MultiplicativeExpressionCast,
· · · · · · · · · · · CastExpression: &cc.CastExpression{
· · · · · · · · · · · · Case: CastExpressionUnary,
· · · · · · · · · · · · UnaryExpression: &cc.UnaryExpression{
· · · · · · · · · · · · · Case: UnaryExpressionPostfix,
· · · · · · · · · · · · · PostfixExpression: &cc.PostfixExpression{
· · · · · · · · · · · · · · Case: PostfixExpressionPrimary,
· · · · · · · · · · · · · · PrimaryExpression: &cc.PrimaryExpression{
· · · · · · · · · · · · · · · Case: PrimaryExpressionIdent,
· · · · · · · · · · · · · · · Token: example.c:1:9: IDENTIFIER "x",
· · · · · · · · · · · · · · },
· · · · · · · · · · · · · },
· · · · · · · · · · · · },
· · · · · · · · · · · },
· · · · · · · · · · },
· · · · · · · · · },
· · · · · · · · · Case: ShiftExpressionAdd,
· · · · · · · · },
· · · · · · · },
· · · · · · },
· · · · · },
· · · · · Case: ExclusiveOrExpressionAnd,
· · · · },
· · · },
· · },
· },
· Token: example.c:1:11: '?' "?",
· Token2: example.c:1:15: ':' ":",
}
Example (LOr)
fmt.Println(exampleAST(69, "int i = x;"))
Output:

&cc.ConditionalExpression{
· Case: ConditionalExpressionLOr,
· LogicalOrExpression: &cc.LogicalOrExpression{
· · Case: LogicalOrExpressionLAnd,
· · LogicalAndExpression: &cc.LogicalAndExpression{
· · · Case: LogicalAndExpressionOr,
· · · InclusiveOrExpression: &cc.InclusiveOrExpression{
· · · · Case: InclusiveOrExpressionXor,
· · · · ExclusiveOrExpression: &cc.ExclusiveOrExpression{
· · · · · AndExpression: &cc.AndExpression{
· · · · · · Case: AndExpressionEq,
· · · · · · EqualityExpression: &cc.EqualityExpression{
· · · · · · · Case: EqualityExpressionRel,
· · · · · · · RelationalExpression: &cc.RelationalExpression{
· · · · · · · · Case: RelationalExpressionShift,
· · · · · · · · ShiftExpression: &cc.ShiftExpression{
· · · · · · · · · AdditiveExpression: &cc.AdditiveExpression{
· · · · · · · · · · Case: AdditiveExpressionMul,
· · · · · · · · · · MultiplicativeExpression: &cc.MultiplicativeExpression{
· · · · · · · · · · · Case: MultiplicativeExpressionCast,
· · · · · · · · · · · CastExpression: &cc.CastExpression{
· · · · · · · · · · · · Case: CastExpressionUnary,
· · · · · · · · · · · · UnaryExpression: &cc.UnaryExpression{
· · · · · · · · · · · · · Case: UnaryExpressionPostfix,
· · · · · · · · · · · · · PostfixExpression: &cc.PostfixExpression{
· · · · · · · · · · · · · · Case: PostfixExpressionPrimary,
· · · · · · · · · · · · · · PrimaryExpression: &cc.PrimaryExpression{
· · · · · · · · · · · · · · · Case: PrimaryExpressionIdent,
· · · · · · · · · · · · · · · Token: example.c:1:9: IDENTIFIER "x",
· · · · · · · · · · · · · · },
· · · · · · · · · · · · · },
· · · · · · · · · · · · },
· · · · · · · · · · · },
· · · · · · · · · · },
· · · · · · · · · },
· · · · · · · · · Case: ShiftExpressionAdd,
· · · · · · · · },
· · · · · · · },
· · · · · · },
· · · · · },
· · · · · Case: ExclusiveOrExpressionAnd,
· · · · },
· · · },
· · },
· },
}

func (*ConditionalExpression) Declarator

func (n *ConditionalExpression) Declarator() *Declarator

func (*ConditionalExpression) Position

func (n *ConditionalExpression) Position() (r token.Position)

Position reports the position of the first component of n, if available.

func (*ConditionalExpression) String

func (n *ConditionalExpression) String() string

String implements fmt.Stringer.

type ConditionalExpressionCase

type ConditionalExpressionCase int

ConditionalExpressionCase represents case numbers of production ConditionalExpression

const (
	ConditionalExpressionLOr ConditionalExpressionCase = iota
	ConditionalExpressionCond
)

Values of type ConditionalExpressionCase

func (ConditionalExpressionCase) String

func (n ConditionalExpressionCase) String() string

String implements fmt.Stringer

type Config

type Config struct {
	Config3
	ABI ABI

	PragmaHandler func(Pragma, []Token) // Called on pragmas, other than #pragma STDC ..., if non nil

	// SharedFunctionDefinitions collects function definitions having the same
	// position and definition. This can happen, for example, when a function is
	// defined in a header file included multiple times. Either within a single
	// translation unit or across translation units. In the later case just supply
	// the same SharedFunctionDefinitions in Config when translating/parsing each
	// translation unit.
	SharedFunctionDefinitions *SharedFunctionDefinitions

	// IncludeFileHandler, when non nil, is called by the preprocessor for every
	// successfully included file.
	IncludeFileHandler func(pos gotoken.Position, includePath string)

	MaxErrors int // 0: default (10), < 0: unlimited, n: n.

	CheckExternInlineFnBodies              bool // Translate will consider extern inline function bodies.
	DebugIncludePaths                      bool // Output to stderr.
	DebugWorkingDir                        bool // Output to stderr.
	DoNotTypecheckAsm                      bool
	EnableAssignmentCompatibilityChecking  bool // No such checks performed up to v3.31.0. Currently only partially implemented.
	FixBitfieldPadding                     bool // Fix a bug in calculating field positions after a bitfield.
	InjectTracingCode                      bool // Output to stderr.
	LongDoubleIsDouble                     bool
	PreprocessOnly                         bool
	RejectAnonymousFields                  bool // Pedantic: do not silently accept "struct{int;}".
	RejectCaseRange                        bool // Pedantic: do not silently accept "case 'a'...'z':".
	RejectEmptyCompositeLiterals           bool // Pedantic: do not silently accept "foo = (T){}".
	RejectEmptyDeclarations                bool // Pedantic: do not silently accept "int foo(){};".
	RejectEmptyFields                      bool // Pedantic: do not silently accept "struct {int a;;} foo;".
	RejectEmptyInitializerList             bool // Pedantic: do not silently accept "foo f = {};".
	RejectEmptyStructDeclaration           bool // Pedantic: do not silently accept "struct{; int i}".
	RejectEmptyStructs                     bool // Pedantic: do not silently accept "struct foo {};".
	RejectIncompatibleMacroRedef           bool // Pedantic: do not silently accept "#define MIN(A,B) ...\n#define MIN(a,b) ...\n" etc.
	RejectLabelValues                      bool // Pedantic: do not silently accept "foo: bar(); void *ptr = &&foo;" or "goto *ptr".
	RejectLateBinding                      bool // Pedantic: do not silently accept void f() { g(); } void g() {}
	RejectMissingConditionalExpr           bool // Pedantic: do not silently accept "foo = bar ? : baz;".
	RejectMissingDeclarationSpecifiers     bool // Pedantic: do not silently accept "main() {}".
	RejectMissingFinalStructFieldSemicolon bool // Pedantic: do not silently accept "struct{int i; int j}".
	RejectNestedFunctionDefinitions        bool // Pedantic: do not silently accept nested function definitons.
	RejectParamSemicolon                   bool // Pedantic: do not silently accept "int f(int a; int b)".
	RejectStatementExpressions             bool // Pedantic: do not silently accept "i = ({foo();})".
	RejectTypeof                           bool // Pedantic: do not silently accept "typeof foo" or "typeof(bar*)".
	RejectUninitializedDeclarators         bool // Reject int f() { int j; return j; }
	TrackAssignments                       bool // Collect a list of LHS declarators a declarator is used in RHS or as an function argument.
	// contains filtered or unexported fields
}

Config amends behavior of translation phase 4 and above. Instances of Config are not mutated by this package and it's safe to share/reuse them.

The *Config passed to Parse or Translate should not be mutated afterwards.

type Config3

type Config3 struct {
	// If IgnoreInclude is not nil, its MatchString method will be called by the
	// preprocessor with the argument any include directive expands to. If the call
	// evaluates to is true the include directive will be ignored completely.
	IgnoreInclude *regexp.Regexp

	// Name of a macro to use instead of FD_ZERO.
	//
	// Note: Temporary solution will be removed/replaced
	ReplaceMacroFdZero string
	// Name of a macro to use instead of TCL_DEFAULT_DOUBLE_ROUNDING.
	//
	// Note: Temporary solution will be removed/replaced
	ReplaceMacroTclDefaultDoubleRounding string // Name of a macro to use instead of TCL_DEFAULT_DOUBLE_ROUNDING. Note: Temporrary solution will be removed/replaced
	// Name of a macro to use instead of TCL_IEEE_DOUBLE_ROUNDING.
	//
	// Note: Temporary solution will be removed/replaced
	ReplaceMacroTclIeeeDoubleRounding string

	WorkingDir string     // Overrides os.Getwd if non empty.
	Filesystem Filesystem // Overrides filesystem access if not empty.

	MaxSourceLine int // Zero: Scanner will use default buffer. Non zero: Scanner will use max(default buffer size, MaxSourceLine).

	// DisableBuiltinResolution disables resolution of undefined identifiers such
	// that eg. abort, becomes the same as __builtin_abort, prototype of which is
	// expected to be provided by one of the sources passed to Parse, Preprocess or
	// Translate.
	DisableBuiltinResolution bool

	DisableTrigraphs bool // GCC ignores them unless -trigraphs is used: https://gcc.gnu.org/onlinedocs/cpp/Initial-processing.html
	GCCStructs       bool // Assume __attribute__(gcc_struct) applied to structs by default.
	//TODO MSStructs                               bool // Assume __attribute__(ms_struct) applied to structs by default.
	NoFieldAndBitfieldOverlap               bool // Only bitfields can be grouped together.
	PreserveOnlyLastNonBlankSeparator       bool // If PreserveWhiteSpace is true, keep only the last white space, do not combine
	PreserveWhiteSpace                      bool // Including also comments.
	RejectElseExtraTokens                   bool // Pedantic: do not silently accept "#else foo".
	RejectEndifExtraTokens                  bool // Pedantic: do not silently accept "#endif foo".
	RejectFinalBackslash                    bool // Pedantic: do not silently accept "foo\\\n".
	RejectFunctionMacroEmptyReplacementList bool // Pedantic: do not silently accept "#define foo(bar)\n".
	RejectIfdefExtraTokens                  bool // Pedantic: do not silently accept "#ifdef foo bar".
	RejectIfndefExtraTokens                 bool // Pedantic: do not silently accept "#ifndef foo bar".
	RejectIncludeNext                       bool // Pedantic: do not silently accept "#include_next".
	RejectInvalidVariadicMacros             bool // Pedantic: do not silently accept "#define foo(bar...)". Standard allows only #define foo(bar, ...)
	RejectLineExtraTokens                   bool // Pedantic: do not silently accept "#line 1234 \"foo.c\" bar".
	RejectMissingFinalNewline               bool // Pedantic: do not silently accept "foo\nbar".
	RejectUndefExtraTokens                  bool // Pedantic: do not silently accept "#undef foo bar".
	UnsignedEnums                           bool // GCC compatibility: enums with no negative values will have unsigned type.
}

Config3 amends behavior of translation phases 1 to 3.

type ConstantExpression

type ConstantExpression struct {
	Operand               Operand
	ConditionalExpression *ConditionalExpression
}

ConstantExpression represents data reduced by production:

ConstantExpression:
        ConditionalExpression
Example (Case0)
fmt.Println(exampleAST(85, "struct { int i:3; };"))
Output:

&cc.ConstantExpression{
· ConditionalExpression: &cc.ConditionalExpression{
· · Case: ConditionalExpressionLOr,
· · LogicalOrExpression: &cc.LogicalOrExpression{
· · · Case: LogicalOrExpressionLAnd,
· · · LogicalAndExpression: &cc.LogicalAndExpression{
· · · · Case: LogicalAndExpressionOr,
· · · · InclusiveOrExpression: &cc.InclusiveOrExpression{
· · · · · Case: InclusiveOrExpressionXor,
· · · · · ExclusiveOrExpression: &cc.ExclusiveOrExpression{
· · · · · · AndExpression: &cc.AndExpression{
· · · · · · · Case: AndExpressionEq,
· · · · · · · EqualityExpression: &cc.EqualityExpression{
· · · · · · · · Case: EqualityExpressionRel,
· · · · · · · · RelationalExpression: &cc.RelationalExpression{
· · · · · · · · · Case: RelationalExpressionShift,
· · · · · · · · · ShiftExpression: &cc.ShiftExpression{
· · · · · · · · · · AdditiveExpression: &cc.AdditiveExpression{
· · · · · · · · · · · Case: AdditiveExpressionMul,
· · · · · · · · · · · MultiplicativeExpression: &cc.MultiplicativeExpression{
· · · · · · · · · · · · Case: MultiplicativeExpressionCast,
· · · · · · · · · · · · CastExpression: &cc.CastExpression{
· · · · · · · · · · · · · Case: CastExpressionUnary,
· · · · · · · · · · · · · UnaryExpression: &cc.UnaryExpression{
· · · · · · · · · · · · · · Case: UnaryExpressionPostfix,
· · · · · · · · · · · · · · PostfixExpression: &cc.PostfixExpression{
· · · · · · · · · · · · · · · Case: PostfixExpressionPrimary,
· · · · · · · · · · · · · · · PrimaryExpression: &cc.PrimaryExpression{
· · · · · · · · · · · · · · · · Case: PrimaryExpressionInt,
· · · · · · · · · · · · · · · · Token: example.c:1:16: INTCONST "3",
· · · · · · · · · · · · · · · },
· · · · · · · · · · · · · · },
· · · · · · · · · · · · · },
· · · · · · · · · · · · },
· · · · · · · · · · · },
· · · · · · · · · · },
· · · · · · · · · · Case: ShiftExpressionAdd,
· · · · · · · · · },
· · · · · · · · },
· · · · · · · },
· · · · · · },
· · · · · · Case: ExclusiveOrExpressionAnd,
· · · · · },
· · · · },
· · · },
· · },
· },
}

func (*ConstantExpression) Position

func (n *ConstantExpression) Position() (r token.Position)

Position reports the position of the first component of n, if available.

func (*ConstantExpression) String

func (n *ConstantExpression) String() string

String implements fmt.Stringer.

type Declaration

type Declaration struct {
	DeclarationSpecifiers *DeclarationSpecifiers
	InitDeclaratorList    *InitDeclaratorList
	Token                 Token
}

Declaration represents data reduced by production:

Declaration:
        DeclarationSpecifiers InitDeclaratorList ';'
Example (Case0)
fmt.Println(exampleAST(86, "int i, j;"))
Output:

&cc.Declaration{
· DeclarationSpecifiers: &cc.DeclarationSpecifiers{
· · Case: DeclarationSpecifiersTypeSpec,
· · TypeSpecifier: &cc.TypeSpecifier{
· · · Case: TypeSpecifierInt,
· · · Token: example.c:1:1: INT "int",
· · },
· },
· InitDeclaratorList: &cc.InitDeclaratorList{
· · InitDeclarator: &cc.InitDeclarator{
· · · Case: InitDeclaratorDecl,
· · · Declarator: &cc.Declarator{
· · · · DirectDeclarator: &cc.DirectDeclarator{
· · · · · Case: DirectDeclaratorIdent,
· · · · · Token: example.c:1:5: IDENTIFIER "i",
· · · · },
· · · },
· · },
· · InitDeclaratorList: &cc.InitDeclaratorList{
· · · InitDeclarator: &cc.InitDeclarator{
· · · · Case: InitDeclaratorDecl,
· · · · Declarator: &cc.Declarator{
· · · · · DirectDeclarator: &cc.DirectDeclarator{
· · · · · · Case: DirectDeclaratorIdent,
· · · · · · Token: example.c:1:8: IDENTIFIER "j",
· · · · · },
· · · · },
· · · },
· · · Token: example.c:1:6: ',' ",",
· · },
· },
· Token: example.c:1:9: ';' ";",
}

func (*Declaration) Position

func (n *Declaration) Position() (r token.Position)

Position reports the position of the first component of n, if available.

func (*Declaration) String

func (n *Declaration) String() string

String implements fmt.Stringer.

type DeclarationList

type DeclarationList struct {
	Declaration     *Declaration
	DeclarationList *DeclarationList
}

DeclarationList represents data reduced by productions:

DeclarationList:
        Declaration
|       DeclarationList Declaration
Example (Case0)
fmt.Println(exampleAST(252, "int f(i) int i; {}"))
Output:

&cc.DeclarationList{
· Declaration: &cc.Declaration{
· · DeclarationSpecifiers: &cc.DeclarationSpecifiers{
· · · Case: DeclarationSpecifiersTypeSpec,
· · · TypeSpecifier: &cc.TypeSpecifier{
· · · · Case: TypeSpecifierInt,
· · · · Token: example.c:1:10: INT "int",
· · · },
· · },
· · InitDeclaratorList: &cc.InitDeclaratorList{
· · · InitDeclarator: &cc.InitDeclarator{
· · · · Case: InitDeclaratorDecl,
· · · · Declarator: &cc.Declarator{
· · · · · DirectDeclarator: &cc.DirectDeclarator{
· · · · · · Case: DirectDeclaratorIdent,
· · · · · · Token: example.c:1:14: IDENTIFIER "i",
· · · · · },
· · · · },
· · · },
· · },
· · Token: example.c:1:15: ';' ";",
· },
}
Example (Case1)
fmt.Println(exampleAST(253, "int f(i, j) int i; int j; {}"))
Output:

&cc.DeclarationList{
· Declaration: &cc.Declaration{
· · DeclarationSpecifiers: &cc.DeclarationSpecifiers{
· · · Case: DeclarationSpecifiersTypeSpec,
· · · TypeSpecifier: &cc.TypeSpecifier{
· · · · Case: TypeSpecifierInt,
· · · · Token: example.c:1:13: INT "int",
· · · },
· · },
· · InitDeclaratorList: &cc.InitDeclaratorList{
· · · InitDeclarator: &cc.InitDeclarator{
· · · · Case: InitDeclaratorDecl,
· · · · Declarator: &cc.Declarator{
· · · · · DirectDeclarator: &cc.DirectDeclarator{
· · · · · · Case: DirectDeclaratorIdent,
· · · · · · Token: example.c:1:17: IDENTIFIER "i",
· · · · · },
· · · · },
· · · },
· · },
· · Token: example.c:1:18: ';' ";",
· },
· DeclarationList: &cc.DeclarationList{
· · Declaration: &cc.Declaration{
· · · DeclarationSpecifiers: &cc.DeclarationSpecifiers{
· · · · Case: DeclarationSpecifiersTypeSpec,
· · · · TypeSpecifier: &cc.TypeSpecifier{
· · · · · Case: TypeSpecifierInt,
· · · · · Token: example.c:1:20: INT "int",
· · · · },
· · · },
· · · InitDeclaratorList: &cc.InitDeclaratorList{
· · · · InitDeclarator: &cc.InitDeclarator{
· · · · · Case: InitDeclaratorDecl,
· · · · · Declarator: &cc.Declarator{
· · · · · · DirectDeclarator: &cc.DirectDeclarator{
· · · · · · · Case: DirectDeclaratorIdent,
· · · · · · · Token: example.c:1:24: IDENTIFIER "j",
· · · · · · },
· · · · · },
· · · · },
· · · },
· · · Token: example.c:1:25: ';' ";",
· · },
· },
}

func (*DeclarationList) Position

func (n *DeclarationList) Position() (r token.Position)

Position reports the position of the first component of n, if available.

func (*DeclarationList) String

func (n *DeclarationList) String() string

String implements fmt.Stringer.

type DeclarationSpecifiers

type DeclarationSpecifiers struct {
	AlignmentSpecifier    *AlignmentSpecifier
	AttributeSpecifier    *AttributeSpecifier
	Case                  DeclarationSpecifiersCase `PrettyPrint:"stringer,zero"`
	DeclarationSpecifiers *DeclarationSpecifiers
	FunctionSpecifier     *FunctionSpecifier
	StorageClassSpecifier *StorageClassSpecifier
	TypeQualifier         *TypeQualifier
	TypeSpecifier         *TypeSpecifier
	// contains filtered or unexported fields
}

DeclarationSpecifiers represents data reduced by productions:

DeclarationSpecifiers:
        StorageClassSpecifier DeclarationSpecifiers  // Case DeclarationSpecifiersStorage
|       TypeSpecifier DeclarationSpecifiers          // Case DeclarationSpecifiersTypeSpec
|       TypeQualifier DeclarationSpecifiers          // Case DeclarationSpecifiersTypeQual
|       FunctionSpecifier DeclarationSpecifiers      // Case DeclarationSpecifiersFunc
|       AlignmentSpecifier DeclarationSpecifiers     // Case DeclarationSpecifiersAlignSpec
|       AttributeSpecifier DeclarationSpecifiers     // Case DeclarationSpecifiersAttribute
Example (AlignSpec)
fmt.Println(exampleAST(91, "_Alignas(double) int i;"))
Output:

&cc.DeclarationSpecifiers{
· AlignmentSpecifier: &cc.AlignmentSpecifier{
· · Case: AlignmentSpecifierAlignasType,
· · Token: example.c:1:1: ALIGNAS "_Alignas",
· · Token2: example.c:1:9: '(' "(",
· · Token3: example.c:1:16: ')' ")",
· · TypeName: &cc.TypeName{
· · · SpecifierQualifierList: &cc.SpecifierQualifierList{
· · · · Case: SpecifierQualifierListTypeSpec,
· · · · TypeSpecifier: &cc.TypeSpecifier{
· · · · · Case: TypeSpecifierDouble,
· · · · · Token: example.c:1:10: DOUBLE "double",
· · · · },
· · · },
· · },
· },
· Case: DeclarationSpecifiersAlignSpec,
· DeclarationSpecifiers: &cc.DeclarationSpecifiers{
· · Case: DeclarationSpecifiersTypeSpec,
· · TypeSpecifier: &cc.TypeSpecifier{
· · · Case: TypeSpecifierInt,
· · · Token: example.c:1:18: INT "int",
· · },
· },
}
Example (Attribute)
fmt.Println(exampleAST(92, "int __attribute__((a)) i;"))
Output:

&cc.DeclarationSpecifiers{
· Case: DeclarationSpecifiersTypeSpec,
· DeclarationSpecifiers: &cc.DeclarationSpecifiers{
· · AttributeSpecifier: &cc.AttributeSpecifier{
· · · AttributeValueList: &cc.AttributeValueList{
· · · · AttributeValue: &cc.AttributeValue{
· · · · · Case: AttributeValueIdent,
· · · · · Token: example.c:1:20: IDENTIFIER "a",
· · · · },
· · · },
· · · Token: example.c:1:5: ATTRIBUTE "__attribute__",
· · · Token2: example.c:1:18: '(' "(",
· · · Token3: example.c:1:19: '(' "(",
· · · Token4: example.c:1:21: ')' ")",
· · · Token5: example.c:1:22: ')' ")",
· · },
· · Case: DeclarationSpecifiersAttribute,
· },
· TypeSpecifier: &cc.TypeSpecifier{
· · Case: TypeSpecifierInt,
· · Token: example.c:1:1: INT "int",
· },
}
Example (Func)
fmt.Println(exampleAST(90, "inline int f() {}"))
Output:

&cc.DeclarationSpecifiers{
· Case: DeclarationSpecifiersFunc,
· DeclarationSpecifiers: &cc.DeclarationSpecifiers{
· · Case: DeclarationSpecifiersTypeSpec,
· · TypeSpecifier: &cc.TypeSpecifier{
· · · Case: TypeSpecifierInt,
· · · Token: example.c:1:8: INT "int",
· · },
· },
· FunctionSpecifier: &cc.FunctionSpecifier{
· · Case: FunctionSpecifierInline,
· · Token: example.c:1:1: INLINE "inline",
· },
}
Example (Storage)
fmt.Println(exampleAST(87, "static int i;"))
Output:

&cc.DeclarationSpecifiers{
· Case: DeclarationSpecifiersStorage,
· DeclarationSpecifiers: &cc.DeclarationSpecifiers{
· · Case: DeclarationSpecifiersTypeSpec,
· · TypeSpecifier: &cc.TypeSpecifier{
· · · Case: TypeSpecifierInt,
· · · Token: example.c:1:8: INT "int",
· · },
· },
· StorageClassSpecifier: &cc.StorageClassSpecifier{
· · Case: StorageClassSpecifierStatic,
· · Token: example.c:1:1: STATIC "static",
· },
}
Example (TypeQual)
fmt.Println(exampleAST(89, "volatile int i;"))
Output:

&cc.DeclarationSpecifiers{
· Case: DeclarationSpecifiersTypeQual,
· DeclarationSpecifiers: &cc.DeclarationSpecifiers{
· · Case: DeclarationSpecifiersTypeSpec,
· · TypeSpecifier: &cc.TypeSpecifier{
· · · Case: TypeSpecifierInt,
· · · Token: example.c:1:10: INT "int",
· · },
· },
· TypeQualifier: &cc.TypeQualifier{
· · Case: TypeQualifierVolatile,
· · Token: example.c:1:1: VOLATILE "volatile",
· },
}
Example (TypeSpec)
fmt.Println(exampleAST(88, "int i;"))
Output:

&cc.DeclarationSpecifiers{
· Case: DeclarationSpecifiersTypeSpec,
· TypeSpecifier: &cc.TypeSpecifier{
· · Case: TypeSpecifierInt,
· · Token: example.c:1:1: INT "int",
· },
}

func (*DeclarationSpecifiers) Position

func (n *DeclarationSpecifiers) Position() (r token.Position)

Position reports the position of the first component of n, if available.

func (*DeclarationSpecifiers) String

func (n *DeclarationSpecifiers) String() string

String implements fmt.Stringer.

type DeclarationSpecifiersCase

type DeclarationSpecifiersCase int

DeclarationSpecifiersCase represents case numbers of production DeclarationSpecifiers

const (
	DeclarationSpecifiersStorage DeclarationSpecifiersCase = iota
	DeclarationSpecifiersTypeSpec
	DeclarationSpecifiersTypeQual
	DeclarationSpecifiersFunc
	DeclarationSpecifiersAlignSpec
	DeclarationSpecifiersAttribute
)

Values of type DeclarationSpecifiersCase

func (DeclarationSpecifiersCase) String

func (n DeclarationSpecifiersCase) String() string

String implements fmt.Stringer

type Declarator

type Declarator struct {
	Linkage      Linkage
	Read         int
	StorageClass StorageClass
	Write        int

	AddressTaken    bool
	IsParameter     bool
	IsTypedefName   bool
	SubjectOfAsgnOp bool
	SubjectOfIncDec bool

	AttributeSpecifierList *AttributeSpecifierList
	DirectDeclarator       *DirectDeclarator
	Pointer                *Pointer
	// contains filtered or unexported fields
}

Declarator represents data reduced by production:

Declarator:
        Pointer DirectDeclarator AttributeSpecifierList
Example (Case0)
fmt.Println(exampleAST(166, "int *p __attribute__ ((foo));"))
Output:

&cc.Declarator{
· AttributeSpecifierList: &cc.AttributeSpecifierList{
· · AttributeSpecifier: &cc.AttributeSpecifier{
· · · AttributeValueList: &cc.AttributeValueList{
· · · · AttributeValue: &cc.AttributeValue{
· · · · · Case: AttributeValueIdent,
· · · · · Token: example.c:1:24: IDENTIFIER "foo",
· · · · },
· · · },
· · · Token: example.c:1:8: ATTRIBUTE "__attribute__",
· · · Token2: example.c:1:22: '(' "(",
· · · Token3: example.c:1:23: '(' "(",
· · · Token4: example.c:1:27: ')' ")",
· · · Token5: example.c:1:28: ')' ")",
· · },
· },
· DirectDeclarator: &cc.DirectDeclarator{
· · Case: DirectDeclaratorIdent,
· · Token: example.c:1:6: IDENTIFIER "p",
· },
· Pointer: &cc.Pointer{
· · Case: PointerTypeQual,
· · Token: example.c:1:5: '*' "*",
· },
}

func (*Declarator) Called added in v3.31.0

func (n *Declarator) Called() bool

Called reports whether n is involved in expr in expr(callArgs).

func (*Declarator) DeclarationSpecifiers added in v3.25.2

func (n *Declarator) DeclarationSpecifiers() *DeclarationSpecifiers

DeclarationSpecifiers returns the declaration specifiers associated with n or nil.

func (*Declarator) FunctionDefinition added in v3.27.0

func (n *Declarator) FunctionDefinition() *FunctionDefinition

FunctionDefinition returns the function definition associated with n, if any.

func (*Declarator) HasInitializer

func (n *Declarator) HasInitializer() bool

HasInitializer reports whether d has an initializator.

func (*Declarator) IsExtern

func (n *Declarator) IsExtern() bool

IsExtern reports whether n was declared with storage class specifier 'extern'.

func (*Declarator) IsFunctionPrototype added in v3.25.2

func (n *Declarator) IsFunctionPrototype() bool

IsFunctionPrototype reports whether n is a function prototype.

func (*Declarator) IsImplicit added in v3.35.16

func (n *Declarator) IsImplicit() bool

IsImplicit reports whether n was not declared nor defined, only inferred.

func (*Declarator) IsStatic

func (n *Declarator) IsStatic() bool

func (*Declarator) LHS added in v3.31.0

func (n *Declarator) LHS() map[*Declarator]struct{}

LHS reports which declarators n is used in assignment RHS or which function declarators n is used in a function argument. To collect this information, TrackAssignments in Config must be set during type checking. The returned map may contain a nil key. That means that n is assigned to a declarator not known at typechecking time.

func (*Declarator) LexicalScope

func (n *Declarator) LexicalScope() Scope

LexicalScope returns the lexical scope of n.

func (*Declarator) Name

func (n *Declarator) Name() StringID

Name returns n's declared name.

func (*Declarator) NameTok

func (n *Declarator) NameTok() (r Token)

NameTok returns n's declaring name token.

func (*Declarator) ParamScope

func (n *Declarator) ParamScope() Scope

ParamScope returns the scope in which n's function parameters are declared if the underlying type of n is a function or nil otherwise. If n is part of a function definition the scope is the same as the scope of the function body.

func (*Declarator) Position

func (n *Declarator) Position() (r token.Position)

Position reports the position of the first component of n, if available.

func (*Declarator) SpecifierQualifierList added in v3.25.2

func (n *Declarator) SpecifierQualifierList() *SpecifierQualifierList

SpecifierQualifierList returns the specifier qualifer list associated with n or nil.

func (*Declarator) String

func (n *Declarator) String() string

String implements fmt.Stringer.

func (*Declarator) Type

func (n *Declarator) Type() Type

Type returns the type of n.

func (*Declarator) TypeQualifiers added in v3.25.2

func (n *Declarator) TypeQualifiers() *TypeQualifiers

TypeQualifier returns the type qualifiers associated with n or nil.

type Designation

type Designation struct {
	DesignatorList *DesignatorList
	Token          Token
}

Designation represents data reduced by production:

Designation:
        DesignatorList '='
Example (Case0)
fmt.Println(exampleAST(205, "int a[] = { [42] = 314 };"))
Output:

&cc.Designation{
· DesignatorList: &cc.DesignatorList{
· · Designator: &cc.Designator{
· · · Case: DesignatorIndex,
· · · ConstantExpression: &cc.ConstantExpression{
· · · · ConditionalExpression: &cc.ConditionalExpression{
· · · · · Case: ConditionalExpressionLOr,
· · · · · LogicalOrExpression: &cc.LogicalOrExpression{
· · · · · · Case: LogicalOrExpressionLAnd,
· · · · · · LogicalAndExpression: &cc.LogicalAndExpression{
· · · · · · · Case: LogicalAndExpressionOr,
· · · · · · · InclusiveOrExpression: &cc.InclusiveOrExpression{
· · · · · · · · Case: InclusiveOrExpressionXor,
· · · · · · · · ExclusiveOrExpression: &cc.ExclusiveOrExpression{
· · · · · · · · · AndExpression: &cc.AndExpression{
· · · · · · · · · · Case: AndExpressionEq,
· · · · · · · · · · EqualityExpression: &cc.EqualityExpression{
· · · · · · · · · · · Case: EqualityExpressionRel,
· · · · · · · · · · · RelationalExpression: &cc.RelationalExpression{
· · · · · · · · · · · · Case: RelationalExpressionShift,
· · · · · · · · · · · · ShiftExpression: &cc.ShiftExpression{
· · · · · · · · · · · · · AdditiveExpression: &cc.AdditiveExpression{
· · · · · · · · · · · · · · Case: AdditiveExpressionMul,
· · · · · · · · · · · · · · MultiplicativeExpression: &cc.MultiplicativeExpression{
· · · · · · · · · · · · · · · Case: MultiplicativeExpressionCast,
· · · · · · · · · · · · · · · CastExpression: &cc.CastExpression{
· · · · · · · · · · · · · · · · Case: CastExpressionUnary,
· · · · · · · · · · · · · · · · UnaryExpression: &cc.UnaryExpression{
· · · · · · · · · · · · · · · · · Case: UnaryExpressionPostfix,
· · · · · · · · · · · · · · · · · PostfixExpression: &cc.PostfixExpression{
· · · · · · · · · · · · · · · · · · Case: PostfixExpressionPrimary,
· · · · · · · · · · · · · · · · · · PrimaryExpression: &cc.PrimaryExpression{
· · · · · · · · · · · · · · · · · · · Case: PrimaryExpressionInt,
· · · · · · · · · · · · · · · · · · · Token: example.c:1:14: INTCONST "42",
· · · · · · · · · · · · · · · · · · },
· · · · · · · · · · · · · · · · · },
· · · · · · · · · · · · · · · · },
· · · · · · · · · · · · · · · },
· · · · · · · · · · · · · · },
· · · · · · · · · · · · · },
· · · · · · · · · · · · · Case: ShiftExpressionAdd,
· · · · · · · · · · · · },
· · · · · · · · · · · },
· · · · · · · · · · },
· · · · · · · · · },
· · · · · · · · · Case: ExclusiveOrExpressionAnd,
· · · · · · · · },
· · · · · · · },
· · · · · · },
· · · · · },
· · · · },
· · · },
· · · Token: example.c:1:13: '[' "[",
· · · Token2: example.c:1:16: ']' "]",
· · },
· },
· Token: example.c:1:18: '=' "=",
}

func (*Designation) Position

func (n *Designation) Position() (r token.Position)

Position reports the position of the first component of n, if available.

func (*Designation) String

func (n *Designation) String() string

String implements fmt.Stringer.

type Designator

type Designator struct {
	Case               DesignatorCase `PrettyPrint:"stringer,zero"`
	ConstantExpression *ConstantExpression
	Token              Token
	Token2             Token
	// contains filtered or unexported fields
}

Designator represents data reduced by productions:

Designator:
        '[' ConstantExpression ']'  // Case DesignatorIndex
|       '.' IDENTIFIER              // Case DesignatorField
|       IDENTIFIER ':'              // Case DesignatorField2
Example (Field)
fmt.Println(exampleAST(209, "struct t s = { .fld = 314 };"))
Output:

&cc.Designator{
· Case: DesignatorField,
· Token: example.c:1:16: '.' ".",
· Token2: example.c:1:17: IDENTIFIER "fld",
}
Example (Field2)
fmt.Println(exampleAST(210, "struct t s = { fld: 314 };"))
Output:

&cc.Designator{
· Case: DesignatorField2,
· Token: example.c:1:16: IDENTIFIER "fld",
· Token2: example.c:1:19: ':' ":",
}
Example (Index)
fmt.Println(exampleAST(208, "int a[] = { [42] = 314 };"))
Output:

&cc.Designator{
· Case: DesignatorIndex,
· ConstantExpression: &cc.ConstantExpression{
· · ConditionalExpression: &cc.ConditionalExpression{
· · · Case: ConditionalExpressionLOr,
· · · LogicalOrExpression: &cc.LogicalOrExpression{
· · · · Case: LogicalOrExpressionLAnd,
· · · · LogicalAndExpression: &cc.LogicalAndExpression{
· · · · · Case: LogicalAndExpressionOr,
· · · · · InclusiveOrExpression: &cc.InclusiveOrExpression{
· · · · · · Case: InclusiveOrExpressionXor,
· · · · · · ExclusiveOrExpression: &cc.ExclusiveOrExpression{
· · · · · · · AndExpression: &cc.AndExpression{
· · · · · · · · Case: AndExpressionEq,
· · · · · · · · EqualityExpression: &cc.EqualityExpression{
· · · · · · · · · Case: EqualityExpressionRel,
· · · · · · · · · RelationalExpression: &cc.RelationalExpression{
· · · · · · · · · · Case: RelationalExpressionShift,
· · · · · · · · · · ShiftExpression: &cc.ShiftExpression{
· · · · · · · · · · · AdditiveExpression: &cc.AdditiveExpression{
· · · · · · · · · · · · Case: AdditiveExpressionMul,
· · · · · · · · · · · · MultiplicativeExpression: &cc.MultiplicativeExpression{
· · · · · · · · · · · · · Case: MultiplicativeExpressionCast,
· · · · · · · · · · · · · CastExpression: &cc.CastExpression{
· · · · · · · · · · · · · · Case: CastExpressionUnary,
· · · · · · · · · · · · · · UnaryExpression: &cc.UnaryExpression{
· · · · · · · · · · · · · · · Case: UnaryExpressionPostfix,
· · · · · · · · · · · · · · · PostfixExpression: &cc.PostfixExpression{
· · · · · · · · · · · · · · · · Case: PostfixExpressionPrimary,
· · · · · · · · · · · · · · · · PrimaryExpression: &cc.PrimaryExpression{
· · · · · · · · · · · · · · · · · Case: PrimaryExpressionInt,
· · · · · · · · · · · · · · · · · Token: example.c:1:14: INTCONST "42",
· · · · · · · · · · · · · · · · },
· · · · · · · · · · · · · · · },
· · · · · · · · · · · · · · },
· · · · · · · · · · · · · },
· · · · · · · · · · · · },
· · · · · · · · · · · },
· · · · · · · · · · · Case: ShiftExpressionAdd,
· · · · · · · · · · },
· · · · · · · · · },
· · · · · · · · },
· · · · · · · },
· · · · · · · Case: ExclusiveOrExpressionAnd,
· · · · · · },
· · · · · },
· · · · },
· · · },
· · },
· },
· Token: example.c:1:13: '[' "[",
· Token2: example.c:1:16: ']' "]",
}

func (*Designator) Position

func (n *Designator) Position() (r token.Position)

Position reports the position of the first component of n, if available.

func (*Designator) String

func (n *Designator) String() string

String implements fmt.Stringer.

type DesignatorCase

type DesignatorCase int

DesignatorCase represents case numbers of production Designator

const (
	DesignatorIndex DesignatorCase = iota
	DesignatorField
	DesignatorField2
)

Values of type DesignatorCase

func (DesignatorCase) String

func (n DesignatorCase) String() string

String implements fmt.Stringer

type DesignatorList

type DesignatorList struct {
	Designator     *Designator
	DesignatorList *DesignatorList
}

DesignatorList represents data reduced by productions:

DesignatorList:
        Designator
|       DesignatorList Designator
Example (Case0)
fmt.Println(exampleAST(206, "int a[] = { [42] = 314 };"))
Output:

&cc.DesignatorList{
· Designator: &cc.Designator{
· · Case: DesignatorIndex,
· · ConstantExpression: &cc.ConstantExpression{
· · · ConditionalExpression: &cc.ConditionalExpression{
· · · · Case: ConditionalExpressionLOr,
· · · · LogicalOrExpression: &cc.LogicalOrExpression{
· · · · · Case: LogicalOrExpressionLAnd,
· · · · · LogicalAndExpression: &cc.LogicalAndExpression{
· · · · · · Case: LogicalAndExpressionOr,
· · · · · · InclusiveOrExpression: &cc.InclusiveOrExpression{
· · · · · · · Case: InclusiveOrExpressionXor,
· · · · · · · ExclusiveOrExpression: &cc.ExclusiveOrExpression{
· · · · · · · · AndExpression: &cc.AndExpression{
· · · · · · · · · Case: AndExpressionEq,
· · · · · · · · · EqualityExpression: &cc.EqualityExpression{
· · · · · · · · · · Case: EqualityExpressionRel,
· · · · · · · · · · RelationalExpression: &cc.RelationalExpression{
· · · · · · · · · · · Case: RelationalExpressionShift,
· · · · · · · · · · · ShiftExpression: &cc.ShiftExpression{
· · · · · · · · · · · · AdditiveExpression: &cc.AdditiveExpression{
· · · · · · · · · · · · · Case: AdditiveExpressionMul,
· · · · · · · · · · · · · MultiplicativeExpression: &cc.MultiplicativeExpression{
· · · · · · · · · · · · · · Case: MultiplicativeExpressionCast,
· · · · · · · · · · · · · · CastExpression: &cc.CastExpression{
· · · · · · · · · · · · · · · Case: CastExpressionUnary,
· · · · · · · · · · · · · · · UnaryExpression: &cc.UnaryExpression{
· · · · · · · · · · · · · · · · Case: UnaryExpressionPostfix,
· · · · · · · · · · · · · · · · PostfixExpression: &cc.PostfixExpression{
· · · · · · · · · · · · · · · · · Case: PostfixExpressionPrimary,
· · · · · · · · · · · · · · · · · PrimaryExpression: &cc.PrimaryExpression{
· · · · · · · · · · · · · · · · · · Case: PrimaryExpressionInt,
· · · · · · · · · · · · · · · · · · Token: example.c:1:14: INTCONST "42",
· · · · · · · · · · · · · · · · · },
· · · · · · · · · · · · · · · · },
· · · · · · · · · · · · · · · },
· · · · · · · · · · · · · · },
· · · · · · · · · · · · · },
· · · · · · · · · · · · },
· · · · · · · · · · · · Case: ShiftExpressionAdd,
· · · · · · · · · · · },
· · · · · · · · · · },
· · · · · · · · · },
· · · · · · · · },
· · · · · · · · Case: ExclusiveOrExpressionAnd,
· · · · · · · },
· · · · · · },
· · · · · },
· · · · },
· · · },
· · },
· · Token: example.c:1:13: '[' "[",
· · Token2: example.c:1:16: ']' "]",
· },
}
Example (Case1)
fmt.Println(exampleAST(207, "int a[100][] = { [42][12] = 314 };"))
Output:

&cc.DesignatorList{
· Designator: &cc.Designator{
· · Case: DesignatorIndex,
· · ConstantExpression: &cc.ConstantExpression{
· · · ConditionalExpression: &cc.ConditionalExpression{
· · · · Case: ConditionalExpressionLOr,
· · · · LogicalOrExpression: &cc.LogicalOrExpression{
· · · · · Case: LogicalOrExpressionLAnd,
· · · · · LogicalAndExpression: &cc.LogicalAndExpression{
· · · · · · Case: LogicalAndExpressionOr,
· · · · · · InclusiveOrExpression: &cc.InclusiveOrExpression{
· · · · · · · Case: InclusiveOrExpressionXor,
· · · · · · · ExclusiveOrExpression: &cc.ExclusiveOrExpression{
· · · · · · · · AndExpression: &cc.AndExpression{
· · · · · · · · · Case: AndExpressionEq,
· · · · · · · · · EqualityExpression: &cc.EqualityExpression{
· · · · · · · · · · Case: EqualityExpressionRel,
· · · · · · · · · · RelationalExpression: &cc.RelationalExpression{
· · · · · · · · · · · Case: RelationalExpressionShift,
· · · · · · · · · · · ShiftExpression: &cc.ShiftExpression{
· · · · · · · · · · · · AdditiveExpression: &cc.AdditiveExpression{
· · · · · · · · · · · · · Case: AdditiveExpressionMul,
· · · · · · · · · · · · · MultiplicativeExpression: &cc.MultiplicativeExpression{
· · · · · · · · · · · · · · Case: MultiplicativeExpressionCast,
· · · · · · · · · · · · · · CastExpression: &cc.CastExpression{
· · · · · · · · · · · · · · · Case: CastExpressionUnary,
· · · · · · · · · · · · · · · UnaryExpression: &cc.UnaryExpression{
· · · · · · · · · · · · · · · · Case: UnaryExpressionPostfix,
· · · · · · · · · · · · · · · · PostfixExpression: &cc.PostfixExpression{
· · · · · · · · · · · · · · · · · Case: PostfixExpressionPrimary,
· · · · · · · · · · · · · · · · · PrimaryExpression: &cc.PrimaryExpression{
· · · · · · · · · · · · · · · · · · Case: PrimaryExpressionInt,
· · · · · · · · · · · · · · · · · · Token: example.c:1:19: INTCONST "42",
· · · · · · · · · · · · · · · · · },
· · · · · · · · · · · · · · · · },
· · · · · · · · · · · · · · · },
· · · · · · · · · · · · · · },
· · · · · · · · · · · · · },
· · · · · · · · · · · · },
· · · · · · · · · · · · Case: ShiftExpressionAdd,
· · · · · · · · · · · },
· · · · · · · · · · },
· · · · · · · · · },
· · · · · · · · },
· · · · · · · · Case: ExclusiveOrExpressionAnd,
· · · · · · · },
· · · · · · },
· · · · · },
· · · · },
· · · },
· · },
· · Token: example.c:1:18: '[' "[",
· · Token2: example.c:1:21: ']' "]",
· },
· DesignatorList: &cc.DesignatorList{
· · Designator: &cc.Designator{
· · · Case: DesignatorIndex,
· · · ConstantExpression: &cc.ConstantExpression{
· · · · ConditionalExpression: &cc.ConditionalExpression{
· · · · · Case: ConditionalExpressionLOr,
· · · · · LogicalOrExpression: &cc.LogicalOrExpression{
· · · · · · Case: LogicalOrExpressionLAnd,
· · · · · · LogicalAndExpression: &cc.LogicalAndExpression{
· · · · · · · Case: LogicalAndExpressionOr,
· · · · · · · InclusiveOrExpression: &cc.InclusiveOrExpression{
· · · · · · · · Case: InclusiveOrExpressionXor,
· · · · · · · · ExclusiveOrExpression: &cc.ExclusiveOrExpression{
· · · · · · · · · AndExpression: &cc.AndExpression{
· · · · · · · · · · Case: AndExpressionEq,
· · · · · · · · · · EqualityExpression: &cc.EqualityExpression{
· · · · · · · · · · · Case: EqualityExpressionRel,
· · · · · · · · · · · RelationalExpression: &cc.RelationalExpression{
· · · · · · · · · · · · Case: RelationalExpressionShift,
· · · · · · · · · · · · ShiftExpression: &cc.ShiftExpression{
· · · · · · · · · · · · · AdditiveExpression: &cc.AdditiveExpression{
· · · · · · · · · · · · · · Case: AdditiveExpressionMul,
· · · · · · · · · · · · · · MultiplicativeExpression: &cc.MultiplicativeExpression{
· · · · · · · · · · · · · · · Case: MultiplicativeExpressionCast,
· · · · · · · · · · · · · · · CastExpression: &cc.CastExpression{
· · · · · · · · · · · · · · · · Case: CastExpressionUnary,
· · · · · · · · · · · · · · · · UnaryExpression: &cc.UnaryExpression{
· · · · · · · · · · · · · · · · · Case: UnaryExpressionPostfix,
· · · · · · · · · · · · · · · · · PostfixExpression: &cc.PostfixExpression{
· · · · · · · · · · · · · · · · · · Case: PostfixExpressionPrimary,
· · · · · · · · · · · · · · · · · · PrimaryExpression: &cc.PrimaryExpression{
· · · · · · · · · · · · · · · · · · · Case: PrimaryExpressionInt,
· · · · · · · · · · · · · · · · · · · Token: example.c:1:23: INTCONST "12",
· · · · · · · · · · · · · · · · · · },
· · · · · · · · · · · · · · · · · },
· · · · · · · · · · · · · · · · },
· · · · · · · · · · · · · · · },
· · · · · · · · · · · · · · },
· · · · · · · · · · · · · },
· · · · · · · · · · · · · Case: ShiftExpressionAdd,
· · · · · · · · · · · · },
· · · · · · · · · · · },
· · · · · · · · · · },
· · · · · · · · · },
· · · · · · · · · Case: ExclusiveOrExpressionAnd,
· · · · · · · · },
· · · · · · · },
· · · · · · },
· · · · · },
· · · · },
· · · },
· · · Token: example.c:1:22: '[' "[",
· · · Token2: example.c:1:25: ']' "]",
· · },
· },
}

func (*DesignatorList) Position

func (n *DesignatorList) Position() (r token.Position)

Position reports the position of the first component of n, if available.

func (*DesignatorList) String

func (n *DesignatorList) String() string

String implements fmt.Stringer.

type DirectAbstractDeclarator

type DirectAbstractDeclarator struct {
	AbstractDeclarator       *AbstractDeclarator
	AssignmentExpression     *AssignmentExpression
	Case                     DirectAbstractDeclaratorCase `PrettyPrint:"stringer,zero"`
	DirectAbstractDeclarator *DirectAbstractDeclarator
	ParameterTypeList        *ParameterTypeList
	Token                    Token
	Token2                   Token
	Token3                   Token
	TypeQualifiers           *TypeQualifiers
	// contains filtered or unexported fields
}

DirectAbstractDeclarator represents data reduced by productions:

DirectAbstractDeclarator:
        '(' AbstractDeclarator ')'                                                     // Case DirectAbstractDeclaratorDecl
|       DirectAbstractDeclarator '[' TypeQualifiers AssignmentExpression ']'           // Case DirectAbstractDeclaratorArr
|       DirectAbstractDeclarator '[' "static" TypeQualifiers AssignmentExpression ']'  // Case DirectAbstractDeclaratorStaticArr
|       DirectAbstractDeclarator '[' TypeQualifiers "static" AssignmentExpression ']'  // Case DirectAbstractDeclaratorArrStatic
|       DirectAbstractDeclarator '[' '*' ']'                                           // Case DirectAbstractDeclaratorArrStar
|       DirectAbstractDeclarator '(' ParameterTypeList ')'                             // Case DirectAbstractDeclaratorFunc
Example (Arr)
fmt.Println(exampleAST(196, "void f(int[const 42]);"))
Output:

&cc.DirectAbstractDeclarator{
· AssignmentExpression: &cc.AssignmentExpression{
· · Case: AssignmentExpressionCond,
· · ConditionalExpression: &cc.ConditionalExpression{
· · · Case: ConditionalExpressionLOr,
· · · LogicalOrExpression: &cc.LogicalOrExpression{
· · · · Case: LogicalOrExpressionLAnd,
· · · · LogicalAndExpression: &cc.LogicalAndExpression{
· · · · · Case: LogicalAndExpressionOr,
· · · · · InclusiveOrExpression: &cc.InclusiveOrExpression{
· · · · · · Case: InclusiveOrExpressionXor,
· · · · · · ExclusiveOrExpression: &cc.ExclusiveOrExpression{
· · · · · · · AndExpression: &cc.AndExpression{
· · · · · · · · Case: AndExpressionEq,
· · · · · · · · EqualityExpression: &cc.EqualityExpression{
· · · · · · · · · Case: EqualityExpressionRel,
· · · · · · · · · RelationalExpression: &cc.RelationalExpression{
· · · · · · · · · · Case: RelationalExpressionShift,
· · · · · · · · · · ShiftExpression: &cc.ShiftExpression{
· · · · · · · · · · · AdditiveExpression: &cc.AdditiveExpression{
· · · · · · · · · · · · Case: AdditiveExpressionMul,
· · · · · · · · · · · · MultiplicativeExpression: &cc.MultiplicativeExpression{
· · · · · · · · · · · · · Case: MultiplicativeExpressionCast,
· · · · · · · · · · · · · CastExpression: &cc.CastExpression{
· · · · · · · · · · · · · · Case: CastExpressionUnary,
· · · · · · · · · · · · · · UnaryExpression: &cc.UnaryExpression{
· · · · · · · · · · · · · · · Case: UnaryExpressionPostfix,
· · · · · · · · · · · · · · · PostfixExpression: &cc.PostfixExpression{
· · · · · · · · · · · · · · · · Case: PostfixExpressionPrimary,
· · · · · · · · · · · · · · · · PrimaryExpression: &cc.PrimaryExpression{
· · · · · · · · · · · · · · · · · Case: PrimaryExpressionInt,
· · · · · · · · · · · · · · · · · Token: example.c:1:18: INTCONST "42",
· · · · · · · · · · · · · · · · },
· · · · · · · · · · · · · · · },
· · · · · · · · · · · · · · },
· · · · · · · · · · · · · },
· · · · · · · · · · · · },
· · · · · · · · · · · },
· · · · · · · · · · · Case: ShiftExpressionAdd,
· · · · · · · · · · },
· · · · · · · · · },
· · · · · · · · },
· · · · · · · },
· · · · · · · Case: ExclusiveOrExpressionAnd,
· · · · · · },
· · · · · },
· · · · },
· · · },
· · },
· },
· Case: DirectAbstractDeclaratorArr,
· Token: example.c:1:11: '[' "[",
· Token2: example.c:1:20: ']' "]",
· TypeQualifiers: &cc.TypeQualifiers{
· · Case: TypeQualifiersTypeQual,
· · TypeQualifier: &cc.TypeQualifier{
· · · Case: TypeQualifierConst,
· · · Token: example.c:1:12: CONST "const",
· · },
· },
}
Example (ArrStar)
fmt.Println(exampleAST(199, "void f(int[*]);"))
Output:

&cc.DirectAbstractDeclarator{
· Case: DirectAbstractDeclaratorArrStar,
· Token: example.c:1:11: '[' "[",
· Token2: example.c:1:12: '*' "*",
· Token3: example.c:1:13: ']' "]",
}
Example (ArrStatic)
fmt.Println(exampleAST(198, "void f(int[const static 42]);"))
Output:

&cc.DirectAbstractDeclarator{
· AssignmentExpression: &cc.AssignmentExpression{
· · Case: AssignmentExpressionCond,
· · ConditionalExpression: &cc.ConditionalExpression{
· · · Case: ConditionalExpressionLOr,
· · · LogicalOrExpression: &cc.LogicalOrExpression{
· · · · Case: LogicalOrExpressionLAnd,
· · · · LogicalAndExpression: &cc.LogicalAndExpression{
· · · · · Case: LogicalAndExpressionOr,
· · · · · InclusiveOrExpression: &cc.InclusiveOrExpression{
· · · · · · Case: InclusiveOrExpressionXor,
· · · · · · ExclusiveOrExpression: &cc.ExclusiveOrExpression{
· · · · · · · AndExpression: &cc.AndExpression{
· · · · · · · · Case: AndExpressionEq,
· · · · · · · · EqualityExpression: &cc.EqualityExpression{
· · · · · · · · · Case: EqualityExpressionRel,
· · · · · · · · · RelationalExpression: &cc.RelationalExpression{
· · · · · · · · · · Case: RelationalExpressionShift,
· · · · · · · · · · ShiftExpression: &cc.ShiftExpression{
· · · · · · · · · · · AdditiveExpression: &cc.AdditiveExpression{
· · · · · · · · · · · · Case: AdditiveExpressionMul,
· · · · · · · · · · · · MultiplicativeExpression: &cc.MultiplicativeExpression{
· · · · · · · · · · · · · Case: MultiplicativeExpressionCast,
· · · · · · · · · · · · · CastExpression: &cc.CastExpression{
· · · · · · · · · · · · · · Case: CastExpressionUnary,
· · · · · · · · · · · · · · UnaryExpression: &cc.UnaryExpression{
· · · · · · · · · · · · · · · Case: UnaryExpressionPostfix,
· · · · · · · · · · · · · · · PostfixExpression: &cc.PostfixExpression{
· · · · · · · · · · · · · · · · Case: PostfixExpressionPrimary,
· · · · · · · · · · · · · · · · PrimaryExpression: &cc.PrimaryExpression{
· · · · · · · · · · · · · · · · · Case: PrimaryExpressionInt,
· · · · · · · · · · · · · · · · · Token: example.c:1:25: INTCONST "42",
· · · · · · · · · · · · · · · · },
· · · · · · · · · · · · · · · },
· · · · · · · · · · · · · · },
· · · · · · · · · · · · · },
· · · · · · · · · · · · },
· · · · · · · · · · · },
· · · · · · · · · · · Case: ShiftExpressionAdd,
· · · · · · · · · · },
· · · · · · · · · },
· · · · · · · · },
· · · · · · · },
· · · · · · · Case: ExclusiveOrExpressionAnd,
· · · · · · },
· · · · · },
· · · · },
· · · },
· · },
· },
· Case: DirectAbstractDeclaratorArrStatic,
· Token: example.c:1:11: '[' "[",
· Token2: example.c:1:18: STATIC "static",
· Token3: example.c:1:27: ']' "]",
· TypeQualifiers: &cc.TypeQualifiers{
· · Case: TypeQualifiersTypeQual,
· · TypeQualifier: &cc.TypeQualifier{
· · · Case: TypeQualifierConst,
· · · Token: example.c:1:12: CONST "const",
· · },
· },
}
Example (Decl)
fmt.Println(exampleAST(195, "void f(int());"))
Output:

&cc.DirectAbstractDeclarator{
· Case: DirectAbstractDeclaratorFunc,
· Token: example.c:1:11: '(' "(",
· Token2: example.c:1:12: ')' ")",
}
Example (Func)
fmt.Println(exampleAST(200, "void f(int(char));"))
Output:

&cc.DirectAbstractDeclarator{
· Case: DirectAbstractDeclaratorFunc,
· ParameterTypeList: &cc.ParameterTypeList{
· · Case: ParameterTypeListList,
· · ParameterList: &cc.ParameterList{
· · · ParameterDeclaration: &cc.ParameterDeclaration{
· · · · Case: ParameterDeclarationAbstract,
· · · · DeclarationSpecifiers: &cc.DeclarationSpecifiers{
· · · · · Case: DeclarationSpecifiersTypeSpec,
· · · · · TypeSpecifier: &cc.TypeSpecifier{
· · · · · · Case: TypeSpecifierChar,
· · · · · · Token: example.c:1:12: CHAR "char",
· · · · · },
· · · · },
· · · },
· · },
· },
· Token: example.c:1:11: '(' "(",
· Token2: example.c:1:16: ')' ")",
}
Example (StaticArr)
fmt.Println(exampleAST(197, "void f(int[static const 42]);"))
Output:

&cc.DirectAbstractDeclarator{
· AssignmentExpression: &cc.AssignmentExpression{
· · Case: AssignmentExpressionCond,
· · ConditionalExpression: &cc.ConditionalExpression{
· · · Case: ConditionalExpressionLOr,
· · · LogicalOrExpression: &cc.LogicalOrExpression{
· · · · Case: LogicalOrExpressionLAnd,
· · · · LogicalAndExpression: &cc.LogicalAndExpression{
· · · · · Case: LogicalAndExpressionOr,
· · · · · InclusiveOrExpression: &cc.InclusiveOrExpression{
· · · · · · Case: InclusiveOrExpressionXor,
· · · · · · ExclusiveOrExpression: &cc.ExclusiveOrExpression{
· · · · · · · AndExpression: &cc.AndExpression{
· · · · · · · · Case: AndExpressionEq,
· · · · · · · · EqualityExpression: &cc.EqualityExpression{
· · · · · · · · · Case: EqualityExpressionRel,
· · · · · · · · · RelationalExpression: &cc.RelationalExpression{
· · · · · · · · · · Case: RelationalExpressionShift,
· · · · · · · · · · ShiftExpression: &cc.ShiftExpression{
· · · · · · · · · · · AdditiveExpression: &cc.AdditiveExpression{
· · · · · · · · · · · · Case: AdditiveExpressionMul,
· · · · · · · · · · · · MultiplicativeExpression: &cc.MultiplicativeExpression{
· · · · · · · · · · · · · Case: MultiplicativeExpressionCast,
· · · · · · · · · · · · · CastExpression: &cc.CastExpression{
· · · · · · · · · · · · · · Case: CastExpressionUnary,
· · · · · · · · · · · · · · UnaryExpression: &cc.UnaryExpression{
· · · · · · · · · · · · · · · Case: UnaryExpressionPostfix,
· · · · · · · · · · · · · · · PostfixExpression: &cc.PostfixExpression{
· · · · · · · · · · · · · · · · Case: PostfixExpressionPrimary,
· · · · · · · · · · · · · · · · PrimaryExpression: &cc.PrimaryExpression{
· · · · · · · · · · · · · · · · · Case: PrimaryExpressionInt,
· · · · · · · · · · · · · · · · · Token: example.c:1:25: INTCONST "42",
· · · · · · · · · · · · · · · · },
· · · · · · · · · · · · · · · },
· · · · · · · · · · · · · · },
· · · · · · · · · · · · · },
· · · · · · · · · · · · },
· · · · · · · · · · · },
· · · · · · · · · · · Case: ShiftExpressionAdd,
· · · · · · · · · · },
· · · · · · · · · },
· · · · · · · · },
· · · · · · · },
· · · · · · · Case: ExclusiveOrExpressionAnd,
· · · · · · },
· · · · · },
· · · · },
· · · },
· · },
· },
· Case: DirectAbstractDeclaratorStaticArr,
· Token: example.c:1:11: '[' "[",
· Token2: example.c:1:12: STATIC "static",
· Token3: example.c:1:27: ']' "]",
· TypeQualifiers: &cc.TypeQualifiers{
· · Case: TypeQualifiersTypeQual,
· · TypeQualifier: &cc.TypeQualifier{
· · · Case: TypeQualifierConst,
· · · Token: example.c:1:19: CONST "const",
· · },
· },
}

func (*DirectAbstractDeclarator) Position

func (n *DirectAbstractDeclarator) Position() (r token.Position)

Position reports the position of the first component of n, if available.

func (*DirectAbstractDeclarator) String

func (n *DirectAbstractDeclarator) String() string

String implements fmt.Stringer.

func (*DirectAbstractDeclarator) TypeQualifier

func (n *DirectAbstractDeclarator) TypeQualifier() Type

type DirectAbstractDeclaratorCase

type DirectAbstractDeclaratorCase int

DirectAbstractDeclaratorCase represents case numbers of production DirectAbstractDeclarator

const (
	DirectAbstractDeclaratorDecl DirectAbstractDeclaratorCase = iota
	DirectAbstractDeclaratorArr
	DirectAbstractDeclaratorStaticArr
	DirectAbstractDeclaratorArrStatic
	DirectAbstractDeclaratorArrStar
	DirectAbstractDeclaratorFunc
)

Values of type DirectAbstractDeclaratorCase

func (DirectAbstractDeclaratorCase) String

String implements fmt.Stringer

type DirectDeclarator

type DirectDeclarator struct {
	Asm                    *Asm
	AssignmentExpression   *AssignmentExpression
	AttributeSpecifierList *AttributeSpecifierList
	Case                   DirectDeclaratorCase `PrettyPrint:"stringer,zero"`
	Declarator             *Declarator
	DirectDeclarator       *DirectDeclarator
	IdentifierList         *IdentifierList
	ParameterTypeList      *ParameterTypeList
	Token                  Token
	Token2                 Token
	Token3                 Token
	TypeQualifiers         *TypeQualifiers
	// contains filtered or unexported fields
}

DirectDeclarator represents data reduced by productions:

DirectDeclarator:
        IDENTIFIER Asm                                                         // Case DirectDeclaratorIdent
|       '(' AttributeSpecifierList Declarator ')'                              // Case DirectDeclaratorDecl
|       DirectDeclarator '[' TypeQualifiers AssignmentExpression ']'           // Case DirectDeclaratorArr
|       DirectDeclarator '[' "static" TypeQualifiers AssignmentExpression ']'  // Case DirectDeclaratorStaticArr
|       DirectDeclarator '[' TypeQualifiers "static" AssignmentExpression ']'  // Case DirectDeclaratorArrStatic
|       DirectDeclarator '[' TypeQualifiers '*' ']'                            // Case DirectDeclaratorStar
|       DirectDeclarator '(' ParameterTypeList ')'                             // Case DirectDeclaratorFuncParam
|       DirectDeclarator '(' IdentifierList ')'                                // Case DirectDeclaratorFuncIdent
Example (Arr)
fmt.Println(exampleAST(171, "int i[const 42];"))
Output:

&cc.DirectDeclarator{
· AssignmentExpression: &cc.AssignmentExpression{
· · Case: AssignmentExpressionCond,
· · ConditionalExpression: &cc.ConditionalExpression{
· · · Case: ConditionalExpressionLOr,
· · · LogicalOrExpression: &cc.LogicalOrExpression{
· · · · Case: LogicalOrExpressionLAnd,
· · · · LogicalAndExpression: &cc.LogicalAndExpression{
· · · · · Case: LogicalAndExpressionOr,
· · · · · InclusiveOrExpression: &cc.InclusiveOrExpression{
· · · · · · Case: InclusiveOrExpressionXor,
· · · · · · ExclusiveOrExpression: &cc.ExclusiveOrExpression{
· · · · · · · AndExpression: &cc.AndExpression{
· · · · · · · · Case: AndExpressionEq,
· · · · · · · · EqualityExpression: &cc.EqualityExpression{
· · · · · · · · · Case: EqualityExpressionRel,
· · · · · · · · · RelationalExpression: &cc.RelationalExpression{
· · · · · · · · · · Case: RelationalExpressionShift,
· · · · · · · · · · ShiftExpression: &cc.ShiftExpression{
· · · · · · · · · · · AdditiveExpression: &cc.AdditiveExpression{
· · · · · · · · · · · · Case: AdditiveExpressionMul,
· · · · · · · · · · · · MultiplicativeExpression: &cc.MultiplicativeExpression{
· · · · · · · · · · · · · Case: MultiplicativeExpressionCast,
· · · · · · · · · · · · · CastExpression: &cc.CastExpression{
· · · · · · · · · · · · · · Case: CastExpressionUnary,
· · · · · · · · · · · · · · UnaryExpression: &cc.UnaryExpression{
· · · · · · · · · · · · · · · Case: UnaryExpressionPostfix,
· · · · · · · · · · · · · · · PostfixExpression: &cc.PostfixExpression{
· · · · · · · · · · · · · · · · Case: PostfixExpressionPrimary,
· · · · · · · · · · · · · · · · PrimaryExpression: &cc.PrimaryExpression{
· · · · · · · · · · · · · · · · · Case: PrimaryExpressionInt,
· · · · · · · · · · · · · · · · · Token: example.c:1:13: INTCONST "42",
· · · · · · · · · · · · · · · · },
· · · · · · · · · · · · · · · },
· · · · · · · · · · · · · · },
· · · · · · · · · · · · · },
· · · · · · · · · · · · },
· · · · · · · · · · · },
· · · · · · · · · · · Case: ShiftExpressionAdd,
· · · · · · · · · · },
· · · · · · · · · },
· · · · · · · · },
· · · · · · · },
· · · · · · · Case: ExclusiveOrExpressionAnd,
· · · · · · },
· · · · · },
· · · · },
· · · },
· · },
· },
· Case: DirectDeclaratorArr,
· DirectDeclarator: &cc.DirectDeclarator{
· · Case: DirectDeclaratorIdent,
· · Token: example.c:1:5: IDENTIFIER "i",
· },
· Token: example.c:1:6: '[' "[",
· Token2: example.c:1:15: ']' "]",
· TypeQualifiers: &cc.TypeQualifiers{
· · Case: TypeQualifiersTypeQual,
· · TypeQualifier: &cc.TypeQualifier{
· · · Case: TypeQualifierConst,
· · · Token: example.c:1:7: CONST "const",
· · },
· },
}
Example (ArrStatic)
fmt.Println(exampleAST(173, "int i[const static 42];"))
Output:

&cc.DirectDeclarator{
· AssignmentExpression: &cc.AssignmentExpression{
· · Case: AssignmentExpressionCond,
· · ConditionalExpression: &cc.ConditionalExpression{
· · · Case: ConditionalExpressionLOr,
· · · LogicalOrExpression: &cc.LogicalOrExpression{
· · · · Case: LogicalOrExpressionLAnd,
· · · · LogicalAndExpression: &cc.LogicalAndExpression{
· · · · · Case: LogicalAndExpressionOr,
· · · · · InclusiveOrExpression: &cc.InclusiveOrExpression{
· · · · · · Case: InclusiveOrExpressionXor,
· · · · · · ExclusiveOrExpression: &cc.ExclusiveOrExpression{
· · · · · · · AndExpression: &cc.AndExpression{
· · · · · · · · Case: AndExpressionEq,
· · · · · · · · EqualityExpression: &cc.EqualityExpression{
· · · · · · · · · Case: EqualityExpressionRel,
· · · · · · · · · RelationalExpression: &cc.RelationalExpression{
· · · · · · · · · · Case: RelationalExpressionShift,
· · · · · · · · · · ShiftExpression: &cc.ShiftExpression{
· · · · · · · · · · · AdditiveExpression: &cc.AdditiveExpression{
· · · · · · · · · · · · Case: AdditiveExpressionMul,
· · · · · · · · · · · · MultiplicativeExpression: &cc.MultiplicativeExpression{
· · · · · · · · · · · · · Case: MultiplicativeExpressionCast,
· · · · · · · · · · · · · CastExpression: &cc.CastExpression{
· · · · · · · · · · · · · · Case: CastExpressionUnary,
· · · · · · · · · · · · · · UnaryExpression: &cc.UnaryExpression{
· · · · · · · · · · · · · · · Case: UnaryExpressionPostfix,
· · · · · · · · · · · · · · · PostfixExpression: &cc.PostfixExpression{
· · · · · · · · · · · · · · · · Case: PostfixExpressionPrimary,
· · · · · · · · · · · · · · · · PrimaryExpression: &cc.PrimaryExpression{
· · · · · · · · · · · · · · · · · Case: PrimaryExpressionInt,
· · · · · · · · · · · · · · · · · Token: example.c:1:20: INTCONST "42",
· · · · · · · · · · · · · · · · },
· · · · · · · · · · · · · · · },
· · · · · · · · · · · · · · },
· · · · · · · · · · · · · },
· · · · · · · · · · · · },
· · · · · · · · · · · },
· · · · · · · · · · · Case: ShiftExpressionAdd,
· · · · · · · · · · },
· · · · · · · · · },
· · · · · · · · },
· · · · · · · },
· · · · · · · Case: ExclusiveOrExpressionAnd,
· · · · · · },
· · · · · },
· · · · },
· · · },
· · },
· },
· Case: DirectDeclaratorArrStatic,
· DirectDeclarator: &cc.DirectDeclarator{
· · Case: DirectDeclaratorIdent,
· · Token: example.c:1:5: IDENTIFIER "i",
· },
· Token: example.c:1:6: '[' "[",
· Token2: example.c:1:13: STATIC "static",
· Token3: example.c:1:22: ']' "]",
· TypeQualifiers: &cc.TypeQualifiers{
· · Case: TypeQualifiersTypeQual,
· · TypeQualifier: &cc.TypeQualifier{
· · · Case: TypeQualifierConst,
· · · Token: example.c:1:7: CONST "const",
· · },
· },
}
Example (Decl)
fmt.Println(exampleAST(170, "int (f);"))
Output:

&cc.DirectDeclarator{
· Case: DirectDeclaratorDecl,
· Declarator: &cc.Declarator{
· · DirectDeclarator: &cc.DirectDeclarator{
· · · Case: DirectDeclaratorIdent,
· · · Token: example.c:1:6: IDENTIFIER "f",
· · },
· },
· Token: example.c:1:5: '(' "(",
· Token2: example.c:1:7: ')' ")",
}
Example (FuncIdent)
fmt.Println(exampleAST(176, "int f(a);"))
Output:

&cc.DirectDeclarator{
· Case: DirectDeclaratorFuncIdent,
· DirectDeclarator: &cc.DirectDeclarator{
· · Case: DirectDeclaratorIdent,
· · Token: example.c:1:5: IDENTIFIER "f",
· },
· IdentifierList: &cc.IdentifierList{
· · Token: example.c:1:7: IDENTIFIER "a",
· },
· Token: example.c:1:6: '(' "(",
· Token2: example.c:1:8: ')' ")",
}
Example (FuncParam)
fmt.Println(exampleAST(175, "int f(int i);"))
Output:

&cc.DirectDeclarator{
· Case: DirectDeclaratorFuncParam,
· DirectDeclarator: &cc.DirectDeclarator{
· · Case: DirectDeclaratorIdent,
· · Token: example.c:1:5: IDENTIFIER "f",
· },
· ParameterTypeList: &cc.ParameterTypeList{
· · Case: ParameterTypeListList,
· · ParameterList: &cc.ParameterList{
· · · ParameterDeclaration: &cc.ParameterDeclaration{
· · · · Case: ParameterDeclarationDecl,
· · · · DeclarationSpecifiers: &cc.DeclarationSpecifiers{
· · · · · Case: DeclarationSpecifiersTypeSpec,
· · · · · TypeSpecifier: &cc.TypeSpecifier{
· · · · · · Case: TypeSpecifierInt,
· · · · · · Token: example.c:1:7: INT "int",
· · · · · },
· · · · },
· · · · Declarator: &cc.Declarator{
· · · · · DirectDeclarator: &cc.DirectDeclarator{
· · · · · · Case: DirectDeclaratorIdent,
· · · · · · Token: example.c:1:11: IDENTIFIER "i",
· · · · · },
· · · · },
· · · },
· · },
· },
· Token: example.c:1:6: '(' "(",
· Token2: example.c:1:12: ')' ")",
}
Example (Ident)
fmt.Println(exampleAST(169, "int i;"))
Output:

&cc.DirectDeclarator{
· Case: DirectDeclaratorIdent,
· Token: example.c:1:5: IDENTIFIER "i",
}
Example (Line)
fmt.Println(exampleAST(0, "#line 1234\nint i;"))
Output:

&cc.DirectDeclarator{
· Case: DirectDeclaratorIdent,
· Token: example.c:1234:5: IDENTIFIER "i",
}
Example (Line2)
fmt.Println(exampleAST(0, "#line 1234 \"foo.c\"\nint i;"))
Output:

&cc.DirectDeclarator{
· Case: DirectDeclaratorIdent,
· Token: foo.c:1234:5: IDENTIFIER "i",
}
Example (Line3)
fmt.Println(exampleAST(0, "#line 1234\r\nint i;"))
Output:

&cc.DirectDeclarator{
· Case: DirectDeclaratorIdent,
· Token: example.c:1234:5: IDENTIFIER "i",
}
Example (Line4)
fmt.Println(exampleAST(0, "#line 1234 \"foo.c\"\r\nint i;"))
Output:

&cc.DirectDeclarator{
· Case: DirectDeclaratorIdent,
· Token: foo.c:1234:5: IDENTIFIER "i",
}
Example (Star)
fmt.Println(exampleAST(174, "int i[const *];"))
Output:

&cc.DirectDeclarator{
· Case: DirectDeclaratorStar,
· DirectDeclarator: &cc.DirectDeclarator{
· · Case: DirectDeclaratorIdent,
· · Token: example.c:1:5: IDENTIFIER "i",
· },
· Token: example.c:1:6: '[' "[",
· Token2: example.c:1:13: '*' "*",
· Token3: example.c:1:14: ']' "]",
· TypeQualifiers: &cc.TypeQualifiers{
· · Case: TypeQualifiersTypeQual,
· · TypeQualifier: &cc.TypeQualifier{
· · · Case: TypeQualifierConst,
· · · Token: example.c:1:7: CONST "const",
· · },
· },
}
Example (StaticArr)
fmt.Println(exampleAST(172, "int i[static const 42];"))
Output:

&cc.DirectDeclarator{
· AssignmentExpression: &cc.AssignmentExpression{
· · Case: AssignmentExpressionCond,
· · ConditionalExpression: &cc.ConditionalExpression{
· · · Case: ConditionalExpressionLOr,
· · · LogicalOrExpression: &cc.LogicalOrExpression{
· · · · Case: LogicalOrExpressionLAnd,
· · · · LogicalAndExpression: &cc.LogicalAndExpression{
· · · · · Case: LogicalAndExpressionOr,
· · · · · InclusiveOrExpression: &cc.InclusiveOrExpression{
· · · · · · Case: InclusiveOrExpressionXor,
· · · · · · ExclusiveOrExpression: &cc.ExclusiveOrExpression{
· · · · · · · AndExpression: &cc.AndExpression{
· · · · · · · · Case: AndExpressionEq,
· · · · · · · · EqualityExpression: &cc.EqualityExpression{
· · · · · · · · · Case: EqualityExpressionRel,
· · · · · · · · · RelationalExpression: &cc.RelationalExpression{
· · · · · · · · · · Case: RelationalExpressionShift,
· · · · · · · · · · ShiftExpression: &cc.ShiftExpression{
· · · · · · · · · · · AdditiveExpression: &cc.AdditiveExpression{
· · · · · · · · · · · · Case: AdditiveExpressionMul,
· · · · · · · · · · · · MultiplicativeExpression: &cc.MultiplicativeExpression{
· · · · · · · · · · · · · Case: MultiplicativeExpressionCast,
· · · · · · · · · · · · · CastExpression: &cc.CastExpression{
· · · · · · · · · · · · · · Case: CastExpressionUnary,
· · · · · · · · · · · · · · UnaryExpression: &cc.UnaryExpression{
· · · · · · · · · · · · · · · Case: UnaryExpressionPostfix,
· · · · · · · · · · · · · · · PostfixExpression: &cc.PostfixExpression{
· · · · · · · · · · · · · · · · Case: PostfixExpressionPrimary,
· · · · · · · · · · · · · · · · PrimaryExpression: &cc.PrimaryExpression{
· · · · · · · · · · · · · · · · · Case: PrimaryExpressionInt,
· · · · · · · · · · · · · · · · · Token: example.c:1:20: INTCONST "42",
· · · · · · · · · · · · · · · · },
· · · · · · · · · · · · · · · },
· · · · · · · · · · · · · · },
· · · · · · · · · · · · · },
· · · · · · · · · · · · },
· · · · · · · · · · · },
· · · · · · · · · · · Case: ShiftExpressionAdd,
· · · · · · · · · · },
· · · · · · · · · },
· · · · · · · · },
· · · · · · · },
· · · · · · · Case: ExclusiveOrExpressionAnd,
· · · · · · },
· · · · · },
· · · · },
· · · },
· · },
· },
· Case: DirectDeclaratorStaticArr,
· DirectDeclarator: &cc.DirectDeclarator{
· · Case: DirectDeclaratorIdent,
· · Token: example.c:1:5: IDENTIFIER "i",
· },
· Token: example.c:1:6: '[' "[",
· Token2: example.c:1:7: STATIC "static",
· Token3: example.c:1:22: ']' "]",
· TypeQualifiers: &cc.TypeQualifiers{
· · Case: TypeQualifiersTypeQual,
· · TypeQualifier: &cc.TypeQualifier{
· · · Case: TypeQualifierConst,
· · · Token: example.c:1:14: CONST "const",
· · },
· },
}

func (*DirectDeclarator) Name

func (n *DirectDeclarator) Name() StringID

Name returns n's declared name.

func (*DirectDeclarator) NameTok

func (n *DirectDeclarator) NameTok() (r Token)

NameTok returns n's declarin name token.

func (*DirectDeclarator) ParamScope

func (n *DirectDeclarator) ParamScope() Scope

ParamScope returns the innermost scope in which function parameters are declared for Case DirectDeclaratorFuncParam or DirectDeclaratorFuncIdent or nil otherwise.

func (*DirectDeclarator) Position

func (n *DirectDeclarator) Position() (r token.Position)

Position reports the position of the first component of n, if available.

func (*DirectDeclarator) String

func (n *DirectDeclarator) String() string

String implements fmt.Stringer.

func (*DirectDeclarator) TypeQualifier

func (n *DirectDeclarator) TypeQualifier() Type

type DirectDeclaratorCase

type DirectDeclaratorCase int

DirectDeclaratorCase represents case numbers of production DirectDeclarator

const (
	DirectDeclaratorIdent DirectDeclaratorCase = iota
	DirectDeclaratorDecl
	DirectDeclaratorArr
	DirectDeclaratorStaticArr
	DirectDeclaratorArrStatic
	DirectDeclaratorStar
	DirectDeclaratorFuncParam
	DirectDeclaratorFuncIdent
)

Values of type DirectDeclaratorCase

func (DirectDeclaratorCase) String

func (n DirectDeclaratorCase) String() string

String implements fmt.Stringer

type EnumSpecifier

type EnumSpecifier struct {
	AttributeSpecifierList *AttributeSpecifierList
	Case                   EnumSpecifierCase `PrettyPrint:"stringer,zero"`
	EnumeratorList         *EnumeratorList
	Token                  Token
	Token2                 Token
	Token3                 Token
	Token4                 Token
	Token5                 Token
	// contains filtered or unexported fields
}

EnumSpecifier represents data reduced by productions:

EnumSpecifier:
        "enum" AttributeSpecifierList IDENTIFIER '{' EnumeratorList ',' '}'  // Case EnumSpecifierDef
|       "enum" AttributeSpecifierList IDENTIFIER                             // Case EnumSpecifierTag
Example (Def)
fmt.Println(exampleAST(153, "enum e {a};"))
Output:

&cc.EnumSpecifier{
· Case: EnumSpecifierDef,
· EnumeratorList: &cc.EnumeratorList{
· · Enumerator: &cc.Enumerator{
· · · Case: EnumeratorIdent,
· · · Token: example.c:1:9: IDENTIFIER "a",
· · },
· },
· Token: example.c:1:1: ENUM "enum",
· Token2: example.c:1:6: IDENTIFIER "e",
· Token3: example.c:1:8: '{' "{",
· Token5: example.c:1:10: '}' "}",
}
Example (Tag)
fmt.Println(exampleAST(154, "enum e i;"))
Output:

&cc.EnumSpecifier{
· Case: EnumSpecifierTag,
· Token: example.c:1:1: ENUM "enum",
· Token2: example.c:1:6: IDENTIFIER "e",
}

func (*EnumSpecifier) LexicalScope added in v3.25.2

func (n *EnumSpecifier) LexicalScope() Scope

LexicalScope returns the lexical scope of n.

func (*EnumSpecifier) Position

func (n *EnumSpecifier) Position() (r token.Position)

Position reports the position of the first component of n, if available.

func (*EnumSpecifier) String

func (n *EnumSpecifier) String() string

String implements fmt.Stringer.

func (*EnumSpecifier) Type

func (n *EnumSpecifier) Type() Type

type EnumSpecifierCase

type EnumSpecifierCase int

EnumSpecifierCase represents case numbers of production EnumSpecifier

const (
	EnumSpecifierDef EnumSpecifierCase = iota
	EnumSpecifierTag
)

Values of type EnumSpecifierCase

func (EnumSpecifierCase) String

func (n EnumSpecifierCase) String() string

String implements fmt.Stringer

type Enumerator

type Enumerator struct {
	Operand                Operand
	AttributeSpecifierList *AttributeSpecifierList
	Case                   EnumeratorCase `PrettyPrint:"stringer,zero"`
	ConstantExpression     *ConstantExpression
	Token                  Token
	Token2                 Token
	// contains filtered or unexported fields
}

Enumerator represents data reduced by productions:

Enumerator:
        IDENTIFIER AttributeSpecifierList                         // Case EnumeratorIdent
|       IDENTIFIER AttributeSpecifierList '=' ConstantExpression  // Case EnumeratorExpr
Example (Expr)
fmt.Println(exampleAST(158, "enum e {a = 42};"))
Output:

&cc.Enumerator{
· Case: EnumeratorExpr,
· ConstantExpression: &cc.ConstantExpression{
· · ConditionalExpression: &cc.ConditionalExpression{
· · · Case: ConditionalExpressionLOr,
· · · LogicalOrExpression: &cc.LogicalOrExpression{
· · · · Case: LogicalOrExpressionLAnd,
· · · · LogicalAndExpression: &cc.LogicalAndExpression{
· · · · · Case: LogicalAndExpressionOr,
· · · · · InclusiveOrExpression: &cc.InclusiveOrExpression{
· · · · · · Case: InclusiveOrExpressionXor,
· · · · · · ExclusiveOrExpression: &cc.ExclusiveOrExpression{
· · · · · · · AndExpression: &cc.AndExpression{
· · · · · · · · Case: AndExpressionEq,
· · · · · · · · EqualityExpression: &cc.EqualityExpression{
· · · · · · · · · Case: EqualityExpressionRel,
· · · · · · · · · RelationalExpression: &cc.RelationalExpression{
· · · · · · · · · · Case: RelationalExpressionShift,
· · · · · · · · · · ShiftExpression: &cc.ShiftExpression{
· · · · · · · · · · · AdditiveExpression: &cc.AdditiveExpression{
· · · · · · · · · · · · Case: AdditiveExpressionMul,
· · · · · · · · · · · · MultiplicativeExpression: &cc.MultiplicativeExpression{
· · · · · · · · · · · · · Case: MultiplicativeExpressionCast,
· · · · · · · · · · · · · CastExpression: &cc.CastExpression{
· · · · · · · · · · · · · · Case: CastExpressionUnary,
· · · · · · · · · · · · · · UnaryExpression: &cc.UnaryExpression{
· · · · · · · · · · · · · · · Case: UnaryExpressionPostfix,
· · · · · · · · · · · · · · · PostfixExpression: &cc.PostfixExpression{
· · · · · · · · · · · · · · · · Case: PostfixExpressionPrimary,
· · · · · · · · · · · · · · · · PrimaryExpression: &cc.PrimaryExpression{
· · · · · · · · · · · · · · · · · Case: PrimaryExpressionInt,
· · · · · · · · · · · · · · · · · Token: example.c:1:13: INTCONST "42",
· · · · · · · · · · · · · · · · },
· · · · · · · · · · · · · · · },
· · · · · · · · · · · · · · },
· · · · · · · · · · · · · },
· · · · · · · · · · · · },
· · · · · · · · · · · },
· · · · · · · · · · · Case: ShiftExpressionAdd,
· · · · · · · · · · },
· · · · · · · · · },
· · · · · · · · },
· · · · · · · },
· · · · · · · Case: ExclusiveOrExpressionAnd,
· · · · · · },
· · · · · },
· · · · },
· · · },
· · },
· },
· Token: example.c:1:9: IDENTIFIER "a",
· Token2: example.c:1:11: '=' "=",
}
Example (Ident)
fmt.Println(exampleAST(157, "enum e {a};"))
Output:

&cc.Enumerator{
· Case: EnumeratorIdent,
· Token: example.c:1:9: IDENTIFIER "a",
}

func (*Enumerator) Position

func (n *Enumerator) Position() (r token.Position)

Position reports the position of the first component of n, if available.

func (*Enumerator) String

func (n *Enumerator) String() string

String implements fmt.Stringer.

type EnumeratorCase

type EnumeratorCase int

EnumeratorCase represents case numbers of production Enumerator

const (
	EnumeratorIdent EnumeratorCase = iota
	EnumeratorExpr
)

Values of type EnumeratorCase

func (EnumeratorCase) String

func (n EnumeratorCase) String() string

String implements fmt.Stringer

type EnumeratorList

type EnumeratorList struct {
	Enumerator     *Enumerator
	EnumeratorList *EnumeratorList
	Token          Token
}

EnumeratorList represents data reduced by productions:

EnumeratorList:
        Enumerator
|       EnumeratorList ',' Enumerator
Example (Case0)
fmt.Println(exampleAST(155, "enum e {a};"))
Output:

&cc.EnumeratorList{
· Enumerator: &cc.Enumerator{
· · Case: EnumeratorIdent,
· · Token: example.c:1:9: IDENTIFIER "a",
· },
}
Example (Case1)
fmt.Println(exampleAST(156, "enum e {a, b};"))
Output:

&cc.EnumeratorList{
· Enumerator: &cc.Enumerator{
· · Case: EnumeratorIdent,
· · Token: example.c:1:9: IDENTIFIER "a",
· },
· EnumeratorList: &cc.EnumeratorList{
· · Enumerator: &cc.Enumerator{
· · · Case: EnumeratorIdent,
· · · Token: example.c:1:12: IDENTIFIER "b",
· · },
· · Token: example.c:1:10: ',' ",",
· },
}

func (*EnumeratorList) Position

func (n *EnumeratorList) Position() (r token.Position)

Position reports the position of the first component of n, if available.

func (*EnumeratorList) String

func (n *EnumeratorList) String() string

String implements fmt.Stringer.

type EqualityExpression

type EqualityExpression struct {
	Operand Operand

	IsSideEffectsFree    bool
	Case                 EqualityExpressionCase `PrettyPrint:"stringer,zero"`
	EqualityExpression   *EqualityExpression
	RelationalExpression *RelationalExpression
	Token                Token
	// contains filtered or unexported fields
}

EqualityExpression represents data reduced by productions:

EqualityExpression:
        RelationalExpression                          // Case EqualityExpressionRel
|       EqualityExpression "==" RelationalExpression  // Case EqualityExpressionEq
|       EqualityExpression "!=" RelationalExpression  // Case EqualityExpressionNeq
Example (Eq)
fmt.Println(exampleAST(57, "int i = x == y;"))
Output:

&cc.EqualityExpression{
· Case: EqualityExpressionEq,
· EqualityExpression: &cc.EqualityExpression{
· · Case: EqualityExpressionRel,
· · RelationalExpression: &cc.RelationalExpression{
· · · Case: RelationalExpressionShift,
· · · ShiftExpression: &cc.ShiftExpression{
· · · · AdditiveExpression: &cc.AdditiveExpression{
· · · · · Case: AdditiveExpressionMul,
· · · · · MultiplicativeExpression: &cc.MultiplicativeExpression{
· · · · · · Case: MultiplicativeExpressionCast,
· · · · · · CastExpression: &cc.CastExpression{
· · · · · · · Case: CastExpressionUnary,
· · · · · · · UnaryExpression: &cc.UnaryExpression{
· · · · · · · · Case: UnaryExpressionPostfix,
· · · · · · · · PostfixExpression: &cc.PostfixExpression{
· · · · · · · · · Case: PostfixExpressionPrimary,
· · · · · · · · · PrimaryExpression: &cc.PrimaryExpression{
· · · · · · · · · · Case: PrimaryExpressionIdent,
· · · · · · · · · · Token: example.c:1:9: IDENTIFIER "x",
· · · · · · · · · },
· · · · · · · · },
· · · · · · · },
· · · · · · },
· · · · · },
· · · · },
· · · · Case: ShiftExpressionAdd,
· · · },
· · },
· },
· RelationalExpression: &cc.RelationalExpression{
· · Case: RelationalExpressionShift,
· · ShiftExpression: &cc.ShiftExpression{
· · · AdditiveExpression: &cc.AdditiveExpression{
· · · · Case: AdditiveExpressionMul,
· · · · MultiplicativeExpression: &cc.MultiplicativeExpression{
· · · · · Case: MultiplicativeExpressionCast,
· · · · · CastExpression: &cc.CastExpression{
· · · · · · Case: CastExpressionUnary,
· · · · · · UnaryExpression: &cc.UnaryExpression{
· · · · · · · Case: UnaryExpressionPostfix,
· · · · · · · PostfixExpression: &cc.PostfixExpression{
· · · · · · · · Case: PostfixExpressionPrimary,
· · · · · · · · PrimaryExpression: &cc.PrimaryExpression{
· · · · · · · · · Case: PrimaryExpressionIdent,
· · · · · · · · · Token: example.c:1:14: IDENTIFIER "y",
· · · · · · · · },
· · · · · · · },
· · · · · · },
· · · · · },
· · · · },
· · · },
· · · Case: ShiftExpressionAdd,
· · },
· },
· Token: example.c:1:11: EQ "==",
}
Example (Neq)
fmt.Println(exampleAST(58, "int i = x != y;"))
Output:

&cc.EqualityExpression{
· Case: EqualityExpressionNeq,
· EqualityExpression: &cc.EqualityExpression{
· · Case: EqualityExpressionRel,
· · RelationalExpression: &cc.RelationalExpression{
· · · Case: RelationalExpressionShift,
· · · ShiftExpression: &cc.ShiftExpression{
· · · · AdditiveExpression: &cc.AdditiveExpression{
· · · · · Case: AdditiveExpressionMul,
· · · · · MultiplicativeExpression: &cc.MultiplicativeExpression{
· · · · · · Case: MultiplicativeExpressionCast,
· · · · · · CastExpression: &cc.CastExpression{
· · · · · · · Case: CastExpressionUnary,
· · · · · · · UnaryExpression: &cc.UnaryExpression{
· · · · · · · · Case: UnaryExpressionPostfix,
· · · · · · · · PostfixExpression: &cc.PostfixExpression{
· · · · · · · · · Case: PostfixExpressionPrimary,
· · · · · · · · · PrimaryExpression: &cc.PrimaryExpression{
· · · · · · · · · · Case: PrimaryExpressionIdent,
· · · · · · · · · · Token: example.c:1:9: IDENTIFIER "x",
· · · · · · · · · },
· · · · · · · · },
· · · · · · · },
· · · · · · },
· · · · · },
· · · · },
· · · · Case: ShiftExpressionAdd,
· · · },
· · },
· },
· RelationalExpression: &cc.RelationalExpression{
· · Case: RelationalExpressionShift,
· · ShiftExpression: &cc.ShiftExpression{
· · · AdditiveExpression: &cc.AdditiveExpression{
· · · · Case: AdditiveExpressionMul,
· · · · MultiplicativeExpression: &cc.MultiplicativeExpression{
· · · · · Case: MultiplicativeExpressionCast,
· · · · · CastExpression: &cc.CastExpression{
· · · · · · Case: CastExpressionUnary,
· · · · · · UnaryExpression: &cc.UnaryExpression{
· · · · · · · Case: UnaryExpressionPostfix,
· · · · · · · PostfixExpression: &cc.PostfixExpression{
· · · · · · · · Case: PostfixExpressionPrimary,
· · · · · · · · PrimaryExpression: &cc.PrimaryExpression{
· · · · · · · · · Case: PrimaryExpressionIdent,
· · · · · · · · · Token: example.c:1:14: IDENTIFIER "y",
· · · · · · · · },
· · · · · · · },
· · · · · · },
· · · · · },
· · · · },
· · · },
· · · Case: ShiftExpressionAdd,
· · },
· },
· Token: example.c:1:11: NEQ "!=",
}
Example (Rel)
fmt.Println(exampleAST(56, "int i = x;"))
Output:

&cc.EqualityExpression{
· Case: EqualityExpressionRel,
· RelationalExpression: &cc.RelationalExpression{
· · Case: RelationalExpressionShift,
· · ShiftExpression: &cc.ShiftExpression{
· · · AdditiveExpression: &cc.AdditiveExpression{
· · · · Case: AdditiveExpressionMul,
· · · · MultiplicativeExpression: &cc.MultiplicativeExpression{
· · · · · Case: MultiplicativeExpressionCast,
· · · · · CastExpression: &cc.CastExpression{
· · · · · · Case: CastExpressionUnary,
· · · · · · UnaryExpression: &cc.UnaryExpression{
· · · · · · · Case: UnaryExpressionPostfix,
· · · · · · · PostfixExpression: &cc.PostfixExpression{
· · · · · · · · Case: PostfixExpressionPrimary,
· · · · · · · · PrimaryExpression: &cc.PrimaryExpression{
· · · · · · · · · Case: PrimaryExpressionIdent,
· · · · · · · · · Token: example.c:1:9: IDENTIFIER "x",
· · · · · · · · },
· · · · · · · },
· · · · · · },
· · · · · },
· · · · },
· · · },
· · · Case: ShiftExpressionAdd,
· · },
· },
}

func (*EqualityExpression) Declarator

func (n *EqualityExpression) Declarator() *Declarator

func (*EqualityExpression) Position

func (n *EqualityExpression) Position() (r token.Position)

Position reports the position of the first component of n, if available.

func (*EqualityExpression) Promote

func (n *EqualityExpression) Promote() Type

Promote returns the type the operands of the binary operation are promoted to.

func (*EqualityExpression) String

func (n *EqualityExpression) String() string

String implements fmt.Stringer.

type EqualityExpressionCase

type EqualityExpressionCase int

EqualityExpressionCase represents case numbers of production EqualityExpression

const (
	EqualityExpressionRel EqualityExpressionCase = iota
	EqualityExpressionEq
	EqualityExpressionNeq
)

Values of type EqualityExpressionCase

func (EqualityExpressionCase) String

func (n EqualityExpressionCase) String() string

String implements fmt.Stringer

type ExclusiveOrExpression

type ExclusiveOrExpression struct {
	Operand Operand

	IsSideEffectsFree     bool
	AndExpression         *AndExpression
	Case                  ExclusiveOrExpressionCase `PrettyPrint:"stringer,zero"`
	ExclusiveOrExpression *ExclusiveOrExpression
	Token                 Token
	// contains filtered or unexported fields
}

ExclusiveOrExpression represents data reduced by productions:

ExclusiveOrExpression:
        AndExpression                            // Case ExclusiveOrExpressionAnd
|       ExclusiveOrExpression '^' AndExpression  // Case ExclusiveOrExpressionXor
Example (And)
fmt.Println(exampleAST(61, "int i = x;"))
Output:

&cc.ExclusiveOrExpression{
· AndExpression: &cc.AndExpression{
· · Case: AndExpressionEq,
· · EqualityExpression: &cc.EqualityExpression{
· · · Case: EqualityExpressionRel,
· · · RelationalExpression: &cc.RelationalExpression{
· · · · Case: RelationalExpressionShift,
· · · · ShiftExpression: &cc.ShiftExpression{
· · · · · AdditiveExpression: &cc.AdditiveExpression{
· · · · · · Case: AdditiveExpressionMul,
· · · · · · MultiplicativeExpression: &cc.MultiplicativeExpression{
· · · · · · · Case: MultiplicativeExpressionCast,
· · · · · · · CastExpression: &cc.CastExpression{
· · · · · · · · Case: CastExpressionUnary,
· · · · · · · · UnaryExpression: &cc.UnaryExpression{
· · · · · · · · · Case: UnaryExpressionPostfix,
· · · · · · · · · PostfixExpression: &cc.PostfixExpression{
· · · · · · · · · · Case: PostfixExpressionPrimary,
· · · · · · · · · · PrimaryExpression: &cc.PrimaryExpression{
· · · · · · · · · · · Case: PrimaryExpressionIdent,
· · · · · · · · · · · Token: example.c:1:9: IDENTIFIER "x",
· · · · · · · · · · },
· · · · · · · · · },
· · · · · · · · },
· · · · · · · },
· · · · · · },
· · · · · },
· · · · · Case: ShiftExpressionAdd,
· · · · },
· · · },
· · },
· },
· Case: ExclusiveOrExpressionAnd,
}
Example (Xor)
fmt.Println(exampleAST(62, "int i = x^y;"))
Output:

&cc.ExclusiveOrExpression{
· AndExpression: &cc.AndExpression{
· · Case: AndExpressionEq,
· · EqualityExpression: &cc.EqualityExpression{
· · · Case: EqualityExpressionRel,
· · · RelationalExpression: &cc.RelationalExpression{
· · · · Case: RelationalExpressionShift,
· · · · ShiftExpression: &cc.ShiftExpression{
· · · · · AdditiveExpression: &cc.AdditiveExpression{
· · · · · · Case: AdditiveExpressionMul,
· · · · · · MultiplicativeExpression: &cc.MultiplicativeExpression{
· · · · · · · Case: MultiplicativeExpressionCast,
· · · · · · · CastExpression: &cc.CastExpression{
· · · · · · · · Case: CastExpressionUnary,
· · · · · · · · UnaryExpression: &cc.UnaryExpression{
· · · · · · · · · Case: UnaryExpressionPostfix,
· · · · · · · · · PostfixExpression: &cc.PostfixExpression{
· · · · · · · · · · Case: PostfixExpressionPrimary,
· · · · · · · · · · PrimaryExpression: &cc.PrimaryExpression{
· · · · · · · · · · · Case: PrimaryExpressionIdent,
· · · · · · · · · · · Token: example.c:1:11: IDENTIFIER "y",
· · · · · · · · · · },
· · · · · · · · · },
· · · · · · · · },
· · · · · · · },
· · · · · · },
· · · · · },
· · · · · Case: ShiftExpressionAdd,
· · · · },
· · · },
· · },
· },
· Case: ExclusiveOrExpressionXor,
· ExclusiveOrExpression: &cc.ExclusiveOrExpression{
· · AndExpression: &cc.AndExpression{
· · · Case: AndExpressionEq,
· · · EqualityExpression: &cc.EqualityExpression{
· · · · Case: EqualityExpressionRel,
· · · · RelationalExpression: &cc.RelationalExpression{
· · · · · Case: RelationalExpressionShift,
· · · · · ShiftExpression: &cc.ShiftExpression{
· · · · · · AdditiveExpression: &cc.AdditiveExpression{
· · · · · · · Case: AdditiveExpressionMul,
· · · · · · · MultiplicativeExpression: &cc.MultiplicativeExpression{
· · · · · · · · Case: MultiplicativeExpressionCast,
· · · · · · · · CastExpression: &cc.CastExpression{
· · · · · · · · · Case: CastExpressionUnary,
· · · · · · · · · UnaryExpression: &cc.UnaryExpression{
· · · · · · · · · · Case: UnaryExpressionPostfix,
· · · · · · · · · · PostfixExpression: &cc.PostfixExpression{
· · · · · · · · · · · Case: PostfixExpressionPrimary,
· · · · · · · · · · · PrimaryExpression: &cc.PrimaryExpression{
· · · · · · · · · · · · Case: PrimaryExpressionIdent,
· · · · · · · · · · · · Token: example.c:1:9: IDENTIFIER "x",
· · · · · · · · · · · },
· · · · · · · · · · },
· · · · · · · · · },
· · · · · · · · },
· · · · · · · },
· · · · · · },
· · · · · · Case: ShiftExpressionAdd,
· · · · · },
· · · · },
· · · },
· · },
· · Case: ExclusiveOrExpressionAnd,
· },
· Token: example.c:1:10: '^' "^",
}

func (*ExclusiveOrExpression) Declarator

func (n *ExclusiveOrExpression) Declarator() *Declarator

func (*ExclusiveOrExpression) Position

func (n *ExclusiveOrExpression) Position() (r token.Position)

Position reports the position of the first component of n, if available.

func (*ExclusiveOrExpression) Promote added in v3.25.2

func (n *ExclusiveOrExpression) Promote() Type

Promote returns the type the operands of the binary operation are promoted to.

func (*ExclusiveOrExpression) String

func (n *ExclusiveOrExpression) String() string

String implements fmt.Stringer.

type ExclusiveOrExpressionCase

type ExclusiveOrExpressionCase int

ExclusiveOrExpressionCase represents case numbers of production ExclusiveOrExpression

const (
	ExclusiveOrExpressionAnd ExclusiveOrExpressionCase = iota
	ExclusiveOrExpressionXor
)

Values of type ExclusiveOrExpressionCase

func (ExclusiveOrExpressionCase) String

func (n ExclusiveOrExpressionCase) String() string

String implements fmt.Stringer

type Expression

type Expression struct {
	Operand              Operand
	IsSideEffectsFree    bool
	AssignmentExpression *AssignmentExpression
	Case                 ExpressionCase `PrettyPrint:"stringer,zero"`
	Expression           *Expression
	Token                Token
}

Expression represents data reduced by productions:

Expression:
        AssignmentExpression                 // Case ExpressionAssign
|       Expression ',' AssignmentExpression  // Case ExpressionComma
Example (Assign)
fmt.Println(exampleAST(83, "int f() { i = x; };"))
Output:

&cc.Expression{
· AssignmentExpression: &cc.AssignmentExpression{
· · AssignmentExpression: &cc.AssignmentExpression{
· · · Case: AssignmentExpressionCond,
· · · ConditionalExpression: &cc.ConditionalExpression{
· · · · Case: ConditionalExpressionLOr,
· · · · LogicalOrExpression: &cc.LogicalOrExpression{
· · · · · Case: LogicalOrExpressionLAnd,
· · · · · LogicalAndExpression: &cc.LogicalAndExpression{
· · · · · · Case: LogicalAndExpressionOr,
· · · · · · InclusiveOrExpression: &cc.InclusiveOrExpression{
· · · · · · · Case: InclusiveOrExpressionXor,
· · · · · · · ExclusiveOrExpression: &cc.ExclusiveOrExpression{
· · · · · · · · AndExpression: &cc.AndExpression{
· · · · · · · · · Case: AndExpressionEq,
· · · · · · · · · EqualityExpression: &cc.EqualityExpression{
· · · · · · · · · · Case: EqualityExpressionRel,
· · · · · · · · · · RelationalExpression: &cc.RelationalExpression{
· · · · · · · · · · · Case: RelationalExpressionShift,
· · · · · · · · · · · ShiftExpression: &cc.ShiftExpression{
· · · · · · · · · · · · AdditiveExpression: &cc.AdditiveExpression{
· · · · · · · · · · · · · Case: AdditiveExpressionMul,
· · · · · · · · · · · · · MultiplicativeExpression: &cc.MultiplicativeExpression{
· · · · · · · · · · · · · · Case: MultiplicativeExpressionCast,
· · · · · · · · · · · · · · CastExpression: &cc.CastExpression{
· · · · · · · · · · · · · · · Case: CastExpressionUnary,
· · · · · · · · · · · · · · · UnaryExpression: &cc.UnaryExpression{
· · · · · · · · · · · · · · · · Case: UnaryExpressionPostfix,
· · · · · · · · · · · · · · · · PostfixExpression: &cc.PostfixExpression{
· · · · · · · · · · · · · · · · · Case: PostfixExpressionPrimary,
· · · · · · · · · · · · · · · · · PrimaryExpression: &cc.PrimaryExpression{
· · · · · · · · · · · · · · · · · · Case: PrimaryExpressionIdent,
· · · · · · · · · · · · · · · · · · Token: example.c:1:15: IDENTIFIER "x",
· · · · · · · · · · · · · · · · · },
· · · · · · · · · · · · · · · · },
· · · · · · · · · · · · · · · },
· · · · · · · · · · · · · · },
· · · · · · · · · · · · · },
· · · · · · · · · · · · },
· · · · · · · · · · · · Case: ShiftExpressionAdd,
· · · · · · · · · · · },
· · · · · · · · · · },
· · · · · · · · · },
· · · · · · · · },
· · · · · · · · Case: ExclusiveOrExpressionAnd,
· · · · · · · },
· · · · · · },
· · · · · },
· · · · },
· · · },
· · },
· · Case: AssignmentExpressionAssign,
· · Token: example.c:1:13: '=' "=",
· · UnaryExpression: &cc.UnaryExpression{
· · · Case: UnaryExpressionPostfix,
· · · PostfixExpression: &cc.PostfixExpression{
· · · · Case: PostfixExpressionPrimary,
· · · · PrimaryExpression: &cc.PrimaryExpression{
· · · · · Case: PrimaryExpressionIdent,
· · · · · Token: example.c:1:11: IDENTIFIER "i",
· · · · },
· · · },
· · },
· },
· Case: ExpressionAssign,
}
Example (Comma)
fmt.Println(exampleAST(84, "int f() { x, y; };"))
Output:

&cc.Expression{
· AssignmentExpression: &cc.AssignmentExpression{
· · Case: AssignmentExpressionCond,
· · ConditionalExpression: &cc.ConditionalExpression{
· · · Case: ConditionalExpressionLOr,
· · · LogicalOrExpression: &cc.LogicalOrExpression{
· · · · Case: LogicalOrExpressionLAnd,
· · · · LogicalAndExpression: &cc.LogicalAndExpression{
· · · · · Case: LogicalAndExpressionOr,
· · · · · InclusiveOrExpression: &cc.InclusiveOrExpression{
· · · · · · Case: InclusiveOrExpressionXor,
· · · · · · ExclusiveOrExpression: &cc.ExclusiveOrExpression{
· · · · · · · AndExpression: &cc.AndExpression{
· · · · · · · · Case: AndExpressionEq,
· · · · · · · · EqualityExpression: &cc.EqualityExpression{
· · · · · · · · · Case: EqualityExpressionRel,
· · · · · · · · · RelationalExpression: &cc.RelationalExpression{
· · · · · · · · · · Case: RelationalExpressionShift,
· · · · · · · · · · ShiftExpression: &cc.ShiftExpression{
· · · · · · · · · · · AdditiveExpression: &cc.AdditiveExpression{
· · · · · · · · · · · · Case: AdditiveExpressionMul,
· · · · · · · · · · · · MultiplicativeExpression: &cc.MultiplicativeExpression{
· · · · · · · · · · · · · Case: MultiplicativeExpressionCast,
· · · · · · · · · · · · · CastExpression: &cc.CastExpression{
· · · · · · · · · · · · · · Case: CastExpressionUnary,
· · · · · · · · · · · · · · UnaryExpression: &cc.UnaryExpression{
· · · · · · · · · · · · · · · Case: UnaryExpressionPostfix,
· · · · · · · · · · · · · · · PostfixExpression: &cc.PostfixExpression{
· · · · · · · · · · · · · · · · Case: PostfixExpressionPrimary,
· · · · · · · · · · · · · · · · PrimaryExpression: &cc.PrimaryExpression{
· · · · · · · · · · · · · · · · · Case: PrimaryExpressionIdent,
· · · · · · · · · · · · · · · · · Token: example.c:1:14: IDENTIFIER "y",
· · · · · · · · · · · · · · · · },
· · · · · · · · · · · · · · · },
· · · · · · · · · · · · · · },
· · · · · · · · · · · · · },
· · · · · · · · · · · · },
· · · · · · · · · · · },
· · · · · · · · · · · Case: ShiftExpressionAdd,
· · · · · · · · · · },
· · · · · · · · · },
· · · · · · · · },
· · · · · · · },
· · · · · · · Case: ExclusiveOrExpressionAnd,
· · · · · · },
· · · · · },
· · · · },
· · · },
· · },
· },
· Case: ExpressionComma,
· Expression: &cc.Expression{
· · AssignmentExpression: &cc.AssignmentExpression{
· · · Case: AssignmentExpressionCond,
· · · ConditionalExpression: &cc.ConditionalExpression{
· · · · Case: ConditionalExpressionLOr,
· · · · LogicalOrExpression: &cc.LogicalOrExpression{
· · · · · Case: LogicalOrExpressionLAnd,
· · · · · LogicalAndExpression: &cc.LogicalAndExpression{
· · · · · · Case: LogicalAndExpressionOr,
· · · · · · InclusiveOrExpression: &cc.InclusiveOrExpression{
· · · · · · · Case: InclusiveOrExpressionXor,
· · · · · · · ExclusiveOrExpression: &cc.ExclusiveOrExpression{
· · · · · · · · AndExpression: &cc.AndExpression{
· · · · · · · · · Case: AndExpressionEq,
· · · · · · · · · EqualityExpression: &cc.EqualityExpression{
· · · · · · · · · · Case: EqualityExpressionRel,
· · · · · · · · · · RelationalExpression: &cc.RelationalExpression{
· · · · · · · · · · · Case: RelationalExpressionShift,
· · · · · · · · · · · ShiftExpression: &cc.ShiftExpression{
· · · · · · · · · · · · AdditiveExpression: &cc.AdditiveExpression{
· · · · · · · · · · · · · Case: AdditiveExpressionMul,
· · · · · · · · · · · · · MultiplicativeExpression: &cc.MultiplicativeExpression{
· · · · · · · · · · · · · · Case: MultiplicativeExpressionCast,
· · · · · · · · · · · · · · CastExpression: &cc.CastExpression{
· · · · · · · · · · · · · · · Case: CastExpressionUnary,
· · · · · · · · · · · · · · · UnaryExpression: &cc.UnaryExpression{
· · · · · · · · · · · · · · · · Case: UnaryExpressionPostfix,
· · · · · · · · · · · · · · · · PostfixExpression: &cc.PostfixExpression{
· · · · · · · · · · · · · · · · · Case: PostfixExpressionPrimary,
· · · · · · · · · · · · · · · · · PrimaryExpression: &cc.PrimaryExpression{
· · · · · · · · · · · · · · · · · · Case: PrimaryExpressionIdent,
· · · · · · · · · · · · · · · · · · Token: example.c:1:11: IDENTIFIER "x",
· · · · · · · · · · · · · · · · · },
· · · · · · · · · · · · · · · · },
· · · · · · · · · · · · · · · },
· · · · · · · · · · · · · · },
· · · · · · · · · · · · · },
· · · · · · · · · · · · },
· · · · · · · · · · · · Case: ShiftExpressionAdd,
· · · · · · · · · · · },
· · · · · · · · · · },
· · · · · · · · · },
· · · · · · · · },
· · · · · · · · Case: ExclusiveOrExpressionAnd,
· · · · · · · },
· · · · · · },
· · · · · },
· · · · },
· · · },
· · },
· · Case: ExpressionAssign,
· },
· Token: example.c:1:12: ',' ",",
}

func (*Expression) Declarator

func (n *Expression) Declarator() *Declarator

func (*Expression) Position

func (n *Expression) Position() (r token.Position)

Position reports the position of the first component of n, if available.

func (*Expression) String

func (n *Expression) String() string

String implements fmt.Stringer.

type ExpressionCase

type ExpressionCase int

ExpressionCase represents case numbers of production Expression

const (
	ExpressionAssign ExpressionCase = iota
	ExpressionComma
)

Values of type ExpressionCase

func (ExpressionCase) String

func (n ExpressionCase) String() string

String implements fmt.Stringer

type ExpressionList

type ExpressionList struct {
	AssignmentExpression *AssignmentExpression
	ExpressionList       *ExpressionList
	Token                Token
}

ExpressionList represents data reduced by productions:

ExpressionList:
        AssignmentExpression
|       ExpressionList ',' AssignmentExpression
Example (Case0)
fmt.Println(exampleAST(268, "int i __attribute__((a(b)));"))
Output:

&cc.ExpressionList{
· AssignmentExpression: &cc.AssignmentExpression{
· · Case: AssignmentExpressionCond,
· · ConditionalExpression: &cc.ConditionalExpression{
· · · Case: ConditionalExpressionLOr,
· · · LogicalOrExpression: &cc.LogicalOrExpression{
· · · · Case: LogicalOrExpressionLAnd,
· · · · LogicalAndExpression: &cc.LogicalAndExpression{
· · · · · Case: LogicalAndExpressionOr,
· · · · · InclusiveOrExpression: &cc.InclusiveOrExpression{
· · · · · · Case: InclusiveOrExpressionXor,
· · · · · · ExclusiveOrExpression: &cc.ExclusiveOrExpression{
· · · · · · · AndExpression: &cc.AndExpression{
· · · · · · · · Case: AndExpressionEq,
· · · · · · · · EqualityExpression: &cc.EqualityExpression{
· · · · · · · · · Case: EqualityExpressionRel,
· · · · · · · · · RelationalExpression: &cc.RelationalExpression{
· · · · · · · · · · Case: RelationalExpressionShift,
· · · · · · · · · · ShiftExpression: &cc.ShiftExpression{
· · · · · · · · · · · AdditiveExpression: &cc.AdditiveExpression{
· · · · · · · · · · · · Case: AdditiveExpressionMul,
· · · · · · · · · · · · MultiplicativeExpression: &cc.MultiplicativeExpression{
· · · · · · · · · · · · · Case: MultiplicativeExpressionCast,
· · · · · · · · · · · · · CastExpression: &cc.CastExpression{
· · · · · · · · · · · · · · Case: CastExpressionUnary,
· · · · · · · · · · · · · · UnaryExpression: &cc.UnaryExpression{
· · · · · · · · · · · · · · · Case: UnaryExpressionPostfix,
· · · · · · · · · · · · · · · PostfixExpression: &cc.PostfixExpression{
· · · · · · · · · · · · · · · · Case: PostfixExpressionPrimary,
· · · · · · · · · · · · · · · · PrimaryExpression: &cc.PrimaryExpression{
· · · · · · · · · · · · · · · · · Case: PrimaryExpressionIdent,
· · · · · · · · · · · · · · · · · Token: example.c:1:24: IDENTIFIER "b",
· · · · · · · · · · · · · · · · },
· · · · · · · · · · · · · · · },
· · · · · · · · · · · · · · },
· · · · · · · · · · · · · },
· · · · · · · · · · · · },
· · · · · · · · · · · },
· · · · · · · · · · · Case: ShiftExpressionAdd,
· · · · · · · · · · },
· · · · · · · · · },
· · · · · · · · },
· · · · · · · },
· · · · · · · Case: ExclusiveOrExpressionAnd,
· · · · · · },
· · · · · },
· · · · },
· · · },
· · },
· },
}
Example (Case1)
fmt.Println(exampleAST(269, "int i __attribute__((a(b, c)));"))
Output:

&cc.ExpressionList{
· AssignmentExpression: &cc.AssignmentExpression{
· · Case: AssignmentExpressionCond,
· · ConditionalExpression: &cc.ConditionalExpression{
· · · Case: ConditionalExpressionLOr,
· · · LogicalOrExpression: &cc.LogicalOrExpression{
· · · · Case: LogicalOrExpressionLAnd,
· · · · LogicalAndExpression: &cc.LogicalAndExpression{
· · · · · Case: LogicalAndExpressionOr,
· · · · · InclusiveOrExpression: &cc.InclusiveOrExpression{
· · · · · · Case: InclusiveOrExpressionXor,
· · · · · · ExclusiveOrExpression: &cc.ExclusiveOrExpression{
· · · · · · · AndExpression: &cc.AndExpression{
· · · · · · · · Case: AndExpressionEq,
· · · · · · · · EqualityExpression: &cc.EqualityExpression{
· · · · · · · · · Case: EqualityExpressionRel,
· · · · · · · · · RelationalExpression: &cc.RelationalExpression{
· · · · · · · · · · Case: RelationalExpressionShift,
· · · · · · · · · · ShiftExpression: &cc.ShiftExpression{
· · · · · · · · · · · AdditiveExpression: &cc.AdditiveExpression{
· · · · · · · · · · · · Case: AdditiveExpressionMul,
· · · · · · · · · · · · MultiplicativeExpression: &cc.MultiplicativeExpression{
· · · · · · · · · · · · · Case: MultiplicativeExpressionCast,
· · · · · · · · · · · · · CastExpression: &cc.CastExpression{
· · · · · · · · · · · · · · Case: CastExpressionUnary,
· · · · · · · · · · · · · · UnaryExpression: &cc.UnaryExpression{
· · · · · · · · · · · · · · · Case: UnaryExpressionPostfix,
· · · · · · · · · · · · · · · PostfixExpression: &cc.PostfixExpression{
· · · · · · · · · · · · · · · · Case: PostfixExpressionPrimary,
· · · · · · · · · · · · · · · · PrimaryExpression: &cc.PrimaryExpression{
· · · · · · · · · · · · · · · · · Case: PrimaryExpressionIdent,
· · · · · · · · · · · · · · · · · Token: example.c:1:24: IDENTIFIER "b",
· · · · · · · · · · · · · · · · },
· · · · · · · · · · · · · · · },
· · · · · · · · · · · · · · },
· · · · · · · · · · · · · },
· · · · · · · · · · · · },
· · · · · · · · · · · },
· · · · · · · · · · · Case: ShiftExpressionAdd,
· · · · · · · · · · },
· · · · · · · · · },
· · · · · · · · },
· · · · · · · },
· · · · · · · Case: ExclusiveOrExpressionAnd,
· · · · · · },
· · · · · },
· · · · },
· · · },
· · },
· },
· ExpressionList: &cc.ExpressionList{
· · AssignmentExpression: &cc.AssignmentExpression{
· · · Case: AssignmentExpressionCond,
· · · ConditionalExpression: &cc.ConditionalExpression{
· · · · Case: ConditionalExpressionLOr,
· · · · LogicalOrExpression: &cc.LogicalOrExpression{
· · · · · Case: LogicalOrExpressionLAnd,
· · · · · LogicalAndExpression: &cc.LogicalAndExpression{
· · · · · · Case: LogicalAndExpressionOr,
· · · · · · InclusiveOrExpression: &cc.InclusiveOrExpression{
· · · · · · · Case: InclusiveOrExpressionXor,
· · · · · · · ExclusiveOrExpression: &cc.ExclusiveOrExpression{
· · · · · · · · AndExpression: &cc.AndExpression{
· · · · · · · · · Case: AndExpressionEq,
· · · · · · · · · EqualityExpression: &cc.EqualityExpression{
· · · · · · · · · · Case: EqualityExpressionRel,
· · · · · · · · · · RelationalExpression: &cc.RelationalExpression{
· · · · · · · · · · · Case: RelationalExpressionShift,
· · · · · · · · · · · ShiftExpression: &cc.ShiftExpression{
· · · · · · · · · · · · AdditiveExpression: &cc.AdditiveExpression{
· · · · · · · · · · · · · Case: AdditiveExpressionMul,
· · · · · · · · · · · · · MultiplicativeExpression: &cc.MultiplicativeExpression{
· · · · · · · · · · · · · · Case: MultiplicativeExpressionCast,
· · · · · · · · · · · · · · CastExpression: &cc.CastExpression{
· · · · · · · · · · · · · · · Case: CastExpressionUnary,
· · · · · · · · · · · · · · · UnaryExpression: &cc.UnaryExpression{
· · · · · · · · · · · · · · · · Case: UnaryExpressionPostfix,
· · · · · · · · · · · · · · · · PostfixExpression: &cc.PostfixExpression{
· · · · · · · · · · · · · · · · · Case: PostfixExpressionPrimary,
· · · · · · · · · · · · · · · · · PrimaryExpression: &cc.PrimaryExpression{
· · · · · · · · · · · · · · · · · · Case: PrimaryExpressionIdent,
· · · · · · · · · · · · · · · · · · Token: example.c:1:27: IDENTIFIER "c",
· · · · · · · · · · · · · · · · · },
· · · · · · · · · · · · · · · · },
· · · · · · · · · · · · · · · },
· · · · · · · · · · · · · · },
· · · · · · · · · · · · · },
· · · · · · · · · · · · },
· · · · · · · · · · · · Case: ShiftExpressionAdd,
· · · · · · · · · · · },
· · · · · · · · · · },
· · · · · · · · · },
· · · · · · · · },
· · · · · · · · Case: ExclusiveOrExpressionAnd,
· · · · · · · },
· · · · · · },
· · · · · },
· · · · },
· · · },
· · },
· · Token: example.c:1:25: ',' ",",
· },
}

func (*ExpressionList) Position

func (n *ExpressionList) Position() (r token.Position)

Position reports the position of the first component of n, if available.

func (*ExpressionList) String

func (n *ExpressionList) String() string

String implements fmt.Stringer.

type ExpressionStatement

type ExpressionStatement struct {
	AttributeSpecifierList *AttributeSpecifierList
	Expression             *Expression
	Token                  Token
}

ExpressionStatement represents data reduced by production:

ExpressionStatement:
        Expression AttributeSpecifierList ';'
Example (Case0)
fmt.Println(exampleAST(230, "int f() { g(); }"))
Output:

&cc.ExpressionStatement{
· Expression: &cc.Expression{
· · AssignmentExpression: &cc.AssignmentExpression{
· · · Case: AssignmentExpressionCond,
· · · ConditionalExpression: &cc.ConditionalExpression{
· · · · Case: ConditionalExpressionLOr,
· · · · LogicalOrExpression: &cc.LogicalOrExpression{
· · · · · Case: LogicalOrExpressionLAnd,
· · · · · LogicalAndExpression: &cc.LogicalAndExpression{
· · · · · · Case: LogicalAndExpressionOr,
· · · · · · InclusiveOrExpression: &cc.InclusiveOrExpression{
· · · · · · · Case: InclusiveOrExpressionXor,
· · · · · · · ExclusiveOrExpression: &cc.ExclusiveOrExpression{
· · · · · · · · AndExpression: &cc.AndExpression{
· · · · · · · · · Case: AndExpressionEq,
· · · · · · · · · EqualityExpression: &cc.EqualityExpression{
· · · · · · · · · · Case: EqualityExpressionRel,
· · · · · · · · · · RelationalExpression: &cc.RelationalExpression{
· · · · · · · · · · · Case: RelationalExpressionShift,
· · · · · · · · · · · ShiftExpression: &cc.ShiftExpression{
· · · · · · · · · · · · AdditiveExpression: &cc.AdditiveExpression{
· · · · · · · · · · · · · Case: AdditiveExpressionMul,
· · · · · · · · · · · · · MultiplicativeExpression: &cc.MultiplicativeExpression{
· · · · · · · · · · · · · · Case: MultiplicativeExpressionCast,
· · · · · · · · · · · · · · CastExpression: &cc.CastExpression{
· · · · · · · · · · · · · · · Case: CastExpressionUnary,
· · · · · · · · · · · · · · · UnaryExpression: &cc.UnaryExpression{
· · · · · · · · · · · · · · · · Case: UnaryExpressionPostfix,
· · · · · · · · · · · · · · · · PostfixExpression: &cc.PostfixExpression{
· · · · · · · · · · · · · · · · · Case: PostfixExpressionCall,
· · · · · · · · · · · · · · · · · PostfixExpression: &cc.PostfixExpression{
· · · · · · · · · · · · · · · · · · Case: PostfixExpressionPrimary,
· · · · · · · · · · · · · · · · · · PrimaryExpression: &cc.PrimaryExpression{
· · · · · · · · · · · · · · · · · · · Case: PrimaryExpressionIdent,
· · · · · · · · · · · · · · · · · · · Token: example.c:1:11: IDENTIFIER "g",
· · · · · · · · · · · · · · · · · · },
· · · · · · · · · · · · · · · · · },
· · · · · · · · · · · · · · · · · Token: example.c:1:12: '(' "(",
· · · · · · · · · · · · · · · · · Token2: example.c:1:13: ')' ")",
· · · · · · · · · · · · · · · · },
· · · · · · · · · · · · · · · },
· · · · · · · · · · · · · · },
· · · · · · · · · · · · · },
· · · · · · · · · · · · },
· · · · · · · · · · · · Case: ShiftExpressionAdd,
· · · · · · · · · · · },
· · · · · · · · · · },
· · · · · · · · · },
· · · · · · · · },
· · · · · · · · Case: ExclusiveOrExpressionAnd,
· · · · · · · },
· · · · · · },
· · · · · },
· · · · },
· · · },
· · },
· · Case: ExpressionAssign,
· },
· Token: example.c:1:14: ';' ";",
}

func (*ExpressionStatement) Position

func (n *ExpressionStatement) Position() (r token.Position)

Position reports the position of the first component of n, if available.

func (*ExpressionStatement) String

func (n *ExpressionStatement) String() string

String implements fmt.Stringer.

type ExternalDeclaration

type ExternalDeclaration struct {
	AsmFunctionDefinition *AsmFunctionDefinition
	AsmStatement          *AsmStatement
	Case                  ExternalDeclarationCase `PrettyPrint:"stringer,zero"`
	Declaration           *Declaration
	FunctionDefinition    *FunctionDefinition
	PragmaSTDC            *PragmaSTDC
	Token                 Token
}

ExternalDeclaration represents data reduced by productions:

ExternalDeclaration:
        FunctionDefinition     // Case ExternalDeclarationFuncDef
|       Declaration            // Case ExternalDeclarationDecl
|       AsmFunctionDefinition  // Case ExternalDeclarationAsm
|       AsmStatement           // Case ExternalDeclarationAsmStmt
|       ';'                    // Case ExternalDeclarationEmpty
|       PragmaSTDC             // Case ExternalDeclarationPragma
Example (Asm)
fmt.Println(exampleAST(247, "int f() __asm__(\"nop\");"))
Output:

&cc.ExternalDeclaration{
· AsmFunctionDefinition: &cc.AsmFunctionDefinition{
· · AsmStatement: &cc.AsmStatement{
· · · Asm: &cc.Asm{
· · · · Token: example.c:1:9: ASM "__asm__",
· · · · Token2: example.c:1:16: '(' "(",
· · · · Token3: example.c:1:17: STRINGLITERAL "nop",
· · · · Token4: example.c:1:22: ')' ")",
· · · },
· · · Token: example.c:1:23: ';' ";",
· · },
· · DeclarationSpecifiers: &cc.DeclarationSpecifiers{
· · · Case: DeclarationSpecifiersTypeSpec,
· · · TypeSpecifier: &cc.TypeSpecifier{
· · · · Case: TypeSpecifierInt,
· · · · Token: example.c:1:1: INT "int",
· · · },
· · },
· · Declarator: &cc.Declarator{
· · · DirectDeclarator: &cc.DirectDeclarator{
· · · · Case: DirectDeclaratorFuncIdent,
· · · · DirectDeclarator: &cc.DirectDeclarator{
· · · · · Case: DirectDeclaratorIdent,
· · · · · Token: example.c:1:5: IDENTIFIER "f",
· · · · },
· · · · Token: example.c:1:6: '(' "(",
· · · · Token2: example.c:1:7: ')' ")",
· · · },
· · },
· },
· Case: ExternalDeclarationAsm,
}
Example (AsmStmt)
fmt.Println(exampleAST(248, "__asm__(\"nop\");"))
Output:

&cc.ExternalDeclaration{
· AsmStatement: &cc.AsmStatement{
· · Asm: &cc.Asm{
· · · Token: example.c:1:1: ASM "__asm__",
· · · Token2: example.c:1:8: '(' "(",
· · · Token3: example.c:1:9: STRINGLITERAL "nop",
· · · Token4: example.c:1:14: ')' ")",
· · },
· · Token: example.c:1:15: ';' ";",
· },
· Case: ExternalDeclarationAsmStmt,
}
Example (Decl)
fmt.Println(exampleAST(246, "int i;"))
Output:

&cc.ExternalDeclaration{
· Case: ExternalDeclarationDecl,
· Declaration: &cc.Declaration{
· · DeclarationSpecifiers: &cc.DeclarationSpecifiers{
· · · Case: DeclarationSpecifiersTypeSpec,
· · · TypeSpecifier: &cc.TypeSpecifier{
· · · · Case: TypeSpecifierInt,
· · · · Token: example.c:1:1: INT "int",
· · · },
· · },
· · InitDeclaratorList: &cc.InitDeclaratorList{
· · · InitDeclarator: &cc.InitDeclarator{
· · · · Case: InitDeclaratorDecl,
· · · · Declarator: &cc.Declarator{
· · · · · DirectDeclarator: &cc.DirectDeclarator{
· · · · · · Case: DirectDeclaratorIdent,
· · · · · · Token: example.c:1:5: IDENTIFIER "i",
· · · · · },
· · · · },
· · · },
· · },
· · Token: example.c:1:6: ';' ";",
· },
}
Example (Empty)
fmt.Println(exampleAST(249, ";"))
Output:

&cc.ExternalDeclaration{
· Case: ExternalDeclarationEmpty,
· Token: example.c:1:1: ';' ";",
}
Example (FuncDef)
fmt.Println(exampleAST(245, "int f() {}"))
Output:

&cc.ExternalDeclaration{
· Case: ExternalDeclarationFuncDef,
· FunctionDefinition: &cc.FunctionDefinition{
· · CompoundStatement: &cc.CompoundStatement{
· · · Token: example.c:1:9: '{' "{",
· · · Token2: example.c:1:10: '}' "}",
· · },
· · DeclarationSpecifiers: &cc.DeclarationSpecifiers{
· · · Case: DeclarationSpecifiersTypeSpec,
· · · TypeSpecifier: &cc.TypeSpecifier{
· · · · Case: TypeSpecifierInt,
· · · · Token: example.c:1:1: INT "int",
· · · },
· · },
· · Declarator: &cc.Declarator{
· · · DirectDeclarator: &cc.DirectDeclarator{
· · · · Case: DirectDeclaratorFuncIdent,
· · · · DirectDeclarator: &cc.DirectDeclarator{
· · · · · Case: DirectDeclaratorIdent,
· · · · · Token: example.c:1:5: IDENTIFIER "f",
· · · · },
· · · · Token: example.c:1:6: '(' "(",
· · · · Token2: example.c:1:7: ')' ")",
· · · },
· · },
· },
}
Example (Pragma)
fmt.Println(exampleAST(250, "#pragma STDC CX_LIMITED_RANGE DEFAULT"))
Output:

&cc.ExternalDeclaration{
· Case: ExternalDeclarationPragma,
· PragmaSTDC: &cc.PragmaSTDC{
· · Token: example.c:1:9: PPPRAGMASTDC "__pragma_stdc",
· · Token2: example.c:1:9: IDENTIFIER "STDC",
· · Token3: example.c:1:14: IDENTIFIER "CX_LIMITED_RANGE",
· · Token4: example.c:1:31: IDENTIFIER "DEFAULT",
· },
}

func (*ExternalDeclaration) Position

func (n *ExternalDeclaration) Position() (r token.Position)

Position reports the position of the first component of n, if available.

func (*ExternalDeclaration) String

func (n *ExternalDeclaration) String() string

String implements fmt.Stringer.

type ExternalDeclarationCase

type ExternalDeclarationCase int

ExternalDeclarationCase represents case numbers of production ExternalDeclaration

const (
	ExternalDeclarationFuncDef ExternalDeclarationCase = iota
	ExternalDeclarationDecl
	ExternalDeclarationAsm
	ExternalDeclarationAsmStmt
	ExternalDeclarationEmpty
	ExternalDeclarationPragma
)

Values of type ExternalDeclarationCase

func (ExternalDeclarationCase) String

func (n ExternalDeclarationCase) String() string

String implements fmt.Stringer

type Field

type Field interface {
	BitFieldBlockFirst() Field
	BitFieldBlockWidth() int
	BitFieldOffset() int
	BitFieldWidth() int
	Declarator() *StructDeclarator
	InUnion() bool // Directly or indirectly
	Index() int
	IsBitField() bool
	IsFlexible() bool // https://en.wikipedia.org/wiki/Flexible_array_member
	Mask() uint64
	Name() StringID  // Can be zero.
	Offset() uintptr // In bytes from the beginning of the struct/union.
	Padding() int    // In bytes after the field. N/A for bit fields, fields preceding bit fields or union fields.
	Parent() Type    // The struct/union type that contains the field.
	Promote() Type
	Type() Type // Field type.
}

A Field describes a single field in a struct/union.

type Filesystem added in v3.25.2

type Filesystem interface {
	// Stat is an analog of os.Stat, but also accepts a flag to indicate a system include (<file.h>).
	Stat(path string, sys bool) (os.FileInfo, error)
	// Open is an analog of os.Open, but also accepts a flag to indicate a system include (<file.h>).
	Open(path string, sys bool) (io.ReadCloser, error)
}

Filesystem abstraction used in CC. The underlying value must be comparable (e.g. pointer) to be used in map keys.

func LocalFS added in v3.25.2

func LocalFS() Filesystem

LocalFS returns a local filesystem implementation.

func Overlay added in v3.25.2

func Overlay(pri, sec Filesystem) Filesystem

Overlay is a filesystem implementation that first check if the file is available in the primary FS and if not, falls back to a secondary FS.

func StaticFS added in v3.25.2

func StaticFS(files map[string]string) Filesystem

StaticFS implements filesystem interface by serving string values form the provided map.

func WorkingDir added in v3.25.2

func WorkingDir(wd string, fs Filesystem) Filesystem

WorkingDir is a filesystem implementation that resolves paths relative to a given directory. If filesystem is not specified, the local one will be used.

type Float128Value

type Float128Value struct {
	N   *big.Float
	NaN bool
}

func (*Float128Value) IsConst added in v3.33.6

func (v *Float128Value) IsConst() bool

func (*Float128Value) IsNonZero added in v3.33.6

func (v *Float128Value) IsNonZero() bool

func (*Float128Value) IsZero added in v3.33.6

func (v *Float128Value) IsZero() bool

func (*Float128Value) String

func (v *Float128Value) String() string

type Float32Value

type Float32Value float32

func (Float32Value) IsConst added in v3.33.6

func (v Float32Value) IsConst() bool

func (Float32Value) IsNonZero added in v3.33.6

func (v Float32Value) IsNonZero() bool

func (Float32Value) IsZero added in v3.33.6

func (v Float32Value) IsZero() bool

type Float64Value

type Float64Value float64

func (Float64Value) IsConst added in v3.33.6

func (v Float64Value) IsConst() bool

func (Float64Value) IsNonZero added in v3.33.6

func (v Float64Value) IsNonZero() bool

func (Float64Value) IsZero added in v3.33.6

func (v Float64Value) IsZero() bool

type FunctionDefinition

type FunctionDefinition struct {
	CallSiteComplexExpr []*AssignmentExpression
	CompositeLiterals   []*PostfixExpression
	ComputedGotos       map[StringID]*UnaryExpression
	Gotos               map[StringID]*JumpStatement
	InitDeclarators     []*InitDeclarator
	Labels              map[StringID]*LabeledStatement
	ReturnComplexExpr   []*Expression
	VLAs                []*Declarator

	CompoundStatement     *CompoundStatement
	DeclarationList       *DeclarationList
	DeclarationSpecifiers *DeclarationSpecifiers
	Declarator            *Declarator
	// contains filtered or unexported fields
}

FunctionDefinition represents data reduced by production:

FunctionDefinition:
        DeclarationSpecifiers Declarator DeclarationList CompoundStatement
Example (Case0)
fmt.Println(exampleAST(251, "int f() {}"))
Output:

&cc.FunctionDefinition{
· CompoundStatement: &cc.CompoundStatement{
· · Token: example.c:1:9: '{' "{",
· · Token2: example.c:1:10: '}' "}",
· },
· DeclarationSpecifiers: &cc.DeclarationSpecifiers{
· · Case: DeclarationSpecifiersTypeSpec,
· · TypeSpecifier: &cc.TypeSpecifier{
· · · Case: TypeSpecifierInt,
· · · Token: example.c:1:1: INT "int",
· · },
· },
· Declarator: &cc.Declarator{
· · DirectDeclarator: &cc.DirectDeclarator{
· · · Case: DirectDeclaratorFuncIdent,
· · · DirectDeclarator: &cc.DirectDeclarator{
· · · · Case: DirectDeclaratorIdent,
· · · · Token: example.c:1:5: IDENTIFIER "f",
· · · },
· · · Token: example.c:1:6: '(' "(",
· · · Token2: example.c:1:7: ')' ")",
· · },
· },
}

func (*FunctionDefinition) CompoundStatements

func (n *FunctionDefinition) CompoundStatements() []*CompoundStatement

CompoundStatements returns the list of compound statements in n.

func (*FunctionDefinition) Position

func (n *FunctionDefinition) Position() (r token.Position)

Position reports the position of the first component of n, if available.

func (*FunctionDefinition) String

func (n *FunctionDefinition) String() string

String implements fmt.Stringer.

type FunctionSpecifier

type FunctionSpecifier struct {
	Case  FunctionSpecifierCase `PrettyPrint:"stringer,zero"`
	Token Token
}

FunctionSpecifier represents data reduced by productions:

FunctionSpecifier:
        "inline"     // Case FunctionSpecifierInline
|       "_Noreturn"  // Case FunctionSpecifierNoreturn
Example (Inline)
fmt.Println(exampleAST(164, "inline int f() {}"))
Output:

&cc.FunctionSpecifier{
· Case: FunctionSpecifierInline,
· Token: example.c:1:1: INLINE "inline",
}
Example (Noreturn)
fmt.Println(exampleAST(165, "_Noreturn int f() {}"))
Output:

&cc.FunctionSpecifier{
· Case: FunctionSpecifierNoreturn,
· Token: example.c:1:1: NORETURN "_Noreturn",
}

func (*FunctionSpecifier) Position

func (n *FunctionSpecifier) Position() (r token.Position)

Position reports the position of the first component of n, if available.

func (*FunctionSpecifier) String

func (n *FunctionSpecifier) String() string

String implements fmt.Stringer.

type FunctionSpecifierCase

type FunctionSpecifierCase int

FunctionSpecifierCase represents case numbers of production FunctionSpecifier

const (
	FunctionSpecifierInline FunctionSpecifierCase = iota
	FunctionSpecifierNoreturn
)

Values of type FunctionSpecifierCase

func (FunctionSpecifierCase) String

func (n FunctionSpecifierCase) String() string

String implements fmt.Stringer

type IdentifierList

type IdentifierList struct {
	IdentifierList *IdentifierList
	Token          Token
	Token2         Token
	// contains filtered or unexported fields
}

IdentifierList represents data reduced by productions:

IdentifierList:
        IDENTIFIER
|       IdentifierList ',' IDENTIFIER
Example (Case0)
fmt.Println(exampleAST(190, "int f(i) int i; {}"))
Output:

&cc.IdentifierList{
· Token: example.c:1:7: IDENTIFIER "i",
}
Example (Case1)
fmt.Println(exampleAST(191, "int f(i, j) int i, j; {}"))
Output:

&cc.IdentifierList{
· IdentifierList: &cc.IdentifierList{
· · Token: example.c:1:8: ',' ",",
· · Token2: example.c:1:10: IDENTIFIER "j",
· },
· Token: example.c:1:7: IDENTIFIER "i",
}

func (*IdentifierList) Position

func (n *IdentifierList) Position() (r token.Position)

Position reports the position of the first component of n, if available.

func (*IdentifierList) String

func (n *IdentifierList) String() string

String implements fmt.Stringer.

type InclusiveOrExpression

type InclusiveOrExpression struct {
	Operand Operand

	IsSideEffectsFree     bool
	Case                  InclusiveOrExpressionCase `PrettyPrint:"stringer,zero"`
	ExclusiveOrExpression *ExclusiveOrExpression
	InclusiveOrExpression *InclusiveOrExpression
	Token                 Token
	// contains filtered or unexported fields
}

InclusiveOrExpression represents data reduced by productions:

InclusiveOrExpression:
        ExclusiveOrExpression                            // Case InclusiveOrExpressionXor
|       InclusiveOrExpression '|' ExclusiveOrExpression  // Case InclusiveOrExpressionOr
Example (Or)
fmt.Println(exampleAST(64, "int i = x|y;"))
Output:

&cc.InclusiveOrExpression{
· Case: InclusiveOrExpressionOr,
· ExclusiveOrExpression: &cc.ExclusiveOrExpression{
· · AndExpression: &cc.AndExpression{
· · · Case: AndExpressionEq,
· · · EqualityExpression: &cc.EqualityExpression{
· · · · Case: EqualityExpressionRel,
· · · · RelationalExpression: &cc.RelationalExpression{
· · · · · Case: RelationalExpressionShift,
· · · · · ShiftExpression: &cc.ShiftExpression{
· · · · · · AdditiveExpression: &cc.AdditiveExpression{
· · · · · · · Case: AdditiveExpressionMul,
· · · · · · · MultiplicativeExpression: &cc.MultiplicativeExpression{
· · · · · · · · Case: MultiplicativeExpressionCast,
· · · · · · · · CastExpression: &cc.CastExpression{
· · · · · · · · · Case: CastExpressionUnary,
· · · · · · · · · UnaryExpression: &cc.UnaryExpression{
· · · · · · · · · · Case: UnaryExpressionPostfix,
· · · · · · · · · · PostfixExpression: &cc.PostfixExpression{
· · · · · · · · · · · Case: PostfixExpressionPrimary,
· · · · · · · · · · · PrimaryExpression: &cc.PrimaryExpression{
· · · · · · · · · · · · Case: PrimaryExpressionIdent,
· · · · · · · · · · · · Token: example.c:1:11: IDENTIFIER "y",
· · · · · · · · · · · },
· · · · · · · · · · },
· · · · · · · · · },
· · · · · · · · },
· · · · · · · },
· · · · · · },
· · · · · · Case: ShiftExpressionAdd,
· · · · · },
· · · · },
· · · },
· · },
· · Case: ExclusiveOrExpressionAnd,
· },
· InclusiveOrExpression: &cc.InclusiveOrExpression{
· · Case: InclusiveOrExpressionXor,
· · ExclusiveOrExpression: &cc.ExclusiveOrExpression{
· · · AndExpression: &cc.AndExpression{
· · · · Case: AndExpressionEq,
· · · · EqualityExpression: &cc.EqualityExpression{
· · · · · Case: EqualityExpressionRel,
· · · · · RelationalExpression: &cc.RelationalExpression{
· · · · · · Case: RelationalExpressionShift,
· · · · · · ShiftExpression: &cc.ShiftExpression{
· · · · · · · AdditiveExpression: &cc.AdditiveExpression{
· · · · · · · · Case: AdditiveExpressionMul,
· · · · · · · · MultiplicativeExpression: &cc.MultiplicativeExpression{
· · · · · · · · · Case: MultiplicativeExpressionCast,
· · · · · · · · · CastExpression: &cc.CastExpression{
· · · · · · · · · · Case: CastExpressionUnary,
· · · · · · · · · · UnaryExpression: &cc.UnaryExpression{
· · · · · · · · · · · Case: UnaryExpressionPostfix,
· · · · · · · · · · · PostfixExpression: &cc.PostfixExpression{
· · · · · · · · · · · · Case: PostfixExpressionPrimary,
· · · · · · · · · · · · PrimaryExpression: &cc.PrimaryExpression{
· · · · · · · · · · · · · Case: PrimaryExpressionIdent,
· · · · · · · · · · · · · Token: example.c:1:9: IDENTIFIER "x",
· · · · · · · · · · · · },
· · · · · · · · · · · },
· · · · · · · · · · },
· · · · · · · · · },
· · · · · · · · },
· · · · · · · },
· · · · · · · Case: ShiftExpressionAdd,
· · · · · · },
· · · · · },
· · · · },
· · · },
· · · Case: ExclusiveOrExpressionAnd,
· · },
· },
· Token: example.c:1:10: '|' "|",
}
Example (Xor)
fmt.Println(exampleAST(63, "int i = x;"))
Output:

&cc.InclusiveOrExpression{
· Case: InclusiveOrExpressionXor,
· ExclusiveOrExpression: &cc.ExclusiveOrExpression{
· · AndExpression: &cc.AndExpression{
· · · Case: AndExpressionEq,
· · · EqualityExpression: &cc.EqualityExpression{
· · · · Case: EqualityExpressionRel,
· · · · RelationalExpression: &cc.RelationalExpression{
· · · · · Case: RelationalExpressionShift,
· · · · · ShiftExpression: &cc.ShiftExpression{
· · · · · · AdditiveExpression: &cc.AdditiveExpression{
· · · · · · · Case: AdditiveExpressionMul,
· · · · · · · MultiplicativeExpression: &cc.MultiplicativeExpression{
· · · · · · · · Case: MultiplicativeExpressionCast,
· · · · · · · · CastExpression: &cc.CastExpression{
· · · · · · · · · Case: CastExpressionUnary,
· · · · · · · · · UnaryExpression: &cc.UnaryExpression{
· · · · · · · · · · Case: UnaryExpressionPostfix,
· · · · · · · · · · PostfixExpression: &cc.PostfixExpression{
· · · · · · · · · · · Case: PostfixExpressionPrimary,
· · · · · · · · · · · PrimaryExpression: &cc.PrimaryExpression{
· · · · · · · · · · · · Case: PrimaryExpressionIdent,
· · · · · · · · · · · · Token: example.c:1:9: IDENTIFIER "x",
· · · · · · · · · · · },
· · · · · · · · · · },
· · · · · · · · · },
· · · · · · · · },
· · · · · · · },
· · · · · · },
· · · · · · Case: ShiftExpressionAdd,
· · · · · },
· · · · },
· · · },
· · },
· · Case: ExclusiveOrExpressionAnd,
· },
}

func (*InclusiveOrExpression) Declarator

func (n *InclusiveOrExpression) Declarator() *Declarator

func (*InclusiveOrExpression) Position

func (n *InclusiveOrExpression) Position() (r token.Position)

Position reports the position of the first component of n, if available.

func (*InclusiveOrExpression) Promote added in v3.25.2

func (n *InclusiveOrExpression) Promote() Type

Promote returns the type the operands of the binary operation are promoted to.

func (*InclusiveOrExpression) String

func (n *InclusiveOrExpression) String() string

String implements fmt.Stringer.

type InclusiveOrExpressionCase

type InclusiveOrExpressionCase int

InclusiveOrExpressionCase represents case numbers of production InclusiveOrExpression

const (
	InclusiveOrExpressionXor InclusiveOrExpressionCase = iota
	InclusiveOrExpressionOr
)

Values of type InclusiveOrExpressionCase

func (InclusiveOrExpressionCase) String

func (n InclusiveOrExpressionCase) String() string

String implements fmt.Stringer

type InitDeclarator

type InitDeclarator struct {
	AttributeSpecifierList *AttributeSpecifierList
	Case                   InitDeclaratorCase `PrettyPrint:"stringer,zero"`
	Declarator             *Declarator
	Initializer            *Initializer
	Token                  Token
	// contains filtered or unexported fields
}

InitDeclarator represents data reduced by productions:

InitDeclarator:
        Declarator AttributeSpecifierList                  // Case InitDeclaratorDecl
|       Declarator AttributeSpecifierList '=' Initializer  // Case InitDeclaratorInit
Example (Decl)
fmt.Println(exampleAST(95, "int i;"))
Output:

&cc.InitDeclarator{
· Case: InitDeclaratorDecl,
· Declarator: &cc.Declarator{
· · DirectDeclarator: &cc.DirectDeclarator{
· · · Case: DirectDeclaratorIdent,
· · · Token: example.c:1:5: IDENTIFIER "i",
· · },
· },
}
Example (Init)
fmt.Println(exampleAST(96, "int i = x;"))
Output:

&cc.InitDeclarator{
· Case: InitDeclaratorInit,
· Declarator: &cc.Declarator{
· · DirectDeclarator: &cc.DirectDeclarator{
· · · Case: DirectDeclaratorIdent,
· · · Token: example.c:1:5: IDENTIFIER "i",
· · },
· },
· Initializer: &cc.Initializer{
· · AssignmentExpression: &cc.AssignmentExpression{
· · · Case: AssignmentExpressionCond,
· · · ConditionalExpression: &cc.ConditionalExpression{
· · · · Case: ConditionalExpressionLOr,
· · · · LogicalOrExpression: &cc.LogicalOrExpression{
· · · · · Case: LogicalOrExpressionLAnd,
· · · · · LogicalAndExpression: &cc.LogicalAndExpression{
· · · · · · Case: LogicalAndExpressionOr,
· · · · · · InclusiveOrExpression: &cc.InclusiveOrExpression{
· · · · · · · Case: InclusiveOrExpressionXor,
· · · · · · · ExclusiveOrExpression: &cc.ExclusiveOrExpression{
· · · · · · · · AndExpression: &cc.AndExpression{
· · · · · · · · · Case: AndExpressionEq,
· · · · · · · · · EqualityExpression: &cc.EqualityExpression{
· · · · · · · · · · Case: EqualityExpressionRel,
· · · · · · · · · · RelationalExpression: &cc.RelationalExpression{
· · · · · · · · · · · Case: RelationalExpressionShift,
· · · · · · · · · · · ShiftExpression: &cc.ShiftExpression{
· · · · · · · · · · · · AdditiveExpression: &cc.AdditiveExpression{
· · · · · · · · · · · · · Case: AdditiveExpressionMul,
· · · · · · · · · · · · · MultiplicativeExpression: &cc.MultiplicativeExpression{
· · · · · · · · · · · · · · Case: MultiplicativeExpressionCast,
· · · · · · · · · · · · · · CastExpression: &cc.CastExpression{
· · · · · · · · · · · · · · · Case: CastExpressionUnary,
· · · · · · · · · · · · · · · UnaryExpression: &cc.UnaryExpression{
· · · · · · · · · · · · · · · · Case: UnaryExpressionPostfix,
· · · · · · · · · · · · · · · · PostfixExpression: &cc.PostfixExpression{
· · · · · · · · · · · · · · · · · Case: PostfixExpressionPrimary,
· · · · · · · · · · · · · · · · · PrimaryExpression: &cc.PrimaryExpression{
· · · · · · · · · · · · · · · · · · Case: PrimaryExpressionIdent,
· · · · · · · · · · · · · · · · · · Token: example.c:1:9: IDENTIFIER "x",
· · · · · · · · · · · · · · · · · },
· · · · · · · · · · · · · · · · },
· · · · · · · · · · · · · · · },
· · · · · · · · · · · · · · },
· · · · · · · · · · · · · },
· · · · · · · · · · · · },
· · · · · · · · · · · · Case: ShiftExpressionAdd,
· · · · · · · · · · · },
· · · · · · · · · · },
· · · · · · · · · },
· · · · · · · · },
· · · · · · · · Case: ExclusiveOrExpressionAnd,
· · · · · · · },
· · · · · · },
· · · · · },
· · · · },
· · · },
· · },
· · Case: InitializerExpr,
· },
· Token: example.c:1:7: '=' "=",
}

func (*InitDeclarator) Position

func (n *InitDeclarator) Position() (r token.Position)

Position reports the position of the first component of n, if available.

func (*InitDeclarator) String

func (n *InitDeclarator) String() string

String implements fmt.Stringer.

func (*InitDeclarator) Value

func (n *InitDeclarator) Value() *InitializerValue

type InitDeclaratorCase

type InitDeclaratorCase int

InitDeclaratorCase represents case numbers of production InitDeclarator

const (
	InitDeclaratorDecl InitDeclaratorCase = iota
	InitDeclaratorInit
)

Values of type InitDeclaratorCase

func (InitDeclaratorCase) String

func (n InitDeclaratorCase) String() string

String implements fmt.Stringer

type InitDeclaratorList

type InitDeclaratorList struct {
	AttributeSpecifierList *AttributeSpecifierList
	InitDeclarator         *InitDeclarator
	InitDeclaratorList     *InitDeclaratorList
	Token                  Token
}

InitDeclaratorList represents data reduced by productions:

InitDeclaratorList:
        InitDeclarator
|       InitDeclaratorList ',' AttributeSpecifierList InitDeclarator
Example (Case0)
fmt.Println(exampleAST(93, "int i;"))
Output:

&cc.InitDeclaratorList{
· InitDeclarator: &cc.InitDeclarator{
· · Case: InitDeclaratorDecl,
· · Declarator: &cc.Declarator{
· · · DirectDeclarator: &cc.DirectDeclarator{
· · · · Case: DirectDeclaratorIdent,
· · · · Token: example.c:1:5: IDENTIFIER "i",
· · · },
· · },
· },
}
Example (Case1)
fmt.Println(exampleAST(94, "int i, j;"))
Output:

&cc.InitDeclaratorList{
· InitDeclarator: &cc.InitDeclarator{
· · Case: InitDeclaratorDecl,
· · Declarator: &cc.Declarator{
· · · DirectDeclarator: &cc.DirectDeclarator{
· · · · Case: DirectDeclaratorIdent,
· · · · Token: example.c:1:5: IDENTIFIER "i",
· · · },
· · },
· },
· InitDeclaratorList: &cc.InitDeclaratorList{
· · InitDeclarator: &cc.InitDeclarator{
· · · Case: InitDeclaratorDecl,
· · · Declarator: &cc.Declarator{
· · · · DirectDeclarator: &cc.DirectDeclarator{
· · · · · Case: DirectDeclaratorIdent,
· · · · · Token: example.c:1:8: IDENTIFIER "j",
· · · · },
· · · },
· · },
· · Token: example.c:1:6: ',' ",",
· },
}
Example (UCN)
fmt.Println(exampleAST(0, `int a·z, a\u00b7z;`))
Output:

&cc.InitDeclaratorList{
· InitDeclarator: &cc.InitDeclarator{
· · Case: InitDeclaratorDecl,
· · Declarator: &cc.Declarator{
· · · DirectDeclarator: &cc.DirectDeclarator{
· · · · Case: DirectDeclaratorIdent,
· · · · Token: example.c:1:5: IDENTIFIER "a·z",
· · · },
· · },
· },
· InitDeclaratorList: &cc.InitDeclaratorList{
· · InitDeclarator: &cc.InitDeclarator{
· · · Case: InitDeclaratorDecl,
· · · Declarator: &cc.Declarator{
· · · · DirectDeclarator: &cc.DirectDeclarator{
· · · · · Case: DirectDeclaratorIdent,
· · · · · Token: example.c:1:11: IDENTIFIER "a·z",
· · · · },
· · · },
· · },
· · Token: example.c:1:9: ',' ",",
· },
}

func (*InitDeclaratorList) Position

func (n *InitDeclaratorList) Position() (r token.Position)

Position reports the position of the first component of n, if available.

func (*InitDeclaratorList) String

func (n *InitDeclaratorList) String() string

String implements fmt.Stringer.

type Initializer

type Initializer struct {
	Field  Field   // Where aplicable
	Offset uintptr // Case Expr

	AssignmentExpression *AssignmentExpression
	Case                 InitializerCase `PrettyPrint:"stringer,zero"`
	InitializerList      *InitializerList
	Token                Token
	Token2               Token
	Token3               Token
	// contains filtered or unexported fields
}

Initializer represents data reduced by productions:

Initializer:
        AssignmentExpression         // Case InitializerExpr
|       '{' InitializerList ',' '}'  // Case InitializerInitList
Example (Expr)
fmt.Println(exampleAST(201, "int i = x;"))
Output:

&cc.Initializer{
· AssignmentExpression: &cc.AssignmentExpression{
· · Case: AssignmentExpressionCond,
· · ConditionalExpression: &cc.ConditionalExpression{
· · · Case: ConditionalExpressionLOr,
· · · LogicalOrExpression: &cc.LogicalOrExpression{
· · · · Case: LogicalOrExpressionLAnd,
· · · · LogicalAndExpression: &cc.LogicalAndExpression{
· · · · · Case: LogicalAndExpressionOr,
· · · · · InclusiveOrExpression: &cc.InclusiveOrExpression{
· · · · · · Case: InclusiveOrExpressionXor,
· · · · · · ExclusiveOrExpression: &cc.ExclusiveOrExpression{
· · · · · · · AndExpression: &cc.AndExpression{
· · · · · · · · Case: AndExpressionEq,
· · · · · · · · EqualityExpression: &cc.EqualityExpression{
· · · · · · · · · Case: EqualityExpressionRel,
· · · · · · · · · RelationalExpression: &cc.RelationalExpression{
· · · · · · · · · · Case: RelationalExpressionShift,
· · · · · · · · · · ShiftExpression: &cc.ShiftExpression{
· · · · · · · · · · · AdditiveExpression: &cc.AdditiveExpression{
· · · · · · · · · · · · Case: AdditiveExpressionMul,
· · · · · · · · · · · · MultiplicativeExpression: &cc.MultiplicativeExpression{
· · · · · · · · · · · · · Case: MultiplicativeExpressionCast,
· · · · · · · · · · · · · CastExpression: &cc.CastExpression{
· · · · · · · · · · · · · · Case: CastExpressionUnary,
· · · · · · · · · · · · · · UnaryExpression: &cc.UnaryExpression{
· · · · · · · · · · · · · · · Case: UnaryExpressionPostfix,
· · · · · · · · · · · · · · · PostfixExpression: &cc.PostfixExpression{
· · · · · · · · · · · · · · · · Case: PostfixExpressionPrimary,
· · · · · · · · · · · · · · · · PrimaryExpression: &cc.PrimaryExpression{
· · · · · · · · · · · · · · · · · Case: PrimaryExpressionIdent,
· · · · · · · · · · · · · · · · · Token: example.c:1:9: IDENTIFIER "x",
· · · · · · · · · · · · · · · · },
· · · · · · · · · · · · · · · },
· · · · · · · · · · · · · · },
· · · · · · · · · · · · · },
· · · · · · · · · · · · },
· · · · · · · · · · · },
· · · · · · · · · · · Case: ShiftExpressionAdd,
· · · · · · · · · · },
· · · · · · · · · },
· · · · · · · · },
· · · · · · · },
· · · · · · · Case: ExclusiveOrExpressionAnd,
· · · · · · },
· · · · · },
· · · · },
· · · },
· · },
· },
· Case: InitializerExpr,
}
Example (InitList)
fmt.Println(exampleAST(202, "int i[] = { x };"))
Output:

&cc.Initializer{
· Case: InitializerInitList,
· InitializerList: &cc.InitializerList{
· · Initializer: &cc.Initializer{
· · · AssignmentExpression: &cc.AssignmentExpression{
· · · · Case: AssignmentExpressionCond,
· · · · ConditionalExpression: &cc.ConditionalExpression{
· · · · · Case: ConditionalExpressionLOr,
· · · · · LogicalOrExpression: &cc.LogicalOrExpression{
· · · · · · Case: LogicalOrExpressionLAnd,
· · · · · · LogicalAndExpression: &cc.LogicalAndExpression{
· · · · · · · Case: LogicalAndExpressionOr,
· · · · · · · InclusiveOrExpression: &cc.InclusiveOrExpression{
· · · · · · · · Case: InclusiveOrExpressionXor,
· · · · · · · · ExclusiveOrExpression: &cc.ExclusiveOrExpression{
· · · · · · · · · AndExpression: &cc.AndExpression{
· · · · · · · · · · Case: AndExpressionEq,
· · · · · · · · · · EqualityExpression: &cc.EqualityExpression{
· · · · · · · · · · · Case: EqualityExpressionRel,
· · · · · · · · · · · RelationalExpression: &cc.RelationalExpression{
· · · · · · · · · · · · Case: RelationalExpressionShift,
· · · · · · · · · · · · ShiftExpression: &cc.ShiftExpression{
· · · · · · · · · · · · · AdditiveExpression: &cc.AdditiveExpression{
· · · · · · · · · · · · · · Case: AdditiveExpressionMul,
· · · · · · · · · · · · · · MultiplicativeExpression: &cc.MultiplicativeExpression{
· · · · · · · · · · · · · · · Case: MultiplicativeExpressionCast,
· · · · · · · · · · · · · · · CastExpression: &cc.CastExpression{
· · · · · · · · · · · · · · · · Case: CastExpressionUnary,
· · · · · · · · · · · · · · · · UnaryExpression: &cc.UnaryExpression{
· · · · · · · · · · · · · · · · · Case: UnaryExpressionPostfix,
· · · · · · · · · · · · · · · · · PostfixExpression: &cc.PostfixExpression{
· · · · · · · · · · · · · · · · · · Case: PostfixExpressionPrimary,
· · · · · · · · · · · · · · · · · · PrimaryExpression: &cc.PrimaryExpression{
· · · · · · · · · · · · · · · · · · · Case: PrimaryExpressionIdent,
· · · · · · · · · · · · · · · · · · · Token: example.c:1:13: IDENTIFIER "x",
· · · · · · · · · · · · · · · · · · },
· · · · · · · · · · · · · · · · · },
· · · · · · · · · · · · · · · · },
· · · · · · · · · · · · · · · },
· · · · · · · · · · · · · · },
· · · · · · · · · · · · · },
· · · · · · · · · · · · · Case: ShiftExpressionAdd,
· · · · · · · · · · · · },
· · · · · · · · · · · },
· · · · · · · · · · },
· · · · · · · · · },
· · · · · · · · · Case: ExclusiveOrExpressionAnd,
· · · · · · · · },
· · · · · · · },
· · · · · · },
· · · · · },
· · · · },
· · · },
· · · Case: InitializerExpr,
· · },
· },
· Token: example.c:1:11: '{' "{",
· Token3: example.c:1:15: '}' "}",
}

func (*Initializer) Dump added in v3.35.13

func (n *Initializer) Dump() string

Dump returns a debug form of n.

func (*Initializer) FirstDesignatorField added in v3.31.0

func (n *Initializer) FirstDesignatorField() Field

FirstDesignatorField returns the first field a designator of an union type denotes, if any.

func (*Initializer) IsConst

func (n *Initializer) IsConst() bool

IsConst reports whether n is constant.

func (*Initializer) IsZero added in v3.27.0

func (n *Initializer) IsZero() bool

IsZero reports whether n is a zero value.

func (*Initializer) List

func (n *Initializer) List() []*Initializer

List returns n as a flattened list of all items that are case InitializerExpr.

func (*Initializer) Parent added in v3.31.0

func (n *Initializer) Parent() *Initializer

Parent returns the parent of n, if any.

func (*Initializer) Position

func (n *Initializer) Position() (r token.Position)

Position reports the position of the first component of n, if available.

func (*Initializer) String

func (n *Initializer) String() string

String implements fmt.Stringer.

func (*Initializer) TrailingComma added in v3.31.0

func (n *Initializer) TrailingComma() *Token

TrailingComma returns the comma token following n, if any.

func (*Initializer) Type

func (n *Initializer) Type() Type

Type returns the type this initializer initializes.

type InitializerCase

type InitializerCase int

InitializerCase represents case numbers of production Initializer

const (
	InitializerExpr InitializerCase = iota
	InitializerInitList
)

Values of type InitializerCase

func (InitializerCase) String

func (n InitializerCase) String() string

String implements fmt.Stringer

type InitializerList

type InitializerList struct {
	Designation     *Designation
	Initializer     *Initializer
	InitializerList *InitializerList
	Token           Token
	// contains filtered or unexported fields
}

InitializerList represents data reduced by productions:

InitializerList:
        Designation Initializer
|       InitializerList ',' Designation Initializer
Example (Case0)
fmt.Println(exampleAST(203, "int i[] = { [10] = x };"))
Output:

&cc.InitializerList{
· Designation: &cc.Designation{
· · DesignatorList: &cc.DesignatorList{
· · · Designator: &cc.Designator{
· · · · Case: DesignatorIndex,
· · · · ConstantExpression: &cc.ConstantExpression{
· · · · · ConditionalExpression: &cc.ConditionalExpression{
· · · · · · Case: ConditionalExpressionLOr,
· · · · · · LogicalOrExpression: &cc.LogicalOrExpression{
· · · · · · · Case: LogicalOrExpressionLAnd,
· · · · · · · LogicalAndExpression: &cc.LogicalAndExpression{
· · · · · · · · Case: LogicalAndExpressionOr,
· · · · · · · · InclusiveOrExpression: &cc.InclusiveOrExpression{
· · · · · · · · · Case: InclusiveOrExpressionXor,
· · · · · · · · · ExclusiveOrExpression: &cc.ExclusiveOrExpression{
· · · · · · · · · · AndExpression: &cc.AndExpression{
· · · · · · · · · · · Case: AndExpressionEq,
· · · · · · · · · · · EqualityExpression: &cc.EqualityExpression{
· · · · · · · · · · · · Case: EqualityExpressionRel,
· · · · · · · · · · · · RelationalExpression: &cc.RelationalExpression{
· · · · · · · · · · · · · Case: RelationalExpressionShift,
· · · · · · · · · · · · · ShiftExpression: &cc.ShiftExpression{
· · · · · · · · · · · · · · AdditiveExpression: &cc.AdditiveExpression{
· · · · · · · · · · · · · · · Case: AdditiveExpressionMul,
· · · · · · · · · · · · · · · MultiplicativeExpression: &cc.MultiplicativeExpression{
· · · · · · · · · · · · · · · · Case: MultiplicativeExpressionCast,
· · · · · · · · · · · · · · · · CastExpression: &cc.CastExpression{
· · · · · · · · · · · · · · · · · Case: CastExpressionUnary,
· · · · · · · · · · · · · · · · · UnaryExpression: &cc.UnaryExpression{
· · · · · · · · · · · · · · · · · · Case: UnaryExpressionPostfix,
· · · · · · · · · · · · · · · · · · PostfixExpression: &cc.PostfixExpression{
· · · · · · · · · · · · · · · · · · · Case: PostfixExpressionPrimary,
· · · · · · · · · · · · · · · · · · · PrimaryExpression: &cc.PrimaryExpression{
· · · · · · · · · · · · · · · · · · · · Case: PrimaryExpressionInt,
· · · · · · · · · · · · · · · · · · · · Token: example.c:1:14: INTCONST "10",
· · · · · · · · · · · · · · · · · · · },
· · · · · · · · · · · · · · · · · · },
· · · · · · · · · · · · · · · · · },
· · · · · · · · · · · · · · · · },
· · · · · · · · · · · · · · · },
· · · · · · · · · · · · · · },
· · · · · · · · · · · · · · Case: ShiftExpressionAdd,
· · · · · · · · · · · · · },
· · · · · · · · · · · · },
· · · · · · · · · · · },
· · · · · · · · · · },
· · · · · · · · · · Case: ExclusiveOrExpressionAnd,
· · · · · · · · · },
· · · · · · · · },
· · · · · · · },
· · · · · · },
· · · · · },
· · · · },
· · · · Token: example.c:1:13: '[' "[",
· · · · Token2: example.c:1:16: ']' "]",
· · · },
· · },
· · Token: example.c:1:18: '=' "=",
· },
· Initializer: &cc.Initializer{
· · AssignmentExpression: &cc.AssignmentExpression{
· · · Case: AssignmentExpressionCond,
· · · ConditionalExpression: &cc.ConditionalExpression{
· · · · Case: ConditionalExpressionLOr,
· · · · LogicalOrExpression: &cc.LogicalOrExpression{
· · · · · Case: LogicalOrExpressionLAnd,
· · · · · LogicalAndExpression: &cc.LogicalAndExpression{
· · · · · · Case: LogicalAndExpressionOr,
· · · · · · InclusiveOrExpression: &cc.InclusiveOrExpression{
· · · · · · · Case: InclusiveOrExpressionXor,
· · · · · · · ExclusiveOrExpression: &cc.ExclusiveOrExpression{
· · · · · · · · AndExpression: &cc.AndExpression{
· · · · · · · · · Case: AndExpressionEq,
· · · · · · · · · EqualityExpression: &cc.EqualityExpression{
· · · · · · · · · · Case: EqualityExpressionRel,
· · · · · · · · · · RelationalExpression: &cc.RelationalExpression{
· · · · · · · · · · · Case: RelationalExpressionShift,
· · · · · · · · · · · ShiftExpression: &cc.ShiftExpression{
· · · · · · · · · · · · AdditiveExpression: &cc.AdditiveExpression{
· · · · · · · · · · · · · Case: AdditiveExpressionMul,
· · · · · · · · · · · · · MultiplicativeExpression: &cc.MultiplicativeExpression{
· · · · · · · · · · · · · · Case: MultiplicativeExpressionCast,
· · · · · · · · · · · · · · CastExpression: &cc.CastExpression{
· · · · · · · · · · · · · · · Case: CastExpressionUnary,
· · · · · · · · · · · · · · · UnaryExpression: &cc.UnaryExpression{
· · · · · · · · · · · · · · · · Case: UnaryExpressionPostfix,
· · · · · · · · · · · · · · · · PostfixExpression: &cc.PostfixExpression{
· · · · · · · · · · · · · · · · · Case: PostfixExpressionPrimary,
· · · · · · · · · · · · · · · · · PrimaryExpression: &cc.PrimaryExpression{
· · · · · · · · · · · · · · · · · · Case: PrimaryExpressionIdent,
· · · · · · · · · · · · · · · · · · Token: example.c:1:20: IDENTIFIER "x",
· · · · · · · · · · · · · · · · · },
· · · · · · · · · · · · · · · · },
· · · · · · · · · · · · · · · },
· · · · · · · · · · · · · · },
· · · · · · · · · · · · · },
· · · · · · · · · · · · },
· · · · · · · · · · · · Case: ShiftExpressionAdd,
· · · · · · · · · · · },
· · · · · · · · · · },
· · · · · · · · · },
· · · · · · · · },
· · · · · · · · Case: ExclusiveOrExpressionAnd,
· · · · · · · },
· · · · · · },
· · · · · },
· · · · },
· · · },
· · },
· · Case: InitializerExpr,
· },
}
Example (Case1)
fmt.Println(exampleAST(204, "int i[] = { [10] = x, [20] = y };"))
Output:

&cc.InitializerList{
· Designation: &cc.Designation{
· · DesignatorList: &cc.DesignatorList{
· · · Designator: &cc.Designator{
· · · · Case: DesignatorIndex,
· · · · ConstantExpression: &cc.ConstantExpression{
· · · · · ConditionalExpression: &cc.ConditionalExpression{
· · · · · · Case: ConditionalExpressionLOr,
· · · · · · LogicalOrExpression: &cc.LogicalOrExpression{
· · · · · · · Case: LogicalOrExpressionLAnd,
· · · · · · · LogicalAndExpression: &cc.LogicalAndExpression{
· · · · · · · · Case: LogicalAndExpressionOr,
· · · · · · · · InclusiveOrExpression: &cc.InclusiveOrExpression{
· · · · · · · · · Case: InclusiveOrExpressionXor,
· · · · · · · · · ExclusiveOrExpression: &cc.ExclusiveOrExpression{
· · · · · · · · · · AndExpression: &cc.AndExpression{
· · · · · · · · · · · Case: AndExpressionEq,
· · · · · · · · · · · EqualityExpression: &cc.EqualityExpression{
· · · · · · · · · · · · Case: EqualityExpressionRel,
· · · · · · · · · · · · RelationalExpression: &cc.RelationalExpression{
· · · · · · · · · · · · · Case: RelationalExpressionShift,
· · · · · · · · · · · · · ShiftExpression: &cc.ShiftExpression{
· · · · · · · · · · · · · · AdditiveExpression: &cc.AdditiveExpression{
· · · · · · · · · · · · · · · Case: AdditiveExpressionMul,
· · · · · · · · · · · · · · · MultiplicativeExpression: &cc.MultiplicativeExpression{
· · · · · · · · · · · · · · · · Case: MultiplicativeExpressionCast,
· · · · · · · · · · · · · · · · CastExpression: &cc.CastExpression{
· · · · · · · · · · · · · · · · · Case: CastExpressionUnary,
· · · · · · · · · · · · · · · · · UnaryExpression: &cc.UnaryExpression{
· · · · · · · · · · · · · · · · · · Case: UnaryExpressionPostfix,
· · · · · · · · · · · · · · · · · · PostfixExpression: &cc.PostfixExpression{
· · · · · · · · · · · · · · · · · · · Case: PostfixExpressionPrimary,
· · · · · · · · · · · · · · · · · · · PrimaryExpression: &cc.PrimaryExpression{
· · · · · · · · · · · · · · · · · · · · Case: PrimaryExpressionInt,
· · · · · · · · · · · · · · · · · · · · Token: example.c:1:14: INTCONST "10",
· · · · · · · · · · · · · · · · · · · },
· · · · · · · · · · · · · · · · · · },
· · · · · · · · · · · · · · · · · },
· · · · · · · · · · · · · · · · },
· · · · · · · · · · · · · · · },
· · · · · · · · · · · · · · },
· · · · · · · · · · · · · · Case: ShiftExpressionAdd,
· · · · · · · · · · · · · },
· · · · · · · · · · · · },
· · · · · · · · · · · },
· · · · · · · · · · },
· · · · · · · · · · Case: ExclusiveOrExpressionAnd,
· · · · · · · · · },
· · · · · · · · },
· · · · · · · },
· · · · · · },
· · · · · },
· · · · },
· · · · Token: example.c:1:13: '[' "[",
· · · · Token2: example.c:1:16: ']' "]",
· · · },
· · },
· · Token: example.c:1:18: '=' "=",
· },
· Initializer: &cc.Initializer{
· · AssignmentExpression: &cc.AssignmentExpression{
· · · Case: AssignmentExpressionCond,
· · · ConditionalExpression: &cc.ConditionalExpression{
· · · · Case: ConditionalExpressionLOr,
· · · · LogicalOrExpression: &cc.LogicalOrExpression{
· · · · · Case: LogicalOrExpressionLAnd,
· · · · · LogicalAndExpression: &cc.LogicalAndExpression{
· · · · · · Case: LogicalAndExpressionOr,
· · · · · · InclusiveOrExpression: &cc.InclusiveOrExpression{
· · · · · · · Case: InclusiveOrExpressionXor,
· · · · · · · ExclusiveOrExpression: &cc.ExclusiveOrExpression{
· · · · · · · · AndExpression: &cc.AndExpression{
· · · · · · · · · Case: AndExpressionEq,
· · · · · · · · · EqualityExpression: &cc.EqualityExpression{
· · · · · · · · · · Case: EqualityExpressionRel,
· · · · · · · · · · RelationalExpression: &cc.RelationalExpression{
· · · · · · · · · · · Case: RelationalExpressionShift,
· · · · · · · · · · · ShiftExpression: &cc.ShiftExpression{
· · · · · · · · · · · · AdditiveExpression: &cc.AdditiveExpression{
· · · · · · · · · · · · · Case: AdditiveExpressionMul,
· · · · · · · · · · · · · MultiplicativeExpression: &cc.MultiplicativeExpression{
· · · · · · · · · · · · · · Case: MultiplicativeExpressionCast,
· · · · · · · · · · · · · · CastExpression: &cc.CastExpression{
· · · · · · · · · · · · · · · Case: CastExpressionUnary,
· · · · · · · · · · · · · · · UnaryExpression: &cc.UnaryExpression{
· · · · · · · · · · · · · · · · Case: UnaryExpressionPostfix,
· · · · · · · · · · · · · · · · PostfixExpression: &cc.PostfixExpression{
· · · · · · · · · · · · · · · · · Case: PostfixExpressionPrimary,
· · · · · · · · · · · · · · · · · PrimaryExpression: &cc.PrimaryExpression{
· · · · · · · · · · · · · · · · · · Case: PrimaryExpressionIdent,
· · · · · · · · · · · · · · · · · · Token: example.c:1:20: IDENTIFIER "x",
· · · · · · · · · · · · · · · · · },
· · · · · · · · · · · · · · · · },
· · · · · · · · · · · · · · · },
· · · · · · · · · · · · · · },
· · · · · · · · · · · · · },
· · · · · · · · · · · · },
· · · · · · · · · · · · Case: ShiftExpressionAdd,
· · · · · · · · · · · },
· · · · · · · · · · },
· · · · · · · · · },
· · · · · · · · },
· · · · · · · · Case: ExclusiveOrExpressionAnd,
· · · · · · · },
· · · · · · },
· · · · · },
· · · · },
· · · },
· · },
· · Case: InitializerExpr,
· },
· InitializerList: &cc.InitializerList{
· · Designation: &cc.Designation{
· · · DesignatorList: &cc.DesignatorList{
· · · · Designator: &cc.Designator{
· · · · · Case: DesignatorIndex,
· · · · · ConstantExpression: &cc.ConstantExpression{
· · · · · · ConditionalExpression: &cc.ConditionalExpression{
· · · · · · · Case: ConditionalExpressionLOr,
· · · · · · · LogicalOrExpression: &cc.LogicalOrExpression{
· · · · · · · · Case: LogicalOrExpressionLAnd,
· · · · · · · · LogicalAndExpression: &cc.LogicalAndExpression{
· · · · · · · · · Case: LogicalAndExpressionOr,
· · · · · · · · · InclusiveOrExpression: &cc.InclusiveOrExpression{
· · · · · · · · · · Case: InclusiveOrExpressionXor,
· · · · · · · · · · ExclusiveOrExpression: &cc.ExclusiveOrExpression{
· · · · · · · · · · · AndExpression: &cc.AndExpression{
· · · · · · · · · · · · Case: AndExpressionEq,
· · · · · · · · · · · · EqualityExpression: &cc.EqualityExpression{
· · · · · · · · · · · · · Case: EqualityExpressionRel,
· · · · · · · · · · · · · RelationalExpression: &cc.RelationalExpression{
· · · · · · · · · · · · · · Case: RelationalExpressionShift,
· · · · · · · · · · · · · · ShiftExpression: &cc.ShiftExpression{
· · · · · · · · · · · · · · · AdditiveExpression: &cc.AdditiveExpression{
· · · · · · · · · · · · · · · · Case: AdditiveExpressionMul,
· · · · · · · · · · · · · · · · MultiplicativeExpression: &cc.MultiplicativeExpression{
· · · · · · · · · · · · · · · · · Case: MultiplicativeExpressionCast,
· · · · · · · · · · · · · · · · · CastExpression: &cc.CastExpression{
· · · · · · · · · · · · · · · · · · Case: CastExpressionUnary,
· · · · · · · · · · · · · · · · · · UnaryExpression: &cc.UnaryExpression{
· · · · · · · · · · · · · · · · · · · Case: UnaryExpressionPostfix,
· · · · · · · · · · · · · · · · · · · PostfixExpression: &cc.PostfixExpression{
· · · · · · · · · · · · · · · · · · · · Case: PostfixExpressionPrimary,
· · · · · · · · · · · · · · · · · · · · PrimaryExpression: &cc.PrimaryExpression{
· · · · · · · · · · · · · · · · · · · · · Case: PrimaryExpressionInt,
· · · · · · · · · · · · · · · · · · · · · Token: example.c:1:24: INTCONST "20",
· · · · · · · · · · · · · · · · · · · · },
· · · · · · · · · · · · · · · · · · · },
· · · · · · · · · · · · · · · · · · },
· · · · · · · · · · · · · · · · · },
· · · · · · · · · · · · · · · · },
· · · · · · · · · · · · · · · },
· · · · · · · · · · · · · · · Case: ShiftExpressionAdd,
· · · · · · · · · · · · · · },
· · · · · · · · · · · · · },
· · · · · · · · · · · · },
· · · · · · · · · · · },
· · · · · · · · · · · Case: ExclusiveOrExpressionAnd,
· · · · · · · · · · },
· · · · · · · · · },
· · · · · · · · },
· · · · · · · },
· · · · · · },
· · · · · },
· · · · · Token: example.c:1:23: '[' "[",
· · · · · Token2: example.c:1:26: ']' "]",
· · · · },
· · · },
· · · Token: example.c:1:28: '=' "=",
· · },
· · Initializer: &cc.Initializer{
· · · AssignmentExpression: &cc.AssignmentExpression{
· · · · Case: AssignmentExpressionCond,
· · · · ConditionalExpression: &cc.ConditionalExpression{
· · · · · Case: ConditionalExpressionLOr,
· · · · · LogicalOrExpression: &cc.LogicalOrExpression{
· · · · · · Case: LogicalOrExpressionLAnd,
· · · · · · LogicalAndExpression: &cc.LogicalAndExpression{
· · · · · · · Case: LogicalAndExpressionOr,
· · · · · · · InclusiveOrExpression: &cc.InclusiveOrExpression{
· · · · · · · · Case: InclusiveOrExpressionXor,
· · · · · · · · ExclusiveOrExpression: &cc.ExclusiveOrExpression{
· · · · · · · · · AndExpression: &cc.AndExpression{
· · · · · · · · · · Case: AndExpressionEq,
· · · · · · · · · · EqualityExpression: &cc.EqualityExpression{
· · · · · · · · · · · Case: EqualityExpressionRel,
· · · · · · · · · · · RelationalExpression: &cc.RelationalExpression{
· · · · · · · · · · · · Case: RelationalExpressionShift,
· · · · · · · · · · · · ShiftExpression: &cc.ShiftExpression{
· · · · · · · · · · · · · AdditiveExpression: &cc.AdditiveExpression{
· · · · · · · · · · · · · · Case: AdditiveExpressionMul,
· · · · · · · · · · · · · · MultiplicativeExpression: &cc.MultiplicativeExpression{
· · · · · · · · · · · · · · · Case: MultiplicativeExpressionCast,
· · · · · · · · · · · · · · · CastExpression: &cc.CastExpression{
· · · · · · · · · · · · · · · · Case: CastExpressionUnary,
· · · · · · · · · · · · · · · · UnaryExpression: &cc.UnaryExpression{
· · · · · · · · · · · · · · · · · Case: UnaryExpressionPostfix,
· · · · · · · · · · · · · · · · · PostfixExpression: &cc.PostfixExpression{
· · · · · · · · · · · · · · · · · · Case: PostfixExpressionPrimary,
· · · · · · · · · · · · · · · · · · PrimaryExpression: &cc.PrimaryExpression{
· · · · · · · · · · · · · · · · · · · Case: PrimaryExpressionIdent,
· · · · · · · · · · · · · · · · · · · Token: example.c:1:30: IDENTIFIER "y",
· · · · · · · · · · · · · · · · · · },
· · · · · · · · · · · · · · · · · },
· · · · · · · · · · · · · · · · },
· · · · · · · · · · · · · · · },
· · · · · · · · · · · · · · },
· · · · · · · · · · · · · },
· · · · · · · · · · · · · Case: ShiftExpressionAdd,
· · · · · · · · · · · · },
· · · · · · · · · · · },
· · · · · · · · · · },
· · · · · · · · · },
· · · · · · · · · Case: ExclusiveOrExpressionAnd,
· · · · · · · · },
· · · · · · · },
· · · · · · },
· · · · · },
· · · · },
· · · },
· · · Case: InitializerExpr,
· · },
· · Token: example.c:1:21: ',' ",",
· },
}

func (*InitializerList) Dump added in v3.35.13

func (n *InitializerList) Dump() string

Dump returns a debug form of n.

func (*InitializerList) IsConst

func (n *InitializerList) IsConst() bool

IsConst reports whether n is constant.

func (*InitializerList) IsEmpty added in v3.27.0

func (n *InitializerList) IsEmpty() bool

IsEmpty reprts whether n is an empty list.

func (*InitializerList) IsZero added in v3.27.0

func (n *InitializerList) IsZero() bool

IsZero reports whether n is a zero value.

func (*InitializerList) List

func (n *InitializerList) List() []*Initializer

List returns n as a flattened list of all items that are case InitializerExpr.

func (*InitializerList) Position

func (n *InitializerList) Position() (r token.Position)

Position reports the position of the first component of n, if available.

func (*InitializerList) String

func (n *InitializerList) String() string

String implements fmt.Stringer.

type InitializerValue

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

func (*InitializerValue) IsConst

func (v *InitializerValue) IsConst() bool

func (*InitializerValue) IsNonZero added in v3.33.6

func (v *InitializerValue) IsNonZero() bool

func (*InitializerValue) IsZero added in v3.33.6

func (v *InitializerValue) IsZero() bool

func (*InitializerValue) List

func (v *InitializerValue) List() []*Initializer

func (*InitializerValue) Type

func (v *InitializerValue) Type() Type

type Int64Value

type Int64Value int64

func (Int64Value) IsConst added in v3.33.6

func (v Int64Value) IsConst() bool

func (Int64Value) IsNonZero added in v3.33.6

func (v Int64Value) IsNonZero() bool

func (Int64Value) IsZero added in v3.33.6

func (v Int64Value) IsZero() bool

type IterationStatement

type IterationStatement struct {
	Case        IterationStatementCase `PrettyPrint:"stringer,zero"`
	Declaration *Declaration
	Expression  *Expression
	Expression2 *Expression
	Expression3 *Expression
	Statement   *Statement
	Token       Token
	Token2      Token
	Token3      Token
	Token4      Token
	Token5      Token
}

IterationStatement represents data reduced by productions:

IterationStatement:
        "while" '(' Expression ')' Statement                              // Case IterationStatementWhile
|       "do" Statement "while" '(' Expression ')' ';'                     // Case IterationStatementDo
|       "for" '(' Expression ';' Expression ';' Expression ')' Statement  // Case IterationStatementFor
|       "for" '(' Declaration Expression ';' Expression ')' Statement     // Case IterationStatementForDecl
Example (Do)
fmt.Println(exampleAST(235, "int f() { do x(); while(y); }"))
Output:

&cc.IterationStatement{
· Case: IterationStatementDo,
· Expression: &cc.Expression{
· · AssignmentExpression: &cc.AssignmentExpression{
· · · Case: AssignmentExpressionCond,
· · · ConditionalExpression: &cc.ConditionalExpression{
· · · · Case: ConditionalExpressionLOr,
· · · · LogicalOrExpression: &cc.LogicalOrExpression{
· · · · · Case: LogicalOrExpressionLAnd,
· · · · · LogicalAndExpression: &cc.LogicalAndExpression{
· · · · · · Case: LogicalAndExpressionOr,
· · · · · · InclusiveOrExpression: &cc.InclusiveOrExpression{
· · · · · · · Case: InclusiveOrExpressionXor,
· · · · · · · ExclusiveOrExpression: &cc.ExclusiveOrExpression{
· · · · · · · · AndExpression: &cc.AndExpression{
· · · · · · · · · Case: AndExpressionEq,
· · · · · · · · · EqualityExpression: &cc.EqualityExpression{
· · · · · · · · · · Case: EqualityExpressionRel,
· · · · · · · · · · RelationalExpression: &cc.RelationalExpression{
· · · · · · · · · · · Case: RelationalExpressionShift,
· · · · · · · · · · · ShiftExpression: &cc.ShiftExpression{
· · · · · · · · · · · · AdditiveExpression: &cc.AdditiveExpression{
· · · · · · · · · · · · · Case: AdditiveExpressionMul,
· · · · · · · · · · · · · MultiplicativeExpression: &cc.MultiplicativeExpression{
· · · · · · · · · · · · · · Case: MultiplicativeExpressionCast,
· · · · · · · · · · · · · · CastExpression: &cc.CastExpression{
· · · · · · · · · · · · · · · Case: CastExpressionUnary,
· · · · · · · · · · · · · · · UnaryExpression: &cc.UnaryExpression{
· · · · · · · · · · · · · · · · Case: UnaryExpressionPostfix,
· · · · · · · · · · · · · · · · PostfixExpression: &cc.PostfixExpression{
· · · · · · · · · · · · · · · · · Case: PostfixExpressionPrimary,
· · · · · · · · · · · · · · · · · PrimaryExpression: &cc.PrimaryExpression{
· · · · · · · · · · · · · · · · · · Case: PrimaryExpressionIdent,
· · · · · · · · · · · · · · · · · · Token: example.c:1:25: IDENTIFIER "y",
· · · · · · · · · · · · · · · · · },
· · · · · · · · · · · · · · · · },
· · · · · · · · · · · · · · · },
· · · · · · · · · · · · · · },
· · · · · · · · · · · · · },
· · · · · · · · · · · · },
· · · · · · · · · · · · Case: ShiftExpressionAdd,
· · · · · · · · · · · },
· · · · · · · · · · },
· · · · · · · · · },
· · · · · · · · },
· · · · · · · · Case: ExclusiveOrExpressionAnd,
· · · · · · · },
· · · · · · },
· · · · · },
· · · · },
· · · },
· · },
· · Case: ExpressionAssign,
· },
· Statement: &cc.Statement{
· · Case: StatementExpr,
· · ExpressionStatement: &cc.ExpressionStatement{
· · · Expression: &cc.Expression{
· · · · AssignmentExpression: &cc.AssignmentExpression{
· · · · · Case: AssignmentExpressionCond,
· · · · · ConditionalExpression: &cc.ConditionalExpression{
· · · · · · Case: ConditionalExpressionLOr,
· · · · · · LogicalOrExpression: &cc.LogicalOrExpression{
· · · · · · · Case: LogicalOrExpressionLAnd,
· · · · · · · LogicalAndExpression: &cc.LogicalAndExpression{
· · · · · · · · Case: LogicalAndExpressionOr,
· · · · · · · · InclusiveOrExpression: &cc.InclusiveOrExpression{
· · · · · · · · · Case: InclusiveOrExpressionXor,
· · · · · · · · · ExclusiveOrExpression: &cc.ExclusiveOrExpression{
· · · · · · · · · · AndExpression: &cc.AndExpression{
· · · · · · · · · · · Case: AndExpressionEq,
· · · · · · · · · · · EqualityExpression: &cc.EqualityExpression{
· · · · · · · · · · · · Case: EqualityExpressionRel,
· · · · · · · · · · · · RelationalExpression: &cc.RelationalExpression{
· · · · · · · · · · · · · Case: RelationalExpressionShift,
· · · · · · · · · · · · · ShiftExpression: &cc.ShiftExpression{
· · · · · · · · · · · · · · AdditiveExpression: &cc.AdditiveExpression{
· · · · · · · · · · · · · · · Case: AdditiveExpressionMul,
· · · · · · · · · · · · · · · MultiplicativeExpression: &cc.MultiplicativeExpression{
· · · · · · · · · · · · · · · · Case: MultiplicativeExpressionCast,
· · · · · · · · · · · · · · · · CastExpression: &cc.CastExpression{
· · · · · · · · · · · · · · · · · Case: CastExpressionUnary,
· · · · · · · · · · · · · · · · · UnaryExpression: &cc.UnaryExpression{
· · · · · · · · · · · · · · · · · · Case: UnaryExpressionPostfix,
· · · · · · · · · · · · · · · · · · PostfixExpression: &cc.PostfixExpression{
· · · · · · · · · · · · · · · · · · · Case: PostfixExpressionCall,
· · · · · · · · · · · · · · · · · · · PostfixExpression: &cc.PostfixExpression{
· · · · · · · · · · · · · · · · · · · · Case: PostfixExpressionPrimary,
· · · · · · · · · · · · · · · · · · · · PrimaryExpression: &cc.PrimaryExpression{
· · · · · · · · · · · · · · · · · · · · · Case: PrimaryExpressionIdent,
· · · · · · · · · · · · · · · · · · · · · Token: example.c:1:14: IDENTIFIER "x",
· · · · · · · · · · · · · · · · · · · · },
· · · · · · · · · · · · · · · · · · · },
· · · · · · · · · · · · · · · · · · · Token: example.c:1:15: '(' "(",
· · · · · · · · · · · · · · · · · · · Token2: example.c:1:16: ')' ")",
· · · · · · · · · · · · · · · · · · },
· · · · · · · · · · · · · · · · · },
· · · · · · · · · · · · · · · · },
· · · · · · · · · · · · · · · },
· · · · · · · · · · · · · · },
· · · · · · · · · · · · · · Case: ShiftExpressionAdd,
· · · · · · · · · · · · · },
· · · · · · · · · · · · },
· · · · · · · · · · · },
· · · · · · · · · · },
· · · · · · · · · · Case: ExclusiveOrExpressionAnd,
· · · · · · · · · },
· · · · · · · · },
· · · · · · · },
· · · · · · },
· · · · · },
· · · · },
· · · · Case: ExpressionAssign,
· · · },
· · · Token: example.c:1:17: ';' ";",
· · },
· },
· Token: example.c:1:11: DO "do",
· Token2: example.c:1:19: WHILE "while",
· Token3: example.c:1:24: '(' "(",
· Token4: example.c:1:26: ')' ")",
· Token5: example.c:1:27: ';' ";",
}
Example (For)
fmt.Println(exampleAST(236, "int f() { for( i = 0; i < 10; i++) x(); }"))
Output:

&cc.IterationStatement{
· Case: IterationStatementFor,
· Expression: &cc.Expression{
· · AssignmentExpression: &cc.AssignmentExpression{
· · · AssignmentExpression: &cc.AssignmentExpression{
· · · · Case: AssignmentExpressionCond,
· · · · ConditionalExpression: &cc.ConditionalExpression{
· · · · · Case: ConditionalExpressionLOr,
· · · · · LogicalOrExpression: &cc.LogicalOrExpression{
· · · · · · Case: LogicalOrExpressionLAnd,
· · · · · · LogicalAndExpression: &cc.LogicalAndExpression{
· · · · · · · Case: LogicalAndExpressionOr,
· · · · · · · InclusiveOrExpression: &cc.InclusiveOrExpression{
· · · · · · · · Case: InclusiveOrExpressionXor,
· · · · · · · · ExclusiveOrExpression: &cc.ExclusiveOrExpression{
· · · · · · · · · AndExpression: &cc.AndExpression{
· · · · · · · · · · Case: AndExpressionEq,
· · · · · · · · · · EqualityExpression: &cc.EqualityExpression{
· · · · · · · · · · · Case: EqualityExpressionRel,
· · · · · · · · · · · RelationalExpression: &cc.RelationalExpression{
· · · · · · · · · · · · Case: RelationalExpressionShift,
· · · · · · · · · · · · ShiftExpression: &cc.ShiftExpression{
· · · · · · · · · · · · · AdditiveExpression: &cc.AdditiveExpression{
· · · · · · · · · · · · · · Case: AdditiveExpressionMul,
· · · · · · · · · · · · · · MultiplicativeExpression: &cc.MultiplicativeExpression{
· · · · · · · · · · · · · · · Case: MultiplicativeExpressionCast,
· · · · · · · · · · · · · · · CastExpression: &cc.CastExpression{
· · · · · · · · · · · · · · · · Case: CastExpressionUnary,
· · · · · · · · · · · · · · · · UnaryExpression: &cc.UnaryExpression{
· · · · · · · · · · · · · · · · · Case: UnaryExpressionPostfix,
· · · · · · · · · · · · · · · · · PostfixExpression: &cc.PostfixExpression{
· · · · · · · · · · · · · · · · · · Case: PostfixExpressionPrimary,
· · · · · · · · · · · · · · · · · · PrimaryExpression: &cc.PrimaryExpression{
· · · · · · · · · · · · · · · · · · · Case: PrimaryExpressionInt,
· · · · · · · · · · · · · · · · · · · Token: example.c:1:20: INTCONST "0",
· · · · · · · · · · · · · · · · · · },
· · · · · · · · · · · · · · · · · },
· · · · · · · · · · · · · · · · },
· · · · · · · · · · · · · · · },
· · · · · · · · · · · · · · },
· · · · · · · · · · · · · },
· · · · · · · · · · · · · Case: ShiftExpressionAdd,
· · · · · · · · · · · · },
· · · · · · · · · · · },
· · · · · · · · · · },
· · · · · · · · · },
· · · · · · · · · Case: ExclusiveOrExpressionAnd,
· · · · · · · · },
· · · · · · · },
· · · · · · },
· · · · · },
· · · · },
· · · },
· · · Case: AssignmentExpressionAssign,
· · · Token: example.c:1:18: '=' "=",
· · · UnaryExpression: &cc.UnaryExpression{
· · · · Case: UnaryExpressionPostfix,
· · · · PostfixExpression: &cc.PostfixExpression{
· · · · · Case: PostfixExpressionPrimary,
· · · · · PrimaryExpression: &cc.PrimaryExpression{
· · · · · · Case: PrimaryExpressionIdent,
· · · · · · Token: example.c:1:16: IDENTIFIER "i",
· · · · · },
· · · · },
· · · },
· · },
· · Case: ExpressionAssign,
· },
· Expression2: &cc.Expression{
· · AssignmentExpression: &cc.AssignmentExpression{
· · · Case: AssignmentExpressionCond,
· · · ConditionalExpression: &cc.ConditionalExpression{
· · · · Case: ConditionalExpressionLOr,
· · · · LogicalOrExpression: &cc.LogicalOrExpression{
· · · · · Case: LogicalOrExpressionLAnd,
· · · · · LogicalAndExpression: &cc.LogicalAndExpression{
· · · · · · Case: LogicalAndExpressionOr,
· · · · · · InclusiveOrExpression: &cc.InclusiveOrExpression{
· · · · · · · Case: InclusiveOrExpressionXor,
· · · · · · · ExclusiveOrExpression: &cc.ExclusiveOrExpression{
· · · · · · · · AndExpression: &cc.AndExpression{
· · · · · · · · · Case: AndExpressionEq,
· · · · · · · · · EqualityExpression: &cc.EqualityExpression{
· · · · · · · · · · Case: EqualityExpressionRel,
· · · · · · · · · · RelationalExpression: &cc.RelationalExpression{
· · · · · · · · · · · Case: RelationalExpressionLt,
· · · · · · · · · · · RelationalExpression: &cc.RelationalExpression{
· · · · · · · · · · · · Case: RelationalExpressionShift,
· · · · · · · · · · · · ShiftExpression: &cc.ShiftExpression{
· · · · · · · · · · · · · AdditiveExpression: &cc.AdditiveExpression{
· · · · · · · · · · · · · · Case: AdditiveExpressionMul,
· · · · · · · · · · · · · · MultiplicativeExpression: &cc.MultiplicativeExpression{
· · · · · · · · · · · · · · · Case: MultiplicativeExpressionCast,
· · · · · · · · · · · · · · · CastExpression: &cc.CastExpression{
· · · · · · · · · · · · · · · · Case: CastExpressionUnary,
· · · · · · · · · · · · · · · · UnaryExpression: &cc.UnaryExpression{
· · · · · · · · · · · · · · · · · Case: UnaryExpressionPostfix,
· · · · · · · · · · · · · · · · · PostfixExpression: &cc.PostfixExpression{
· · · · · · · · · · · · · · · · · · Case: PostfixExpressionPrimary,
· · · · · · · · · · · · · · · · · · PrimaryExpression: &cc.PrimaryExpression{
· · · · · · · · · · · · · · · · · · · Case: PrimaryExpressionIdent,
· · · · · · · · · · · · · · · · · · · Token: example.c:1:23: IDENTIFIER "i",
· · · · · · · · · · · · · · · · · · },
· · · · · · · · · · · · · · · · · },
· · · · · · · · · · · · · · · · },
· · · · · · · · · · · · · · · },
· · · · · · · · · · · · · · },
· · · · · · · · · · · · · },
· · · · · · · · · · · · · Case: ShiftExpressionAdd,
· · · · · · · · · · · · },
· · · · · · · · · · · },
· · · · · · · · · · · ShiftExpression: &cc.ShiftExpression{
· · · · · · · · · · · · AdditiveExpression: &cc.AdditiveExpression{
· · · · · · · · · · · · · Case: AdditiveExpressionMul,
· · · · · · · · · · · · · MultiplicativeExpression: &cc.MultiplicativeExpression{
· · · · · · · · · · · · · · Case: MultiplicativeExpressionCast,
· · · · · · · · · · · · · · CastExpression: &cc.CastExpression{
· · · · · · · · · · · · · · · Case: CastExpressionUnary,
· · · · · · · · · · · · · · · UnaryExpression: &cc.UnaryExpression{
· · · · · · · · · · · · · · · · Case: UnaryExpressionPostfix,
· · · · · · · · · · · · · · · · PostfixExpression: &cc.PostfixExpression{
· · · · · · · · · · · · · · · · · Case: PostfixExpressionPrimary,
· · · · · · · · · · · · · · · · · PrimaryExpression: &cc.PrimaryExpression{
· · · · · · · · · · · · · · · · · · Case: PrimaryExpressionInt,
· · · · · · · · · · · · · · · · · · Token: example.c:1:27: INTCONST "10",
· · · · · · · · · · · · · · · · · },
· · · · · · · · · · · · · · · · },
· · · · · · · · · · · · · · · },
· · · · · · · · · · · · · · },
· · · · · · · · · · · · · },
· · · · · · · · · · · · },
· · · · · · · · · · · · Case: ShiftExpressionAdd,
· · · · · · · · · · · },
· · · · · · · · · · · Token: example.c:1:25: '<' "<",
· · · · · · · · · · },
· · · · · · · · · },
· · · · · · · · },
· · · · · · · · Case: ExclusiveOrExpressionAnd,
· · · · · · · },
· · · · · · },
· · · · · },
· · · · },
· · · },
· · },
· · Case: ExpressionAssign,
· },
· Expression3: &cc.Expression{
· · AssignmentExpression: &cc.AssignmentExpression{
· · · Case: AssignmentExpressionCond,
· · · ConditionalExpression: &cc.ConditionalExpression{
· · · · Case: ConditionalExpressionLOr,
· · · · LogicalOrExpression: &cc.LogicalOrExpression{
· · · · · Case: LogicalOrExpressionLAnd,
· · · · · LogicalAndExpression: &cc.LogicalAndExpression{
· · · · · · Case: LogicalAndExpressionOr,
· · · · · · InclusiveOrExpression: &cc.InclusiveOrExpression{
· · · · · · · Case: InclusiveOrExpressionXor,
· · · · · · · ExclusiveOrExpression: &cc.ExclusiveOrExpression{
· · · · · · · · AndExpression: &cc.AndExpression{
· · · · · · · · · Case: AndExpressionEq,
· · · · · · · · · EqualityExpression: &cc.EqualityExpression{
· · · · · · · · · · Case: EqualityExpressionRel,
· · · · · · · · · · RelationalExpression: &cc.RelationalExpression{
· · · · · · · · · · · Case: RelationalExpressionShift,
· · · · · · · · · · · ShiftExpression: &cc.ShiftExpression{
· · · · · · · · · · · · AdditiveExpression: &cc.AdditiveExpression{
· · · · · · · · · · · · · Case: AdditiveExpressionMul,
· · · · · · · · · · · · · MultiplicativeExpression: &cc.MultiplicativeExpression{
· · · · · · · · · · · · · · Case: MultiplicativeExpressionCast,
· · · · · · · · · · · · · · CastExpression: &cc.CastExpression{
· · · · · · · · · · · · · · · Case: CastExpressionUnary,
· · · · · · · · · · · · · · · UnaryExpression: &cc.UnaryExpression{
· · · · · · · · · · · · · · · · Case: UnaryExpressionPostfix,
· · · · · · · · · · · · · · · · PostfixExpression: &cc.PostfixExpression{
· · · · · · · · · · · · · · · · · Case: PostfixExpressionInc,
· · · · · · · · · · · · · · · · · PostfixExpression: &cc.PostfixExpression{
· · · · · · · · · · · · · · · · · · Case: PostfixExpressionPrimary,
· · · · · · · · · · · · · · · · · · PrimaryExpression: &cc.PrimaryExpression{
· · · · · · · · · · · · · · · · · · · Case: PrimaryExpressionIdent,
· · · · · · · · · · · · · · · · · · · Token: example.c:1:31: IDENTIFIER "i",
· · · · · · · · · · · · · · · · · · },
· · · · · · · · · · · · · · · · · },
· · · · · · · · · · · · · · · · · Token: example.c:1:32: INC "++",
· · · · · · · · · · · · · · · · },
· · · · · · · · · · · · · · · },
· · · · · · · · · · · · · · },
· · · · · · · · · · · · · },
· · · · · · · · · · · · },
· · · · · · · · · · · · Case: ShiftExpressionAdd,
· · · · · · · · · · · },
· · · · · · · · · · },
· · · · · · · · · },
· · · · · · · · },
· · · · · · · · Case: ExclusiveOrExpressionAnd,
· · · · · · · },
· · · · · · },
· · · · · },
· · · · },
· · · },
· · },
· · Case: ExpressionAssign,
· },
· Statement: &cc.Statement{
· · Case: StatementExpr,
· · ExpressionStatement: &cc.ExpressionStatement{
· · · Expression: &cc.Expression{
· · · · AssignmentExpression: &cc.AssignmentExpression{
· · · · · Case: AssignmentExpressionCond,
· · · · · ConditionalExpression: &cc.ConditionalExpression{
· · · · · · Case: ConditionalExpressionLOr,
· · · · · · LogicalOrExpression: &cc.LogicalOrExpression{
· · · · · · · Case: LogicalOrExpressionLAnd,
· · · · · · · LogicalAndExpression: &cc.LogicalAndExpression{
· · · · · · · · Case: LogicalAndExpressionOr,
· · · · · · · · InclusiveOrExpression: &cc.InclusiveOrExpression{
· · · · · · · · · Case: InclusiveOrExpressionXor,
· · · · · · · · · ExclusiveOrExpression: &cc.ExclusiveOrExpression{
· · · · · · · · · · AndExpression: &cc.AndExpression{
· · · · · · · · · · · Case: AndExpressionEq,
· · · · · · · · · · · EqualityExpression: &cc.EqualityExpression{
· · · · · · · · · · · · Case: EqualityExpressionRel,
· · · · · · · · · · · · RelationalExpression: &cc.RelationalExpression{
· · · · · · · · · · · · · Case: RelationalExpressionShift,
· · · · · · · · · · · · · ShiftExpression: &cc.ShiftExpression{
· · · · · · · · · · · · · · AdditiveExpression: &cc.AdditiveExpression{
· · · · · · · · · · · · · · · Case: AdditiveExpressionMul,
· · · · · · · · · · · · · · · MultiplicativeExpression: &cc.MultiplicativeExpression{
· · · · · · · · · · · · · · · · Case: MultiplicativeExpressionCast,
· · · · · · · · · · · · · · · · CastExpression: &cc.CastExpression{
· · · · · · · · · · · · · · · · · Case: CastExpressionUnary,
· · · · · · · · · · · · · · · · · UnaryExpression: &cc.UnaryExpression{
· · · · · · · · · · · · · · · · · · Case: UnaryExpressionPostfix,
· · · · · · · · · · · · · · · · · · PostfixExpression: &cc.PostfixExpression{
· · · · · · · · · · · · · · · · · · · Case: PostfixExpressionCall,
· · · · · · · · · · · · · · · · · · · PostfixExpression: &cc.PostfixExpression{
· · · · · · · · · · · · · · · · · · · · Case: PostfixExpressionPrimary,
· · · · · · · · · · · · · · · · · · · · PrimaryExpression: &cc.PrimaryExpression{
· · · · · · · · · · · · · · · · · · · · · Case: PrimaryExpressionIdent,
· · · · · · · · · · · · · · · · · · · · · Token: example.c:1:36: IDENTIFIER "x",
· · · · · · · · · · · · · · · · · · · · },
· · · · · · · · · · · · · · · · · · · },
· · · · · · · · · · · · · · · · · · · Token: example.c:1:37: '(' "(",
· · · · · · · · · · · · · · · · · · · Token2: example.c:1:38: ')' ")",
· · · · · · · · · · · · · · · · · · },
· · · · · · · · · · · · · · · · · },
· · · · · · · · · · · · · · · · },
· · · · · · · · · · · · · · · },
· · · · · · · · · · · · · · },
· · · · · · · · · · · · · · Case: ShiftExpressionAdd,
· · · · · · · · · · · · · },
· · · · · · · · · · · · },
· · · · · · · · · · · },
· · · · · · · · · · },
· · · · · · · · · · Case: ExclusiveOrExpressionAnd,
· · · · · · · · · },
· · · · · · · · },
· · · · · · · },
· · · · · · },
· · · · · },
· · · · },
· · · · Case: ExpressionAssign,
· · · },
· · · Token: example.c:1:39: ';' ";",
· · },
· },
· Token: example.c:1:11: FOR "for",
· Token2: example.c:1:14: '(' "(",
· Token3: example.c:1:21: ';' ";",
· Token4: example.c:1:29: ';' ";",
· Token5: example.c:1:34: ')' ")",
}
Example (ForDecl)
fmt.Println(exampleAST(237, "int f() { for( int i = 0; i < 10; i++) x(); }"))
Output:

&cc.IterationStatement{
· Case: IterationStatementForDecl,
· Declaration: &cc.Declaration{
· · DeclarationSpecifiers: &cc.DeclarationSpecifiers{
· · · Case: DeclarationSpecifiersTypeSpec,
· · · TypeSpecifier: &cc.TypeSpecifier{
· · · · Case: TypeSpecifierInt,
· · · · Token: example.c:1:16: INT "int",
· · · },
· · },
· · InitDeclaratorList: &cc.InitDeclaratorList{
· · · InitDeclarator: &cc.InitDeclarator{
· · · · Case: InitDeclaratorInit,
· · · · Declarator: &cc.Declarator{
· · · · · DirectDeclarator: &cc.DirectDeclarator{
· · · · · · Case: DirectDeclaratorIdent,
· · · · · · Token: example.c:1:20: IDENTIFIER "i",
· · · · · },
· · · · },
· · · · Initializer: &cc.Initializer{
· · · · · AssignmentExpression: &cc.AssignmentExpression{
· · · · · · Case: AssignmentExpressionCond,
· · · · · · ConditionalExpression: &cc.ConditionalExpression{
· · · · · · · Case: ConditionalExpressionLOr,
· · · · · · · LogicalOrExpression: &cc.LogicalOrExpression{
· · · · · · · · Case: LogicalOrExpressionLAnd,
· · · · · · · · LogicalAndExpression: &cc.LogicalAndExpression{
· · · · · · · · · Case: LogicalAndExpressionOr,
· · · · · · · · · InclusiveOrExpression: &cc.InclusiveOrExpression{
· · · · · · · · · · Case: InclusiveOrExpressionXor,
· · · · · · · · · · ExclusiveOrExpression: &cc.ExclusiveOrExpression{
· · · · · · · · · · · AndExpression: &cc.AndExpression{
· · · · · · · · · · · · Case: AndExpressionEq,
· · · · · · · · · · · · EqualityExpression: &cc.EqualityExpression{
· · · · · · · · · · · · · Case: EqualityExpressionRel,
· · · · · · · · · · · · · RelationalExpression: &cc.RelationalExpression{
· · · · · · · · · · · · · · Case: RelationalExpressionShift,
· · · · · · · · · · · · · · ShiftExpression: &cc.ShiftExpression{
· · · · · · · · · · · · · · · AdditiveExpression: &cc.AdditiveExpression{
· · · · · · · · · · · · · · · · Case: AdditiveExpressionMul,
· · · · · · · · · · · · · · · · MultiplicativeExpression: &cc.MultiplicativeExpression{
· · · · · · · · · · · · · · · · · Case: MultiplicativeExpressionCast,
· · · · · · · · · · · · · · · · · CastExpression: &cc.CastExpression{
· · · · · · · · · · · · · · · · · · Case: CastExpressionUnary,
· · · · · · · · · · · · · · · · · · UnaryExpression: &cc.UnaryExpression{
· · · · · · · · · · · · · · · · · · · Case: UnaryExpressionPostfix,
· · · · · · · · · · · · · · · · · · · PostfixExpression: &cc.PostfixExpression{
· · · · · · · · · · · · · · · · · · · · Case: PostfixExpressionPrimary,
· · · · · · · · · · · · · · · · · · · · PrimaryExpression: &cc.PrimaryExpression{
· · · · · · · · · · · · · · · · · · · · · Case: PrimaryExpressionInt,
· · · · · · · · · · · · · · · · · · · · · Token: example.c:1:24: INTCONST "0",
· · · · · · · · · · · · · · · · · · · · },
· · · · · · · · · · · · · · · · · · · },
· · · · · · · · · · · · · · · · · · },
· · · · · · · · · · · · · · · · · },
· · · · · · · · · · · · · · · · },
· · · · · · · · · · · · · · · },
· · · · · · · · · · · · · · · Case: ShiftExpressionAdd,
· · · · · · · · · · · · · · },
· · · · · · · · · · · · · },
· · · · · · · · · · · · },
· · · · · · · · · · · },
· · · · · · · · · · · Case: ExclusiveOrExpressionAnd,
· · · · · · · · · · },
· · · · · · · · · },
· · · · · · · · },
· · · · · · · },
· · · · · · },
· · · · · },
· · · · · Case: InitializerExpr,
· · · · },
· · · · Token: example.c:1:22: '=' "=",
· · · },
· · },
· · Token: example.c:1:25: ';' ";",
· },
· Expression: &cc.Expression{
· · AssignmentExpression: &cc.AssignmentExpression{
· · · Case: AssignmentExpressionCond,
· · · ConditionalExpression: &cc.ConditionalExpression{
· · · · Case: ConditionalExpressionLOr,
· · · · LogicalOrExpression: &cc.LogicalOrExpression{
· · · · · Case: LogicalOrExpressionLAnd,
· · · · · LogicalAndExpression: &cc.LogicalAndExpression{
· · · · · · Case: LogicalAndExpressionOr,
· · · · · · InclusiveOrExpression: &cc.InclusiveOrExpression{
· · · · · · · Case: InclusiveOrExpressionXor,
· · · · · · · ExclusiveOrExpression: &cc.ExclusiveOrExpression{
· · · · · · · · AndExpression: &cc.AndExpression{
· · · · · · · · · Case: AndExpressionEq,
· · · · · · · · · EqualityExpression: &cc.EqualityExpression{
· · · · · · · · · · Case: EqualityExpressionRel,
· · · · · · · · · · RelationalExpression: &cc.RelationalExpression{
· · · · · · · · · · · Case: RelationalExpressionLt,
· · · · · · · · · · · RelationalExpression: &cc.RelationalExpression{
· · · · · · · · · · · · Case: RelationalExpressionShift,
· · · · · · · · · · · · ShiftExpression: &cc.ShiftExpression{
· · · · · · · · · · · · · AdditiveExpression: &cc.AdditiveExpression{
· · · · · · · · · · · · · · Case: AdditiveExpressionMul,
· · · · · · · · · · · · · · MultiplicativeExpression: &cc.MultiplicativeExpression{
· · · · · · · · · · · · · · · Case: MultiplicativeExpressionCast,
· · · · · · · · · · · · · · · CastExpression: &cc.CastExpression{
· · · · · · · · · · · · · · · · Case: CastExpressionUnary,
· · · · · · · · · · · · · · · · UnaryExpression: &cc.UnaryExpression{
· · · · · · · · · · · · · · · · · Case: UnaryExpressionPostfix,
· · · · · · · · · · · · · · · · · PostfixExpression: &cc.PostfixExpression{
· · · · · · · · · · · · · · · · · · Case: PostfixExpressionPrimary,
· · · · · · · · · · · · · · · · · · PrimaryExpression: &cc.PrimaryExpression{
· · · · · · · · · · · · · · · · · · · Case: PrimaryExpressionIdent,
· · · · · · · · · · · · · · · · · · · Token: example.c:1:27: IDENTIFIER "i",
· · · · · · · · · · · · · · · · · · },
· · · · · · · · · · · · · · · · · },
· · · · · · · · · · · · · · · · },
· · · · · · · · · · · · · · · },
· · · · · · · · · · · · · · },
· · · · · · · · · · · · · },
· · · · · · · · · · · · · Case: ShiftExpressionAdd,
· · · · · · · · · · · · },
· · · · · · · · · · · },
· · · · · · · · · · · ShiftExpression: &cc.ShiftExpression{
· · · · · · · · · · · · AdditiveExpression: &cc.AdditiveExpression{
· · · · · · · · · · · · · Case: AdditiveExpressionMul,
· · · · · · · · · · · · · MultiplicativeExpression: &cc.MultiplicativeExpression{
· · · · · · · · · · · · · · Case: MultiplicativeExpressionCast,
· · · · · · · · · · · · · · CastExpression: &cc.CastExpression{
· · · · · · · · · · · · · · · Case: CastExpressionUnary,
· · · · · · · · · · · · · · · UnaryExpression: &cc.UnaryExpression{
· · · · · · · · · · · · · · · · Case: UnaryExpressionPostfix,
· · · · · · · · · · · · · · · · PostfixExpression: &cc.PostfixExpression{
· · · · · · · · · · · · · · · · · Case: PostfixExpressionPrimary,
· · · · · · · · · · · · · · · · · PrimaryExpression: &cc.PrimaryExpression{
· · · · · · · · · · · · · · · · · · Case: PrimaryExpressionInt,
· · · · · · · · · · · · · · · · · · Token: example.c:1:31: INTCONST "10",
· · · · · · · · · · · · · · · · · },
· · · · · · · · · · · · · · · · },
· · · · · · · · · · · · · · · },
· · · · · · · · · · · · · · },
· · · · · · · · · · · · · },
· · · · · · · · · · · · },
· · · · · · · · · · · · Case: ShiftExpressionAdd,
· · · · · · · · · · · },
· · · · · · · · · · · Token: example.c:1:29: '<' "<",
· · · · · · · · · · },
· · · · · · · · · },
· · · · · · · · },
· · · · · · · · Case: ExclusiveOrExpressionAnd,
· · · · · · · },
· · · · · · },
· · · · · },
· · · · },
· · · },
· · },
· · Case: ExpressionAssign,
· },
· Expression2: &cc.Expression{
· · AssignmentExpression: &cc.AssignmentExpression{
· · · Case: AssignmentExpressionCond,
· · · ConditionalExpression: &cc.ConditionalExpression{
· · · · Case: ConditionalExpressionLOr,
· · · · LogicalOrExpression: &cc.LogicalOrExpression{
· · · · · Case: LogicalOrExpressionLAnd,
· · · · · LogicalAndExpression: &cc.LogicalAndExpression{
· · · · · · Case: LogicalAndExpressionOr,
· · · · · · InclusiveOrExpression: &cc.InclusiveOrExpression{
· · · · · · · Case: InclusiveOrExpressionXor,
· · · · · · · ExclusiveOrExpression: &cc.ExclusiveOrExpression{
· · · · · · · · AndExpression: &cc.AndExpression{
· · · · · · · · · Case: AndExpressionEq,
· · · · · · · · · EqualityExpression: &cc.EqualityExpression{
· · · · · · · · · · Case: EqualityExpressionRel,
· · · · · · · · · · RelationalExpression: &cc.RelationalExpression{
· · · · · · · · · · · Case: RelationalExpressionShift,
· · · · · · · · · · · ShiftExpression: &cc.ShiftExpression{
· · · · · · · · · · · · AdditiveExpression: &cc.AdditiveExpression{
· · · · · · · · · · · · · Case: AdditiveExpressionMul,
· · · · · · · · · · · · · MultiplicativeExpression: &cc.MultiplicativeExpression{
· · · · · · · · · · · · · · Case: MultiplicativeExpressionCast,
· · · · · · · · · · · · · · CastExpression: &cc.CastExpression{
· · · · · · · · · · · · · · · Case: CastExpressionUnary,
· · · · · · · · · · · · · · · UnaryExpression: &cc.UnaryExpression{
· · · · · · · · · · · · · · · · Case: UnaryExpressionPostfix,
· · · · · · · · · · · · · · · · PostfixExpression: &cc.PostfixExpression{
· · · · · · · · · · · · · · · · · Case: PostfixExpressionInc,
· · · · · · · · · · · · · · · · · PostfixExpression: &cc.PostfixExpression{
· · · · · · · · · · · · · · · · · · Case: PostfixExpressionPrimary,
· · · · · · · · · · · · · · · · · · PrimaryExpression: &cc.PrimaryExpression{
· · · · · · · · · · · · · · · · · · · Case: PrimaryExpressionIdent,
· · · · · · · · · · · · · · · · · · · Token: example.c:1:35: IDENTIFIER "i",
· · · · · · · · · · · · · · · · · · },
· · · · · · · · · · · · · · · · · },
· · · · · · · · · · · · · · · · · Token: example.c:1:36: INC "++",
· · · · · · · · · · · · · · · · },
· · · · · · · · · · · · · · · },
· · · · · · · · · · · · · · },
· · · · · · · · · · · · · },
· · · · · · · · · · · · },
· · · · · · · · · · · · Case: ShiftExpressionAdd,
· · · · · · · · · · · },
· · · · · · · · · · },
· · · · · · · · · },
· · · · · · · · },
· · · · · · · · Case: ExclusiveOrExpressionAnd,
· · · · · · · },
· · · · · · },
· · · · · },
· · · · },
· · · },
· · },
· · Case: ExpressionAssign,
· },
· Statement: &cc.Statement{
· · Case: StatementExpr,
· · ExpressionStatement: &cc.ExpressionStatement{
· · · Expression: &cc.Expression{
· · · · AssignmentExpression: &cc.AssignmentExpression{
· · · · · Case: AssignmentExpressionCond,
· · · · · ConditionalExpression: &cc.ConditionalExpression{
· · · · · · Case: ConditionalExpressionLOr,
· · · · · · LogicalOrExpression: &cc.LogicalOrExpression{
· · · · · · · Case: LogicalOrExpressionLAnd,
· · · · · · · LogicalAndExpression: &cc.LogicalAndExpression{
· · · · · · · · Case: LogicalAndExpressionOr,
· · · · · · · · InclusiveOrExpression: &cc.InclusiveOrExpression{
· · · · · · · · · Case: InclusiveOrExpressionXor,
· · · · · · · · · ExclusiveOrExpression: &cc.ExclusiveOrExpression{
· · · · · · · · · · AndExpression: &cc.AndExpression{
· · · · · · · · · · · Case: AndExpressionEq,
· · · · · · · · · · · EqualityExpression: &cc.EqualityExpression{
· · · · · · · · · · · · Case: EqualityExpressionRel,
· · · · · · · · · · · · RelationalExpression: &cc.RelationalExpression{
· · · · · · · · · · · · · Case: RelationalExpressionShift,
· · · · · · · · · · · · · ShiftExpression: &cc.ShiftExpression{
· · · · · · · · · · · · · · AdditiveExpression: &cc.AdditiveExpression{
· · · · · · · · · · · · · · · Case: AdditiveExpressionMul,
· · · · · · · · · · · · · · · MultiplicativeExpression: &cc.MultiplicativeExpression{
· · · · · · · · · · · · · · · · Case: MultiplicativeExpressionCast,
· · · · · · · · · · · · · · · · CastExpression: &cc.CastExpression{
· · · · · · · · · · · · · · · · · Case: CastExpressionUnary,
· · · · · · · · · · · · · · · · · UnaryExpression: &cc.UnaryExpression{
· · · · · · · · · · · · · · · · · · Case: UnaryExpressionPostfix,
· · · · · · · · · · · · · · · · · · PostfixExpression: &cc.PostfixExpression{
· · · · · · · · · · · · · · · · · · · Case: PostfixExpressionCall,
· · · · · · · · · · · · · · · · · · · PostfixExpression: &cc.PostfixExpression{
· · · · · · · · · · · · · · · · · · · · Case: PostfixExpressionPrimary,
· · · · · · · · · · · · · · · · · · · · PrimaryExpression: &cc.PrimaryExpression{
· · · · · · · · · · · · · · · · · · · · · Case: PrimaryExpressionIdent,
· · · · · · · · · · · · · · · · · · · · · Token: example.c:1:40: IDENTIFIER "x",
· · · · · · · · · · · · · · · · · · · · },
· · · · · · · · · · · · · · · · · · · },
· · · · · · · · · · · · · · · · · · · Token: example.c:1:41: '(' "(",
· · · · · · · · · · · · · · · · · · · Token2: example.c:1:42: ')' ")",
· · · · · · · · · · · · · · · · · · },
· · · · · · · · · · · · · · · · · },
· · · · · · · · · · · · · · · · },
· · · · · · · · · · · · · · · },
· · · · · · · · · · · · · · },
· · · · · · · · · · · · · · Case: ShiftExpressionAdd,
· · · · · · · · · · · · · },
· · · · · · · · · · · · },
· · · · · · · · · · · },
· · · · · · · · · · },
· · · · · · · · · · Case: ExclusiveOrExpressionAnd,
· · · · · · · · · },
· · · · · · · · },
· · · · · · · },
· · · · · · },
· · · · · },
· · · · },
· · · · Case: ExpressionAssign,
· · · },
· · · Token: example.c:1:43: ';' ";",
· · },
· },
· Token: example.c:1:11: FOR "for",
· Token2: example.c:1:14: '(' "(",
· Token3: example.c:1:33: ';' ";",
· Token4: example.c:1:38: ')' ")",
}
Example (While)
fmt.Println(exampleAST(234, "int f() { while(x) y(); }"))
Output:

&cc.IterationStatement{
· Case: IterationStatementWhile,
· Expression: &cc.Expression{
· · AssignmentExpression: &cc.AssignmentExpression{
· · · Case: AssignmentExpressionCond,
· · · ConditionalExpression: &cc.ConditionalExpression{
· · · · Case: ConditionalExpressionLOr,
· · · · LogicalOrExpression: &cc.LogicalOrExpression{
· · · · · Case: LogicalOrExpressionLAnd,
· · · · · LogicalAndExpression: &cc.LogicalAndExpression{
· · · · · · Case: LogicalAndExpressionOr,
· · · · · · InclusiveOrExpression: &cc.InclusiveOrExpression{
· · · · · · · Case: InclusiveOrExpressionXor,
· · · · · · · ExclusiveOrExpression: &cc.ExclusiveOrExpression{
· · · · · · · · AndExpression: &cc.AndExpression{
· · · · · · · · · Case: AndExpressionEq,
· · · · · · · · · EqualityExpression: &cc.EqualityExpression{
· · · · · · · · · · Case: EqualityExpressionRel,
· · · · · · · · · · RelationalExpression: &cc.RelationalExpression{
· · · · · · · · · · · Case: RelationalExpressionShift,
· · · · · · · · · · · ShiftExpression: &cc.ShiftExpression{
· · · · · · · · · · · · AdditiveExpression: &cc.AdditiveExpression{
· · · · · · · · · · · · · Case: AdditiveExpressionMul,
· · · · · · · · · · · · · MultiplicativeExpression: &cc.MultiplicativeExpression{
· · · · · · · · · · · · · · Case: MultiplicativeExpressionCast,
· · · · · · · · · · · · · · CastExpression: &cc.CastExpression{
· · · · · · · · · · · · · · · Case: CastExpressionUnary,
· · · · · · · · · · · · · · · UnaryExpression: &cc.UnaryExpression{
· · · · · · · · · · · · · · · · Case: UnaryExpressionPostfix,
· · · · · · · · · · · · · · · · PostfixExpression: &cc.PostfixExpression{
· · · · · · · · · · · · · · · · · Case: PostfixExpressionPrimary,
· · · · · · · · · · · · · · · · · PrimaryExpression: &cc.PrimaryExpression{
· · · · · · · · · · · · · · · · · · Case: PrimaryExpressionIdent,
· · · · · · · · · · · · · · · · · · Token: example.c:1:17: IDENTIFIER "x",
· · · · · · · · · · · · · · · · · },
· · · · · · · · · · · · · · · · },
· · · · · · · · · · · · · · · },
· · · · · · · · · · · · · · },
· · · · · · · · · · · · · },
· · · · · · · · · · · · },
· · · · · · · · · · · · Case: ShiftExpressionAdd,
· · · · · · · · · · · },
· · · · · · · · · · },
· · · · · · · · · },
· · · · · · · · },
· · · · · · · · Case: ExclusiveOrExpressionAnd,
· · · · · · · },
· · · · · · },
· · · · · },
· · · · },
· · · },
· · },
· · Case: ExpressionAssign,
· },
· Statement: &cc.Statement{
· · Case: StatementExpr,
· · ExpressionStatement: &cc.ExpressionStatement{
· · · Expression: &cc.Expression{
· · · · AssignmentExpression: &cc.AssignmentExpression{
· · · · · Case: AssignmentExpressionCond,
· · · · · ConditionalExpression: &cc.ConditionalExpression{
· · · · · · Case: ConditionalExpressionLOr,
· · · · · · LogicalOrExpression: &cc.LogicalOrExpression{
· · · · · · · Case: LogicalOrExpressionLAnd,
· · · · · · · LogicalAndExpression: &cc.LogicalAndExpression{
· · · · · · · · Case: LogicalAndExpressionOr,
· · · · · · · · InclusiveOrExpression: &cc.InclusiveOrExpression{
· · · · · · · · · Case: InclusiveOrExpressionXor,
· · · · · · · · · ExclusiveOrExpression: &cc.ExclusiveOrExpression{
· · · · · · · · · · AndExpression: &cc.AndExpression{
· · · · · · · · · · · Case: AndExpressionEq,
· · · · · · · · · · · EqualityExpression: &cc.EqualityExpression{
· · · · · · · · · · · · Case: EqualityExpressionRel,
· · · · · · · · · · · · RelationalExpression: &cc.RelationalExpression{
· · · · · · · · · · · · · Case: RelationalExpressionShift,
· · · · · · · · · · · · · ShiftExpression: &cc.ShiftExpression{
· · · · · · · · · · · · · · AdditiveExpression: &cc.AdditiveExpression{
· · · · · · · · · · · · · · · Case: AdditiveExpressionMul,
· · · · · · · · · · · · · · · MultiplicativeExpression: &cc.MultiplicativeExpression{
· · · · · · · · · · · · · · · · Case: MultiplicativeExpressionCast,
· · · · · · · · · · · · · · · · CastExpression: &cc.CastExpression{
· · · · · · · · · · · · · · · · · Case: CastExpressionUnary,
· · · · · · · · · · · · · · · · · UnaryExpression: &cc.UnaryExpression{
· · · · · · · · · · · · · · · · · · Case: UnaryExpressionPostfix,
· · · · · · · · · · · · · · · · · · PostfixExpression: &cc.PostfixExpression{
· · · · · · · · · · · · · · · · · · · Case: PostfixExpressionCall,
· · · · · · · · · · · · · · · · · · · PostfixExpression: &cc.PostfixExpression{
· · · · · · · · · · · · · · · · · · · · Case: PostfixExpressionPrimary,
· · · · · · · · · · · · · · · · · · · · PrimaryExpression: &cc.PrimaryExpression{
· · · · · · · · · · · · · · · · · · · · · Case: PrimaryExpressionIdent,
· · · · · · · · · · · · · · · · · · · · · Token: example.c:1:20: IDENTIFIER "y",
· · · · · · · · · · · · · · · · · · · · },
· · · · · · · · · · · · · · · · · · · },
· · · · · · · · · · · · · · · · · · · Token: example.c:1:21: '(' "(",
· · · · · · · · · · · · · · · · · · · Token2: example.c:1:22: ')' ")",
· · · · · · · · · · · · · · · · · · },
· · · · · · · · · · · · · · · · · },
· · · · · · · · · · · · · · · · },
· · · · · · · · · · · · · · · },
· · · · · · · · · · · · · · },
· · · · · · · · · · · · · · Case: ShiftExpressionAdd,
· · · · · · · · · · · · · },
· · · · · · · · · · · · },
· · · · · · · · · · · },
· · · · · · · · · · },
· · · · · · · · · · Case: ExclusiveOrExpressionAnd,
· · · · · · · · · },
· · · · · · · · },
· · · · · · · },
· · · · · · },
· · · · · },
· · · · },
· · · · Case: ExpressionAssign,
· · · },
· · · Token: example.c:1:23: ';' ";",
· · },
· },
· Token: example.c:1:11: WHILE "while",
· Token2: example.c:1:16: '(' "(",
· Token3: example.c:1:18: ')' ")",
}

func (*IterationStatement) Position

func (n *IterationStatement) Position() (r token.Position)

Position reports the position of the first component of n, if available.

func (*IterationStatement) String

func (n *IterationStatement) String() string

String implements fmt.Stringer.

type IterationStatementCase

type IterationStatementCase int

IterationStatementCase represents case numbers of production IterationStatement

const (
	IterationStatementWhile IterationStatementCase = iota
	IterationStatementDo
	IterationStatementFor
	IterationStatementForDecl
)

Values of type IterationStatementCase

func (IterationStatementCase) String

func (n IterationStatementCase) String() string

String implements fmt.Stringer

type JumpStatement

type JumpStatement struct {
	Case       JumpStatementCase `PrettyPrint:"stringer,zero"`
	Expression *Expression
	Token      Token
	Token2     Token
	Token3     Token
	// contains filtered or unexported fields
}

JumpStatement represents data reduced by productions:

JumpStatement:
        "goto" IDENTIFIER ';'      // Case JumpStatementGoto
|       "goto" '*' Expression ';'  // Case JumpStatementGotoExpr
|       "continue" ';'             // Case JumpStatementContinue
|       "break" ';'                // Case JumpStatementBreak
|       "return" Expression ';'    // Case JumpStatementReturn
Example (Break)
fmt.Println(exampleAST(241, "int f() { for(;;) if (i) break; }"))
Output:

&cc.JumpStatement{
· Case: JumpStatementBreak,
· Token: example.c:1:26: BREAK "break",
· Token2: example.c:1:31: ';' ";",
}
Example (Continue)
fmt.Println(exampleAST(240, "int f() { for(;;) if (i) continue; }"))
Output:

&cc.JumpStatement{
· Case: JumpStatementContinue,
· Token: example.c:1:26: CONTINUE "continue",
· Token2: example.c:1:34: ';' ";",
}
Example (Goto)
fmt.Println(exampleAST(238, "int f() { L: goto L; }"))
Output:

&cc.JumpStatement{
· Case: JumpStatementGoto,
· Token: example.c:1:14: GOTO "goto",
· Token2: example.c:1:19: IDENTIFIER "L",
· Token3: example.c:1:20: ';' ";",
}
Example (GotoExpr)
fmt.Println(exampleAST(239, "int f() { L: x(); void *p = &&L; goto *p; }"))
Output:

&cc.JumpStatement{
· Case: JumpStatementGotoExpr,
· Expression: &cc.Expression{
· · AssignmentExpression: &cc.AssignmentExpression{
· · · Case: AssignmentExpressionCond,
· · · ConditionalExpression: &cc.ConditionalExpression{
· · · · Case: ConditionalExpressionLOr,
· · · · LogicalOrExpression: &cc.LogicalOrExpression{
· · · · · Case: LogicalOrExpressionLAnd,
· · · · · LogicalAndExpression: &cc.LogicalAndExpression{
· · · · · · Case: LogicalAndExpressionOr,
· · · · · · InclusiveOrExpression: &cc.InclusiveOrExpression{
· · · · · · · Case: InclusiveOrExpressionXor,
· · · · · · · ExclusiveOrExpression: &cc.ExclusiveOrExpression{
· · · · · · · · AndExpression: &cc.AndExpression{
· · · · · · · · · Case: AndExpressionEq,
· · · · · · · · · EqualityExpression: &cc.EqualityExpression{
· · · · · · · · · · Case: EqualityExpressionRel,
· · · · · · · · · · RelationalExpression: &cc.RelationalExpression{
· · · · · · · · · · · Case: RelationalExpressionShift,
· · · · · · · · · · · ShiftExpression: &cc.ShiftExpression{
· · · · · · · · · · · · AdditiveExpression: &cc.AdditiveExpression{
· · · · · · · · · · · · · Case: AdditiveExpressionMul,
· · · · · · · · · · · · · MultiplicativeExpression: &cc.MultiplicativeExpression{
· · · · · · · · · · · · · · Case: MultiplicativeExpressionCast,
· · · · · · · · · · · · · · CastExpression: &cc.CastExpression{
· · · · · · · · · · · · · · · Case: CastExpressionUnary,
· · · · · · · · · · · · · · · UnaryExpression: &cc.UnaryExpression{
· · · · · · · · · · · · · · · · Case: UnaryExpressionPostfix,
· · · · · · · · · · · · · · · · PostfixExpression: &cc.PostfixExpression{
· · · · · · · · · · · · · · · · · Case: PostfixExpressionPrimary,
· · · · · · · · · · · · · · · · · PrimaryExpression: &cc.PrimaryExpression{
· · · · · · · · · · · · · · · · · · Case: PrimaryExpressionIdent,
· · · · · · · · · · · · · · · · · · Token: example.c:1:40: IDENTIFIER "p",
· · · · · · · · · · · · · · · · · },
· · · · · · · · · · · · · · · · },
· · · · · · · · · · · · · · · },
· · · · · · · · · · · · · · },
· · · · · · · · · · · · · },
· · · · · · · · · · · · },
· · · · · · · · · · · · Case: ShiftExpressionAdd,
· · · · · · · · · · · },
· · · · · · · · · · },
· · · · · · · · · },
· · · · · · · · },
· · · · · · · · Case: ExclusiveOrExpressionAnd,
· · · · · · · },
· · · · · · },
· · · · · },
· · · · },
· · · },
· · },
· · Case: ExpressionAssign,
· },
· Token: example.c:1:34: GOTO "goto",
· Token2: example.c:1:39: '*' "*",
· Token3: example.c:1:41: ';' ";",
}
Example (Return)
fmt.Println(exampleAST(242, "int f() { if (i) return x; }"))
Output:

&cc.JumpStatement{
· Case: JumpStatementReturn,
· Expression: &cc.Expression{
· · AssignmentExpression: &cc.AssignmentExpression{
· · · Case: AssignmentExpressionCond,
· · · ConditionalExpression: &cc.ConditionalExpression{
· · · · Case: ConditionalExpressionLOr,
· · · · LogicalOrExpression: &cc.LogicalOrExpression{
· · · · · Case: LogicalOrExpressionLAnd,
· · · · · LogicalAndExpression: &cc.LogicalAndExpression{
· · · · · · Case: LogicalAndExpressionOr,
· · · · · · InclusiveOrExpression: &cc.InclusiveOrExpression{
· · · · · · · Case: InclusiveOrExpressionXor,
· · · · · · · ExclusiveOrExpression: &cc.ExclusiveOrExpression{
· · · · · · · · AndExpression: &cc.AndExpression{
· · · · · · · · · Case: AndExpressionEq,
· · · · · · · · · EqualityExpression: &cc.EqualityExpression{
· · · · · · · · · · Case: EqualityExpressionRel,
· · · · · · · · · · RelationalExpression: &cc.RelationalExpression{
· · · · · · · · · · · Case: RelationalExpressionShift,
· · · · · · · · · · · ShiftExpression: &cc.ShiftExpression{
· · · · · · · · · · · · AdditiveExpression: &cc.AdditiveExpression{
· · · · · · · · · · · · · Case: AdditiveExpressionMul,
· · · · · · · · · · · · · MultiplicativeExpression: &cc.MultiplicativeExpression{
· · · · · · · · · · · · · · Case: MultiplicativeExpressionCast,
· · · · · · · · · · · · · · CastExpression: &cc.CastExpression{
· · · · · · · · · · · · · · · Case: CastExpressionUnary,
· · · · · · · · · · · · · · · UnaryExpression: &cc.UnaryExpression{
· · · · · · · · · · · · · · · · Case: UnaryExpressionPostfix,
· · · · · · · · · · · · · · · · PostfixExpression: &cc.PostfixExpression{
· · · · · · · · · · · · · · · · · Case: PostfixExpressionPrimary,
· · · · · · · · · · · · · · · · · PrimaryExpression: &cc.PrimaryExpression{
· · · · · · · · · · · · · · · · · · Case: PrimaryExpressionIdent,
· · · · · · · · · · · · · · · · · · Token: example.c:1:25: IDENTIFIER "x",
· · · · · · · · · · · · · · · · · },
· · · · · · · · · · · · · · · · },
· · · · · · · · · · · · · · · },
· · · · · · · · · · · · · · },
· · · · · · · · · · · · · },
· · · · · · · · · · · · },
· · · · · · · · · · · · Case: ShiftExpressionAdd,
· · · · · · · · · · · },
· · · · · · · · · · },
· · · · · · · · · },
· · · · · · · · },
· · · · · · · · Case: ExclusiveOrExpressionAnd,
· · · · · · · },
· · · · · · },
· · · · · },
· · · · },
· · · },
· · },
· · Case: ExpressionAssign,
· },
· Token: example.c:1:18: RETURN "return",
· Token2: example.c:1:26: ';' ";",
}

func (*JumpStatement) Context

func (n *JumpStatement) Context() Node

Context reports the statement, if any, a break or continue belongs to. Valid only after typecheck and for n.Case == JumpStatementBreak or JumpStatementContinue.

func (*JumpStatement) LexicalScope

func (n *JumpStatement) LexicalScope() Scope

LexicalScope returns the lexical scope of n.

func (*JumpStatement) Position

func (n *JumpStatement) Position() (r token.Position)

Position reports the position of the first component of n, if available.

func (*JumpStatement) String

func (n *JumpStatement) String() string

String implements fmt.Stringer.

type JumpStatementCase

type JumpStatementCase int

JumpStatementCase represents case numbers of production JumpStatement

const (
	JumpStatementGoto JumpStatementCase = iota
	JumpStatementGotoExpr
	JumpStatementContinue
	JumpStatementBreak
	JumpStatementReturn
)

Values of type JumpStatementCase

func (JumpStatementCase) String

func (n JumpStatementCase) String() string

String implements fmt.Stringer

type Kind

type Kind uint

A Kind represents the specific kind of type that a Type represents. The zero Kind is not a valid kind.

const (
	Invalid Kind = iota

	Array             // T[]
	Bool              // _Bool
	Char              // char
	ComplexChar       // complex char
	ComplexDouble     // complex double
	ComplexFloat      // complex float
	ComplexInt        // complex int
	ComplexLong       // complex long
	ComplexLongDouble // complex long double
	ComplexLongLong   // complex long long
	ComplexShort      // complex short
	ComplexUInt       // complex unsigned
	ComplexULong      // complex unsigned long
	ComplexULongLong  // complex unsigned long long
	ComplexUShort     // complex shor
	Decimal128        // _Decimal128
	Decimal32         // _Decimal32
	Decimal64         // _Decimal64
	Double            // double
	Enum              // enum
	Float             // float
	Float128          // _Float128
	Float32           // _Float32
	Float32x          // _Float32x
	Float64           // _Float64
	Float64x          // _Float64x
	Function          // function
	Int               // int
	Int8              // __int8
	Int16             // __int16
	Int32             // __int32
	Int64             // __int64
	Int128            // __int128
	Long              // long
	LongDouble        // long double
	LongLong          // long long
	Ptr               // pointer
	SChar             // signed char
	Short             // short
	Struct            // struct
	TypedefName       // typedefname
	UChar             // unsigned char
	UInt              // unsigned
	UInt8             // unsigned __int8
	UInt16            // unsigned __int16
	UInt32            // unsigned __int32
	UInt64            // unsigned __int64
	UInt128           // unsigned __int128
	ULong             // unsigned long
	ULongLong         // unsigned long long
	UShort            // unsigned short
	Union             // union
	Void              // void
	Vector            // vector

)

Values of Kind

func (Kind) String

func (i Kind) String() string

type LabelDeclaration

type LabelDeclaration struct {
	IdentifierList *IdentifierList
	Token          Token
	Token2         Token
}

LabelDeclaration represents data reduced by production:

LabelDeclaration:
        "__label__" IdentifierList ';'
Example (Case0)
fmt.Println(exampleAST(267, "int f() { __label__ L; L: x(); }"))
Output:

&cc.LabelDeclaration{
· IdentifierList: &cc.IdentifierList{
· · Token: example.c:1:21: IDENTIFIER "L",
· },
· Token: example.c:1:11: LABEL "__label__",
· Token2: example.c:1:22: ';' ";",
}

func (*LabelDeclaration) Position

func (n *LabelDeclaration) Position() (r token.Position)

Position reports the position of the first component of n, if available.

func (*LabelDeclaration) String

func (n *LabelDeclaration) String() string

String implements fmt.Stringer.

type LabeledStatement

type LabeledStatement struct {
	AttributeSpecifierList *AttributeSpecifierList
	Case                   LabeledStatementCase `PrettyPrint:"stringer,zero"`
	ConstantExpression     *ConstantExpression
	ConstantExpression2    *ConstantExpression
	Statement              *Statement
	Token                  Token
	Token2                 Token
	Token3                 Token
	// contains filtered or unexported fields
}

LabeledStatement represents data reduced by productions:

LabeledStatement:
        IDENTIFIER ':' AttributeSpecifierList Statement                   // Case LabeledStatementLabel
|       "case" ConstantExpression ':' Statement                           // Case LabeledStatementCaseLabel
|       "case" ConstantExpression "..." ConstantExpression ':' Statement  // Case LabeledStatementRange
|       "default" ':' Statement                                           // Case LabeledStatementDefault
Example (CaseLabel)
fmt.Println(exampleAST(219, "int f() { switch(i) case 42: x(); }"))
Output:

&cc.LabeledStatement{
· Case: LabeledStatementCaseLabel,
· ConstantExpression: &cc.ConstantExpression{
· · ConditionalExpression: &cc.ConditionalExpression{
· · · Case: ConditionalExpressionLOr,
· · · LogicalOrExpression: &cc.LogicalOrExpression{
· · · · Case: LogicalOrExpressionLAnd,
· · · · LogicalAndExpression: &cc.LogicalAndExpression{
· · · · · Case: LogicalAndExpressionOr,
· · · · · InclusiveOrExpression: &cc.InclusiveOrExpression{
· · · · · · Case: InclusiveOrExpressionXor,
· · · · · · ExclusiveOrExpression: &cc.ExclusiveOrExpression{
· · · · · · · AndExpression: &cc.AndExpression{
· · · · · · · · Case: AndExpressionEq,
· · · · · · · · EqualityExpression: &cc.EqualityExpression{
· · · · · · · · · Case: EqualityExpressionRel,
· · · · · · · · · RelationalExpression: &cc.RelationalExpression{
· · · · · · · · · · Case: RelationalExpressionShift,
· · · · · · · · · · ShiftExpression: &cc.ShiftExpression{
· · · · · · · · · · · AdditiveExpression: &cc.AdditiveExpression{
· · · · · · · · · · · · Case: AdditiveExpressionMul,
· · · · · · · · · · · · MultiplicativeExpression: &cc.MultiplicativeExpression{
· · · · · · · · · · · · · Case: MultiplicativeExpressionCast,
· · · · · · · · · · · · · CastExpression: &cc.CastExpression{
· · · · · · · · · · · · · · Case: CastExpressionUnary,
· · · · · · · · · · · · · · UnaryExpression: &cc.UnaryExpression{
· · · · · · · · · · · · · · · Case: UnaryExpressionPostfix,
· · · · · · · · · · · · · · · PostfixExpression: &cc.PostfixExpression{
· · · · · · · · · · · · · · · · Case: PostfixExpressionPrimary,
· · · · · · · · · · · · · · · · PrimaryExpression: &cc.PrimaryExpression{
· · · · · · · · · · · · · · · · · Case: PrimaryExpressionInt,
· · · · · · · · · · · · · · · · · Token: example.c:1:26: INTCONST "42",
· · · · · · · · · · · · · · · · },
· · · · · · · · · · · · · · · },
· · · · · · · · · · · · · · },
· · · · · · · · · · · · · },
· · · · · · · · · · · · },
· · · · · · · · · · · },
· · · · · · · · · · · Case: ShiftExpressionAdd,
· · · · · · · · · · },
· · · · · · · · · },
· · · · · · · · },
· · · · · · · },
· · · · · · · Case: ExclusiveOrExpressionAnd,
· · · · · · },
· · · · · },
· · · · },
· · · },
· · },
· },
· Statement: &cc.Statement{
· · Case: StatementExpr,
· · ExpressionStatement: &cc.ExpressionStatement{
· · · Expression: &cc.Expression{
· · · · AssignmentExpression: &cc.AssignmentExpression{
· · · · · Case: AssignmentExpressionCond,
· · · · · ConditionalExpression: &cc.ConditionalExpression{
· · · · · · Case: ConditionalExpressionLOr,
· · · · · · LogicalOrExpression: &cc.LogicalOrExpression{
· · · · · · · Case: LogicalOrExpressionLAnd,
· · · · · · · LogicalAndExpression: &cc.LogicalAndExpression{
· · · · · · · · Case: LogicalAndExpressionOr,
· · · · · · · · InclusiveOrExpression: &cc.InclusiveOrExpression{
· · · · · · · · · Case: InclusiveOrExpressionXor,
· · · · · · · · · ExclusiveOrExpression: &cc.ExclusiveOrExpression{
· · · · · · · · · · AndExpression: &cc.AndExpression{
· · · · · · · · · · · Case: AndExpressionEq,
· · · · · · · · · · · EqualityExpression: &cc.EqualityExpression{
· · · · · · · · · · · · Case: EqualityExpressionRel,
· · · · · · · · · · · · RelationalExpression: &cc.RelationalExpression{
· · · · · · · · · · · · · Case: RelationalExpressionShift,
· · · · · · · · · · · · · ShiftExpression: &cc.ShiftExpression{
· · · · · · · · · · · · · · AdditiveExpression: &cc.AdditiveExpression{
· · · · · · · · · · · · · · · Case: AdditiveExpressionMul,
· · · · · · · · · · · · · · · MultiplicativeExpression: &cc.MultiplicativeExpression{
· · · · · · · · · · · · · · · · Case: MultiplicativeExpressionCast,
· · · · · · · · · · · · · · · · CastExpression: &cc.CastExpression{
· · · · · · · · · · · · · · · · · Case: CastExpressionUnary,
· · · · · · · · · · · · · · · · · UnaryExpression: &cc.UnaryExpression{
· · · · · · · · · · · · · · · · · · Case: UnaryExpressionPostfix,
· · · · · · · · · · · · · · · · · · PostfixExpression: &cc.PostfixExpression{
· · · · · · · · · · · · · · · · · · · Case: PostfixExpressionCall,
· · · · · · · · · · · · · · · · · · · PostfixExpression: &cc.PostfixExpression{
· · · · · · · · · · · · · · · · · · · · Case: PostfixExpressionPrimary,
· · · · · · · · · · · · · · · · · · · · PrimaryExpression: &cc.PrimaryExpression{
· · · · · · · · · · · · · · · · · · · · · Case: PrimaryExpressionIdent,
· · · · · · · · · · · · · · · · · · · · · Token: example.c:1:30: IDENTIFIER "x",
· · · · · · · · · · · · · · · · · · · · },
· · · · · · · · · · · · · · · · · · · },
· · · · · · · · · · · · · · · · · · · Token: example.c:1:31: '(' "(",
· · · · · · · · · · · · · · · · · · · Token2: example.c:1:32: ')' ")",
· · · · · · · · · · · · · · · · · · },
· · · · · · · · · · · · · · · · · },
· · · · · · · · · · · · · · · · },
· · · · · · · · · · · · · · · },
· · · · · · · · · · · · · · },
· · · · · · · · · · · · · · Case: ShiftExpressionAdd,
· · · · · · · · · · · · · },
· · · · · · · · · · · · },
· · · · · · · · · · · },
· · · · · · · · · · },
· · · · · · · · · · Case: ExclusiveOrExpressionAnd,
· · · · · · · · · },
· · · · · · · · },
· · · · · · · },
· · · · · · },
· · · · · },
· · · · },
· · · · Case: ExpressionAssign,
· · · },
· · · Token: example.c:1:33: ';' ";",
· · },
· },
· Token: example.c:1:21: CASE "case",
· Token2: example.c:1:28: ':' ":",
}
Example (Default)
fmt.Println(exampleAST(221, "int f() { switch(i) default: x(); }"))
Output:

&cc.LabeledStatement{
· Case: LabeledStatementDefault,
· Statement: &cc.Statement{
· · Case: StatementExpr,
· · ExpressionStatement: &cc.ExpressionStatement{
· · · Expression: &cc.Expression{
· · · · AssignmentExpression: &cc.AssignmentExpression{
· · · · · Case: AssignmentExpressionCond,
· · · · · ConditionalExpression: &cc.ConditionalExpression{
· · · · · · Case: ConditionalExpressionLOr,
· · · · · · LogicalOrExpression: &cc.LogicalOrExpression{
· · · · · · · Case: LogicalOrExpressionLAnd,
· · · · · · · LogicalAndExpression: &cc.LogicalAndExpression{
· · · · · · · · Case: LogicalAndExpressionOr,
· · · · · · · · InclusiveOrExpression: &cc.InclusiveOrExpression{
· · · · · · · · · Case: InclusiveOrExpressionXor,
· · · · · · · · · ExclusiveOrExpression: &cc.ExclusiveOrExpression{
· · · · · · · · · · AndExpression: &cc.AndExpression{
· · · · · · · · · · · Case: AndExpressionEq,
· · · · · · · · · · · EqualityExpression: &cc.EqualityExpression{
· · · · · · · · · · · · Case: EqualityExpressionRel,
· · · · · · · · · · · · RelationalExpression: &cc.RelationalExpression{
· · · · · · · · · · · · · Case: RelationalExpressionShift,
· · · · · · · · · · · · · ShiftExpression: &cc.ShiftExpression{
· · · · · · · · · · · · · · AdditiveExpression: &cc.AdditiveExpression{
· · · · · · · · · · · · · · · Case: AdditiveExpressionMul,
· · · · · · · · · · · · · · · MultiplicativeExpression: &cc.MultiplicativeExpression{
· · · · · · · · · · · · · · · · Case: MultiplicativeExpressionCast,
· · · · · · · · · · · · · · · · CastExpression: &cc.CastExpression{
· · · · · · · · · · · · · · · · · Case: CastExpressionUnary,
· · · · · · · · · · · · · · · · · UnaryExpression: &cc.UnaryExpression{
· · · · · · · · · · · · · · · · · · Case: UnaryExpressionPostfix,
· · · · · · · · · · · · · · · · · · PostfixExpression: &cc.PostfixExpression{
· · · · · · · · · · · · · · · · · · · Case: PostfixExpressionCall,
· · · · · · · · · · · · · · · · · · · PostfixExpression: &cc.PostfixExpression{
· · · · · · · · · · · · · · · · · · · · Case: PostfixExpressionPrimary,
· · · · · · · · · · · · · · · · · · · · PrimaryExpression: &cc.PrimaryExpression{
· · · · · · · · · · · · · · · · · · · · · Case: PrimaryExpressionIdent,
· · · · · · · · · · · · · · · · · · · · · Token: example.c:1:30: IDENTIFIER "x",
· · · · · · · · · · · · · · · · · · · · },
· · · · · · · · · · · · · · · · · · · },
· · · · · · · · · · · · · · · · · · · Token: example.c:1:31: '(' "(",
· · · · · · · · · · · · · · · · · · · Token2: example.c:1:32: ')' ")",
· · · · · · · · · · · · · · · · · · },
· · · · · · · · · · · · · · · · · },
· · · · · · · · · · · · · · · · },
· · · · · · · · · · · · · · · },
· · · · · · · · · · · · · · },
· · · · · · · · · · · · · · Case: ShiftExpressionAdd,
· · · · · · · · · · · · · },
· · · · · · · · · · · · },
· · · · · · · · · · · },
· · · · · · · · · · },
· · · · · · · · · · Case: ExclusiveOrExpressionAnd,
· · · · · · · · · },
· · · · · · · · },
· · · · · · · },
· · · · · · },
· · · · · },
· · · · },
· · · · Case: ExpressionAssign,
· · · },
· · · Token: example.c:1:33: ';' ";",
· · },
· },
· Token: example.c:1:21: DEFAULT "default",
· Token2: example.c:1:28: ':' ":",
}
Example (Label)
fmt.Println(exampleAST(218, "int f() { L: goto L; }"))
Output:

&cc.LabeledStatement{
· Case: LabeledStatementLabel,
· Statement: &cc.Statement{
· · Case: StatementJump,
· · JumpStatement: &cc.JumpStatement{
· · · Case: JumpStatementGoto,
· · · Token: example.c:1:14: GOTO "goto",
· · · Token2: example.c:1:19: IDENTIFIER "L",
· · · Token3: example.c:1:20: ';' ";",
· · },
· },
· Token: example.c:1:11: IDENTIFIER "L",
· Token2: example.c:1:12: ':' ":",
}
Example (Range)
fmt.Println(exampleAST(220, "int f() { switch(i) case 42 ... 56: x(); }"))
Output:

&cc.LabeledStatement{
· Case: LabeledStatementRange,
· ConstantExpression: &cc.ConstantExpression{
· · ConditionalExpression: &cc.ConditionalExpression{
· · · Case: ConditionalExpressionLOr,
· · · LogicalOrExpression: &cc.LogicalOrExpression{
· · · · Case: LogicalOrExpressionLAnd,
· · · · LogicalAndExpression: &cc.LogicalAndExpression{
· · · · · Case: LogicalAndExpressionOr,
· · · · · InclusiveOrExpression: &cc.InclusiveOrExpression{
· · · · · · Case: InclusiveOrExpressionXor,
· · · · · · ExclusiveOrExpression: &cc.ExclusiveOrExpression{
· · · · · · · AndExpression: &cc.AndExpression{
· · · · · · · · Case: AndExpressionEq,
· · · · · · · · EqualityExpression: &cc.EqualityExpression{
· · · · · · · · · Case: EqualityExpressionRel,
· · · · · · · · · RelationalExpression: &cc.RelationalExpression{
· · · · · · · · · · Case: RelationalExpressionShift,
· · · · · · · · · · ShiftExpression: &cc.ShiftExpression{
· · · · · · · · · · · AdditiveExpression: &cc.AdditiveExpression{
· · · · · · · · · · · · Case: AdditiveExpressionMul,
· · · · · · · · · · · · MultiplicativeExpression: &cc.MultiplicativeExpression{
· · · · · · · · · · · · · Case: MultiplicativeExpressionCast,
· · · · · · · · · · · · · CastExpression: &cc.CastExpression{
· · · · · · · · · · · · · · Case: CastExpressionUnary,
· · · · · · · · · · · · · · UnaryExpression: &cc.UnaryExpression{
· · · · · · · · · · · · · · · Case: UnaryExpressionPostfix,
· · · · · · · · · · · · · · · PostfixExpression: &cc.PostfixExpression{
· · · · · · · · · · · · · · · · Case: PostfixExpressionPrimary,
· · · · · · · · · · · · · · · · PrimaryExpression: &cc.PrimaryExpression{
· · · · · · · · · · · · · · · · · Case: PrimaryExpressionInt,
· · · · · · · · · · · · · · · · · Token: example.c:1:26: INTCONST "42",
· · · · · · · · · · · · · · · · },
· · · · · · · · · · · · · · · },
· · · · · · · · · · · · · · },
· · · · · · · · · · · · · },
· · · · · · · · · · · · },
· · · · · · · · · · · },
· · · · · · · · · · · Case: ShiftExpressionAdd,
· · · · · · · · · · },
· · · · · · · · · },
· · · · · · · · },
· · · · · · · },
· · · · · · · Case: ExclusiveOrExpressionAnd,
· · · · · · },
· · · · · },
· · · · },
· · · },
· · },
· },
· ConstantExpression2: &cc.ConstantExpression{
· · ConditionalExpression: &cc.ConditionalExpression{
· · · Case: ConditionalExpressionLOr,
· · · LogicalOrExpression: &cc.LogicalOrExpression{
· · · · Case: LogicalOrExpressionLAnd,
· · · · LogicalAndExpression: &cc.LogicalAndExpression{
· · · · · Case: LogicalAndExpressionOr,
· · · · · InclusiveOrExpression: &cc.InclusiveOrExpression{
· · · · · · Case: InclusiveOrExpressionXor,
· · · · · · ExclusiveOrExpression: &cc.ExclusiveOrExpression{
· · · · · · · AndExpression: &cc.AndExpression{
· · · · · · · · Case: AndExpressionEq,
· · · · · · · · EqualityExpression: &cc.EqualityExpression{
· · · · · · · · · Case: EqualityExpressionRel,
· · · · · · · · · RelationalExpression: &cc.RelationalExpression{
· · · · · · · · · · Case: RelationalExpressionShift,
· · · · · · · · · · ShiftExpression: &cc.ShiftExpression{
· · · · · · · · · · · AdditiveExpression: &cc.AdditiveExpression{
· · · · · · · · · · · · Case: AdditiveExpressionMul,
· · · · · · · · · · · · MultiplicativeExpression: &cc.MultiplicativeExpression{
· · · · · · · · · · · · · Case: MultiplicativeExpressionCast,
· · · · · · · · · · · · · CastExpression: &cc.CastExpression{
· · · · · · · · · · · · · · Case: CastExpressionUnary,
· · · · · · · · · · · · · · UnaryExpression: &cc.UnaryExpression{
· · · · · · · · · · · · · · · Case: UnaryExpressionPostfix,
· · · · · · · · · · · · · · · PostfixExpression: &cc.PostfixExpression{
· · · · · · · · · · · · · · · · Case: PostfixExpressionPrimary,
· · · · · · · · · · · · · · · · PrimaryExpression: &cc.PrimaryExpression{
· · · · · · · · · · · · · · · · · Case: PrimaryExpressionInt,
· · · · · · · · · · · · · · · · · Token: example.c:1:33: INTCONST "56",
· · · · · · · · · · · · · · · · },
· · · · · · · · · · · · · · · },
· · · · · · · · · · · · · · },
· · · · · · · · · · · · · },
· · · · · · · · · · · · },
· · · · · · · · · · · },
· · · · · · · · · · · Case: ShiftExpressionAdd,
· · · · · · · · · · },
· · · · · · · · · },
· · · · · · · · },
· · · · · · · },
· · · · · · · Case: ExclusiveOrExpressionAnd,
· · · · · · },
· · · · · },
· · · · },
· · · },
· · },
· },
· Statement: &cc.Statement{
· · Case: StatementExpr,
· · ExpressionStatement: &cc.ExpressionStatement{
· · · Expression: &cc.Expression{
· · · · AssignmentExpression: &cc.AssignmentExpression{
· · · · · Case: AssignmentExpressionCond,
· · · · · ConditionalExpression: &cc.ConditionalExpression{
· · · · · · Case: ConditionalExpressionLOr,
· · · · · · LogicalOrExpression: &cc.LogicalOrExpression{
· · · · · · · Case: LogicalOrExpressionLAnd,
· · · · · · · LogicalAndExpression: &cc.LogicalAndExpression{
· · · · · · · · Case: LogicalAndExpressionOr,
· · · · · · · · InclusiveOrExpression: &cc.InclusiveOrExpression{
· · · · · · · · · Case: InclusiveOrExpressionXor,
· · · · · · · · · ExclusiveOrExpression: &cc.ExclusiveOrExpression{
· · · · · · · · · · AndExpression: &cc.AndExpression{
· · · · · · · · · · · Case: AndExpressionEq,
· · · · · · · · · · · EqualityExpression: &cc.EqualityExpression{
· · · · · · · · · · · · Case: EqualityExpressionRel,
· · · · · · · · · · · · RelationalExpression: &cc.RelationalExpression{
· · · · · · · · · · · · · Case: RelationalExpressionShift,
· · · · · · · · · · · · · ShiftExpression: &cc.ShiftExpression{
· · · · · · · · · · · · · · AdditiveExpression: &cc.AdditiveExpression{
· · · · · · · · · · · · · · · Case: AdditiveExpressionMul,
· · · · · · · · · · · · · · · MultiplicativeExpression: &cc.MultiplicativeExpression{
· · · · · · · · · · · · · · · · Case: MultiplicativeExpressionCast,
· · · · · · · · · · · · · · · · CastExpression: &cc.CastExpression{
· · · · · · · · · · · · · · · · · Case: CastExpressionUnary,
· · · · · · · · · · · · · · · · · UnaryExpression: &cc.UnaryExpression{
· · · · · · · · · · · · · · · · · · Case: UnaryExpressionPostfix,
· · · · · · · · · · · · · · · · · · PostfixExpression: &cc.PostfixExpression{
· · · · · · · · · · · · · · · · · · · Case: PostfixExpressionCall,
· · · · · · · · · · · · · · · · · · · PostfixExpression: &cc.PostfixExpression{
· · · · · · · · · · · · · · · · · · · · Case: PostfixExpressionPrimary,
· · · · · · · · · · · · · · · · · · · · PrimaryExpression: &cc.PrimaryExpression{
· · · · · · · · · · · · · · · · · · · · · Case: PrimaryExpressionIdent,
· · · · · · · · · · · · · · · · · · · · · Token: example.c:1:37: IDENTIFIER "x",
· · · · · · · · · · · · · · · · · · · · },
· · · · · · · · · · · · · · · · · · · },
· · · · · · · · · · · · · · · · · · · Token: example.c:1:38: '(' "(",
· · · · · · · · · · · · · · · · · · · Token2: example.c:1:39: ')' ")",
· · · · · · · · · · · · · · · · · · },
· · · · · · · · · · · · · · · · · },
· · · · · · · · · · · · · · · · },
· · · · · · · · · · · · · · · },
· · · · · · · · · · · · · · },
· · · · · · · · · · · · · · Case: ShiftExpressionAdd,
· · · · · · · · · · · · · },
· · · · · · · · · · · · },
· · · · · · · · · · · },
· · · · · · · · · · },
· · · · · · · · · · Case: ExclusiveOrExpressionAnd,
· · · · · · · · · },
· · · · · · · · },
· · · · · · · },
· · · · · · },
· · · · · },
· · · · },
· · · · Case: ExpressionAssign,
· · · },
· · · Token: example.c:1:40: ';' ";",
· · },
· },
· Token: example.c:1:21: CASE "case",
· Token2: example.c:1:29: DDD "...",
· Token3: example.c:1:35: ':' ":",
}

func (*LabeledStatement) CompoundStatement

func (n *LabeledStatement) CompoundStatement() *CompoundStatement

CompoundStatement returns the block containing n.

func (*LabeledStatement) LexicalScope

func (n *LabeledStatement) LexicalScope() Scope

LexicalScope returns the lexical scope of n.

func (*LabeledStatement) Position

func (n *LabeledStatement) Position() (r token.Position)

Position reports the position of the first component of n, if available.

func (*LabeledStatement) String

func (n *LabeledStatement) String() string

String implements fmt.Stringer.

type LabeledStatementCase

type LabeledStatementCase int

LabeledStatementCase represents case numbers of production LabeledStatement

const (
	LabeledStatementLabel LabeledStatementCase = iota
	LabeledStatementCaseLabel
	LabeledStatementRange
	LabeledStatementDefault
)

Values of type LabeledStatementCase

func (LabeledStatementCase) String

func (n LabeledStatementCase) String() string

String implements fmt.Stringer

type Linkage

type Linkage int

Linkage represents identifier linkage.

[0]6.2.2: An identifier declared in different scopes or in the same scope more than once can be made to refer to the same object or function by a process called linkage. There are three kinds of linkage: External, Internal, and None.

const (
	None Linkage = iota
	Internal
	External
)

Values of Linkage

func (Linkage) String

func (i Linkage) String() string

type LogicalAndExpression

type LogicalAndExpression struct {
	Operand               Operand
	IsSideEffectsFree     bool
	Case                  LogicalAndExpressionCase `PrettyPrint:"stringer,zero"`
	InclusiveOrExpression *InclusiveOrExpression
	LogicalAndExpression  *LogicalAndExpression
	Token                 Token
}

LogicalAndExpression represents data reduced by productions:

LogicalAndExpression:
        InclusiveOrExpression                            // Case LogicalAndExpressionOr
|       LogicalAndExpression "&&" InclusiveOrExpression  // Case LogicalAndExpressionLAnd
Example (LAnd)
fmt.Println(exampleAST(66, "int i = x && y;"))
Output:

&cc.LogicalAndExpression{
· Case: LogicalAndExpressionLAnd,
· InclusiveOrExpression: &cc.InclusiveOrExpression{
· · Case: InclusiveOrExpressionXor,
· · ExclusiveOrExpression: &cc.ExclusiveOrExpression{
· · · AndExpression: &cc.AndExpression{
· · · · Case: AndExpressionEq,
· · · · EqualityExpression: &cc.EqualityExpression{
· · · · · Case: EqualityExpressionRel,
· · · · · RelationalExpression: &cc.RelationalExpression{
· · · · · · Case: RelationalExpressionShift,
· · · · · · ShiftExpression: &cc.ShiftExpression{
· · · · · · · AdditiveExpression: &cc.AdditiveExpression{
· · · · · · · · Case: AdditiveExpressionMul,
· · · · · · · · MultiplicativeExpression: &cc.MultiplicativeExpression{
· · · · · · · · · Case: MultiplicativeExpressionCast,
· · · · · · · · · CastExpression: &cc.CastExpression{
· · · · · · · · · · Case: CastExpressionUnary,
· · · · · · · · · · UnaryExpression: &cc.UnaryExpression{
· · · · · · · · · · · Case: UnaryExpressionPostfix,
· · · · · · · · · · · PostfixExpression: &cc.PostfixExpression{
· · · · · · · · · · · · Case: PostfixExpressionPrimary,
· · · · · · · · · · · · PrimaryExpression: &cc.PrimaryExpression{
· · · · · · · · · · · · · Case: PrimaryExpressionIdent,
· · · · · · · · · · · · · Token: example.c:1:14: IDENTIFIER "y",
· · · · · · · · · · · · },
· · · · · · · · · · · },
· · · · · · · · · · },
· · · · · · · · · },
· · · · · · · · },
· · · · · · · },
· · · · · · · Case: ShiftExpressionAdd,
· · · · · · },
· · · · · },
· · · · },
· · · },
· · · Case: ExclusiveOrExpressionAnd,
· · },
· },
· LogicalAndExpression: &cc.LogicalAndExpression{
· · Case: LogicalAndExpressionOr,
· · InclusiveOrExpression: &cc.InclusiveOrExpression{
· · · Case: InclusiveOrExpressionXor,
· · · ExclusiveOrExpression: &cc.ExclusiveOrExpression{
· · · · AndExpression: &cc.AndExpression{
· · · · · Case: AndExpressionEq,
· · · · · EqualityExpression: &cc.EqualityExpression{
· · · · · · Case: EqualityExpressionRel,
· · · · · · RelationalExpression: &cc.RelationalExpression{
· · · · · · · Case: RelationalExpressionShift,
· · · · · · · ShiftExpression: &cc.ShiftExpression{
· · · · · · · · AdditiveExpression: &cc.AdditiveExpression{
· · · · · · · · · Case: AdditiveExpressionMul,
· · · · · · · · · MultiplicativeExpression: &cc.MultiplicativeExpression{
· · · · · · · · · · Case: MultiplicativeExpressionCast,
· · · · · · · · · · CastExpression: &cc.CastExpression{
· · · · · · · · · · · Case: CastExpressionUnary,
· · · · · · · · · · · UnaryExpression: &cc.UnaryExpression{
· · · · · · · · · · · · Case: UnaryExpressionPostfix,
· · · · · · · · · · · · PostfixExpression: &cc.PostfixExpression{
· · · · · · · · · · · · · Case: PostfixExpressionPrimary,
· · · · · · · · · · · · · PrimaryExpression: &cc.PrimaryExpression{
· · · · · · · · · · · · · · Case: PrimaryExpressionIdent,
· · · · · · · · · · · · · · Token: example.c:1:9: IDENTIFIER "x",
· · · · · · · · · · · · · },
· · · · · · · · · · · · },
· · · · · · · · · · · },
· · · · · · · · · · },
· · · · · · · · · },
· · · · · · · · },
· · · · · · · · Case: ShiftExpressionAdd,
· · · · · · · },
· · · · · · },
· · · · · },
· · · · },
· · · · Case: ExclusiveOrExpressionAnd,
· · · },
· · },
· },
· Token: example.c:1:11: ANDAND "&&",
}
Example (Or)
fmt.Println(exampleAST(65, "int i = x;"))
Output:

&cc.LogicalAndExpression{
· Case: LogicalAndExpressionOr,
· InclusiveOrExpression: &cc.InclusiveOrExpression{
· · Case: InclusiveOrExpressionXor,
· · ExclusiveOrExpression: &cc.ExclusiveOrExpression{
· · · AndExpression: &cc.AndExpression{
· · · · Case: AndExpressionEq,
· · · · EqualityExpression: &cc.EqualityExpression{
· · · · · Case: EqualityExpressionRel,
· · · · · RelationalExpression: &cc.RelationalExpression{
· · · · · · Case: RelationalExpressionShift,
· · · · · · ShiftExpression: &cc.ShiftExpression{
· · · · · · · AdditiveExpression: &cc.AdditiveExpression{
· · · · · · · · Case: AdditiveExpressionMul,
· · · · · · · · MultiplicativeExpression: &cc.MultiplicativeExpression{
· · · · · · · · · Case: MultiplicativeExpressionCast,
· · · · · · · · · CastExpression: &cc.CastExpression{
· · · · · · · · · · Case: CastExpressionUnary,
· · · · · · · · · · UnaryExpression: &cc.UnaryExpression{
· · · · · · · · · · · Case: UnaryExpressionPostfix,
· · · · · · · · · · · PostfixExpression: &cc.PostfixExpression{
· · · · · · · · · · · · Case: PostfixExpressionPrimary,
· · · · · · · · · · · · PrimaryExpression: &cc.PrimaryExpression{
· · · · · · · · · · · · · Case: PrimaryExpressionIdent,
· · · · · · · · · · · · · Token: example.c:1:9: IDENTIFIER "x",
· · · · · · · · · · · · },
· · · · · · · · · · · },
· · · · · · · · · · },
· · · · · · · · · },
· · · · · · · · },
· · · · · · · },
· · · · · · · Case: ShiftExpressionAdd,
· · · · · · },
· · · · · },
· · · · },
· · · },
· · · Case: ExclusiveOrExpressionAnd,
· · },
· },
}

func (*LogicalAndExpression) Declarator

func (n *LogicalAndExpression) Declarator() *Declarator

func (*LogicalAndExpression) Position

func (n *LogicalAndExpression) Position() (r token.Position)

Position reports the position of the first component of n, if available.

func (*LogicalAndExpression) String

func (n *LogicalAndExpression) String() string

String implements fmt.Stringer.

type LogicalAndExpressionCase

type LogicalAndExpressionCase int

LogicalAndExpressionCase represents case numbers of production LogicalAndExpression

const (
	LogicalAndExpressionOr LogicalAndExpressionCase = iota
	LogicalAndExpressionLAnd
)

Values of type LogicalAndExpressionCase

func (LogicalAndExpressionCase) String

func (n LogicalAndExpressionCase) String() string

String implements fmt.Stringer

type LogicalOrExpression

type LogicalOrExpression struct {
	Operand              Operand
	IsSideEffectsFree    bool
	Case                 LogicalOrExpressionCase `PrettyPrint:"stringer,zero"`
	LogicalAndExpression *LogicalAndExpression
	LogicalOrExpression  *LogicalOrExpression
	Token                Token
}

LogicalOrExpression represents data reduced by productions:

LogicalOrExpression:
        LogicalAndExpression                           // Case LogicalOrExpressionLAnd
|       LogicalOrExpression "||" LogicalAndExpression  // Case LogicalOrExpressionLOr
Example (LAnd)
fmt.Println(exampleAST(67, "int i = x;"))
Output:

&cc.LogicalOrExpression{
· Case: LogicalOrExpressionLAnd,
· LogicalAndExpression: &cc.LogicalAndExpression{
· · Case: LogicalAndExpressionOr,
· · InclusiveOrExpression: &cc.InclusiveOrExpression{
· · · Case: InclusiveOrExpressionXor,
· · · ExclusiveOrExpression: &cc.ExclusiveOrExpression{
· · · · AndExpression: &cc.AndExpression{
· · · · · Case: AndExpressionEq,
· · · · · EqualityExpression: &cc.EqualityExpression{
· · · · · · Case: EqualityExpressionRel,
· · · · · · RelationalExpression: &cc.RelationalExpression{
· · · · · · · Case: RelationalExpressionShift,
· · · · · · · ShiftExpression: &cc.ShiftExpression{
· · · · · · · · AdditiveExpression: &cc.AdditiveExpression{
· · · · · · · · · Case: AdditiveExpressionMul,
· · · · · · · · · MultiplicativeExpression: &cc.MultiplicativeExpression{
· · · · · · · · · · Case: MultiplicativeExpressionCast,
· · · · · · · · · · CastExpression: &cc.CastExpression{
· · · · · · · · · · · Case: CastExpressionUnary,
· · · · · · · · · · · UnaryExpression: &cc.UnaryExpression{
· · · · · · · · · · · · Case: UnaryExpressionPostfix,
· · · · · · · · · · · · PostfixExpression: &cc.PostfixExpression{
· · · · · · · · · · · · · Case: PostfixExpressionPrimary,
· · · · · · · · · · · · · PrimaryExpression: &cc.PrimaryExpression{
· · · · · · · · · · · · · · Case: PrimaryExpressionIdent,
· · · · · · · · · · · · · · Token: example.c:1:9: IDENTIFIER "x",
· · · · · · · · · · · · · },
· · · · · · · · · · · · },
· · · · · · · · · · · },
· · · · · · · · · · },
· · · · · · · · · },
· · · · · · · · },
· · · · · · · · Case: ShiftExpressionAdd,
· · · · · · · },
· · · · · · },
· · · · · },
· · · · },
· · · · Case: ExclusiveOrExpressionAnd,
· · · },
· · },
· },
}
Example (LOr)
fmt.Println(exampleAST(68, "int i = x || y;"))
Output:

&cc.LogicalOrExpression{
· Case: LogicalOrExpressionLOr,
· LogicalAndExpression: &cc.LogicalAndExpression{
· · Case: LogicalAndExpressionOr,
· · InclusiveOrExpression: &cc.InclusiveOrExpression{
· · · Case: InclusiveOrExpressionXor,
· · · ExclusiveOrExpression: &cc.ExclusiveOrExpression{
· · · · AndExpression: &cc.AndExpression{
· · · · · Case: AndExpressionEq,
· · · · · EqualityExpression: &cc.EqualityExpression{
· · · · · · Case: EqualityExpressionRel,
· · · · · · RelationalExpression: &cc.RelationalExpression{
· · · · · · · Case: RelationalExpressionShift,
· · · · · · · ShiftExpression: &cc.ShiftExpression{
· · · · · · · · AdditiveExpression: &cc.AdditiveExpression{
· · · · · · · · · Case: AdditiveExpressionMul,
· · · · · · · · · MultiplicativeExpression: &cc.MultiplicativeExpression{
· · · · · · · · · · Case: MultiplicativeExpressionCast,
· · · · · · · · · · CastExpression: &cc.CastExpression{
· · · · · · · · · · · Case: CastExpressionUnary,
· · · · · · · · · · · UnaryExpression: &cc.UnaryExpression{
· · · · · · · · · · · · Case: UnaryExpressionPostfix,
· · · · · · · · · · · · PostfixExpression: &cc.PostfixExpression{
· · · · · · · · · · · · · Case: PostfixExpressionPrimary,
· · · · · · · · · · · · · PrimaryExpression: &cc.PrimaryExpression{
· · · · · · · · · · · · · · Case: PrimaryExpressionIdent,
· · · · · · · · · · · · · · Token: example.c:1:14: IDENTIFIER "y",
· · · · · · · · · · · · · },
· · · · · · · · · · · · },
· · · · · · · · · · · },
· · · · · · · · · · },
· · · · · · · · · },
· · · · · · · · },
· · · · · · · · Case: ShiftExpressionAdd,
· · · · · · · },
· · · · · · },
· · · · · },
· · · · },
· · · · Case: ExclusiveOrExpressionAnd,
· · · },
· · },
· },
· LogicalOrExpression: &cc.LogicalOrExpression{
· · Case: LogicalOrExpressionLAnd,
· · LogicalAndExpression: &cc.LogicalAndExpression{
· · · Case: LogicalAndExpressionOr,
· · · InclusiveOrExpression: &cc.InclusiveOrExpression{
· · · · Case: InclusiveOrExpressionXor,
· · · · ExclusiveOrExpression: &cc.ExclusiveOrExpression{
· · · · · AndExpression: &cc.AndExpression{
· · · · · · Case: AndExpressionEq,
· · · · · · EqualityExpression: &cc.EqualityExpression{
· · · · · · · Case: EqualityExpressionRel,
· · · · · · · RelationalExpression: &cc.RelationalExpression{
· · · · · · · · Case: RelationalExpressionShift,
· · · · · · · · ShiftExpression: &cc.ShiftExpression{
· · · · · · · · · AdditiveExpression: &cc.AdditiveExpression{
· · · · · · · · · · Case: AdditiveExpressionMul,
· · · · · · · · · · MultiplicativeExpression: &cc.MultiplicativeExpression{
· · · · · · · · · · · Case: MultiplicativeExpressionCast,
· · · · · · · · · · · CastExpression: &cc.CastExpression{
· · · · · · · · · · · · Case: CastExpressionUnary,
· · · · · · · · · · · · UnaryExpression: &cc.UnaryExpression{
· · · · · · · · · · · · · Case: UnaryExpressionPostfix,
· · · · · · · · · · · · · PostfixExpression: &cc.PostfixExpression{
· · · · · · · · · · · · · · Case: PostfixExpressionPrimary,
· · · · · · · · · · · · · · PrimaryExpression: &cc.PrimaryExpression{
· · · · · · · · · · · · · · · Case: PrimaryExpressionIdent,
· · · · · · · · · · · · · · · Token: example.c:1:9: IDENTIFIER "x",
· · · · · · · · · · · · · · },
· · · · · · · · · · · · · },
· · · · · · · · · · · · },
· · · · · · · · · · · },
· · · · · · · · · · },
· · · · · · · · · },
· · · · · · · · · Case: ShiftExpressionAdd,
· · · · · · · · },
· · · · · · · },
· · · · · · },
· · · · · },
· · · · · Case: ExclusiveOrExpressionAnd,
· · · · },
· · · },
· · },
· },
· Token: example.c:1:11: OROR "||",
}

func (*LogicalOrExpression) Declarator

func (n *LogicalOrExpression) Declarator() *Declarator

func (*LogicalOrExpression) Position

func (n *LogicalOrExpression) Position() (r token.Position)

Position reports the position of the first component of n, if available.

func (*LogicalOrExpression) String

func (n *LogicalOrExpression) String() string

String implements fmt.Stringer.

type LogicalOrExpressionCase

type LogicalOrExpressionCase int

LogicalOrExpressionCase represents case numbers of production LogicalOrExpression

const (
	LogicalOrExpressionLAnd LogicalOrExpressionCase = iota
	LogicalOrExpressionLOr
)

Values of type LogicalOrExpressionCase

func (LogicalOrExpressionCase) String

func (n LogicalOrExpressionCase) String() string

String implements fmt.Stringer

type Macro

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

Macro represents a preprocessor macro definition.

func (*Macro) IsFnLike

func (m *Macro) IsFnLike() bool

IsFnLike reports whether m is a function-like macro.

func (*Macro) Parameters

func (m *Macro) Parameters() []StringID

Parameters return the list of function-like macro parameters.

func (*Macro) Position added in v3.25.2

func (m *Macro) Position() token.Position

Position reports the position of the macro definition.

func (*Macro) ReplacementTokens

func (m *Macro) ReplacementTokens() []Token

ReplacementTokens return the list of tokens m is replaced with. Tokens in the returned list have only the Rune and Value fields valid.

type MultiplicativeExpression

type MultiplicativeExpression struct {
	Operand Operand

	IsSideEffectsFree        bool
	Case                     MultiplicativeExpressionCase `PrettyPrint:"stringer,zero"`
	CastExpression           *CastExpression
	MultiplicativeExpression *MultiplicativeExpression
	Token                    Token
	// contains filtered or unexported fields
}

MultiplicativeExpression represents data reduced by productions:

MultiplicativeExpression:
        CastExpression                               // Case MultiplicativeExpressionCast
|       MultiplicativeExpression '*' CastExpression  // Case MultiplicativeExpressionMul
|       MultiplicativeExpression '/' CastExpression  // Case MultiplicativeExpressionDiv
|       MultiplicativeExpression '%' CastExpression  // Case MultiplicativeExpressionMod
Example (Cast)
fmt.Println(exampleAST(41, "int i = x;"))
Output:

&cc.MultiplicativeExpression{
· Case: MultiplicativeExpressionCast,
· CastExpression: &cc.CastExpression{
· · Case: CastExpressionUnary,
· · UnaryExpression: &cc.UnaryExpression{
· · · Case: UnaryExpressionPostfix,
· · · PostfixExpression: &cc.PostfixExpression{
· · · · Case: PostfixExpressionPrimary,
· · · · PrimaryExpression: &cc.PrimaryExpression{
· · · · · Case: PrimaryExpressionIdent,
· · · · · Token: example.c:1:9: IDENTIFIER "x",
· · · · },
· · · },
· · },
· },
}
Example (Div)
fmt.Println(exampleAST(43, "int i = x / y;"))
Output:

&cc.MultiplicativeExpression{
· Case: MultiplicativeExpressionDiv,
· CastExpression: &cc.CastExpression{
· · Case: CastExpressionUnary,
· · UnaryExpression: &cc.UnaryExpression{
· · · Case: UnaryExpressionPostfix,
· · · PostfixExpression: &cc.PostfixExpression{
· · · · Case: PostfixExpressionPrimary,
· · · · PrimaryExpression: &cc.PrimaryExpression{
· · · · · Case: PrimaryExpressionIdent,
· · · · · Token: example.c:1:13: IDENTIFIER "y",
· · · · },
· · · },
· · },
· },
· MultiplicativeExpression: &cc.MultiplicativeExpression{
· · Case: MultiplicativeExpressionCast,
· · CastExpression: &cc.CastExpression{
· · · Case: CastExpressionUnary,
· · · UnaryExpression: &cc.UnaryExpression{
· · · · Case: UnaryExpressionPostfix,
· · · · PostfixExpression: &cc.PostfixExpression{
· · · · · Case: PostfixExpressionPrimary,
· · · · · PrimaryExpression: &cc.PrimaryExpression{
· · · · · · Case: PrimaryExpressionIdent,
· · · · · · Token: example.c:1:9: IDENTIFIER "x",
· · · · · },
· · · · },
· · · },
· · },
· },
· Token: example.c:1:11: '/' "/",
}
Example (Mod)
fmt.Println(exampleAST(44, "int i = x % y;"))
Output:

&cc.MultiplicativeExpression{
· Case: MultiplicativeExpressionMod,
· CastExpression: &cc.CastExpression{
· · Case: CastExpressionUnary,
· · UnaryExpression: &cc.UnaryExpression{
· · · Case: UnaryExpressionPostfix,
· · · PostfixExpression: &cc.PostfixExpression{
· · · · Case: PostfixExpressionPrimary,
· · · · PrimaryExpression: &cc.PrimaryExpression{
· · · · · Case: PrimaryExpressionIdent,
· · · · · Token: example.c:1:13: IDENTIFIER "y",
· · · · },
· · · },
· · },
· },
· MultiplicativeExpression: &cc.MultiplicativeExpression{
· · Case: MultiplicativeExpressionCast,
· · CastExpression: &cc.CastExpression{
· · · Case: CastExpressionUnary,
· · · UnaryExpression: &cc.UnaryExpression{
· · · · Case: UnaryExpressionPostfix,
· · · · PostfixExpression: &cc.PostfixExpression{
· · · · · Case: PostfixExpressionPrimary,
· · · · · PrimaryExpression: &cc.PrimaryExpression{
· · · · · · Case: PrimaryExpressionIdent,
· · · · · · Token: example.c:1:9: IDENTIFIER "x",
· · · · · },
· · · · },
· · · },
· · },
· },
· Token: example.c:1:11: '%' "%",
}
Example (Mul)
fmt.Println(exampleAST(42, "int i = x * y;"))
Output:

&cc.MultiplicativeExpression{
· Case: MultiplicativeExpressionMul,
· CastExpression: &cc.CastExpression{
· · Case: CastExpressionUnary,
· · UnaryExpression: &cc.UnaryExpression{
· · · Case: UnaryExpressionPostfix,
· · · PostfixExpression: &cc.PostfixExpression{
· · · · Case: PostfixExpressionPrimary,
· · · · PrimaryExpression: &cc.PrimaryExpression{
· · · · · Case: PrimaryExpressionIdent,
· · · · · Token: example.c:1:13: IDENTIFIER "y",
· · · · },
· · · },
· · },
· },
· MultiplicativeExpression: &cc.MultiplicativeExpression{
· · Case: MultiplicativeExpressionCast,
· · CastExpression: &cc.CastExpression{
· · · Case: CastExpressionUnary,
· · · UnaryExpression: &cc.UnaryExpression{
· · · · Case: UnaryExpressionPostfix,
· · · · PostfixExpression: &cc.PostfixExpression{
· · · · · Case: PostfixExpressionPrimary,
· · · · · PrimaryExpression: &cc.PrimaryExpression{
· · · · · · Case: PrimaryExpressionIdent,
· · · · · · Token: example.c:1:9: IDENTIFIER "x",
· · · · · },
· · · · },
· · · },
· · },
· },
· Token: example.c:1:11: '*' "*",
}

func (*MultiplicativeExpression) Declarator

func (n *MultiplicativeExpression) Declarator() *Declarator

func (*MultiplicativeExpression) Position

func (n *MultiplicativeExpression) Position() (r token.Position)

Position reports the position of the first component of n, if available.

func (*MultiplicativeExpression) Promote

func (n *MultiplicativeExpression) Promote() Type

Promote returns the type the operands of the binary operation are promoted to.

func (*MultiplicativeExpression) String

func (n *MultiplicativeExpression) String() string

String implements fmt.Stringer.

type MultiplicativeExpressionCase

type MultiplicativeExpressionCase int

MultiplicativeExpressionCase represents case numbers of production MultiplicativeExpression

const (
	MultiplicativeExpressionCast MultiplicativeExpressionCase = iota
	MultiplicativeExpressionMul
	MultiplicativeExpressionDiv
	MultiplicativeExpressionMod
)

Values of type MultiplicativeExpressionCase

func (MultiplicativeExpressionCase) String

String implements fmt.Stringer

type Node

type Node interface {
	Position() token.Position
}

Node is implemented by Token and all AST nodes.

type Operand