cc

package
v0.0.0-...-d673e9b Latest Latest
Warning

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

Go to latest
Published: Nov 22, 2018 License: BSD-3-Clause, BSD-3-Clause Imports: 26 Imported by: 0

README

c99

Package CC is a C99 compiler front end. Work In Progress. API unstable.

Installation

$ go get github.com/cznic/cc/v2

Documentation: godoc.org/github.com/cznic/cc/v2

Documentation

Overview

Package cc is a C99 compiler front end. Work In Progress. API unstable.

Index

Examples

Constants

View Source
const (
	ADDASSIGN           = 57346
	ALIGNOF             = 57347
	ANDAND              = 57348
	ANDASSIGN           = 57349
	ARROW               = 57350
	AUTO                = 57351
	BOOL                = 57352
	BREAK               = 57353
	CASE                = 57354
	CAST                = 57355
	CHAR                = 57356
	CHARCONST           = 57357
	COMPLEX             = 57358
	CONST               = 57359
	CONSTANT_EXPRESSION = 1048576
	CONTINUE            = 57360
	DDD                 = 57361
	DEC                 = 57362
	DEFAULT             = 57363
	DIRECTIVE           = 57364
	DIVASSIGN           = 57365
	DO                  = 57366
	DOUBLE              = 57367
	ELSE                = 57368
	ENUM                = 57369
	EQ                  = 57370
	EXTERN              = 57371
	FLOAT               = 57372
	FLOATCONST          = 57373
	FOR                 = 57374
	GEQ                 = 57375
	GOTO                = 57376
	IDENTIFIER          = 57377
	IF                  = 57378
	INC                 = 57379
	INLINE              = 57380
	INT                 = 57381
	INTCONST            = 57382
	LEQ                 = 57383
	LONG                = 57384
	LONGCHARCONST       = 57385
	LONGSTRINGLITERAL   = 57386
	LSH                 = 57387
	LSHASSIGN           = 57388
	MODASSIGN           = 57389
	MULASSIGN           = 57390
	NEQ                 = 57391
	NOELSE              = 57392
	NON_REPL            = 57393
	NOSEMI              = 57394
	ORASSIGN            = 57395
	OROR                = 57396
	PPNUMBER            = 57397
	PPPASTE             = 57398
	REGISTER            = 57399
	RESTRICT            = 57400
	RETURN              = 57401
	RSH                 = 57402
	RSHASSIGN           = 57403
	SHORT               = 57404
	SIGNED              = 57405
	SIZEOF              = 57406
	STATIC              = 57407
	STRINGLITERAL       = 57408
	STRUCT              = 57409
	SUBASSIGN           = 57410
	SWITCH              = 57411
	TRANSLATION_UNIT    = 1048577
	TYPEDEF             = 57412
	TYPEDEF_NAME        = 57413
	TYPEOF              = 57414
	UNARY               = 57415
	UNION               = 57416
	UNSIGNED            = 57417
	VOID                = 57418
	VOLATILE            = 57419
	WHILE               = 57420
	XORASSIGN           = 57421
)
View Source
const (
	// CRT0Source is the source code of the C startup code.
	CRT0Source = `` /* 297-byte string literal not displayed */

)

Variables

View Source
var (

	// Null pointer, [0]6.3.2.3-3.
	Null = &ir.AddressValue{}
)
View Source
var (

	// YYDebug points to parser's yyDebug variable.
	YYDebug = &yyDebug
)

Functions

func ConvertFloat64

func ConvertFloat64(v float64, t Type, m Model) int64

ConvertFloat64 converts v to t, which must be an integer type.

func ConvertInt64

func ConvertInt64(n int64, t Type, m Model) int64

ConvertInt64 converts n to t, which must be an integer or enum type, doing masking and/or sign extending as appropriate.

func ErrString

func ErrString(err error) string

ErrString is like error.Error() but expands scanner.ErrorList.

func FlushCache

func FlushCache()

FlushCache removes all items in the file cache used by instances of FileSource.

func HostConfig

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

HostConfig executes HostCppConfig with the cpp argument set to "cpp". For more info please see the documentation of HostCppConfig.

func HostCppConfig

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

HostCppConfig returns the system C preprocessor configuration, or an error, if any. The configuration is obtained by running the cpp command. 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 compatible C preprocessor installed. Execution of HostConfig is not free, so caching the results is recommended whenever possible.

func ImportPath

func ImportPath() string

ImportPath reports the import path of this package.

func IncompatibleTypeDiff

func IncompatibleTypeDiff(a, b Type)

IncompatibleTypeDiff is a debug helper.

func Paths

func Paths(local bool) ([]string, error)

Paths returns the system header search paths, or an error, if any. If local is true the package-local, cached header search paths are returned.

func PrettyString

func PrettyString(v interface{}) string

PrettyString returns pretty strings for things produced by this package.

func TokSrc

func TokSrc(t xc.Token) string

TokSrc returns t in its source form.

func UsualArithmeticConversions

func UsualArithmeticConversions(m Model, a, b Operand) (Operand, Operand)

UsualArithmeticConversions performs transformations of operands of a binary operation. The function panics if either of the operands is not an artithmetic type.

[0]6.3.1.8

Many operators that expect operands of arithmetic type cause conversions and yield result types in a similar way. The purpose is to determine a common real type for the operands and result. For the specified operands, each operand is converted, without change of type domain, to a type whose corresponding real type is the common real type. Unless explicitly stated otherwise, the common real type is also the corresponding real type of the result, whose type domain is the type domain of the operands if they are the same, and complex otherwise. This pattern is called the usual arithmetic conversions:

Types

type AbstractDeclarator

type AbstractDeclarator struct {
	DeclarationSpecifier     *DeclarationSpecifier
	Type                     Type
	TypeQualifiers           []*TypeQualifier // From the PointerOpt production, if any.
	Case                     AbstractDeclaratorCase
	DirectAbstractDeclarator *DirectAbstractDeclarator
	Pointer                  *Pointer
	PointerOpt               *PointerOpt
}

AbstractDeclarator represents data reduced by productions:

AbstractDeclarator:
        Pointer                              // Case AbstractDeclaratorPointer
|       PointerOpt DirectAbstractDeclarator  // Case AbstractDeclaratorAbstract
Example (Abstract)
fmt.Println(exampleAST(178, "\U00100000 ( _Bool ( ) )"))
Output:

&cc.AbstractDeclarator{
· Case: 1,
· DirectAbstractDeclarator: &cc.DirectAbstractDeclarator{
· · Case: 1,
· · Token: '(',
· · Token2: ')',
· },
}
Example (Pointer)
fmt.Println(exampleAST(177, "\U00100000 ( _Bool * )"))
Output:

&cc.AbstractDeclarator{
· Pointer: &cc.Pointer{
· · Token: '*',
· },
}

func (*AbstractDeclarator) Pos

func (n *AbstractDeclarator) Pos() token.Pos

Pos reports the position of the first component of n or zero if it's empty.

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 (
	AbstractDeclaratorPointer AbstractDeclaratorCase = iota
	AbstractDeclaratorAbstract
)

Values of type AbstractDeclaratorCase

func (AbstractDeclaratorCase) String

func (n AbstractDeclaratorCase) String() string

String implements fmt.Stringer

type AbstractDeclaratorOpt

type AbstractDeclaratorOpt struct {
	AbstractDeclarator *AbstractDeclarator
}

AbstractDeclaratorOpt represents data reduced by productions:

AbstractDeclaratorOpt:
        /* empty */         // Case 0
|       AbstractDeclarator  // Case 1
Example (Case0)
fmt.Println(exampleAST(179, "\U00100000 ( _Bool )") == (*AbstractDeclaratorOpt)(nil))
Output:

true
Example (Case1)
fmt.Println(exampleAST(180, "\U00100000 ( _Bool * )"))
Output:

&cc.AbstractDeclaratorOpt{
· AbstractDeclarator: &cc.AbstractDeclarator{
· · Pointer: &cc.Pointer{
· · · Token: '*',
· · },
· },
}

func (*AbstractDeclaratorOpt) Pos

func (n *AbstractDeclaratorOpt) Pos() token.Pos

Pos reports the position of the first component of n or zero if it's empty.

func (*AbstractDeclaratorOpt) String

func (n *AbstractDeclaratorOpt) String() string

String implements fmt.Stringer.

type Address

type Address struct {
	Declarator *Declarator
	Offset     uintptr
}

Address represents the address of a variable.

func (*Address) String

func (a *Address) String() string

type ArgumentExprList

type ArgumentExprList struct {
	ArgumentExprList *ArgumentExprList
	Case             int
	Expr             *Expr
	Token            xc.Token
}

ArgumentExprList represents data reduced by productions:

ArgumentExprList:
        Expr                       // Case 0
|       ArgumentExprList ',' Expr  // Case 1
Example (Case0)
fmt.Println(exampleAST(4, "\U00100000 'a' ( 'b' )"))
Output:

&cc.ArgumentExprList{
· Expr: &cc.Expr{
· · Case: ExprChar,
· · Token: CHARCONST "'b'",
· },
}
Example (Case1)
fmt.Println(exampleAST(5, "\U00100000 'a' ( 'b' , 'c' )"))
Output:

&cc.ArgumentExprList{
· ArgumentExprList: &cc.ArgumentExprList{
· · Case: 1,
· · Expr: &cc.Expr{
· · · Case: ExprChar,
· · · Token: CHARCONST "'c'",
· · },
· · Token: ',',
· },
· Expr: &cc.Expr{
· · Case: ExprChar,
· · Token: CHARCONST "'b'",
· },
}

func (*ArgumentExprList) Pos

func (n *ArgumentExprList) Pos() token.Pos

Pos reports the position of the first component of n or zero if it's empty.

func (*ArgumentExprList) String

func (n *ArgumentExprList) String() string

String implements fmt.Stringer.

type ArgumentExprListOpt

type ArgumentExprListOpt struct {
	ArgumentExprList *ArgumentExprList
}

ArgumentExprListOpt represents data reduced by productions:

ArgumentExprListOpt:
        /* empty */       // Case 0
|       ArgumentExprList  // Case 1
Example (Case0)
fmt.Println(exampleAST(6, "\U00100000 'a' ( )") == (*ArgumentExprListOpt)(nil))
Output:

true
Example (Case1)
fmt.Println(exampleAST(7, "\U00100000 'a' ( 'b' )"))
Output:

&cc.ArgumentExprListOpt{
· ArgumentExprList: &cc.ArgumentExprList{
· · Expr: &cc.Expr{
· · · Case: ExprChar,
· · · Token: CHARCONST "'b'",
· · },
· },
}

func (*ArgumentExprListOpt) Pos

func (n *ArgumentExprListOpt) Pos() token.Pos

Pos reports the position of the first component of n or zero if it's empty.

func (*ArgumentExprListOpt) String

func (n *ArgumentExprListOpt) String() string

String implements fmt.Stringer.

type ArrayType

type ArrayType struct {
	Item           Type
	Size           Operand
	TypeQualifiers []*TypeQualifier // Eg. double a[restrict 3][5], see 6.7.5.3-21.
}

ArrayType type represents an array type.

func (*ArrayType) Equal

func (t *ArrayType) Equal(u Type) bool

Equal implements Type.

func (*ArrayType) IsArithmeticType

func (t *ArrayType) IsArithmeticType() bool

IsArithmeticType implements Type.

func (*ArrayType) IsCompatible

func (t *ArrayType) IsCompatible(u Type) bool

IsCompatible implements Type.

func (*ArrayType) IsIntegerType

func (t *ArrayType) IsIntegerType() bool

IsIntegerType implements Type.

func (*ArrayType) IsPointerType

func (t *ArrayType) IsPointerType() bool

IsPointerType implements Type.

func (*ArrayType) IsScalarType

func (t *ArrayType) IsScalarType() bool

IsScalarType implements Type.

func (*ArrayType) IsUnsigned

func (t *ArrayType) IsUnsigned() bool

IsUnsigned implements Type.

func (*ArrayType) IsVoidPointerType

func (t *ArrayType) IsVoidPointerType() bool

IsVoidPointerType implements Type.

func (*ArrayType) Kind

func (t *ArrayType) Kind() TypeKind

Kind implements Type.

func (*ArrayType) String

func (t *ArrayType) String() string

type BlockItem

type BlockItem struct {
	Case        BlockItemCase
	Declaration *Declaration
	Stmt        *Stmt
}

BlockItem represents data reduced by productions:

BlockItem:
        Declaration  // Case BlockItemDecl
|       Stmt         // Case BlockItemStmt
Example (Decl)
fmt.Println(exampleAST(219, "\U00100001 a { auto ; !"))
Output:

&cc.BlockItem{
· Declaration: &cc.Declaration{
· · Scope: &cc.Scope{
· · },
· · DeclarationSpecifiers: &cc.DeclarationSpecifiers{
· · · Case: 1,
· · · DeclarationSpecifiersOpt: &cc.DeclarationSpecifiersOpt{
· · · · DeclarationSpecifiers: &cc.DeclarationSpecifiers{
· · · · · Case: 2,
· · · · · DeclarationSpecifiersOpt: &cc.DeclarationSpecifiersOpt{
· · · · · · DeclarationSpecifiers: &cc.DeclarationSpecifiers{
· · · · · · · Case: 3,
· · · · · · · TypeSpecifier: &cc.TypeSpecifier{
· · · · · · · · Case: 2,
· · · · · · · · Token: CHAR "char",
· · · · · · · },
· · · · · · },
· · · · · },
· · · · · TypeQualifier: &cc.TypeQualifier{
· · · · · · Token: CONST "const",
· · · · · },
· · · · },
· · · },
· · · StorageClassSpecifier: &cc.StorageClassSpecifier{
· · · · Case: 3,
· · · · Token: STATIC "static",
· · · },
· · },
· · InitDeclaratorListOpt: &cc.InitDeclaratorListOpt{
· · · InitDeclaratorList: &cc.InitDeclaratorList{
· · · · InitDeclarator: &cc.InitDeclarator{
· · · · · Case: 1,
· · · · · Declarator: &cc.Declarator{
· · · · · · Linkage: LinkageNone,
· · · · · · Scope: &cc.Scope{ /* recursive/repetitive pointee not shown */ },
· · · · · · StorageDuration: StorageDurationAutomatic,
· · · · · · DirectDeclarator: &cc.DirectDeclarator{
· · · · · · · Case: DirectDeclaratorArray,
· · · · · · · DirectDeclarator: &cc.DirectDeclarator{
· · · · · · · · Case: DirectDeclaratorIdent,
· · · · · · · · Token: IDENTIFIER "__func__",
· · · · · · · },
· · · · · · · Token: '[',
· · · · · · · Token2: ']',
· · · · · · },
· · · · · },
· · · · · Initializer: &cc.Initializer{
· · · · · · Case: 1,
· · · · · · Expr: &cc.Expr{
· · · · · · · Case: ExprString,
· · · · · · · Token: STRINGLITERAL "\"a\"",
· · · · · · },
· · · · · },
· · · · · Token: '=',
· · · · },
· · · },
· · },
· · Token: ';',
· },
}
Example (Stmt)
fmt.Println(exampleAST(220, "\U00100001 a { ; !"))
Output:

&cc.BlockItem{
· Case: 1,
· Stmt: &cc.Stmt{
· · Case: 1,
· · ExprStmt: &cc.ExprStmt{
· · · Token: ';',
· · },
· },
}

func (*BlockItem) Pos

func (n *BlockItem) Pos() token.Pos

Pos reports the position of the first component of n or zero if it's empty.

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
)

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
	Case          int
}

BlockItemList represents data reduced by productions:

BlockItemList:
        BlockItem                // Case 0
|       BlockItemList BlockItem  // Case 1
Example (Case0)
fmt.Println(exampleAST(215, "\U00100001 a { ; !"))
Output:

&cc.BlockItemList{
· BlockItem: &cc.BlockItem{
· · Declaration: &cc.Declaration{
· · · Scope: &cc.Scope{
· · · },
· · · DeclarationSpecifiers: &cc.DeclarationSpecifiers{
· · · · Case: 1,
· · · · DeclarationSpecifiersOpt: &cc.DeclarationSpecifiersOpt{
· · · · · DeclarationSpecifiers: &cc.DeclarationSpecifiers{
· · · · · · Case: 2,
· · · · · · DeclarationSpecifiersOpt: &cc.DeclarationSpecifiersOpt{
· · · · · · · DeclarationSpecifiers: &cc.DeclarationSpecifiers{
· · · · · · · · Case: 3,
· · · · · · · · TypeSpecifier: &cc.TypeSpecifier{
· · · · · · · · · Case: 2,
· · · · · · · · · Token: CHAR "char",
· · · · · · · · },
· · · · · · · },
· · · · · · },
· · · · · · TypeQualifier: &cc.TypeQualifier{
· · · · · · · Token: CONST "const",
· · · · · · },
· · · · · },
· · · · },
· · · · StorageClassSpecifier: &cc.StorageClassSpecifier{
· · · · · Case: 3,
· · · · · Token: STATIC "static",
· · · · },
· · · },
· · · InitDeclaratorListOpt: &cc.InitDeclaratorListOpt{
· · · · InitDeclaratorList: &cc.InitDeclaratorList{
· · · · · InitDeclarator: &cc.InitDeclarator{
· · · · · · Case: 1,
· · · · · · Declarator: &cc.Declarator{
· · · · · · · Linkage: LinkageNone,
· · · · · · · Scope: &cc.Scope{ /* recursive/repetitive pointee not shown */ },
· · · · · · · StorageDuration: StorageDurationAutomatic,
· · · · · · · DirectDeclarator: &cc.DirectDeclarator{
· · · · · · · · Case: DirectDeclaratorArray,
· · · · · · · · DirectDeclarator: &cc.DirectDeclarator{
· · · · · · · · · Case: DirectDeclaratorIdent,
· · · · · · · · · Token: IDENTIFIER "__func__",
· · · · · · · · },
· · · · · · · · Token: '[',
· · · · · · · · Token2: ']',
· · · · · · · },
· · · · · · },
· · · · · · Initializer: &cc.Initializer{
· · · · · · · Case: 1,
· · · · · · · Expr: &cc.Expr{
· · · · · · · · Case: ExprString,
· · · · · · · · Token: STRINGLITERAL "\"a\"",
· · · · · · · },
· · · · · · },
· · · · · · Token: '=',
· · · · · },
· · · · },
· · · },
· · · Token: ';',
· · },
· },
}
Example (Case1)
fmt.Println(exampleAST(216, "\U00100001 a { ; ; !"))
Output:

&cc.BlockItemList{
· BlockItem: &cc.BlockItem{
· · Declaration: &cc.Declaration{
· · · Scope: &cc.Scope{
· · · },
· · · DeclarationSpecifiers: &cc.DeclarationSpecifiers{
· · · · Case: 1,
· · · · DeclarationSpecifiersOpt: &cc.DeclarationSpecifiersOpt{
· · · · · DeclarationSpecifiers: &cc.DeclarationSpecifiers{
· · · · · · Case: 2,
· · · · · · DeclarationSpecifiersOpt: &cc.DeclarationSpecifiersOpt{
· · · · · · · DeclarationSpecifiers: &cc.DeclarationSpecifiers{
· · · · · · · · Case: 3,
· · · · · · · · TypeSpecifier: &cc.TypeSpecifier{
· · · · · · · · · Case: 2,
· · · · · · · · · Token: CHAR "char",
· · · · · · · · },
· · · · · · · },
· · · · · · },
· · · · · · TypeQualifier: &cc.TypeQualifier{
· · · · · · · Token: CONST "const",
· · · · · · },
· · · · · },
· · · · },
· · · · StorageClassSpecifier: &cc.StorageClassSpecifier{
· · · · · Case: 3,
· · · · · Token: STATIC "static",
· · · · },
· · · },
· · · InitDeclaratorListOpt: &cc.InitDeclaratorListOpt{
· · · · InitDeclaratorList: &cc.InitDeclaratorList{
· · · · · InitDeclarator: &cc.InitDeclarator{
· · · · · · Case: 1,
· · · · · · Declarator: &cc.Declarator{
· · · · · · · Linkage: LinkageNone,
· · · · · · · Scope: &cc.Scope{ /* recursive/repetitive pointee not shown */ },
· · · · · · · StorageDuration: StorageDurationAutomatic,
· · · · · · · DirectDeclarator: &cc.DirectDeclarator{
· · · · · · · · Case: DirectDeclaratorArray,
· · · · · · · · DirectDeclarator: &cc.DirectDeclarator{
· · · · · · · · · Case: DirectDeclaratorIdent,
· · · · · · · · · Token: IDENTIFIER "__func__",
· · · · · · · · },
· · · · · · · · Token: '[',
· · · · · · · · Token2: ']',
· · · · · · · },
· · · · · · },
· · · · · · Initializer: &cc.Initializer{
· · · · · · · Case: 1,
· · · · · · · Expr: &cc.Expr{
· · · · · · · · Case: ExprString,
· · · · · · · · Token: STRINGLITERAL "\"a\"",
· · · · · · · },
· · · · · · },
· · · · · · Token: '=',
· · · · · },
· · · · },
· · · },
· · · Token: ';',
· · },
· },
· BlockItemList: &cc.BlockItemList{
· · BlockItem: &cc.BlockItem{
· · · Case: 1,
· · · Stmt: &cc.Stmt{
· · · · Case: 1,
· · · · ExprStmt: &cc.ExprStmt{
· · · · · Token: ';',
· · · · },
· · · },
· · },
· · Case: 1,
· },
}

func (*BlockItemList) Pos

func (n *BlockItemList) Pos() token.Pos

Pos reports the position of the first component of n or zero if it's empty.

func (*BlockItemList) String

func (n *BlockItemList) String() string

String implements fmt.Stringer.

type BlockItemListOpt

type BlockItemListOpt struct {
	BlockItemList *BlockItemList
}

BlockItemListOpt represents data reduced by productions:

BlockItemListOpt:
        /* empty */    // Case 0
|       BlockItemList  // Case 1
Example (Case0)
fmt.Println(exampleAST(217, "\U00100001 a { }") == (*BlockItemListOpt)(nil))
Output:

false
Example (Case1)
fmt.Println(exampleAST(218, "\U00100001 a { ; }"))
Output:

&cc.BlockItemListOpt{
· BlockItemList: &cc.BlockItemList{
· · BlockItem: &cc.BlockItem{
· · · Declaration: &cc.Declaration{
· · · · Scope: &cc.Scope{
· · · · },
· · · · DeclarationSpecifiers: &cc.DeclarationSpecifiers{
· · · · · Case: 1,
· · · · · DeclarationSpecifiersOpt: &cc.DeclarationSpecifiersOpt{
· · · · · · DeclarationSpecifiers: &cc.DeclarationSpecifiers{
· · · · · · · Case: 2,
· · · · · · · DeclarationSpecifiersOpt: &cc.DeclarationSpecifiersOpt{
· · · · · · · · DeclarationSpecifiers: &cc.DeclarationSpecifiers{
· · · · · · · · · Case: 3,
· · · · · · · · · TypeSpecifier: &cc.TypeSpecifier{
· · · · · · · · · · Case: 2,
· · · · · · · · · · Token: CHAR "char",
· · · · · · · · · },
· · · · · · · · },
· · · · · · · },
· · · · · · · TypeQualifier: &cc.TypeQualifier{
· · · · · · · · Token: CONST "const",
· · · · · · · },
· · · · · · },
· · · · · },
· · · · · StorageClassSpecifier: &cc.StorageClassSpecifier{
· · · · · · Case: 3,
· · · · · · Token: STATIC "static",
· · · · · },
· · · · },
· · · · InitDeclaratorListOpt: &cc.InitDeclaratorListOpt{
· · · · · InitDeclaratorList: &cc.InitDeclaratorList{
· · · · · · InitDeclarator: &cc.InitDeclarator{
· · · · · · · Case: 1,
· · · · · · · Declarator: &cc.Declarator{
· · · · · · · · Linkage: LinkageNone,
· · · · · · · · Scope: &cc.Scope{ /* recursive/repetitive pointee not shown */ },
· · · · · · · · StorageDuration: StorageDurationAutomatic,
· · · · · · · · DirectDeclarator: &cc.DirectDeclarator{
· · · · · · · · · Case: DirectDeclaratorArray,
· · · · · · · · · DirectDeclarator: &cc.DirectDeclarator{
· · · · · · · · · · Case: DirectDeclaratorIdent,
· · · · · · · · · · Token: IDENTIFIER "__func__",
· · · · · · · · · },
· · · · · · · · · Token: '[',
· · · · · · · · · Token2: ']',
· · · · · · · · },
· · · · · · · },
· · · · · · · Initializer: &cc.Initializer{
· · · · · · · · Case: 1,
· · · · · · · · Expr: &cc.Expr{
· · · · · · · · · Case: ExprString,
· · · · · · · · · Token: STRINGLITERAL "\"a\"",
· · · · · · · · },
· · · · · · · },
· · · · · · · Token: '=',
· · · · · · },
· · · · · },
· · · · },
· · · · Token: ';',
· · · },
· · },
· · BlockItemList: &cc.BlockItemList{
· · · BlockItem: &cc.BlockItem{
· · · · Case: 1,
· · · · Stmt: &cc.Stmt{
· · · · · Case: 1,
· · · · · ExprStmt: &cc.ExprStmt{
· · · · · · Token: ';',
· · · · · },
· · · · },
· · · },
· · · Case: 1,
· · },
· },
}

func (*BlockItemListOpt) Pos

func (n *BlockItemListOpt) Pos() token.Pos

Pos reports the position of the first component of n or zero if it's empty.

func (*BlockItemListOpt) String

func (n *BlockItemListOpt) String() string

String implements fmt.Stringer.

type CommaOpt

type CommaOpt struct {
	Token xc.Token
}

CommaOpt represents data reduced by productions:

CommaOpt:
        /* empty */  // Case 0
|       ','          // Case 1
Example (Case0)
fmt.Println(exampleAST(129, "\U00100000 ( _Bool ) { }") == (*CommaOpt)(nil))
Output:

true
Example (Case1)
fmt.Println(exampleAST(130, "\U00100001 auto a = { , }"))
Output:

&cc.CommaOpt{
· Token: ',',
}

func (*CommaOpt) Pos

func (n *CommaOpt) Pos() token.Pos

Pos reports the position of the first component of n or zero if it's empty.

func (*CommaOpt) String

func (n *CommaOpt) String() string

String implements fmt.Stringer.

type CompoundStmt

type CompoundStmt struct {
	BlockItemListOpt *BlockItemListOpt
	Token            xc.Token
	Token2           xc.Token
	// contains filtered or unexported fields
}

CompoundStmt represents data reduced by production:

CompoundStmt:
        '{' BlockItemListOpt '}'  // Case 0
Example (Case0)
fmt.Println(exampleAST(214, "\U00100001 a { }"))
Output:

&cc.CompoundStmt{
· BlockItemListOpt: &cc.BlockItemListOpt{
· · BlockItemList: &cc.BlockItemList{
· · · BlockItem: &cc.BlockItem{
· · · · Declaration: &cc.Declaration{
· · · · · Scope: &cc.Scope{
· · · · · },
· · · · · DeclarationSpecifiers: &cc.DeclarationSpecifiers{
· · · · · · Case: 1,
· · · · · · DeclarationSpecifiersOpt: &cc.DeclarationSpecifiersOpt{
· · · · · · · DeclarationSpecifiers: &cc.DeclarationSpecifiers{
· · · · · · · · Case: 2,
· · · · · · · · DeclarationSpecifiersOpt: &cc.DeclarationSpecifiersOpt{
· · · · · · · · · DeclarationSpecifiers: &cc.DeclarationSpecifiers{
· · · · · · · · · · Case: 3,
· · · · · · · · · · TypeSpecifier: &cc.TypeSpecifier{
· · · · · · · · · · · Case: 2,
· · · · · · · · · · · Token: CHAR "char",
· · · · · · · · · · },
· · · · · · · · · },
· · · · · · · · },
· · · · · · · · TypeQualifier: &cc.TypeQualifier{
· · · · · · · · · Token: CONST "const",
· · · · · · · · },
· · · · · · · },
· · · · · · },
· · · · · · StorageClassSpecifier: &cc.StorageClassSpecifier{
· · · · · · · Case: 3,
· · · · · · · Token: STATIC "static",
· · · · · · },
· · · · · },
· · · · · InitDeclaratorListOpt: &cc.InitDeclaratorListOpt{
· · · · · · InitDeclaratorList: &cc.InitDeclaratorList{
· · · · · · · InitDeclarator: &cc.InitDeclarator{
· · · · · · · · Case: 1,
· · · · · · · · Declarator: &cc.Declarator{
· · · · · · · · · Linkage: LinkageNone,
· · · · · · · · · Scope: &cc.Scope{ /* recursive/repetitive pointee not shown */ },
· · · · · · · · · StorageDuration: StorageDurationAutomatic,
· · · · · · · · · DirectDeclarator: &cc.DirectDeclarator{
· · · · · · · · · · Case: DirectDeclaratorArray,
· · · · · · · · · · DirectDeclarator: &cc.DirectDeclarator{
· · · · · · · · · · · Case: DirectDeclaratorIdent,
· · · · · · · · · · · Token: IDENTIFIER "__func__",
· · · · · · · · · · },
· · · · · · · · · · Token: '[',
· · · · · · · · · · Token2: ']',
· · · · · · · · · },
· · · · · · · · },
· · · · · · · · Initializer: &cc.Initializer{
· · · · · · · · · Case: 1,
· · · · · · · · · Expr: &cc.Expr{
· · · · · · · · · · Case: ExprString,
· · · · · · · · · · Token: STRINGLITERAL "\"a\"",
· · · · · · · · · },
· · · · · · · · },
· · · · · · · · Token: '=',
· · · · · · · },
· · · · · · },
· · · · · },
· · · · · Token: ';',
· · · · },
· · · },
· · },
· },
· Token: '{',
· Token2: '}',
}

func (*CompoundStmt) Pos

func (n *CompoundStmt) Pos() token.Pos

Pos reports the position of the first component of n or zero if it's empty.

func (*CompoundStmt) String

func (n *CompoundStmt) String() string

String implements fmt.Stringer.

type ConstExpr

type ConstExpr struct {
	Operand Operand
	Expr    *Expr
}

ConstExpr represents data reduced by production:

ConstExpr:
        Expr  // Case 0
Example (Case0)
fmt.Println(exampleAST(73, "\U00100000 'a'"))
Output:

&cc.ConstExpr{
· Expr: &cc.Expr{
· · Case: ExprChar,
· · Token: CHARCONST "'a'",
· },
}

func (*ConstExpr) Pos

func (n *ConstExpr) Pos() token.Pos

Pos reports the position of the first component of n or zero if it's empty.

func (*ConstExpr) String

func (n *ConstExpr) String() string

String implements fmt.Stringer.

type Declaration

type Declaration struct {
	Attributes            [][]xc.Token
	Scope                 *Scope
	DeclarationSpecifiers *DeclarationSpecifiers
	InitDeclaratorListOpt *InitDeclaratorListOpt
	Token                 xc.Token
}

Declaration represents data reduced by production:

Declaration:
        DeclarationSpecifiers InitDeclaratorListOpt ';'  // Case 0
Example (Case0)
fmt.Println(exampleAST(75, "\U00100001 auto ;"))
Output:

&cc.Declaration{
· DeclarationSpecifiers: &cc.DeclarationSpecifiers{
· · Case: 1,
· · StorageClassSpecifier: &cc.StorageClassSpecifier{
· · · Token: AUTO "auto",
· · },
· },
· Token: ';',
}

func (*Declaration) Pos

func (n *Declaration) Pos() token.Pos

Pos reports the position of the first component of n or zero if it's empty.

func (*Declaration) String

func (n *Declaration) String() string

String implements fmt.Stringer.

type DeclarationList

type DeclarationList struct {
	Case            int
	Declaration     *Declaration
	DeclarationList *DeclarationList
}

DeclarationList represents data reduced by productions:

DeclarationList:
        Declaration                  // Case 0
|       DeclarationList Declaration  // Case 1
Example (Case0)
fmt.Println(exampleAST(243, "\U00100001 a auto ; {"))
Output:

&cc.DeclarationList{
· Declaration: &cc.Declaration{
· · DeclarationSpecifiers: &cc.DeclarationSpecifiers{
· · · Case: 1,
· · · StorageClassSpecifier: &cc.StorageClassSpecifier{
· · · · Token: AUTO "auto",
· · · },
· · },
· · Token: ';',
· },
}
Example (Case1)
fmt.Println(exampleAST(244, "\U00100001 a auto ; auto ; {"))
Output:

&cc.DeclarationList{
· Declaration: &cc.Declaration{
· · DeclarationSpecifiers: &cc.DeclarationSpecifiers{
· · · Case: 1,
· · · StorageClassSpecifier: &cc.StorageClassSpecifier{
· · · · Token: AUTO "auto",
· · · },
· · },
· · Token: ';',
· },
· DeclarationList: &cc.DeclarationList{
· · Case: 1,
· · Declaration: &cc.Declaration{
· · · Scope: &cc.Scope{ /* recursive/repetitive pointee not shown */ },
· · · DeclarationSpecifiers: &cc.DeclarationSpecifiers{
· · · · Case: 1,
· · · · StorageClassSpecifier: &cc.StorageClassSpecifier{
· · · · · Token: AUTO "auto",
· · · · },
· · · },
· · · Token: ';',
· · },
· },
}

func (*DeclarationList) Pos

func (n *DeclarationList) Pos() token.Pos

Pos reports the position of the first component of n or zero if it's empty.

func (*DeclarationList) String

func (n *DeclarationList) String() string

String implements fmt.Stringer.

type DeclarationListOpt

type DeclarationListOpt struct {
	DeclarationList *DeclarationList
}

DeclarationListOpt represents data reduced by productions:

DeclarationListOpt:
        /* empty */      // Case 0
|       DeclarationList  // Case 1
Example (Case0)
fmt.Println(exampleAST(245, "\U00100001 a {") == (*DeclarationListOpt)(nil))
Output:

true
Example (Case1)
fmt.Println(exampleAST(246, "\U00100001 a auto ; {"))
Output:

&cc.DeclarationListOpt{
· DeclarationList: &cc.DeclarationList{
· · Declaration: &cc.Declaration{
· · · DeclarationSpecifiers: &cc.DeclarationSpecifiers{
· · · · Case: 1,
· · · · StorageClassSpecifier: &cc.StorageClassSpecifier{
· · · · · Token: AUTO "auto",
· · · · },
· · · },
· · · Token: ';',
· · },
· },
}

func (*DeclarationListOpt) Pos

func (n *DeclarationListOpt) Pos() token.Pos

Pos reports the position of the first component of n or zero if it's empty.

func (*DeclarationListOpt) String

func (n *DeclarationListOpt) String() string

String implements fmt.Stringer.

type DeclarationSpecifier

type DeclarationSpecifier struct {
	FunctionSpecifiers     []*FunctionSpecifier
	StorageClassSpecifiers []*StorageClassSpecifier
	TypeQualifiers         []*TypeQualifier
	TypeSpecifiers         []*TypeSpecifier
	// contains filtered or unexported fields
}

DeclarationSpecifier describes declaration specifiers.

func (*DeclarationSpecifier) IsExtern

func (d *DeclarationSpecifier) IsExtern() bool

IsExtern reports whether the storage class specifier "extern" is present.

func (*DeclarationSpecifier) IsStatic

func (d *DeclarationSpecifier) IsStatic() bool

IsStatic reports whether the storage class specifier "static" is present.

func (*DeclarationSpecifier) IsTypedef

func (d *DeclarationSpecifier) IsTypedef() bool

IsTypedef reports whether the storage class specifier "typedef" is present.

type DeclarationSpecifiers

type DeclarationSpecifiers struct {
	Case                     DeclarationSpecifiersCase
	DeclarationSpecifiersOpt *DeclarationSpecifiersOpt
	FunctionSpecifier        *FunctionSpecifier
	StorageClassSpecifier    *StorageClassSpecifier
	TypeQualifier            *TypeQualifier
	TypeSpecifier            *TypeSpecifier
}

DeclarationSpecifiers represents data reduced by productions:

DeclarationSpecifiers:
        FunctionSpecifier DeclarationSpecifiersOpt      // Case DeclarationSpecifiersFunc
|       StorageClassSpecifier DeclarationSpecifiersOpt  // Case DeclarationSpecifiersStorage
|       TypeQualifier DeclarationSpecifiersOpt          // Case DeclarationSpecifiersQualifier
|       TypeSpecifier DeclarationSpecifiersOpt          // Case DeclarationSpecifiersSpecifier
Example (Func)
fmt.Println(exampleAST(76, "\U00100001 inline ("))
Output:

&cc.DeclarationSpecifiers{
· FunctionSpecifier: &cc.FunctionSpecifier{
· · Token: INLINE "inline",
· },
}
Example (Qualifier)
fmt.Println(exampleAST(78, "\U00100001 const ("))
Output:

&cc.DeclarationSpecifiers{
· Case: 2,
· TypeQualifier: &cc.TypeQualifier{
· · Token: CONST "const",
· },
}
Example (Specifier)
fmt.Println(exampleAST(79, "\U00100001 _Bool ("))
Output:

&cc.DeclarationSpecifiers{
· Case: 3,
· TypeSpecifier: &cc.TypeSpecifier{
· · Token: BOOL "_Bool",
· },
}
Example (Storage)
fmt.Println(exampleAST(77, "\U00100001 auto ("))
Output:

&cc.DeclarationSpecifiers{
· Case: 1,
· StorageClassSpecifier: &cc.StorageClassSpecifier{
· · Token: AUTO "auto",
· },
}

func (*DeclarationSpecifiers) Pos

func (n *DeclarationSpecifiers) Pos() token.Pos

Pos reports the position of the first component of n or zero if it's empty.

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 (
	DeclarationSpecifiersFunc DeclarationSpecifiersCase = iota
	DeclarationSpecifiersStorage
	DeclarationSpecifiersQualifier
	DeclarationSpecifiersSpecifier
)

Values of type DeclarationSpecifiersCase

func (DeclarationSpecifiersCase) String

func (n DeclarationSpecifiersCase) String() string

String implements fmt.Stringer

type DeclarationSpecifiersOpt

type DeclarationSpecifiersOpt struct {
	DeclarationSpecifiers *DeclarationSpecifiers
}

DeclarationSpecifiersOpt represents data reduced by productions:

DeclarationSpecifiersOpt:
        /* empty */            // Case 0
|       DeclarationSpecifiers  // Case 1
Example (Case0)
fmt.Println(exampleAST(80, "\U00100001 inline (") == (*DeclarationSpecifiersOpt)(nil))
Output:

true
Example (Case1)
fmt.Println(exampleAST(81, "\U00100001 const auto ("))
Output:

&cc.DeclarationSpecifiersOpt{
· DeclarationSpecifiers: &cc.DeclarationSpecifiers{
· · Case: 1,
· · StorageClassSpecifier: &cc.StorageClassSpecifier{
· · · Token: AUTO "auto",
· · },
· },
}

func (*DeclarationSpecifiersOpt) Pos

Pos reports the position of the first component of n or zero if it's empty.

func (*DeclarationSpecifiersOpt) String

func (n *DeclarationSpecifiersOpt) String() string

String implements fmt.Stringer.

type Declarator

type Declarator struct {
	AssignedTo           int // Declarator appears at the left side of assignment.
	Attributes           [][]xc.Token
	Bits                 int                   // StructDeclarator: bit width when a bit field.
	DeclarationSpecifier *DeclarationSpecifier // Nil for embedded declarators.
	Definition           *Declarator           // Declaration -> definition.
	Field                int                   // Declaration order# if struct field declarator.
	FunctionDefinition   *FunctionDefinition   // When the declarator defines a function.
	Initializer          *Initializer          // Only when part of an InitDeclarator.
	Linkage              Linkage               // Linkage of the declared name, [0]6.2.2.
	Parameters           []*Declarator         // Of the function declarator.
	Referenced           int
	Scope                *Scope           // Declaration scope.
	ScopeNum             int              // Sequential scope number within function body.
	StorageDuration      StorageDuration  // Storage duration of the declared name, [0]6.2.4.
	Type                 Type             // Declared type.
	TypeQualifiers       []*TypeQualifier // From the PointerOpt production, if any.

	AddressTaken        bool
	Alloca              bool // Function declarator: Body calls __builtin_alloca
	Embedded            bool // [0]6.7.5-3: Not a full declarator.
	IsField             bool
	IsFunctionParameter bool
	IsBuiltin           bool
	DirectDeclarator    *DirectDeclarator
	PointerOpt          *PointerOpt
	// contains filtered or unexported fields
}

Declarator represents data reduced by production:

Declarator:
        PointerOpt DirectDeclarator  // Case 0
Example (Case0)
fmt.Println(exampleAST(141, "\U00100001 a )"))
Output:

&cc.Declarator{
· Linkage: LinkageNone,
· StorageDuration: StorageDurationAutomatic,
· DirectDeclarator: &cc.DirectDeclarator{
· · Case: DirectDeclaratorIdent,
· · Token: IDENTIFIER "a",
· },
}

func (*Declarator) IsTLD

func (n *Declarator) IsTLD() bool

IsTLD reports whether n is declared in file scope.

func (*Declarator) Name

func (n *Declarator) Name() int

Name returns the ID of the declared name.

func (*Declarator) ParameterNames

func (n *Declarator) ParameterNames() []int

ParameterNames returns a list of IDs of names of parameters of n. The function panics if n is not function type.

func (*Declarator) Pos

func (n *Declarator) Pos() token.Pos

Pos reports the position of the first component of n or zero if it's empty.

func (*Declarator) String

func (n *Declarator) String() string

String implements fmt.Stringer.

type DeclaratorOpt

type DeclaratorOpt struct {
	Declarator *Declarator
}

DeclaratorOpt represents data reduced by productions:

DeclaratorOpt:
        /* empty */  // Case 0
|       Declarator   // Case 1
Example (Case0)
fmt.Println(exampleAST(142, "\U00100001 struct { _Bool :") == (*DeclaratorOpt)(nil))
Output:

true
Example (Case1)
fmt.Println(exampleAST(143, "\U00100001 struct { _Bool a :"))
Output:

&cc.DeclaratorOpt{
· Declarator: &cc.Declarator{
· · Linkage: LinkageNone,
· · Scope: &cc.Scope{
· · },
· · StorageDuration: StorageDurationAutomatic,
· · DirectDeclarator: &cc.DirectDeclarator{
· · · Case: DirectDeclaratorIdent,
· · · Token: IDENTIFIER "a",
· · },
· },
}

func (*DeclaratorOpt) Pos

func (n *DeclaratorOpt) Pos() token.Pos

Pos reports the position of the first component of n or zero if it's empty.

func (*DeclaratorOpt) String

func (n *DeclaratorOpt) String() string

String implements fmt.Stringer.

type Designation

type Designation struct {
	List           []int64
	DesignatorList *DesignatorList
	Token          xc.Token
}

Designation represents data reduced by production:

Designation:
        DesignatorList '='  // Case 0
Example (Case0)
fmt.Println(exampleAST(198, "\U00100000 ( _Bool ) { . a = !"))
Output:

&cc.Designation{
· DesignatorList: &cc.DesignatorList{
· · Designator: &cc.Designator{
· · · Token: '.',
· · · Token2: IDENTIFIER "a",
· · },
· },
· Token: '=',
}

func (*Designation) Pos

func (n *Designation) Pos() token.Pos

Pos reports the position of the first component of n or zero if it's empty.

func (*Designation) String

func (n *Designation) String() string

String implements fmt.Stringer.

type Designator

type Designator struct {
	Case      DesignatorCase
	ConstExpr *ConstExpr
	Token     xc.Token
	Token2    xc.Token
}

Designator represents data reduced by productions:

Designator:
        '.' IDENTIFIER     // Case DesignatorField
|       '[' ConstExpr ']'  // Case DesignatorIndex
Example (Field)
fmt.Println(exampleAST(201, "\U00100000 ( _Bool ) { . a ."))
Output:

&cc.Designator{
· Token: '.',
· Token2: IDENTIFIER "a",
}
Example (Index)
fmt.Println(exampleAST(202, "\U00100000 ( _Bool ) { [ 'a' ] ."))
Output:

&cc.Designator{
· Case: 1,
· ConstExpr: &cc.ConstExpr{
· · Expr: &cc.Expr{
· · · Case: ExprChar,
· · · Token: CHARCONST "'a'",
· · },
· },
· Token: '[',
· Token2: ']',
}

func (*Designator) Pos

func (n *Designator) Pos() token.Pos

Pos reports the position of the first component of n or zero if it's empty.

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 (
	DesignatorField DesignatorCase = iota
	DesignatorIndex
)

Values of type DesignatorCase

func (DesignatorCase) String

func (n DesignatorCase) String() string

String implements fmt.Stringer

type DesignatorList

type DesignatorList struct {
	Case           int
	Designator     *Designator
	DesignatorList *DesignatorList
}

DesignatorList represents data reduced by productions:

DesignatorList:
        Designator                 // Case 0
|       DesignatorList Designator  // Case 1
Example (Case0)
fmt.Println(exampleAST(199, "\U00100000 ( _Bool ) { . a ."))
Output:

&cc.DesignatorList{
· Designator: &cc.Designator{
· · Token: '.',
· · Token2: IDENTIFIER "a",
· },
}
Example (Case1)
fmt.Println(exampleAST(200, "\U00100000 ( _Bool ) { . a . b ."))
Output:

&cc.DesignatorList{
· Designator: &cc.Designator{
· · Token: '.',
· · Token2: IDENTIFIER "a",
· },
· DesignatorList: &cc.DesignatorList{
· · Case: 1,
· · Designator: &cc.Designator{
· · · Token: '.',
· · · Token2: IDENTIFIER "b",
· · },
· },
}

func (*DesignatorList) Pos

func (n *DesignatorList) Pos() token.Pos

Pos reports the position of the first component of n or zero if it's empty.

func (*DesignatorList) String

func (n *DesignatorList) String() string

String implements fmt.Stringer.

type DirectAbstractDeclarator

type DirectAbstractDeclarator struct {
	AbstractDeclarator          *AbstractDeclarator
	Case                        DirectAbstractDeclaratorCase
	DirectAbstractDeclarator    *DirectAbstractDeclarator
	DirectAbstractDeclaratorOpt *DirectAbstractDeclaratorOpt
	Expr                        *Expr
	ExprOpt                     *ExprOpt
	ParameterTypeListOpt        *ParameterTypeListOpt
	Token                       xc.Token
	Token2                      xc.Token
	Token3                      xc.Token
	TypeQualifierList           *TypeQualifierList
	TypeQualifierListOpt        *TypeQualifierListOpt
}

DirectAbstractDeclarator represents data reduced by productions:

DirectAbstractDeclarator:
        '(' AbstractDeclarator ')'                                              // Case DirectAbstractDeclaratorAbstract
|       '(' ParameterTypeListOpt ')'                                            // Case DirectAbstractDeclaratorParamList
|       DirectAbstractDeclarator '(' ParameterTypeListOpt ')'                   // Case DirectAbstractDeclaratorDFn
|       DirectAbstractDeclaratorOpt '[' "static" TypeQualifierListOpt Expr ']'  // Case DirectAbstractDeclaratorDArrSize
|       DirectAbstractDeclaratorOpt '[' '*' ']'                                 // Case DirectAbstractDeclaratorDArrVL
|       DirectAbstractDeclaratorOpt '[' ExprOpt ']'                             // Case DirectAbstractDeclaratorDArr
|       DirectAbstractDeclaratorOpt '[' TypeQualifierList "static" Expr ']'     // Case DirectAbstractDeclaratorDArrSize2
|       DirectAbstractDeclaratorOpt '[' TypeQualifierList ExprOpt ']'           // Case DirectAbstractDeclaratorDArr2
Example (Abstract)
fmt.Println(exampleAST(181, "\U00100000 ( _Bool ( * ) ("))
Output:

&cc.DirectAbstractDeclarator{
· AbstractDeclarator: &cc.AbstractDeclarator{
· · Pointer: &cc.Pointer{
· · · Token: '*',
· · },
· },
· Token: '(',
· Token2: ')',
}
Example (DArr)
fmt.Println(exampleAST(186, "\U00100000 ( _Bool [ ] ("))
Output:

&cc.DirectAbstractDeclarator{
· Case: 5,
· Token: '[',
· Token2: ']',
}
Example (DArr2)
fmt.Println(exampleAST(188, "\U00100000 ( _Bool [ const ] ("))
Output:

&cc.DirectAbstractDeclarator{
· Case: 7,
· Token: '[',
· Token2: ']',
· TypeQualifierList: &cc.TypeQualifierList{
· · TypeQualifier: &cc.TypeQualifier{
· · · Token: CONST "const",
· · },
· },
}
Example (DArrSize)
fmt.Println(exampleAST(184, "\U00100000 ( _Bool [ static 'a' ] ("))
Output:

&cc.DirectAbstractDeclarator{
· Case: 3,
· Expr: &cc.Expr{
· · Case: ExprChar,
· · Token: CHARCONST "'a'",
· },
· Token: '[',
· Token2: STATIC "static",
· Token3: ']',
}
Example (DArrSize2)
fmt.Println(exampleAST(187, "\U00100000 ( _Bool [ const static 'a' ] ("))
Output:

&cc.DirectAbstractDeclarator{
· Case: 6,
· Expr: &cc.Expr{
· · Case: ExprChar,
· · Token: CHARCONST "'a'",
· },
· Token: '[',
· Token2: STATIC "static",
· Token3: ']',
· TypeQualifierList: &cc.TypeQualifierList{
· · TypeQualifier: &cc.TypeQualifier{
· · · Token: CONST "const",
· · },
· },
}
Example (DArrVL)
fmt.Println(exampleAST(185, "\U00100000 ( _Bool [ * ] ("))
Output:

&cc.DirectAbstractDeclarator{
· Case: 4,
· Token: '[',
· Token2: '*',
· Token3: ']',
}
Example (DFn)
fmt.Println(exampleAST(183, "\U00100000 ( _Bool ( ) ( ) ("))
Output:

&cc.DirectAbstractDeclarator{
· Case: 2,
· DirectAbstractDeclarator: &cc.DirectAbstractDeclarator{
· · Case: 1,
· · Token: '(',
· · Token2: ')',
· },
· Token: '(',
· Token2: ')',
}
Example (ParamList)
fmt.Println(exampleAST(182, "\U00100000 ( _Bool ( ) ("))
Output:

&cc.DirectAbstractDeclarator{
· Case: 1,
· Token: '(',
· Token2: ')',
}

func (*DirectAbstractDeclarator) Pos

Pos reports the position of the first component of n or zero if it's empty.

func (*DirectAbstractDeclarator) String

func (n *DirectAbstractDeclarator) String() string

String implements fmt.Stringer.

type DirectAbstractDeclaratorCase

type DirectAbstractDeclaratorCase int

DirectAbstractDeclaratorCase represents case numbers of production DirectAbstractDeclarator

const (
	DirectAbstractDeclaratorAbstract DirectAbstractDeclaratorCase = iota
	DirectAbstractDeclaratorParamList
	DirectAbstractDeclaratorDFn
	DirectAbstractDeclaratorDArrSize
	DirectAbstractDeclaratorDArrVL
	DirectAbstractDeclaratorDArr
	DirectAbstractDeclaratorDArrSize2
	DirectAbstractDeclaratorDArr2
)

Values of type DirectAbstractDeclaratorCase

func (DirectAbstractDeclaratorCase) String

String implements fmt.Stringer

type DirectAbstractDeclaratorOpt

type DirectAbstractDeclaratorOpt struct {
	DirectAbstractDeclarator *DirectAbstractDeclarator
}

DirectAbstractDeclaratorOpt represents data reduced by productions:

DirectAbstractDeclaratorOpt:
        /* empty */               // Case 0
|       DirectAbstractDeclarator  // Case 1
Example (Case0)
fmt.Println(exampleAST(189, "\U00100000 ( _Bool [") == (*DirectAbstractDeclaratorOpt)(nil))
Output:

true
Example (Case1)
fmt.Println(exampleAST(190, "\U00100000 ( _Bool ( ) ["))
Output:

&cc.DirectAbstractDeclaratorOpt{
· DirectAbstractDeclarator: &cc.DirectAbstractDeclarator{
· · Case: 1,
· · Token: '(',
· · Token2: ')',
· },
}

func (*DirectAbstractDeclaratorOpt) Pos

Pos reports the position of the first component of n or zero if it's empty.

func (*DirectAbstractDeclaratorOpt) String

func (n *DirectAbstractDeclaratorOpt) String() string

String implements fmt.Stringer.

type DirectDeclarator

type DirectDeclarator struct {
	Case                 DirectDeclaratorCase
	Declarator           *Declarator
	DirectDeclarator     *DirectDeclarator
	Expr                 *Expr
	ExprOpt              *ExprOpt
	IdentifierListOpt    *IdentifierListOpt
	ParameterTypeList    *ParameterTypeList
	Token                xc.Token
	Token2               xc.Token
	Token3               xc.Token
	TypeQualifierList    *TypeQualifierList
	TypeQualifierListOpt *TypeQualifierListOpt
	// contains filtered or unexported fields
}

DirectDeclarator represents data reduced by productions:

DirectDeclarator:
        '(' Declarator ')'                                           // Case DirectDeclaratorParen
|       DirectDeclarator '(' IdentifierListOpt ')'                   // Case DirectDeclaratorIdentList
|       DirectDeclarator '(' ParameterTypeList ')'                   // Case DirectDeclaratorParamList
|       DirectDeclarator '[' "static" TypeQualifierListOpt Expr ']'  // Case DirectDeclaratorArraySize
|       DirectDeclarator '[' TypeQualifierList "static" Expr ']'     // Case DirectDeclaratorArraySize2
|       DirectDeclarator '[' TypeQualifierListOpt '*' ']'            // Case DirectDeclaratorArrayVar
|       DirectDeclarator '[' TypeQualifierListOpt ExprOpt ']'        // Case DirectDeclaratorArray
|       IDENTIFIER                                                   // Case DirectDeclaratorIdent
Example (Array)
fmt.Println(exampleAST(152, "\U00100001 a [ ] ("))
Output:

&cc.DirectDeclarator{
· Case: DirectDeclaratorArray,
· DirectDeclarator: &cc.DirectDeclarator{
· · Case: DirectDeclaratorIdent,
· · Token: IDENTIFIER "a",
· },
· Token: '[',
· Token2: ']',
}
Example (ArraySize)
fmt.Println(exampleAST(149, "\U00100001 a [ static 'b' ] ("))
Output:

&cc.DirectDeclarator{
· Case: DirectDeclaratorArraySize,
· DirectDeclarator: &cc.DirectDeclarator{
· · Case: DirectDeclaratorIdent,
· · Token: IDENTIFIER "a",
· },
· Expr: &cc.Expr{
· · Case: ExprChar,
· · Token: CHARCONST "'b'",
· },
· Token: '[',
· Token2: STATIC "static",
· Token3: ']',
}
Example (ArraySize2)
fmt.Println(exampleAST(150, "\U00100001 a [ const static 'b' ] ("))
Output:

&cc.DirectDeclarator{
· Case: DirectDeclaratorArraySize2,
· DirectDeclarator: &cc.DirectDeclarator{
· · Case: DirectDeclaratorIdent,
· · Token: IDENTIFIER "a",
· },
· Expr: &cc.Expr{
· · Case: ExprChar,
· · Token: CHARCONST "'b'",
· },
· Token: '[',
· Token2: STATIC "static",
· Token3: ']',
· TypeQualifierList: &cc.TypeQualifierList{
· · TypeQualifier: &cc.TypeQualifier{
· · · Token: CONST "const",
· · },
· },
}
Example (ArrayVar)
fmt.Println(exampleAST(151, "\U00100001 a [ * ] ("))
Output:

&cc.DirectDeclarator{
· Case: DirectDeclaratorArrayVar,
· DirectDeclarator: &cc.DirectDeclarator{
· · Case: DirectDeclaratorIdent,
· · Token: IDENTIFIER "a",
· },
· Token: '[',
· Token2: '*',
· Token3: ']',
}
Example (Ident)
fmt.Println(exampleAST(153, "\U00100001 a ("))
Output:

&cc.DirectDeclarator{
· Case: DirectDeclaratorIdent,
· Token: IDENTIFIER "a",
}
Example (IdentList)
fmt.Println(exampleAST(146, "\U00100001 a ( ) ("))
Output:

&cc.DirectDeclarator{
· Case: DirectDeclaratorIdentList,
· DirectDeclarator: &cc.DirectDeclarator{
· · Case: DirectDeclaratorIdent,
· · Token: IDENTIFIER "a",
· },
· Token: '(',
· Token2: ')',
}
Example (ParamList)
fmt.Println(exampleAST(148, "\U00100001 a ( auto ) ("))
Output:

&cc.DirectDeclarator{
· Case: DirectDeclaratorParamList,
· DirectDeclarator: &cc.DirectDeclarator{
· · Case: DirectDeclaratorIdent,
· · Token: IDENTIFIER "a",
· },
· ParameterTypeList: &cc.ParameterTypeList{
· · ParameterList: &cc.ParameterList{
· · · ParameterDeclaration: &cc.ParameterDeclaration{
· · · · DeclarationSpecifiers: &cc.DeclarationSpecifiers{
· · · · · Case: 1,
· · · · · StorageClassSpecifier: &cc.StorageClassSpecifier{
· · · · · · Token: AUTO "auto",
· · · · · },
· · · · },
· · · },
· · },
· },
· Token: '(',
· Token2: ')',
}
Example (Paren)
fmt.Println(exampleAST(144, "\U00100001 ( a ) ("))
Output:

&cc.DirectDeclarator{
· Case: DirectDeclaratorParen,
· Declarator: &cc.Declarator{
· · Linkage: LinkageNone,
· · StorageDuration: StorageDurationAutomatic,
· · Embedded: true,
· · DirectDeclarator: &cc.DirectDeclarator{
· · · Case: DirectDeclaratorIdent,
· · · Token: IDENTIFIER "a",
· · },
· },
· Token: '(',
· Token2: ')',
}

func (*DirectDeclarator) Pos

func (n *DirectDeclarator) Pos() token.Pos

Pos reports the position of the first component of n or zero if it's empty.

func (*DirectDeclarator) String

func (n *DirectDeclarator) String() string

String implements fmt.Stringer.

type DirectDeclaratorCase

type DirectDeclaratorCase int

DirectDeclaratorCase represents case numbers of production DirectDeclarator

const (
	DirectDeclaratorParen DirectDeclaratorCase = iota
	DirectDeclaratorIdentList
	DirectDeclaratorParamList
	DirectDeclaratorArraySize
	DirectDeclaratorArraySize2
	DirectDeclaratorArrayVar
	DirectDeclaratorArray
	DirectDeclaratorIdent
)

Values of type DirectDeclaratorCase

func (DirectDeclaratorCase) String

func (n DirectDeclaratorCase) String() string

String implements fmt.Stringer

type EnumSpecifier

type EnumSpecifier struct {
	Tag int

	Case           EnumSpecifierCase
	CommaOpt       *CommaOpt
	EnumeratorList *EnumeratorList
	IdentifierOpt  *IdentifierOpt
	Token          xc.Token
	Token2         xc.Token
	Token3         xc.Token
	// contains filtered or unexported fields
}

EnumSpecifier represents data reduced by productions:

EnumSpecifier:
        "enum" IDENTIFIER                                     // Case EnumSpecifierTag
|       "enum" IdentifierOpt '{' EnumeratorList CommaOpt '}'  // Case EnumSpecifierDefine
Example (Define)
fmt.Println(exampleAST(132, "\U00100001 enum { a } ("))
Output:

&cc.EnumSpecifier{
· Case: 1,
· EnumeratorList: &cc.EnumeratorList{
· · Enumerator: &cc.Enumerator{
· · · EnumerationConstant: &cc.EnumerationConstant{
· · · · Token: IDENTIFIER "a",
· · · },
· · },
· },
· Token: ENUM "enum",
· Token2: '{',
· Token3: '}',
}
Example (Tag)
fmt.Println(exampleAST(131, "\U00100001 enum a ("))
Output:

&cc.EnumSpecifier{
· Token: ENUM "enum",
· Token2: IDENTIFIER "a",
}

func (*EnumSpecifier) Pos

func (n *EnumSpecifier) Pos() token.Pos

Pos reports the position of the first component of n or zero if it's empty.

func (*EnumSpecifier) String

func (n *EnumSpecifier) String() string

String implements fmt.Stringer.

type EnumSpecifierCase

type EnumSpecifierCase int

EnumSpecifierCase represents case numbers of production EnumSpecifier

const (
	EnumSpecifierTag EnumSpecifierCase = iota
	EnumSpecifierDefine
)

Values of type EnumSpecifierCase

func (EnumSpecifierCase) String

func (n EnumSpecifierCase) String() string

String implements fmt.Stringer

type EnumType

type EnumType struct {
	Tag   int
	Enums []*EnumerationConstant
	Min   int64
	Max   uint64
}

EnumType represents an enum type.

func (*EnumType) Equal

func (t *EnumType) Equal(u Type) bool

Equal implements Type.

func (*EnumType) IsArithmeticType

func (t *EnumType) IsArithmeticType() bool

IsArithmeticType implements Type.

func (*EnumType) IsCompatible

func (t *EnumType) IsCompatible(u Type) bool

IsCompatible implements Type.

func (*EnumType) IsIntegerType

func (t *EnumType) IsIntegerType() bool

IsIntegerType implements Type.

func (*EnumType) IsPointerType

func (t *EnumType) IsPointerType() bool

IsPointerType implements Type.

func (*EnumType) IsScalarType

func (t *EnumType) IsScalarType() bool

IsScalarType implements Type.

func (*EnumType) IsUnsigned

func (t *EnumType) IsUnsigned() bool

IsUnsigned implements Type.

func (*EnumType) IsVoidPointerType

func (t *EnumType) IsVoidPointerType() bool

IsVoidPointerType implements Type.

func (*EnumType) Kind

func (t *EnumType) Kind() TypeKind

Kind implements Type.

func (*EnumType) String

func (t *EnumType) String() string

type EnumerationConstant

type EnumerationConstant struct {
	Operand Operand
	Token   xc.Token
}

EnumerationConstant represents data reduced by production:

EnumerationConstant:
        IDENTIFIER  // Case 0
Example (Case0)
fmt.Println(exampleAST(3, "\U00100001 enum { a ,"))
Output:

&cc.EnumerationConstant{
· Token: IDENTIFIER "a",
}

func (*EnumerationConstant) Pos

func (n *EnumerationConstant) Pos() token.Pos

Pos reports the position of the first component of n or zero if it's empty.

func (*EnumerationConstant) String

func (n *EnumerationConstant) String() string

String implements fmt.Stringer.

type Enumerator

type Enumerator struct {
	Case                EnumeratorCase
	ConstExpr           *ConstExpr
	EnumerationConstant *EnumerationConstant
	Token               xc.Token
}

Enumerator represents data reduced by productions:

Enumerator:
        EnumerationConstant                // Case EnumeratorBase
|       EnumerationConstant '=' ConstExpr  // Case EnumeratorInit
Example (Base)
fmt.Println(exampleAST(135, "\U00100001 enum { a ,"))
Output:

&cc.Enumerator{
· EnumerationConstant: &cc.EnumerationConstant{
· · Token: IDENTIFIER "a",
· },
}
Example (Init)
fmt.Println(exampleAST(136, "\U00100001 enum { a = 'b' ,"))
Output:

&cc.Enumerator{
· Case: 1,
· ConstExpr: &cc.ConstExpr{
· · Expr: &cc.Expr{
· · · Case: ExprChar,
· · · Token: CHARCONST "'b'",
· · },
· },
· EnumerationConstant: &cc.EnumerationConstant{
· · Token: IDENTIFIER "a",
· },
· Token: '=',
}

func (*Enumerator) Pos

func (n *Enumerator) Pos() token.Pos

Pos reports the position of the first component of n or zero if it's empty.

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 (
	EnumeratorBase EnumeratorCase = iota
	EnumeratorInit
)

Values of type EnumeratorCase

func (EnumeratorCase) String

func (n EnumeratorCase) String() string

String implements fmt.Stringer

type EnumeratorList

type EnumeratorList struct {
	Case           int
	Enumerator     *Enumerator
	EnumeratorList *EnumeratorList
	Token          xc.Token
}

EnumeratorList represents data reduced by productions:

EnumeratorList:
        Enumerator                     // Case 0
|       EnumeratorList ',' Enumerator  // Case 1
Example (Case0)
fmt.Println(exampleAST(133, "\U00100001 enum { a ,"))
Output:

&cc.EnumeratorList{
· Enumerator: &cc.Enumerator{
· · EnumerationConstant: &cc.EnumerationConstant{
· · · Token: IDENTIFIER "a",
· · },
· },
}
Example (Case1)
fmt.Println(exampleAST(134, "\U00100001 enum { a , b ,"))
Output:

&cc.EnumeratorList{
· Enumerator: &cc.Enumerator{
· · EnumerationConstant: &cc.EnumerationConstant{
· · · Token: IDENTIFIER "a",
· · },
· },
· EnumeratorList: &cc.EnumeratorList{
· · Case: 1,
· · Enumerator: &cc.Enumerator{
· · · EnumerationConstant: &cc.EnumerationConstant{
· · · · Token: IDENTIFIER "b",
· · · },
· · },
· · Token: ',',
· },
}

func (*EnumeratorList) Pos

func (n *EnumeratorList) Pos() token.Pos

Pos reports the position of the first component of n or zero if it's empty.

func (*EnumeratorList) String

func (n *EnumeratorList) String() string

String implements fmt.Stringer.

type Expr

type Expr struct {
	CallArgs   []Operand   // Promoted arguments of Call.
	Declarator *Declarator // Case Ident.
	Operand    Operand
	Scope      *Scope // Case Ident, CompLit.

	AssignedTo          bool // Expression appears at the left side of assignment.
	ArgumentExprListOpt *ArgumentExprListOpt
	Case                ExprCase
	CommaOpt            *CommaOpt
	CompoundStmt        *CompoundStmt
	Expr                *Expr
	Expr2               *Expr
	ExprList            *ExprList
	InitializerList     *InitializerList
	Token               xc.Token
	Token2              xc.Token
	Token3              xc.Token
	Token4              xc.Token
	TypeName            *TypeName
	// contains filtered or unexported fields
}

Expr represents data reduced by productions:

Expr:
        "++" Expr                                          // Case ExprPreInc
|       "--" Expr                                          // Case ExprPreDec
|       "__alignof__" '(' TypeName ')'                     // Case ExprAlignofType
|       "__alignof__" Expr                                 // Case ExprAlignofExpr
|       "sizeof" '(' TypeName ')'                          // Case ExprSizeofType
|       "sizeof" Expr                                      // Case ExprSizeofExpr
|       '!' Expr                                           // Case ExprNot
|       '&' Expr                                           // Case ExprAddrof
|       '(' CompoundStmt ')'                               // Case ExprStatement
|       '(' ExprList ')'                                   // Case ExprPExprList
|       '(' TypeName ')' '{' InitializerList CommaOpt '}'  // Case ExprCompLit
|       '(' TypeName ')' Expr                              // Case ExprCast
|       '*' Expr                                           // Case ExprDeref
|       '+' Expr                                           // Case ExprUnaryPlus
|       '-' Expr                                           // Case ExprUnaryMinus
|       '~' Expr                                           // Case ExprCpl
|       CHARCONST                                          // Case ExprChar
|       Expr "!=" Expr                                     // Case ExprNe
|       Expr "%=" Expr                                     // Case ExprModAssign
|       Expr "&&" Expr                                     // Case ExprLAnd
|       Expr "&=" Expr                                     // Case ExprAndAssign
|       Expr "*=" Expr                                     // Case ExprMulAssign
|       Expr "++"                                          // Case ExprPostInc
|       Expr "+=" Expr                                     // Case ExprAddAssign
|       Expr "--"                                          // Case ExprPostDec
|       Expr "-=" Expr                                     // Case ExprSubAssign
|       Expr "->" IDENTIFIER                               // Case ExprPSelect
|       Expr "/=" Expr                                     // Case ExprDivAssign
|       Expr "<<" Expr                                     // Case ExprLsh
|       Expr "<<=" Expr                                    // Case ExprLshAssign
|       Expr "<=" Expr                                     // Case ExprLe
|       Expr "==" Expr                                     // Case ExprEq
|       Expr ">=" Expr                                     // Case ExprGe
|       Expr ">>" Expr                                     // Case ExprRsh
|       Expr ">>=" Expr                                    // Case ExprRshAssign
|       Expr "^=" Expr                                     // Case ExprXorAssign
|       Expr "|=" Expr                                     // Case ExprOrAssign
|       Expr "||" Expr                                     // Case ExprLOr
|       Expr '%' Expr                                      // Case ExprMod
|       Expr '&' Expr                                      // Case ExprAnd
|       Expr '(' ArgumentExprListOpt ')'                   // Case ExprCall
|       Expr '*' Expr                                      // Case ExprMul
|       Expr '+' Expr                                      // Case ExprAdd
|       Expr '-' Expr                                      // Case ExprSub
|       Expr '.' IDENTIFIER                                // Case ExprSelect
|       Expr '/' Expr                                      // Case ExprDiv
|       Expr '<' Expr                                      // Case ExprLt
|       Expr '=' Expr                                      // Case ExprAssign
|       Expr '>' Expr                                      // Case ExprGt
|       Expr '?' ExprList ':' Expr                         // Case ExprCond
|       Expr '[' ExprList ']'                              // Case ExprIndex
|       Expr '^' Expr                                      // Case ExprXor
|       Expr '|' Expr                                      // Case ExprOr
|       FLOATCONST                                         // Case ExprFloat
|       IDENTIFIER                                         // Case ExprIdent
|       INTCONST                                           // Case ExprInt
|       LONGCHARCONST                                      // Case ExprLChar
|       LONGSTRINGLITERAL                                  // Case ExprLString
|       STRINGLITERAL                                      // Case ExprString
Example (Add)
fmt.Println(exampleAST(50, "\U00100000 'a' + 'b'"))
Output:

&cc.Expr{
· Case: ExprAdd,
· Expr: &cc.Expr{
· · Case: ExprChar,
· · Token: CHARCONST "'a'",
· },
· Expr2: &cc.Expr{
· · Case: ExprChar,
· · Token: CHARCONST "'b'",
· },
· Token: '+',
}
Example (AddAssign)
fmt.Println(exampleAST(31, "\U00100000 'a' += 'b'"))
Output:

&cc.Expr{
· Case: ExprAddAssign,
· Expr: &cc.Expr{
· · Case: ExprChar,
· · Token: CHARCONST "'a'",
· },
· Expr2: &cc.Expr{
· · Case: ExprChar,
· · Token: CHARCONST "'b'",
· },
· Token: ADDASSIGN,
}
Example (Addrof)
fmt.Println(exampleAST(15, "\U00100000 & 'a'"))
Output:

&cc.Expr{
· Case: ExprAddrof,
· Expr: &cc.Expr{
· · Case: ExprChar,
· · Token: CHARCONST "'a'",
· },
· Token: '&',
}
Example (AlignofExpr)
fmt.Println(exampleAST(11, "\U00100000 __alignof__ 'a'"))
Output:

&cc.Expr{
· Case: ExprAlignofExpr,
· Expr: &cc.Expr{
· · Case: ExprChar,
· · Token: CHARCONST "'a'",
· },
· Token: ALIGNOF "__alignof__",
}
Example (AlignofType)
fmt.Println(exampleAST(10, "\U00100000 __alignof__ ( _Bool )"))
Output:

&cc.Expr{
· Case: ExprAlignofType,
· Token: ALIGNOF "__alignof__",
· Token2: '(',
· Token3: ')',
· TypeName: &cc.TypeName{
· · SpecifierQualifierList: &cc.SpecifierQualifierList{
· · · Case: 1,
· · · TypeSpecifier: &cc.TypeSpecifier{
· · · · Token: BOOL "_Bool",
· · · },
· · },
· },
}
Example (And)
fmt.Println(exampleAST(47, "\U00100000 'a' & 'b'"))
Output:

&cc.Expr{
· Case: ExprAnd,
· Expr: &cc.Expr{
· · Case: ExprChar,
· · Token: CHARCONST "'a'",
· },
· Expr2: &cc.Expr{
· · Case: ExprChar,
· · Token: CHARCONST "'b'",
· },
· Token: '&',
}
Example (AndAssign)
fmt.Println(exampleAST(28, "\U00100000 'a' &= 'b'"))
Output:

&cc.Expr{
· Case: ExprAndAssign,
· Expr: &cc.Expr{
· · Case: ExprChar,
· · Token: CHARCONST "'a'",
· },
· Expr2: &cc.Expr{
· · Case: ExprChar,
· · Token: CHARCONST "'b'",
· },
· Token: ANDASSIGN,
}
Example (Assign)
fmt.Println(exampleAST(55, "\U00100000 'a' = 'b'"))
Output:

&cc.Expr{
· Case: ExprAssign,
· Expr: &cc.Expr{
· · Case: ExprChar,
· · Token: CHARCONST "'a'",
· },
· Expr2: &cc.Expr{
· · Case: ExprChar,
· · Token: CHARCONST "'b'",
· },
· Token: '=',
}
Example (Call)
fmt.Println(exampleAST(48, "\U00100000 'a' ( )"))
Output:

&cc.Expr{
· Case: ExprCall,
· Expr: &cc.Expr{
· · Case: ExprChar,
· · Token: CHARCONST "'a'",
· },
· Token: '(',
· Token2: ')',
}
Example (Cast)
fmt.Println(exampleAST(19, "\U00100000 ( _Bool ) 'a'"))
Output:

&cc.Expr{
· Case: ExprCast,
· Expr: &cc.Expr{
· · Case: ExprChar,
· · Token: CHARCONST "'a'",
· },
· Token: '(',
· Token2: ')',
· TypeName: &cc.TypeName{
· · SpecifierQualifierList: &cc.SpecifierQualifierList{
· · · Case: 1,
· · · TypeSpecifier: &cc.TypeSpecifier{
· · · · Token: BOOL "_Bool",
· · · },
· · },
· },
}
Example (Char)
fmt.Println(exampleAST(24, "\U00100000 'a'"))
Output:

&cc.Expr{
· Case: ExprChar,
· Token: CHARCONST "'a'",
}
Example (CompLit)
fmt.Println(exampleAST(18, "\U00100000 ( _Bool ) { }"))
Output:

&cc.Expr{
· Case: ExprCompLit,
· Token: '(',
· Token2: ')',
· Token3: '{',
· Token4: '}',
· TypeName: &cc.TypeName{
· · SpecifierQualifierList: &cc.SpecifierQualifierList{
· · · Case: 1,
· · · TypeSpecifier: &cc.TypeSpecifier{
· · · · Token: BOOL "_Bool",
· · · },
· · },
· },
}
Example (Cond)
fmt.Println(exampleAST(57, "\U00100000 'a' ? 'b' : 'c'"))
Output:

&cc.Expr{
· Case: ExprCond,
· Expr: &cc.Expr{
· · Case: ExprChar,
· · Token: CHARCONST "'a'",
· },
· Expr2: &cc.Expr{
· · Case: ExprChar,
· · Token: CHARCONST "'c'",
· },
· ExprList: &cc.ExprList{
· · Expr: &cc.Expr{
· · · Case: ExprChar,
· · · Token: CHARCONST "'b'",
· · },
· },
· Token: '?',
· Token2: ':',
}
Example (Cpl)
fmt.Println(exampleAST(23, "\U00100000 ~ 'a'"))
Output:

&cc.Expr{
· Case: ExprCpl,
· Expr: &cc.Expr{
· · Case: ExprChar,
· · Token: CHARCONST "'a'",
· },
· Token: '~',
}
Example (Deref)
fmt.Println(exampleAST(20, "\U00100000 * 'a'"))
Output:

&cc.Expr{
· Case: ExprDeref,
· Expr: &cc.Expr{
· · Case: ExprChar,
· · Token: CHARCONST "'a'",
· },
· Token: '*',
}
Example (Div)
fmt.Println(exampleAST(53, "\U00100000 'a' / 'b'"))
Output:

&cc.Expr{
· Case: ExprDiv,
· Expr: &cc.Expr{
· · Case: ExprChar,
· · Token: CHARCONST "'a'",
· },
· Expr2: &cc.Expr{
· · Case: ExprChar,
· · Token: CHARCONST "'b'",
· },
· Token: '/',
}
Example (DivAssign)
fmt.Println(exampleAST(35, "\U00100000 'a' /= 'b'"))
Output:

&cc.Expr{
· Case: ExprDivAssign,
· Expr: &cc.Expr{
· · Case: ExprChar,
· · Token: CHARCONST "'a'",
· },
· Expr2: &cc.Expr{
· · Case: ExprChar,
· · Token: CHARCONST "'b'",
· },
· Token: DIVASSIGN,
}
Example (Eq)
fmt.Println(exampleAST(39, "\U00100000 'a' == 'b'"))
Output:

&cc.Expr{
· Case: ExprEq,
· Expr: &cc.Expr{
· · Case: ExprChar,
· · Token: CHARCONST "'a'",
· },
· Expr2: &cc.Expr{
· · Case: ExprChar,
· · Token: CHARCONST "'b'",
· },
· Token: EQ,
}
Example (Float)
fmt.Println(exampleAST(61, "\U00100000 1.97"))
Output:

&cc.Expr{
· Case: ExprFloat,
· Token: FLOATCONST "1.97",
}
Example (Ge)
fmt.Println(exampleAST(40, "\U00100000 'a' >= 'b'"))
Output:

&cc.Expr{
· Case: ExprGe,
· Expr: &cc.Expr{
· · Case: ExprChar,
· · Token: CHARCONST "'a'",
· },
· Expr2: &cc.Expr{
· · Case: ExprChar,
· · Token: CHARCONST "'b'",
· },
· Token: GEQ,
}
Example (Gt)
fmt.Println(exampleAST(56, "\U00100000 'a' > 'b'"))
Output:

&cc.Expr{
· Case: ExprGt,
· Expr: &cc.Expr{
· · Case: ExprChar,
· · Token: CHARCONST "'a'",
· },
· Expr2: &cc.Expr{
· · Case: ExprChar,
· · Token: CHARCONST "'b'",
· },
· Token: '>',
}
Example (Ident)
fmt.Println(exampleAST(62, "\U00100001 a { b %"))
Output:

&cc.Expr{
· Scope: &cc.Scope{
· },
· Case: ExprIdent,
· Token: IDENTIFIER "b",
}
Example (Index)
fmt.Println(exampleAST(58, "\U00100000 'a' [ 'b' ]"))
Output:

&cc.Expr{
· Case: ExprIndex,
· Expr: &cc.Expr{
· · Case: ExprChar,
· · Token: CHARCONST "'a'",
· },
· ExprList: &cc.ExprList{
· · Expr: &cc.Expr{
· · · Case: ExprChar,
· · · Token: CHARCONST "'b'",
· · },
· },
· Token: '[',
· Token2: ']',
}
Example (Int)
fmt.Println(exampleAST(63, "\U00100000 97"))
Output:

&cc.Expr{
· Case: ExprInt,
· Token: INTCONST "97",
}
Example (LAnd)
fmt.Println(exampleAST(27, "\U00100000 'a' && 'b'"))
Output:

&cc.Expr{
· Case: ExprLAnd,
· Expr: &cc.Expr{
· · Case: ExprChar,
· · Token: CHARCONST "'a'",
· },
· Expr2: &cc.Expr{
· · Case: ExprChar,
· · Token: CHARCONST "'b'",
· },
· Token: ANDAND,
}
Example (LChar)
fmt.Println(exampleAST(64, "\U00100000 L'a'"))
Output:

&cc.Expr{
· Case: ExprLChar,
· Token: LONGCHARCONST "L'a'",
}
Example (LOr)
fmt.Println(exampleAST(45, "\U00100000 'a' || 'b'"))
Output:

&cc.Expr{
· Case: ExprLOr,
· Expr: &cc.Expr{
· · Case: ExprChar,
· · Token: CHARCONST "'a'",
· },
· Expr2: &cc.Expr{
· · Case: ExprChar,
· · Token: CHARCONST "'b'",
· },
· Token: OROR,
}
Example (LString)
fmt.Println(exampleAST(65, "\U00100000 L\"a\""))
Output:

&cc.Expr{
· Case: ExprLString,
· Token: LONGSTRINGLITERAL "L\"a\"",
}
Example (Le)
fmt.Println(exampleAST(38, "\U00100000 'a' <= 'b'"))
Output:

&cc.Expr{
· Case: ExprLe,
· Expr: &cc.Expr{
· · Case: ExprChar,
· · Token: CHARCONST "'a'",
· },
· Expr2: &cc.Expr{
· · Case: ExprChar,
· · Token: CHARCONST "'b'",
· },
· Token: LEQ,
}
Example (Lsh)
fmt.Println(exampleAST(36, "\U00100000 'a' << 'b'"))
Output:

&cc.Expr{
· Case: ExprLsh,
· Expr: &cc.Expr{
· · Case: ExprChar,
· · Token: CHARCONST "'a'",
· },
· Expr2: &cc.Expr{
· · Case: ExprChar,
· · Token: CHARCONST "'b'",
· },
· Token: LSH,
}
Example (LshAssign)
fmt.Println(exampleAST(37, "\U00100000 'a' <<= 'b'"))
Output:

&cc.Expr{
· Case: ExprLshAssign,
· Expr: &cc.Expr{
· · Case: ExprChar,
· · Token: CHARCONST "'a'",
· },
· Expr2: &cc.Expr{
· · Case: ExprChar,
· · Token: CHARCONST "'b'",
· },
· Token: LSHASSIGN,
}
Example (Lt)
fmt.Println(exampleAST(54, "\U00100000 'a' < 'b'"))
Output:

&cc.Expr{
· Case: ExprLt,
· Expr: &cc.Expr{
· · Case: ExprChar,
· · Token: CHARCONST "'a'",
· },
· Expr2: &cc.Expr{
· · Case: ExprChar,
· · Token: CHARCONST "'b'",
· },
· Token: '<',
}
Example (Mod)
fmt.Println(exampleAST(46, "\U00100000 'a' % 'b'"))
Output:

&cc.Expr{
· Case: ExprMod,
· Expr: &cc.Expr{
· · Case: ExprChar,
· · Token: CHARCONST "'a'",
· },
· Expr2: &cc.Expr{
· · Case: ExprChar,
· · Token: CHARCONST "'b'",
· },
· Token: '%',
}
Example (ModAssign)
fmt.Println(exampleAST(26, "\U00100000 'a' %= 'b'"))
Output:

&cc.Expr{
· Case: ExprModAssign,
· Expr: &cc.Expr{
· · Case: ExprChar,
· · Token: CHARCONST "'a'",
· },
· Expr2: &cc.Expr{
· · Case: ExprChar,
· · Token: CHARCONST "'b'",
· },
· Token: MODASSIGN,
}
Example (Mul)
fmt.Println(exampleAST(49, "\U00100000 'a' * 'b'"))
Output:

&cc.Expr{
· Case: ExprMul,
· Expr: &cc.Expr{
· · Case: ExprChar,
· · Token: CHARCONST "'a'",
· },
· Expr2: &cc.Expr{
· · Case: ExprChar,
· · Token: CHARCONST "'b'",
· },
· Token: '*',
}
Example (MulAssign)
fmt.Println(exampleAST(29, "\U00100000 'a' *= 'b'"))
Output:

&cc.Expr{
· Case: ExprMulAssign,
· Expr: &cc.Expr{
· · Case: ExprChar,
· · Token: CHARCONST "'a'",
· },
· Expr2: &cc.Expr{
· · Case: ExprChar,
· · Token: CHARCONST "'b'",
· },
· Token: MULASSIGN,
}
Example (Ne)
fmt.Println(exampleAST(25, "\U00100000 'a' != 'b'"))
Output:

&cc.Expr{
· Case: ExprNe,
· Expr: &cc.Expr{
· · Case: ExprChar,
· · Token: CHARCONST "'a'",
· },
· Expr2: &cc.Expr{
· · Case: ExprChar,
· · Token: CHARCONST "'b'",
· },
· Token: NEQ,
}
Example (Not)
fmt.Println(exampleAST(14, "\U00100000 ! 'a'"))
Output:

&cc.Expr{
· Case: ExprNot,
· Expr: &cc.Expr{
· · Case: ExprChar,
· · Token: CHARCONST "'a'",
· },
· Token: '!',
}
Example (Or)
fmt.Println(exampleAST(60, "\U00100000 'a' | 'b'"))
Output:

&cc.Expr{
· Case: ExprOr,
· Expr: &cc.Expr{
· · Case: ExprChar,
· · Token: CHARCONST "'a'",
· },
· Expr2: &cc.Expr{
· · Case: ExprChar,
· · Token: CHARCONST "'b'",
· },
· Token: '|',
}
Example (OrAssign)
fmt.Println(exampleAST(44, "\U00100000 'a' |= 'b'"))
Output:

&cc.Expr{
· Case: ExprOrAssign,
· Expr: &cc.Expr{
· · Case: ExprChar,
· · Token: CHARCONST "'a'",
· },
· Expr2: &cc.Expr{
· · Case: ExprChar,
· · Token: CHARCONST "'b'",
· },
· Token: ORASSIGN,
}
Example (PExprList)
fmt.Println(exampleAST(17, "\U00100000 ( 'a' )"))
Output:

&cc.Expr{
· Case: ExprPExprList,
· ExprList: &cc.ExprList{
· · Expr: &cc.Expr{
· · · Case: ExprChar,
· · · Token: CHARCONST "'a'",
· · },
· },
· Token: '(',
· Token2: ')',
}
Example (PSelect)
fmt.Println(exampleAST(34, "\U00100000 'a' -> b"))
Output:

&cc.Expr{
· Case: ExprPSelect,
· Expr: &cc.Expr{
· · Case: ExprChar,
· · Token: CHARCONST "'a'",
· },
· Token: ARROW,
· Token2: IDENTIFIER "b",
}
Example (PostDec)
fmt.Println(exampleAST(32, "\U00100000 'a' --"))
Output:

&cc.Expr{
· Case: ExprPostDec,
· Expr: &cc.Expr{
· · Case: ExprChar,
· · Token: CHARCONST "'a'",
· },
· Token: DEC,
}
Example (PostInc)
fmt.Println(exampleAST(30, "\U00100000 'a' ++"))
Output:

&cc.Expr{
· Case: ExprPostInc,
· Expr: &cc.Expr{
· · Case: ExprChar,
· · Token: CHARCONST "'a'",
· },
· Token: INC,
}
Example (PreDec)
fmt.Println(exampleAST(9, "\U00100000 -- 'a'"))
Output:

&cc.Expr{
· Case: ExprPreDec,
· Expr: &cc.Expr{
· · Case: ExprChar,
· · Token: CHARCONST "'a'",
· },
· Token: DEC,
}
Example (PreInc)
fmt.Println(exampleAST(8, "\U00100000 ++ 'a'"))
Output:

&cc.Expr{
· Case: ExprPreInc,
· Expr: &cc.Expr{
· · Case: ExprChar,
· · Token: CHARCONST "'a'",
· },
· Token: INC,
}
Example (Rsh)
fmt.Println(exampleAST(41, "\U00100000 'a' >> 'b'"))
Output:

&cc.Expr{
· Case: ExprRsh,
· Expr: &cc.Expr{
· · Case: ExprChar,
· · Token: CHARCONST "'a'",
· },
· Expr2: &cc.Expr{
· · Case: ExprChar,
· · Token: CHARCONST "'b'",
· },
· Token: RSH,
}
Example (RshAssign)
fmt.Println(exampleAST(42, "\U00100000 'a' >>= 'b'"))
Output:

&cc.Expr{
· Case: ExprRshAssign,
· Expr: &cc.Expr{
· · Case: ExprChar,
· · Token: CHARCONST "'a'",
· },
· Expr2: &cc.Expr{
· · Case: ExprChar,
· · Token: CHARCONST "'b'",
· },
· Token: RSHASSIGN,
}
Example (Select)
fmt.Println(exampleAST(52, "\U00100000 'a' . b"))
Output:

&cc.Expr{
· Case: ExprSelect,
· Expr: &cc.Expr{
· · Case: ExprChar,
· · Token: CHARCONST "'a'",
· },
· Token: '.',
· Token2: IDENTIFIER "b",
}
Example (SizeofExpr)
fmt.Println(exampleAST(13, "\U00100000 sizeof 'a'"))
Output:

&cc.Expr{
· Case: ExprSizeofExpr,
· Expr: &cc.Expr{
· · Case: ExprChar,
· · Token: CHARCONST "'a'",
· },
· Token: SIZEOF "sizeof",
}
Example (SizeofType)
fmt.Println(exampleAST(12, "\U00100000 sizeof ( _Bool )"))
Output:

&cc.Expr{
· Case: ExprSizeofType,
· Token: SIZEOF "sizeof",
· Token2: '(',
· Token3: ')',
· TypeName: &cc.TypeName{
· · SpecifierQualifierList: &cc.SpecifierQualifierList{
· · · Case: 1,
· · · TypeSpecifier: &cc.TypeSpecifier{
· · · · Token: BOOL "_Bool",
· · · },
· · },
· },
}
Example (Statement)
fmt.Println(exampleAST(16, "\U00100000 ( { } )"))
Output:

&cc.Expr{
· Case: ExprStatement,
· CompoundStmt: &cc.CompoundStmt{
· · Token: '{',
· · Token2: '}',
· },
· Token: '(',
· Token2: ')',
}
Example (String)
fmt.Println(exampleAST(66, "\U00100000 \"a\""))
Output:

&cc.Expr{
· Case: ExprString,
· Token: STRINGLITERAL "\"a\"",
}
Example (Sub)
fmt.Println(exampleAST(51, "\U00100000 'a' - 'b'"))
Output:

&cc.Expr{
· Case: ExprSub,
· Expr: &cc.Expr{
· · Case: ExprChar,
· · Token: CHARCONST "'a'",
· },
· Expr2: &cc.Expr{
· · Case: ExprChar,
· · Token: CHARCONST "'b'",
· },
· Token: '-',
}
Example (SubAssign)
fmt.Println(exampleAST(33, "\U00100000 'a' -= 'b'"))
Output:

&cc.Expr{
· Case: ExprSubAssign,
· Expr: &cc.Expr{
· · Case: ExprChar,
· · Token: CHARCONST "'a'",
· },
· Expr2: &cc.Expr{
· · Case: ExprChar,
· · Token: CHARCONST "'b'",
· },
· Token: SUBASSIGN,
}
Example (UnaryMinus)
fmt.Println(exampleAST(22, "\U00100000 - 'a'"))
Output:

&cc.Expr{
· Case: ExprUnaryMinus,
· Expr: &cc.Expr{
· · Case: ExprChar,
· · Token: CHARCONST "'a'",
· },
· Token: '-',
}
Example (UnaryPlus)
fmt.Println(exampleAST(21, "\U00100000 + 'a'"))
Output:

&cc.Expr{
· Case: ExprUnaryPlus,
· Expr: &cc.Expr{
· · Case: ExprChar,
· · Token: CHARCONST "'a'",
· },
· Token: '+',
}
Example (Xor)
fmt.Println(exampleAST(59, "\U00100000 'a' ^ 'b'"))
Output:

&cc.Expr{
· Case: ExprXor,
· Expr: &cc.Expr{
· · Case: ExprChar,
· · Token: CHARCONST "'a'",
· },
· Expr2: &cc.Expr{
· · Case: ExprChar,
· · Token: CHARCONST "'b'",
· },
· Token: '^',
}
Example (XorAssign)
fmt.Println(exampleAST(43, "\U00100000 'a' ^= 'b'"))
Output:

&cc.Expr{
· Case: ExprXorAssign,
· Expr: &cc.Expr{
· · Case: ExprChar,
· · Token: CHARCONST "'a'",
· },
· Expr2: &cc.Expr{
· · Case: ExprChar,
· · Token: CHARCONST "'b'",
· },
· Token: XORASSIGN,
}

func (*Expr) DumpOperands

func (n *Expr) DumpOperands(s string)

DumpOperands dumps the operands of n to stdout.

func (*Expr) Equals

func (n *Expr) Equals(m *Expr) bool

Equals reports whether s equals m.

func (*Expr) IsNonZero

func (n *Expr) IsNonZero() bool

IsNonZero reports whether n is provably non zero.

func (*Expr) IsZero

func (n *Expr) IsZero() bool

IsZero reports whether n is provably zero.

func (*Expr) Pos

func (n *Expr) Pos() token.Pos

Pos reports the position of the first component of n or zero if it's empty.

func (*Expr) String

func (n *Expr) String() string

String implements fmt.Stringer.

type ExprCase

type ExprCase int

ExprCase represents case numbers of production Expr

const (
	ExprPreInc ExprCase = iota
	ExprPreDec
	ExprAlignofType
	ExprAlignofExpr
	ExprSizeofType
	ExprSizeofExpr
	ExprNot
	ExprAddrof
	ExprStatement
	ExprPExprList
	ExprCompLit
	ExprCast
	ExprDeref
	ExprUnaryPlus
	ExprUnaryMinus
	ExprCpl
	ExprChar
	ExprNe
	ExprModAssign
	ExprLAnd
	ExprAndAssign
	ExprMulAssign
	ExprPostInc
	ExprAddAssign
	ExprPostDec
	ExprSubAssign
	ExprPSelect
	ExprDivAssign
	ExprLsh
	ExprLshAssign
	ExprLe
	ExprEq
	ExprGe
	ExprRsh
	ExprRshAssign
	ExprXorAssign
	ExprOrAssign
	ExprLOr
	ExprMod
	ExprAnd
	ExprCall
	ExprMul
	ExprAdd
	ExprSub
	ExprSelect
	ExprDiv
	ExprLt
	ExprAssign
	ExprGt
	ExprCond
	ExprIndex
	ExprXor
	ExprOr
	ExprFloat
	ExprIdent
	ExprInt
	ExprLChar
	ExprLString
	ExprString
)

Values of type ExprCase

func (ExprCase) String

func (n ExprCase) String() string

String implements fmt.Stringer

type ExprList

type ExprList struct {
	Operand  Operand
	Case     int
	Expr     *Expr
	ExprList *ExprList
	Token    xc.Token
}

ExprList represents data reduced by productions:

ExprList:
        Expr               // Case 0
|       ExprList ',' Expr  // Case 1
Example (Case0)
fmt.Println(exampleAST(69, "\U00100000 ( 'a' )"))
Output:

&cc.ExprList{
· Expr: &cc.Expr{
· · Case: ExprChar,
· · Token: CHARCONST "'a'",
· },
}
Example (Case1)
fmt.Println(exampleAST(70, "\U00100000 ( 'a' , 'b' )"))
Output:

&cc.ExprList{
· Expr: &cc.Expr{
· · Case: ExprChar,
· · Token: CHARCONST "'a'",
· },
· ExprList: &cc.ExprList{
· · Case: 1,
· · Expr: &cc.Expr{
· · · Case: ExprChar,
· · · Token: CHARCONST "'b'",
· · },
· · Token: ',',
· },
}

func (*ExprList) DumpOperands

func (n *ExprList) DumpOperands(s string)

DumpOperands dumps the operands of n to stdout.

func (*ExprList) IsNonZero

func (n *ExprList) IsNonZero() bool

IsNonZero reports whether n is provably non zero.

func (*ExprList) IsZero

func (n *ExprList) IsZero() bool

IsZero reports whether n is provably zero.

func (*ExprList) Pos

func (n *ExprList) Pos() token.Pos

Pos reports the position of the first component of n or zero if it's empty.

func (*ExprList) String

func (n *ExprList) String() string

String implements fmt.Stringer.

type ExprListOpt

type ExprListOpt struct {
	ExprList *ExprList
}

ExprListOpt represents data reduced by productions:

ExprListOpt:
        /* empty */  // Case 0
|       ExprList     // Case 1
Example (Case0)
fmt.Println(exampleAST(71, "\U00100001 a { ;") == (*ExprListOpt)(nil))
Output:

true
Example (Case1)
fmt.Println(exampleAST(72, "\U00100001 a { 'b' )"))
Output:

&cc.ExprListOpt{
· ExprList: &cc.ExprList{
· · Expr: &cc.Expr{
· · · Case: ExprChar,
· · · Token: CHARCONST "'b'",
· · },
· },
}

func (*ExprListOpt) Pos

func (n *ExprListOpt) Pos() token.Pos

Pos reports the position of the first component of n or zero if it's empty.

func (*ExprListOpt) String

func (n *ExprListOpt) String() string

String implements fmt.Stringer.

type ExprOpt

type ExprOpt struct {
	Expr *Expr
}

ExprOpt represents data reduced by productions:

ExprOpt:
        /* empty */  // Case 0
|       Expr         // Case 1
Example (Case0)
fmt.Println(exampleAST(67, "\U00100000 ( _Bool [ ]") == (*ExprOpt)(nil))
Output:

true
Example (Case1)
fmt.Println(exampleAST(68, "\U00100001 a [ 'b' ]"))
Output:

&cc.ExprOpt{
· Expr: &cc.Expr{
· · Case: ExprChar,
· · Token: CHARCONST "'b'",
· },
}

func (*ExprOpt) Pos

func (n *ExprOpt) Pos() token.Pos

Pos reports the position of the first component of n or zero if it's empty.

func (*ExprOpt) String

func (n *ExprOpt) String() string

String implements fmt.Stringer.

type ExprStmt

type ExprStmt struct {
	ExprListOpt *ExprListOpt
	Token       xc.Token
}

ExprStmt represents data reduced by production:

ExprStmt:
        ExprListOpt ';'  // Case 0
Example (Case0)
fmt.Println(exampleAST(221, "\U00100001 a { ; !"))
Output:

&cc.ExprStmt{
· Token: ';',
}

func (*ExprStmt) Pos

func (n *ExprStmt) Pos() token.Pos

Pos reports the position of the first component of n or zero if it's empty.

func (*ExprStmt) String

func (n *ExprStmt) String() string

String implements fmt.Stringer.

type ExternalDeclaration

type ExternalDeclaration struct {
	Case               ExternalDeclarationCase
	Declaration        *Declaration
	FunctionDefinition *FunctionDefinition
}

ExternalDeclaration represents data reduced by productions:

ExternalDeclaration:
        Declaration         // Case ExternalDeclarationDecl
|       FunctionDefinition  // Case ExternalDeclarationFunc
Example (Decl)
fmt.Println(exampleAST(235, "\U00100001 auto ;"))
Output:

&cc.ExternalDeclaration{
· Declaration: &cc.Declaration{
· · DeclarationSpecifiers: &cc.DeclarationSpecifiers{
· · · Case: 1,
· · · StorageClassSpecifier: &cc.StorageClassSpecifier{
· · · · Token: AUTO "auto",
· · · },
· · },
· · Token: ';',
· },
}
Example (Func)
fmt.Println(exampleAST(236, "\U00100001 a { }"))
Output:

&cc.ExternalDeclaration{
· Case: 1,
· FunctionDefinition: &cc.FunctionDefinition{
· · Case: 1,
· · Declarator: &cc.Declarator{
· · · FunctionDefinition: &cc.FunctionDefinition{ /* recursive/repetitive pointee not shown */ },
· · · Linkage: LinkageNone,
· · · StorageDuration: StorageDurationAutomatic,
· · · DirectDeclarator: &cc.DirectDeclarator{
· · · · Case: DirectDeclaratorIdent,
· · · · Token: IDENTIFIER "a",
· · · },
· · },
· · FunctionBody: &cc.FunctionBody{
· · · CompoundStmt: &cc.CompoundStmt{
· · · · BlockItemListOpt: &cc.BlockItemListOpt{
· · · · · BlockItemList: &cc.BlockItemList{
· · · · · · BlockItem: &cc.BlockItem{
· · · · · · · Declaration: &cc.Declaration{
· · · · · · · · Scope: &cc.Scope{
· · · · · · · · · Parent: &cc.Scope{ /* recursive/repetitive pointee not shown */ },
· · · · · · · · },
· · · · · · · · DeclarationSpecifiers: &cc.DeclarationSpecifiers{
· · · · · · · · · Case: 1,
· · · · · · · · · DeclarationSpecifiersOpt: &cc.DeclarationSpecifiersOpt{
· · · · · · · · · · DeclarationSpecifiers: &cc.DeclarationSpecifiers{
· · · · · · · · · · · Case: 2,
· · · · · · · · · · · DeclarationSpecifiersOpt: &cc.DeclarationSpecifiersOpt{
· · · · · · · · · · · · DeclarationSpecifiers: &cc.DeclarationSpecifiers{
· · · · · · · · · · · · · Case: 3,
· · · · · · · · · · · · · TypeSpecifier: &cc.TypeSpecifier{
· · · · · · · · · · · · · · Case: 2,
· · · · · · · · · · · · · · Token: CHAR "char",
· · · · · · · · · · · · · },
· · · · · · · · · · · · },
· · · · · · · · · · · },
· · · · · · · · · · · TypeQualifier: &cc.TypeQualifier{
· · · · · · · · · · · · Token: CONST "const",
· · · · · · · · · · · },
· · · · · · · · · · },
· · · · · · · · · },
· · · · · · · · · StorageClassSpecifier: &cc.StorageClassSpecifier{
· · · · · · · · · · Case: 3,
· · · · · · · · · · Token: STATIC "static",
· · · · · · · · · },
· · · · · · · · },
· · · · · · · · InitDeclaratorListOpt: &cc.InitDeclaratorListOpt{
· · · · · · · · · InitDeclaratorList: &cc.InitDeclaratorList{
· · · · · · · · · · InitDeclarator: &cc.InitDeclarator{
· · · · · · · · · · · Case: 1,
· · · · · · · · · · · Declarator: &cc.Declarator{
· · · · · · · · · · · · Linkage: LinkageNone,
· · · · · · · · · · · · Scope: &cc.Scope{ /* recursive/repetitive pointee not shown */ },
· · · · · · · · · · · · StorageDuration: StorageDurationAutomatic,
· · · · · · · · · · · · DirectDeclarator: &cc.DirectDeclarator{
· · · · · · · · · · · · · Case: DirectDeclaratorArray,
· · · · · · · · · · · · · DirectDeclarator: &cc.DirectDeclarator{
· · · · · · · · · · · · · · Case: DirectDeclaratorIdent,
· · · · · · · · · · · · · · Token: IDENTIFIER "__func__",
· · · · · · · · · · · · · },
· · · · · · · · · · · · · Token: '[',
· · · · · · · · · · · · · Token2: ']',
· · · · · · · · · · · · },
· · · · · · · · · · · },
· · · · · · · · · · · Initializer: &cc.Initializer{
· · · · · · · · · · · · Case: 1,
· · · · · · · · · · · · Expr: &cc.Expr{
· · · · · · · · · · · · · Case: ExprString,
· · · · · · · · · · · · · Token: STRINGLITERAL "\"a\"",
· · · · · · · · · · · · },
· · · · · · · · · · · },
· · · · · · · · · · · Token: '=',
· · · · · · · · · · },
· · · · · · · · · },
· · · · · · · · },
· · · · · · · · Token: ';',
· · · · · · · },
· · · · · · },
· · · · · },
· · · · },
· · · · Token: '{',
· · · · Token2: '}',
· · · },
· · },
· },
}

func (*ExternalDeclaration) Pos

func (n *ExternalDeclaration) Pos() token.Pos

Pos reports the position of the first component of n or zero if it's empty.

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 (
	ExternalDeclarationDecl ExternalDeclarationCase = iota
	ExternalDeclarationFunc
)

Values of type ExternalDeclarationCase

func (ExternalDeclarationCase) String

func (n ExternalDeclarationCase) String() string

String implements fmt.Stringer

type ExternalDeclarationList

type ExternalDeclarationList struct {
	Case                    int
	ExternalDeclaration     *ExternalDeclaration
	ExternalDeclarationList *ExternalDeclarationList
}

ExternalDeclarationList represents data reduced by productions:

ExternalDeclarationList:
        ExternalDeclaration                          // Case 0
|       ExternalDeclarationList ExternalDeclaration  // Case 1
Example (Case0)
fmt.Println(exampleAST(233, "\U00100001 auto ;"))
Output:

&cc.ExternalDeclarationList{
· ExternalDeclaration: &cc.ExternalDeclaration{
· · Declaration: &cc.Declaration{
· · · DeclarationSpecifiers: &cc.DeclarationSpecifiers{
· · · · Case: 1,
· · · · StorageClassSpecifier: &cc.StorageClassSpecifier{
· · · · · Token: AUTO "auto",
· · · · },
· · · },
· · · Token: ';',
· · },
· },
}
Example (Case1)
fmt.Println(exampleAST(234, "\U00100001 auto ; auto ;"))
Output:

&cc.ExternalDeclarationList{
· ExternalDeclaration: &cc.ExternalDeclaration{
· · Declaration: &cc.Declaration{
· · · DeclarationSpecifiers: &cc.DeclarationSpecifiers{
· · · · Case: 1,
· · · · StorageClassSpecifier: &cc.StorageClassSpecifier{
· · · · · Token: AUTO "auto",
· · · · },
· · · },
· · · Token: ';',
· · },
· },
· ExternalDeclarationList: &cc.ExternalDeclarationList{
· · Case: 1,
· · ExternalDeclaration: &cc.ExternalDeclaration{
· · · Declaration: &cc.Declaration{
· · · · Scope: &cc.Scope{ /* recursive/repetitive pointee not shown */ },
· · · · DeclarationSpecifiers: &cc.DeclarationSpecifiers{
· · · · · Case: 1,
· · · · · StorageClassSpecifier: &cc.StorageClassSpecifier{
· · · · · · Token: AUTO "auto",
· · · · · },
· · · · },
· · · · Token: ';',
· · · },
· · },
· },
}

func (*ExternalDeclarationList) Pos

Pos reports the position of the first component of n or zero if it's empty.

func (*ExternalDeclarationList) String

func (n *ExternalDeclarationList) String() string

String implements fmt.Stringer.

type Field

type Field struct {
	Bits       int
	Declarator *Declarator
	Name       int
	PackedType Type // Bits != 0: underlaying struct field type
	Type       Type

	Anonymous bool
}

Field represents a struct/union field.

func (Field) String

func (f Field) String() string

type FieldProperties

type FieldProperties struct {
	Bitoff     int // Zero based bit number of a bitfield
	Bits       int // Width of a bit field or zero otherwise.
	Declarator *Declarator
	Offset     int64 // Byte offset relative to start of the struct/union.
	PackedType Type  // Bits != 0: Storage type holding the bit field.
	Padding    int   // Adjustment to enforce proper alignment.
	Size       int64 // Field size for copying.
	Type       Type

	Anonymous bool
}

FieldProperties describe a struct/union field.

func (*FieldProperties) Mask

func (f *FieldProperties) Mask() uint64

Mask returns the bit mask of bit field described by f.

type FileSource

type FileSource struct {
	*bufio.Reader
	// contains filtered or unexported fields
}

FileSource is a Source reading from a named file.

func MustFileSource

func MustFileSource(nm string) *FileSource

MustFileSource is like NewFileSource but panics on error.

func MustFileSource2

func MustFileSource2(nm string, cacheable bool) *FileSource

MustFileSource2 is like NewFileSource but panics on error.

func NewFileSource

func NewFileSource(name string) (*FileSource, error)

NewFileSource returns a newly created *FileSource reading from name.

func NewFileSource2

func NewFileSource2(name string, cacheable bool) (*FileSource, error)

NewFileSource2 returns a newly created *FileSource reading from name.

func (*FileSource) Cache

func (s *FileSource) Cache(a []uint32)

Cache implements Source.

func (*FileSource) Cached

func (s *FileSource) Cached() (r []uint32)

Cached implements Source.

func (*FileSource) Close

func (s *FileSource) Close() error

Close implements io.ReadCloser.

func (*FileSource) Name

func (s *FileSource) Name() string

Name implements Source.

func (*FileSource) ReadCloser

func (s *FileSource) ReadCloser() (io.ReadCloser, error)

ReadCloser implements Source.

func (*FileSource) Size

func (s *FileSource) Size() (int64, error)

Size implements Source.

func (*FileSource) String

func (s *FileSource) String() string

type FunctionBody

type FunctionBody struct {
	CompoundStmt *CompoundStmt
}

FunctionBody represents data reduced by production:

FunctionBody:
        CompoundStmt  // Case 0
Example (Case0)
fmt.Println(exampleAST(242, "\U00100001 a { }"))
Output:

&cc.FunctionBody{
· CompoundStmt: &cc.CompoundStmt{
· · BlockItemListOpt: &cc.BlockItemListOpt{
· · · BlockItemList: &cc.BlockItemList{
· · · · BlockItem: &cc.BlockItem{
· · · · · Declaration: &cc.Declaration{
· · · · · · Scope: &cc.Scope{
· · · · · · },
· · · · · · DeclarationSpecifiers: &cc.DeclarationSpecifiers{
· · · · · · · Case: 1,
· · · · · · · DeclarationSpecifiersOpt: &cc.DeclarationSpecifiersOpt{
· · · · · · · · DeclarationSpecifiers: &cc.DeclarationSpecifiers{
· · · · · · · · · Case: 2,
· · · · · · · · · DeclarationSpecifiersOpt: &cc.DeclarationSpecifiersOpt{
· · · · · · · · · · DeclarationSpecifiers: &cc.DeclarationSpecifiers{
· · · · · · · · · · · Case: 3,
· · · · · · · · · · · TypeSpecifier: &cc.TypeSpecifier{
· · · · · · · · · · · · Case: 2,
· · · · · · · · · · · · Token: CHAR "char",
· · · · · · · · · · · },
· · · · · · · · · · },
· · · · · · · · · },
· · · · · · · · · TypeQualifier: &cc.TypeQualifier{
· · · · · · · · · · Token: CONST "const",
· · · · · · · · · },
· · · · · · · · },
· · · · · · · },
· · · · · · · StorageClassSpecifier: &cc.StorageClassSpecifier{
· · · · · · · · Case: 3,
· · · · · · · · Token: STATIC "static",
· · · · · · · },
· · · · · · },
· · · · · · InitDeclaratorListOpt: &cc.InitDeclaratorListOpt{
· · · · · · · InitDeclaratorList: &cc.InitDeclaratorList{
· · · · · · · · InitDeclarator: &cc.InitDeclarator{
· · · · · · · · · Case: 1,
· · · · · · · · · Declarator: &cc.Declarator{
· · · · · · · · · · Linkage: LinkageNone,
· · · · · · · · · · Scope: &cc.Scope{ /* recursive/repetitive pointee not shown */ },
· · · · · · · · · · StorageDuration: StorageDurationAutomatic,
· · · · · · · · · · DirectDeclarator: &cc.DirectDeclarator{
· · · · · · · · · · · Case: DirectDeclaratorArray,
· · · · · · · · · · · DirectDeclarator: &cc.DirectDeclarator{
· · · · · · · · · · · · Case: DirectDeclaratorIdent,
· · · · · · · · · · · · Token: IDENTIFIER "__func__",
· · · · · · · · · · · },
· · · · · · · · · · · Token: '[',
· · · · · · · · · · · Token2: ']',
· · · · · · · · · · },
· · · · · · · · · },
· · · · · · · · · Initializer: &cc.Initializer{
· · · · · · · · · · Case: 1,
· · · · · · · · · · Expr: &cc.Expr{
· · · · · · · · · · · Case: ExprString,
· · · · · · · · · · · Token: STRINGLITERAL "\"a\"",
· · · · · · · · · · },
· · · · · · · · · },
· · · · · · · · · Token: '=',
· · · · · · · · },
· · · · · · · },
· · · · · · },
· · · · · · Token: ';',
· · · · · },
· · · · },
· · · },
· · },
· · Token: '{',
· · Token2: '}',
· },
}

func (*FunctionBody) Pos

func (n *FunctionBody) Pos() token.Pos

Pos reports the position of the first component of n or zero if it's empty.

func (*FunctionBody) String

func (n *FunctionBody) String() string

String implements fmt.Stringer.

type FunctionDefinition

type FunctionDefinition struct {
	Case                  FunctionDefinitionCase
	DeclarationListOpt    *DeclarationListOpt
	DeclarationSpecifiers *DeclarationSpecifiers
	Declarator            *Declarator
	FunctionBody          *FunctionBody
}

FunctionDefinition represents data reduced by productions:

FunctionDefinition:
        DeclarationSpecifiers Declarator DeclarationListOpt FunctionBody  // Case FunctionDefinitionSpec
|       Declarator DeclarationListOpt FunctionBody                        // Case FunctionDefinitionInt
Example (Int)
fmt.Println(exampleAST(240, "\U00100001 a { }"))
Output:

&cc.FunctionDefinition{
· Case: 1,
· Declarator: &cc.Declarator{
· · FunctionDefinition: &cc.FunctionDefinition{ /* recursive/repetitive pointee not shown */ },
· · Linkage: LinkageNone,
· · StorageDuration: StorageDurationAutomatic,
· · DirectDeclarator: &cc.DirectDeclarator{
· · · Case: DirectDeclaratorIdent,
· · · Token: IDENTIFIER "a",
· · },
· },
· FunctionBody: &cc.FunctionBody{
· · CompoundStmt: &cc.CompoundStmt{
· · · BlockItemListOpt: &cc.BlockItemListOpt{
· · · · BlockItemList: &cc.BlockItemList{
· · · · · BlockItem: &cc.BlockItem{
· · · · · · Declaration: &cc.Declaration{
· · · · · · · Scope: &cc.Scope{
· · · · · · · · Parent: &cc.Scope{ /* recursive/repetitive pointee not shown */ },
· · · · · · · },
· · · · · · · DeclarationSpecifiers: &cc.DeclarationSpecifiers{
· · · · · · · · Case: 1,
· · · · · · · · DeclarationSpecifiersOpt: &cc.DeclarationSpecifiersOpt{
· · · · · · · · · DeclarationSpecifiers: &cc.DeclarationSpecifiers{
· · · · · · · · · · Case: 2,
· · · · · · · · · · DeclarationSpecifiersOpt: &cc.DeclarationSpecifiersOpt{
· · · · · · · · · · · DeclarationSpecifiers: &cc.DeclarationSpecifiers{
· · · · · · · · · · · · Case: 3,
· · · · · · · · · · · · TypeSpecifier: &cc.TypeSpecifier{
· · · · · · · · · · · · · Case: 2,
· · · · · · · · · · · · · Token: CHAR "char",
· · · · · · · · · · · · },
· · · · · · · · · · · },
· · · · · · · · · · },
· · · · · · · · · · TypeQualifier: &cc.TypeQualifier{
· · · · · · · · · · · Token: CONST "const",
· · · · · · · · · · },
· · · · · · · · · },
· · · · · · · · },
· · · · · · · · StorageClassSpecifier: &cc.StorageClassSpecifier{
· · · · · · · · · Case: 3,
· · · · · · · · · Token: STATIC "static",
· · · · · · · · },
· · · · · · · },
· · · · · · · InitDeclaratorListOpt: &cc.InitDeclaratorListOpt{
· · · · · · · · InitDeclaratorList: &cc.InitDeclaratorList{
· · · · · · · · · InitDeclarator: &cc.InitDeclarator{
· · · · · · · · · · Case: 1,
· · · · · · · · · · Declarator: &cc.Declarator{
· · · · · · · · · · · Linkage: LinkageNone,
· · · · · · · · · · · Scope: &cc.Scope{ /* recursive/repetitive pointee not shown */ },
· · · · · · · · · · · StorageDuration: StorageDurationAutomatic,
· · · · · · · · · · · DirectDeclarator: &cc.DirectDeclarator{
· · · · · · · · · · · · Case: DirectDeclaratorArray,
· · · · · · · · · · · · DirectDeclarator: &cc.DirectDeclarator{
· · · · · · · · · · · · · Case: DirectDeclaratorIdent,
· · · · · · · · · · · · · Token: IDENTIFIER "__func__",
· · · · · · · · · · · · },
· · · · · · · · · · · · Token: '[',
· · · · · · · · · · · · Token2: ']',
· · · · · · · · · · · },
· · · · · · · · · · },
· · · · · · · · · · Initializer: &cc.Initializer{
· · · · · · · · · · · Case: 1,
· · · · · · · · · · · Expr: &cc.Expr{
· · · · · · · · · · · · Case: ExprString,
· · · · · · · · · · · · Token: STRINGLITERAL "\"a\"",
· · · · · · · · · · · },
· · · · · · · · · · },
· · · · · · · · · · Token: '=',
· · · · · · · · · },
· · · · · · · · },
· · · · · · · },
· · · · · · · Token: ';',
· · · · · · },
· · · · · },
· · · · },
· · · },
· · · Token: '{',
· · · Token2: '}',
· · },
· },
}
Example (Spec)
fmt.Println(exampleAST(238, "\U00100001 auto a { }"))
Output:

&cc.FunctionDefinition{
· DeclarationSpecifiers: &cc.DeclarationSpecifiers{
· · Case: 1,
· · StorageClassSpecifier: &cc.StorageClassSpecifier{
· · · Token: AUTO "auto",
· · },
· },
· Declarator: &cc.Declarator{
· · FunctionDefinition: &cc.FunctionDefinition{ /* recursive/repetitive pointee not shown */ },
· · Linkage: LinkageNone,
· · StorageDuration: StorageDurationAutomatic,
· · DirectDeclarator: &cc.DirectDeclarator{
· · · Case: DirectDeclaratorIdent,
· · · Token: IDENTIFIER "a",
· · },
· },
· FunctionBody: &cc.FunctionBody{
· · CompoundStmt: &cc.CompoundStmt{
· · · BlockItemListOpt: &cc.BlockItemListOpt{
· · · · BlockItemList: &cc.BlockItemList{
· · · · · BlockItem: &cc.BlockItem{
· · · · · · Declaration: &cc.Declaration{
· · · · · · · Scope: &cc.Scope{
· · · · · · · · Parent: &cc.Scope{ /* recursive/repetitive pointee not shown */ },
· · · · · · · },
· · · · · · · DeclarationSpecifiers: &cc.DeclarationSpecifiers{
· · · · · · · · Case: 1,
· · · · · · · · DeclarationSpecifiersOpt: &cc.DeclarationSpecifiersOpt{
· · · · · · · · · DeclarationSpecifiers: &cc.DeclarationSpecifiers{
· · · · · · · · · · Case: 2,
· · · · · · · · · · DeclarationSpecifiersOpt: &cc.DeclarationSpecifiersOpt{
· · · · · · · · · · · DeclarationSpecifiers: &cc.DeclarationSpecifiers{
· · · · · · · · · · · · Case: 3,
· · · · · · · · · · · · TypeSpecifier: &cc.TypeSpecifier{
· · · · · · · · · · · · · Case: 2,
· · · · · · · · · · · · · Token: CHAR "char",
· · · · · · · · · · · · },
· · · · · · · · · · · },
· · · · · · · · · · },
· · · · · · · · · · TypeQualifier: &cc.TypeQualifier{
· · · · · · · · · · · Token: CONST "const",
· · · · · · · · · · },
· · · · · · · · · },
· · · · · · · · },
· · · · · · · · StorageClassSpecifier: &cc.StorageClassSpecifier{
· · · · · · · · · Case: 3,
· · · · · · · · · Token: STATIC "static",
· · · · · · · · },
· · · · · · · },
· · · · · · · InitDeclaratorListOpt: &cc.InitDeclaratorListOpt{
· · · · · · · · InitDeclaratorList: &cc.InitDeclaratorList{
· · · · · · · · · InitDeclarator: &cc.InitDeclarator{
· · · · · · · · · · Case: 1,
· · · · · · · · · · Declarator: &cc.Declarator{
· · · · · · · · · · · Linkage: LinkageNone,
· · · · · · · · · · · Scope: &cc.Scope{ /* recursive/repetitive pointee not shown */ },
· · · · · · · · · · · StorageDuration: StorageDurationAutomatic,
· · · · · · · · · · · DirectDeclarator: &cc.DirectDeclarator{
· · · · · · · · · · · · Case: DirectDeclaratorArray,
· · · · · · · · · · · · DirectDeclarator: &cc.DirectDeclarator{
· · · · · · · · · · · · · Case: DirectDeclaratorIdent,
· · · · · · · · · · · · · Token: IDENTIFIER "__func__",
· · · · · · · · · · · · },
· · · · · · · · · · · · Token: '[',
· · · · · · · · · · · · Token2: ']',
· · · · · · · · · · · },
· · · · · · · · · · },
· · · · · · · · · · Initializer: &cc.Initializer{
· · · · · · · · · · · Case: 1,
· · · · · · · · · · · Expr: &cc.Expr{
· · · · · · · · · · · · Case: ExprString,
· · · · · · · · · · · · Token: STRINGLITERAL "\"a\"",
· · · · · · · · · · · },
· · · · · · · · · · },
· · · · · · · · · · Token: '=',
· · · · · · · · · },
· · · · · · · · },
· · · · · · · },
· · · · · · · Token: ';',
· · · · · · },
· · · · · },
· · · · },
· · · },
· · · Token: '{',
· · · Token2: '}',
· · },
· },
}

func (*FunctionDefinition) LocalVariables

func (n *FunctionDefinition) LocalVariables() []*Declarator

LocalVariables returns all local variables declared in a function in the order of appearance. The result does not include function parameters.

func (*FunctionDefinition) Pos

func (n *FunctionDefinition) Pos() token.Pos

Pos reports the position of the first component of n or zero if it's empty.

func (*FunctionDefinition) String

func (n *FunctionDefinition) String() string

String implements fmt.Stringer.

type FunctionDefinitionCase

type FunctionDefinitionCase int

FunctionDefinitionCase represents case numbers of production FunctionDefinition

const (
	FunctionDefinitionSpec FunctionDefinitionCase = iota
	FunctionDefinitionInt
)

Values of type FunctionDefinitionCase

func (FunctionDefinitionCase) String

func (n FunctionDefinitionCase) String() string

String implements fmt.Stringer

type FunctionSpecifier

type FunctionSpecifier struct {
	Token xc.Token
}

FunctionSpecifier represents data reduced by production:

FunctionSpecifier:
        "inline"  // Case 0
Example (Case0)
fmt.Println(exampleAST(140, "\U00100001 inline ("))
Output:

&cc.FunctionSpecifier{
· Token: INLINE "inline",
}

func (*FunctionSpecifier) Pos

func (n *FunctionSpecifier) Pos() token.Pos

Pos reports the position of the first component of n or zero if it's empty.

func (*FunctionSpecifier) String

func (n *FunctionSpecifier) String() string

String implements fmt.Stringer.

type FunctionType

type FunctionType struct {
	Params   []Type
	Result   Type
	Variadic bool
	// contains filtered or unexported fields
}

FunctionType represents a function type.

func (*FunctionType) Equal

func (t *FunctionType) Equal(u Type) bool

Equal implements Type.

func (*FunctionType) IsArithmeticType

func (t *FunctionType) IsArithmeticType() bool

IsArithmeticType implements Type.

func (*FunctionType) IsCompatible

func (t *FunctionType) IsCompatible(u Type) bool

IsCompatible implements Type.

func (*FunctionType) IsIntegerType

func (t *FunctionType) IsIntegerType() bool

IsIntegerType implements Type.

func (*FunctionType) IsPointerType

func (t *FunctionType) IsPointerType() bool

IsPointerType implements Type.

func (*FunctionType) IsScalarType

func (t *FunctionType) IsScalarType() bool

IsScalarType implements Type.

func (*FunctionType) IsUnsigned

func (t *FunctionType) IsUnsigned() bool

IsUnsigned implements Type.

func (*FunctionType) IsVoidPointerType

func (t *FunctionType) IsVoidPointerType() bool

IsVoidPointerType implements Type.

func (*FunctionType) Kind

func (t *FunctionType) Kind() TypeKind

Kind implements Type.

func (*FunctionType) String

func (t *FunctionType) String() string

type IdentifierList

type IdentifierList struct {
	Case           int
	IdentifierList *IdentifierList
	Token          xc.Token
	Token2         xc.Token
}

IdentifierList represents data reduced by productions:

IdentifierList:
        IDENTIFIER                     // Case 0
|       IdentifierList ',' IDENTIFIER  // Case 1
Example (Case0)
fmt.Println(exampleAST(170, "\U00100001 a ( b )"))
Output:

&cc.IdentifierList{
· Token: IDENTIFIER "b",
}
Example (Case1)
fmt.Println(exampleAST(171, "\U00100001 a ( b , c )"))
Output:

&cc.IdentifierList{
· IdentifierList: &cc.IdentifierList{
· · Case: 1,
· · Token: ',',
· · Token2: IDENTIFIER "c",
· },
· Token: IDENTIFIER "b",
}

func (*IdentifierList) Pos

func (n *IdentifierList) Pos() token.Pos

Pos reports the position of the first component of n or zero if it's empty.

func (*IdentifierList) String

func (n *IdentifierList) String() string

String implements fmt.Stringer.

type IdentifierListOpt

type IdentifierListOpt struct {
	IdentifierList *IdentifierList
}

IdentifierListOpt represents data reduced by productions:

IdentifierListOpt:
        /* empty */     // Case 0
|       IdentifierList  // Case 1
Example (Case0)
fmt.Println(exampleAST(172, "\U00100001 a ( )") == (*IdentifierListOpt)(nil))
Output:

true
Example (Case1)
fmt.Println(exampleAST(173, "\U00100001 a ( b )"))
Output:

&cc.IdentifierListOpt{
· IdentifierList: &cc.IdentifierList{
· · Token: IDENTIFIER "b",
· },
}

func (*IdentifierListOpt) Pos

func (n *IdentifierListOpt) Pos() token.Pos

Pos reports the position of the first component of n or zero if it's empty.

func (*IdentifierListOpt) String

func (n *IdentifierListOpt) String() string

String implements fmt.Stringer.

type IdentifierOpt

type IdentifierOpt struct {
	Token xc.Token
}

IdentifierOpt represents data reduced by productions:

IdentifierOpt:
        /* empty */  // Case 0
|       IDENTIFIER   // Case 1
Example (Case0)
fmt.Println(exampleAST(174, "\U00100001 struct {") == (*IdentifierOpt)(nil))
Output:

true
Example (Case1)
fmt.Println(exampleAST(175, "\U00100001 enum a {"))
Output:

&cc.IdentifierOpt{
· Token: IDENTIFIER "a",
}

func (*IdentifierOpt) Pos

func (n *IdentifierOpt) Pos() token.Pos

Pos reports the position of the first component of n or zero if it's empty.

func (*IdentifierOpt) String

func (n *IdentifierOpt) String() string

String implements fmt.Stringer.

type InitDeclarator

type InitDeclarator struct {
	Case        InitDeclaratorCase
	Declarator  *Declarator
	Initializer *Initializer
	Token       xc.Token
}

InitDeclarator represents data reduced by productions:

InitDeclarator:
        Declarator                  // Case InitDeclaratorBase
|       Declarator '=' Initializer  // Case InitDeclaratorInit
Example (Base)
fmt.Println(exampleAST(86, "\U00100001 a auto b ,"))
Output:

&cc.InitDeclarator{
· Declarator: &cc.Declarator{
· · Linkage: LinkageNone,
· · StorageDuration: StorageDurationAutomatic,
· · DirectDeclarator: &cc.DirectDeclarator{
· · · Case: DirectDeclaratorIdent,
· · · Token: IDENTIFIER "b",
· · },
· },
}
Example (Init)
fmt.Println(exampleAST(87, "\U00100001 auto a = 'b' ,"))
Output:

&cc.InitDeclarator{
· Case: 1,
· Declarator: &cc.Declarator{
· · Linkage: LinkageNone,
· · StorageDuration: StorageDurationAutomatic,
· · DirectDeclarator: &cc.DirectDeclarator{
· · · Case: DirectDeclaratorIdent,
· · · Token: IDENTIFIER "a",
· · },
· },
· Initializer: &cc.Initializer{
· · Case: 1,
· · Expr: &cc.Expr{
· · · Case: ExprChar,
· · · Token: CHARCONST "'b'",
· · },
· },
· Token: '=',
}

func (*InitDeclarator) Pos

func (n *InitDeclarator) Pos() token.Pos

Pos reports the position of the first component of n or zero if it's empty.

func (*InitDeclarator) String

func (n *InitDeclarator) String() string

String implements fmt.Stringer.

type InitDeclaratorCase

type InitDeclaratorCase int

InitDeclaratorCase represents case numbers of production InitDeclarator

const (
	InitDeclaratorBase InitDeclaratorCase = iota
	InitDeclaratorInit
)

Values of type InitDeclaratorCase

func (InitDeclaratorCase) String

func (n InitDeclaratorCase) String() string

String implements fmt.Stringer

type InitDeclaratorList

type InitDeclaratorList struct {
	Case               int
	InitDeclarator     *InitDeclarator
	InitDeclaratorList *InitDeclaratorList
	Token              xc.Token
}

InitDeclaratorList represents data reduced by productions:

InitDeclaratorList:
        InitDeclarator                         // Case 0
|       InitDeclaratorList ',' InitDeclarator  // Case 1
Example (Case0)
fmt.Println(exampleAST(82, "\U00100001 auto a ,"))
Output:

&cc.InitDeclaratorList{
· InitDeclarator: &cc.InitDeclarator{
· · Declarator: &cc.Declarator{
· · · Linkage: LinkageNone,
· · · StorageDuration: StorageDurationAutomatic,
· · · DirectDeclarator: &cc.DirectDeclarator{
· · · · Case: DirectDeclaratorIdent,
· · · · Token: IDENTIFIER "a",
· · · },
· · },
· },
}
Example (Case1)
fmt.Println(exampleAST(83, "\U00100001 auto a , b ,"))
Output:

&cc.InitDeclaratorList{
· InitDeclarator: &cc.InitDeclarator{
· · Declarator: &cc.Declarator{
· · · Linkage: LinkageNone,
· · · StorageDuration: StorageDurationAutomatic,
· · · DirectDeclarator: &cc.DirectDeclarator{
· · · · Case: DirectDeclaratorIdent,
· · · · Token: IDENTIFIER "a",
· · · },
· · },
· },
· InitDeclaratorList: &cc.InitDeclaratorList{
· · Case: 1,
· · InitDeclarator: &cc.InitDeclarator{
· · · Declarator: &cc.Declarator{
· · · · Linkage: LinkageNone,
· · · · Scope: &cc.Scope{ /* recursive/repetitive pointee not shown */ },
· · · · StorageDuration: StorageDurationAutomatic,
· · · · DirectDeclarator: &cc.DirectDeclarator{
· · · · · Case: DirectDeclaratorIdent,
· · · · · Token: IDENTIFIER "b",
· · · · },
· · · },
· · },
· · Token: ',',
· },
}

func (*InitDeclaratorList) Pos

func (n *InitDeclaratorList) Pos() token.Pos

Pos reports the position of the first component of n or zero if it's empty.

func (*InitDeclaratorList) String

func (n *InitDeclaratorList) String() string

String implements fmt.Stringer.

type InitDeclaratorListOpt

type InitDeclaratorListOpt struct {
	InitDeclaratorList *InitDeclaratorList
}

InitDeclaratorListOpt represents data reduced by productions:

InitDeclaratorListOpt:
        /* empty */         // Case 0
|       InitDeclaratorList  // Case 1
Example (Case0)
fmt.Println(exampleAST(84, "\U00100001 auto ;") == (*InitDeclaratorListOpt)(nil))
Output:

true
Example (Case1)
fmt.Println(exampleAST(85, "\U00100001 auto a ;"))
Output:

&cc.InitDeclaratorListOpt{
· InitDeclaratorList: &cc.InitDeclaratorList{
· · InitDeclarator: &cc.InitDeclarator{
· · · Declarator: &cc.Declarator{
· · · · Linkage: LinkageNone,
· · · · StorageDuration: StorageDurationAutomatic,
· · · · DirectDeclarator: &cc.DirectDeclarator{
· · · · · Case: DirectDeclaratorIdent,
· · · · · Token: IDENTIFIER "a",
· · · · },
· · · },
· · },
· },
}

func (*InitDeclaratorListOpt) Pos

func (n *InitDeclaratorListOpt) Pos() token.Pos

Pos reports the position of the first component of n or zero if it's empty.

func (*InitDeclaratorListOpt) String

func (n *InitDeclaratorListOpt) String() string

String implements fmt.Stringer.

type Initializer

type Initializer struct {
	Case            InitializerCase
	CommaOpt        *CommaOpt
	Expr            *Expr
	InitializerList *InitializerList
	Token           xc.Token
	Token2          xc.Token
}

Initializer represents data reduced by productions:

Initializer:
        '{' InitializerList CommaOpt '}'  // Case InitializerCompLit
|       Expr                              // Case InitializerExpr
Example (CompLit)
fmt.Println(exampleAST(191, "\U00100001 auto a = { } ,"))
Output:

&cc.Initializer{
· Token: '{',
· Token2: '}',
}
Example (Expr)
fmt.Println(exampleAST(192, "\U00100001 auto a = 'b' ,"))
Output:

&cc.Initializer{
· Case: 1,
· Expr: &cc.Expr{
· · Case: ExprChar,
· · Token: CHARCONST "'b'",
· },
}

func (*Initializer) Pos

func (n *Initializer) Pos() token.Pos

Pos reports the position of the first component of n or zero if it's empty.

func (*Initializer) String

func (n *Initializer) String() string

String implements fmt.Stringer.

type InitializerCase

type InitializerCase int

InitializerCase represents case numbers of production Initializer

const (
	InitializerCompLit InitializerCase = iota
	InitializerExpr
)

Values of type InitializerCase

func (InitializerCase) String

func (n InitializerCase) String() string

String implements fmt.Stringer

type InitializerList

type InitializerList struct {
	Operand         Operand //TODO-
	Len             int
	Case            int
	Designation     *Designation
	Initializer     *Initializer
	InitializerList *InitializerList
	Token           xc.Token
}

InitializerList represents data reduced by productions:

InitializerList:
        /* empty */                                  // Case 0
|       Initializer                                  // Case 1
|       Designation Initializer                      // Case 2
|       InitializerList ',' Initializer              // Case 3
|       InitializerList ',' Designation Initializer  // Case 4
Example (Case0)
fmt.Println(exampleAST(193, "\U00100000 ( _Bool ) { ,") == (*InitializerList)(nil))
Output:

true
Example (Case1)
fmt.Println(exampleAST(194, "\U00100000 ( _Bool ) { 'a' ,"))
Output:

&cc.InitializerList{
· Case: 1,
· Initializer: &cc.Initializer{
· · Case: 1,
· · Expr: &cc.Expr{
· · · Case: ExprChar,
· · · Token: CHARCONST "'a'",
· · },
· },
}
Example (Case2)
fmt.Println(exampleAST(195, "\U00100001 auto a = { . b = 'c' ,"))
Output:

&cc.InitializerList{
· Case: 2,
· Designation: &cc.Designation{
· · DesignatorList: &cc.DesignatorList{
· · · Designator: &cc.Designator{
· · · · Token: '.',
· · · · Token2: IDENTIFIER "b",
· · · },
· · },
· · Token: '=',
· },
· Initializer: &cc.Initializer{
· · Case: 1,
· · Expr: &cc.Expr{
· · · Case: ExprChar,
· · · Token: CHARCONST "'c'",
· · },
· },
}
Example (Case3)
fmt.Println(exampleAST(196, "\U00100001 auto a = { , 'b' ,"))
Output:

&cc.InitializerList{
· Case: 3,
· Initializer: &cc.Initializer{
· · Case: 1,
· · Expr: &cc.Expr{
· · · Case: ExprChar,
· · · Token: CHARCONST "'b'",
· · },
· },
· Token: ',',
}
Example (Case4)
fmt.Println(exampleAST(197, "\U00100001 auto a = { , . b = 'c' ,"))
Output:

&cc.InitializerList{
· Case: 4,
· Designation: &cc.Designation{
· · DesignatorList: &cc.DesignatorList{
· · · Designator: &cc.Designator{
· · · · Token: '.',
· · · · Token2: IDENTIFIER "b",
· · · },
· · },
· · Token: '=',
· },
· Initializer: &cc.Initializer{
· · Case: 1,
· · Expr: &cc.Expr{
· · · Case: ExprChar,
· · · Token: CHARCONST "'c'",
· · },
· },
· Token: ',',
}

func (*InitializerList) Pos

func (n *InitializerList) Pos() token.Pos

Pos reports the position of the first component of n or zero if it's empty.

func (*InitializerList) String

func (n *InitializerList) String() string

String implements fmt.Stringer.

type IterationStmt

type IterationStmt struct {
	Case         IterationStmtCase
	Declaration  *Declaration
	ExprList     *ExprList
	ExprListOpt  *ExprListOpt
	ExprListOpt2 *ExprListOpt
	ExprListOpt3 *ExprListOpt
	Stmt         *Stmt
	Token        xc.Token
	Token2       xc.Token
	Token3       xc.Token
	Token4       xc.Token
	Token5       xc.Token
}

IterationStmt represents data reduced by productions:

IterationStmt:
        "do" Stmt "while" '(' ExprList ')' ';'                          // Case IterationStmtDo
|       "for" '(' Declaration ExprListOpt ';' ExprListOpt ')' Stmt      // Case IterationStmtForDecl
|       "for" '(' ExprListOpt ';' ExprListOpt ';' ExprListOpt ')' Stmt  // Case IterationStmtFor
|       "while" '(' ExprList ')' Stmt                                   // Case IterationStmtWhile
Example (Do)
fmt.Println(exampleAST(225, "\U00100001 a { do ; while ( 'b' ) ; !"))
Output:

&cc.IterationStmt{
· ExprList: &cc.ExprList{
· · Expr: &cc.Expr{
· · · Case: ExprChar,
· · · Token: CHARCONST "'b'",
· · },
· },
· Stmt: &cc.Stmt{
· · Case: 1,
· · ExprStmt: &cc.ExprStmt{
· · · Token: ';',
· · },
· },
· Token: DO "do",
· Token2: WHILE "while",
· Token3: '(',
· Token4: ')',
· Token5: ';',
}
Example (For)
fmt.Println(exampleAST(227, "\U00100001 a { for ( ; ; ) ; !"))
Output:

&cc.IterationStmt{
· Case: 2,
· Stmt: &cc.Stmt{
· · Case: 1,
· · ExprStmt: &cc.ExprStmt{
· · · Token: ';',
· · },
· },
· Token: FOR "for",
· Token2: '(',
· Token3: ';',
· Token4: ';',
· Token5: ')',
}
Example (ForDecl)
fmt.Println(exampleAST(226, "\U00100001 a { for ( auto ; ; ) ; !"))
Output:

&cc.IterationStmt{
· Case: 1,
· Declaration: &cc.Declaration{
· · Scope: &cc.Scope{
· · · Parent: &cc.Scope{
· · · },
· · },
· · DeclarationSpecifiers: &cc.DeclarationSpecifiers{
· · · Case: 1,
· · · StorageClassSpecifier: &cc.StorageClassSpecifier{
· · · · Token: AUTO "auto",
· · · },
· · },
· · Token: ';',
· },
· Stmt: &cc.Stmt{
· · Case: 1,
· · ExprStmt: &cc.ExprStmt{
· · · Token: ';',
· · },
· },
· Token: FOR "for",
· Token2: '(',
· Token3: ';',
· Token4: ')',
}
Example (While)
fmt.Println(exampleAST(228, "\U00100001 a { while ( 'b' ) ; !"))
Output:

&cc.IterationStmt{
· Case: 3,
· ExprList: &cc.ExprList{
· · Expr: &cc.Expr{
· · · Case: ExprChar,
· · · Token: CHARCONST "'b'",
· · },
· },
· Stmt: &cc.Stmt{
· · Case: 1,
· · ExprStmt: &cc.ExprStmt{
· · · Token: ';',
· · },
· },
· Token: WHILE "while",
· Token2: '(',
· Token3: ')',
}

func (*IterationStmt) Pos

func (n *IterationStmt) Pos() token.Pos

Pos reports the position of the first component of n or zero if it's empty.

func (*IterationStmt) String

func (n *IterationStmt) String() string

String implements fmt.Stringer.

type IterationStmtCase

type IterationStmtCase int

IterationStmtCase represents case numbers of production IterationStmt

const (
	IterationStmtDo IterationStmtCase = iota
	IterationStmtForDecl
	IterationStmtFor
	IterationStmtWhile
)

Values of type IterationStmtCase

func (IterationStmtCase) String

func (n IterationStmtCase) String() string

String implements fmt.Stringer

type JumpStmt

type JumpStmt struct {
	ReturnOperand Operand

	Case        JumpStmtCase
	ExprListOpt *ExprListOpt
	Token       xc.Token
	Token2      xc.Token
	Token3      xc.Token
	// contains filtered or unexported fields
}

JumpStmt represents data reduced by productions:

JumpStmt:
        "break" ';'               // Case JumpStmtBreak
|       "continue" ';'            // Case JumpStmtContinue
|       "goto" IDENTIFIER ';'     // Case JumpStmtGoto
|       "return" ExprListOpt ';'  // Case JumpStmtReturn
Example (Break)
fmt.Println(exampleAST(229, "\U00100001 a { break ; !"))
Output:

&cc.JumpStmt{
· Token: BREAK "break",
· Token2: ';',
}
Example (Continue)
fmt.Println(exampleAST(230, "\U00100001 a { continue ; !"))
Output:

&cc.JumpStmt{
· Case: 1,
· Token: CONTINUE "continue",
· Token2: ';',
}
Example (Goto)
fmt.Println(exampleAST(231, "\U00100001 a { goto b ; !"))
Output:

&cc.JumpStmt{
· Case: 2,
· Token: GOTO "goto",
· Token2: IDENTIFIER "b",
· Token3: ';',
}
Example (Return)
fmt.Println(exampleAST(232, "\U00100001 a { return ; !"))
Output:

&cc.JumpStmt{
· Case: 3,
· Token: RETURN "return",
· Token2: ';',
}

func (*JumpStmt) Pos

func (n *JumpStmt) Pos() token.Pos

Pos reports the position of the first component of n or zero if it's empty.

func (*JumpStmt) String

func (n *JumpStmt) String() string

String implements fmt.Stringer.

type JumpStmtCase

type JumpStmtCase int

JumpStmtCase represents case numbers of production JumpStmt

const (
	JumpStmtBreak JumpStmtCase = iota
	JumpStmtContinue
	JumpStmtGoto
	JumpStmtReturn
)

Values of type JumpStmtCase

func (JumpStmtCase) String

func (n JumpStmtCase) String() string

String implements fmt.Stringer

type LabeledStmt

type LabeledStmt struct {
	Case      LabeledStmtCase
	ConstExpr *ConstExpr
	Stmt      *Stmt
	Token     xc.Token
	Token2    xc.Token
}

LabeledStmt represents data reduced by productions:

LabeledStmt:
        "case" ConstExpr ':' Stmt  // Case LabeledStmtSwitchCase
|       "default" ':' Stmt         // Case LabeledStmtDefault
|       IDENTIFIER ':' Stmt        // Case LabeledStmtLabel
|       TYPEDEF_NAME ':' Stmt      // Case LabeledStmtLabel2
Example (Default)
fmt.Println(exampleAST(210, "\U00100001 a { default : ; !"))
Output:

&cc.LabeledStmt{
· Case: 1,
· Stmt: &cc.Stmt{
· · Case: 1,
· · ExprStmt: &cc.ExprStmt{
· · · Token: ';',
· · },
· },
· Token: DEFAULT "default",
· Token2: ':',
}
Example (Label)
fmt.Println(exampleAST(211, "\U00100001 a { b : ; !"))
Output:

&cc.LabeledStmt{
· Case: 2,
· Stmt: &cc.Stmt{
· · Case: 1,
· · ExprStmt: &cc.ExprStmt{
· · · Token: ';',
· · },
· },
· Token: IDENTIFIER "b",
· Token2: ':',
}
Example (Label2)
fmt.Println(exampleAST(212, "\U00100001 a { typedef name : ; !"))
Output:

TODO: example212.c:1:19: unexpected ':', expected one of [',', ';', '=']
Example (SwitchCase)
fmt.Println(exampleAST(209, "\U00100001 a { case 'b' : ; !"))
Output:

&cc.LabeledStmt{
· ConstExpr: &cc.ConstExpr{
· · Expr: &cc.Expr{
· · · Case: ExprChar,
· · · Token: CHARCONST "'b'",
· · },
· },
· Stmt: &cc.Stmt{
· · Case: 1,
· · ExprStmt: &cc.ExprStmt{
· · · Token: ';',
· · },
· },
· Token: CASE "case",
· Token2: ':',
}

func (*LabeledStmt) Pos

func (n *LabeledStmt) Pos() token.Pos

Pos reports the position of the first component of n or zero if it's empty.

func (*LabeledStmt) String

func (n *LabeledStmt) String() string

String implements fmt.Stringer.

type LabeledStmtCase

type LabeledStmtCase int

LabeledStmtCase represents case numbers of production LabeledStmt

const (
	LabeledStmtSwitchCase LabeledStmtCase = iota
	LabeledStmtDefault
	LabeledStmtLabel
	LabeledStmtLabel2
)

Values of type LabeledStmtCase

func (LabeledStmtCase) String

func (n LabeledStmtCase) String() string

String implements fmt.Stringer

type Linkage

type Linkage int

Linkage describes linkage of identifiers, [0]6.2.2.

const (
	LinkageNone     Linkage = iota
	LinkageInternal Linkage = Linkage(ir.InternalLinkage)
	LinkageExternal Linkage = Linkage(ir.ExternalLinkage)
)

Values of Linkage

func (Linkage) String

func (i Linkage) String() string

type Macro

type Macro struct {
	Args            []int      // Numeric IDs of argument identifiers.
	DefTok          xc.Token   // Macro name definition token.
	ReplacementToks []xc.Token // The tokens that replace the macro. R/O

	IsFnLike   bool // Whether the macro is function like.
	IsVariadic bool // Whether the macro is variadic.
	// contains filtered or unexported fields
}

Macro represents a preprocessor Macro.

func (*Macro) Eval

func (m *Macro) Eval(model Model, macros map[int]*Macro) (op Operand, err error)

Eval attempts to evaluate m, which must be a simple macro, like `#define foo numeric-literal`.

type Model

type Model map[TypeKind]ModelItem

Model describes properties of scalar Types.

func NewModel

func NewModel() (m Model, err error)

NewModel returns the model appropriate for the current OS and architecture or according to the environment variables GOOS and GOARCH, if set.

func (Model) Alignof

func (m Model) Alignof(t Type) int

Alignof computes the memory alignment requirements of t. One is returned for a struct/union type with no fields.

func (Model) Equal

func (m Model) Equal(n Model) bool

Equal returns whether m equals n.

func (Model) Layout

func (m Model) Layout(t Type) (r []FieldProperties)

Layout computes the memory layout of t.

func (Model) Sizeof

func (m Model) Sizeof(t Type) int64

Sizeof returns the size in bytes of a variable of type t.

func (Model) StructAlignof

func (m Model) StructAlignof(t Type) int

StructAlignof computes the memory alignment requirements of t when its instance is a struct field. One is returned for a struct/union type with no fields.

type ModelItem

type ModelItem struct {
	Size        int
	Align       int
	StructAlign int
}

ModelItem describers properties of a particular Type.

type NamedType

type NamedType struct {
	Name int
	Type Type // The type Name refers to.
}

NamedType represents a type described by a typedef name.

func (*NamedType) Equal

func (t *NamedType) Equal(u Type) bool

Equal implements Type.

func (*NamedType) IsArithmeticType

func (t *NamedType) IsArithmeticType() bool

IsArithmeticType implements Type.

func (*NamedType) IsCompatible

func (t *NamedType) IsCompatible(u Type) (r bool)

IsCompatible implements Type.

func (*NamedType) IsIntegerType

func (t *NamedType) IsIntegerType() bool

IsIntegerType implements Type.

func (*NamedType) IsPointerType

func (t *NamedType) IsPointerType() bool

IsPointerType implements Type.

func (*NamedType) IsScalarType

func (t *NamedType) IsScalarType() bool

IsScalarType implements Type.

func (*NamedType) IsUnsigned

func (t *NamedType) IsUnsigned() bool

IsUnsigned implements Type.

func (*NamedType) IsVoidPointerType

func (t *NamedType) IsVoidPointerType() bool

IsVoidPointerType implements Type.

func (*NamedType) Kind

func (t *NamedType) Kind() TypeKind

Kind implements Type.

func (*NamedType) String

func (t *NamedType) String() string

type Node

type Node interface {
	Pos() token.Pos
}

Node represents an AST node.

type Operand

type Operand struct {
	Type Type
	ir.Value
	FieldProperties *FieldProperties

	IsEnumConst bool // Blocks int -> unsigned int promotions. See [0]6.4.4.3/2
}

Operand represents the type and optionally the value of an expression.

func (*Operand) Bits

func (o *Operand) Bits() int

Bits return the width of a bit field operand or zero othewise

func (Operand) ConvertTo

func (o Operand) ConvertTo(m Model, t Type) (r Operand)

ConvertTo converts o to type t.

func (Operand) IsNonZero

func (o Operand) IsNonZero() bool

IsNonZero returns true when the value of o is known to be non-zero.

func (Operand) IsZero

func (o Operand) IsZero() bool

IsZero returns true when the value of o is known to be zero.

func (Operand) String

func (o Operand) String() string

type ParameterDeclaration

type ParameterDeclaration struct {
	AbstractDeclaratorOpt *AbstractDeclaratorOpt
	Case                  ParameterDeclarationCase
	DeclarationSpecifiers *DeclarationSpecifiers
	Declarator            *Declarator
}

ParameterDeclaration represents data reduced by productions:

ParameterDeclaration:
        DeclarationSpecifiers AbstractDeclaratorOpt  // Case ParameterDeclarationAbstract
|       DeclarationSpecifiers Declarator             // Case ParameterDeclarationDeclarator
Example (Abstract)
fmt.Println(exampleAST(168, "\U00100001 a ( auto )"))
Output:

&cc.ParameterDeclaration{
· DeclarationSpecifiers: &cc.DeclarationSpecifiers{
· · Case: 1,
· · StorageClassSpecifier: &cc.StorageClassSpecifier{
· · · Token: AUTO "auto",
· · },
· },
}
Example (Declarator)
fmt.Println(exampleAST(169, "\U00100001 a ( auto b )"))
Output:

&cc.ParameterDeclaration{
· Case: 1,
· DeclarationSpecifiers: &cc.DeclarationSpecifiers{
· · Case: 1,
· · StorageClassSpecifier: &cc.StorageClassSpecifier{
· · · Token: AUTO "auto",
· · },
· },
· Declarator: &cc.Declarator{
· · Linkage: LinkageNone,
· · Scope: &cc.Scope{
· · },
· · StorageDuration: StorageDurationAutomatic,
· · DirectDeclarator: &cc.DirectDeclarator{
· · · Case: DirectDeclaratorIdent,
· · · Token: IDENTIFIER "b",
· · },
· },
}

func (*ParameterDeclaration) Pos

func (n *ParameterDeclaration) Pos() token.Pos

Pos reports the position of the first component of n or zero if it's empty.

func (*ParameterDeclaration) String

func (n *ParameterDeclaration) String() string

String implements fmt.Stringer.

type ParameterDeclarationCase

type ParameterDeclarationCase int

ParameterDeclarationCase represents case numbers of production ParameterDeclaration

const (
	ParameterDeclarationAbstract ParameterDeclarationCase = iota
	ParameterDeclarationDeclarator
)

Values of type ParameterDeclarationCase

func (ParameterDeclarationCase) String

func (n ParameterDeclarationCase) String() string

String implements fmt.Stringer

type ParameterList

type ParameterList struct {
	Case                 int
	ParameterDeclaration *ParameterDeclaration
	ParameterList        *ParameterList
	Token                xc.Token
}

ParameterList represents data reduced by productions:

ParameterList:
        ParameterDeclaration                    // Case 0
|       ParameterList ',' ParameterDeclaration  // Case 1
Example (Case0)
fmt.Println(exampleAST(166, "\U00100001 a ( auto )"))
Output:

&cc.ParameterList{
· ParameterDeclaration: &cc.ParameterDeclaration{
· · DeclarationSpecifiers: &cc.DeclarationSpecifiers{
· · · Case: 1,
· · · StorageClassSpecifier: &cc.StorageClassSpecifier{
· · · · Token: AUTO "auto",
· · · },
· · },
· },
}
Example (Case1)
fmt.Println(exampleAST(167, "\U00100001 a ( auto , auto )"))
Output:

&cc.ParameterList{
· ParameterDeclaration: &cc.ParameterDeclaration{
· · DeclarationSpecifiers: &cc.DeclarationSpecifiers{
· · · Case: 1,
· · · StorageClassSpecifier: &cc.StorageClassSpecifier{
· · · · Token: AUTO "auto",
· · · },
· · },
· },
· ParameterList: &cc.ParameterList{
· · Case: 1,
· · ParameterDeclaration: &cc.ParameterDeclaration{
· · · DeclarationSpecifiers: &cc.DeclarationSpecifiers{
· · · · Case: 1,
· · · · StorageClassSpecifier: &cc.StorageClassSpecifier{
· · · · · Token: AUTO "auto",
· · · · },
· · · },
· · },
· · Token: ',',
· },
}

func (*ParameterList) Pos

func (n *ParameterList) Pos() token.Pos

Pos reports the position of the first component of n or zero if it's empty.

func (*ParameterList) String

func (n *ParameterList) String() string

String implements fmt.Stringer.

type ParameterTypeList

type ParameterTypeList struct {
	Case          ParameterTypeListCase
	ParameterList *ParameterList
	Token         xc.Token
	Token2        xc.Token
}

ParameterTypeList represents data reduced by productions:

ParameterTypeList:
        ParameterList            // Case ParameterTypeListBase
|       ParameterList ',' "..."  // Case ParameterTypeListDots
Example (Base)
fmt.Println(exampleAST(162, "\U00100001 a ( auto )"))
Output:

&cc.ParameterTypeList{
· ParameterList: &cc.ParameterList{
· · ParameterDeclaration: &cc.ParameterDeclaration{
· · · DeclarationSpecifiers: &cc.DeclarationSpecifiers{
· · · · Case: 1,
· · · · StorageClassSpecifier: &cc.StorageClassSpecifier{
· · · · · Token: AUTO "auto",
· · · · },
· · · },
· · },
· },
}
Example (Dots)
fmt.Println(exampleAST(163, "\U00100001 a ( auto , ... )"))
Output:

&cc.ParameterTypeList{
· Case: 1,
· ParameterList: &cc.ParameterList{
· · ParameterDeclaration: &cc.ParameterDeclaration{
· · · DeclarationSpecifiers: &cc.DeclarationSpecifiers{
· · · · Case: 1,
· · · · StorageClassSpecifier: &cc.StorageClassSpecifier{
· · · · · Token: AUTO "auto",
· · · · },
· · · },
· · },
· },
· Token: ',',
· Token2: DDD,
}

func (*ParameterTypeList) Pos

func (n *ParameterTypeList) Pos() token.Pos

Pos reports the position of the first component of n or zero if it's empty.

func (*ParameterTypeList) String

func (n *ParameterTypeList) String() string

String implements fmt.Stringer.

type ParameterTypeListCase

type ParameterTypeListCase int

ParameterTypeListCase represents case numbers of production ParameterTypeList

const (
	ParameterTypeListBase ParameterTypeListCase = iota
	ParameterTypeListDots
)

Values of type ParameterTypeListCase

func (ParameterTypeListCase) String

func (n ParameterTypeListCase) String() string

String implements fmt.Stringer

type ParameterTypeListOpt

type ParameterTypeListOpt struct {
	ParameterTypeList *ParameterTypeList
}

ParameterTypeListOpt represents data reduced by productions:

ParameterTypeListOpt:
        /* empty */        // Case 0
|       ParameterTypeList  // Case 1
Example (Case0)
fmt.Println(exampleAST(164, "\U00100000 ( _Bool ( )") == (*ParameterTypeListOpt)(nil))
Output:

true
Example (Case1)
fmt.Println(exampleAST(165, "\U00100000 ( _Bool ( auto )"))
Output:

&cc.ParameterTypeListOpt{
· ParameterTypeList: &cc.ParameterTypeList{
· · ParameterList: &cc.ParameterList{
· · · ParameterDeclaration: &cc.ParameterDeclaration{
· · · · DeclarationSpecifiers: &cc.DeclarationSpecifiers{
· · · · · Case: 1,
· · · · · StorageClassSpecifier: &cc.StorageClassSpecifier{
· · · · · · Token: AUTO "auto",
· · · · · },
· · · · },
· · · },
· · },
· },
}

func (*ParameterTypeListOpt) Pos

func (n *ParameterTypeListOpt) Pos() token.Pos

Pos reports the position of the first component of n or zero if it's empty.

func (*ParameterTypeListOpt) String

func (n *ParameterTypeListOpt) String() string

String implements fmt.Stringer.

type Pointer

type Pointer struct {
	Case                 PointerCase
	Pointer              *Pointer
	Token                xc.Token
	TypeQualifierListOpt *TypeQualifierListOpt
}

Pointer represents data reduced by productions:

Pointer:
        '*' TypeQualifierListOpt          // Case PointerBase
|       '*' TypeQualifierListOpt Pointer  // Case PointerPtr
Example (Base)
fmt.Println(exampleAST(154, "\U00100001 * ("))
Output:

&cc.Pointer{
· Token: '*',
}
Example (Ptr)
fmt.Println(exampleAST(155, "\U00100001 * * ("))
Output:

&cc.Pointer{
· Case: 1,
· Pointer: &cc.Pointer{
· · Token: '*',
· },
· Token: '*',
}

func (*Pointer) Pos

func (n *Pointer) Pos() token.Pos

Pos reports the position of the first component of n or zero if it's empty.

func (*Pointer) String

func (n *Pointer) String() string

String implements fmt.Stringer.

type PointerCase

type PointerCase int

PointerCase represents case numbers of production Pointer

const (
	PointerBase PointerCase = iota
	PointerPtr
)

Values of type PointerCase

func (PointerCase) String

func (n PointerCase) String() string

String implements fmt.Stringer

type PointerOpt

type PointerOpt struct {
	Pointer *Pointer
}

PointerOpt represents data reduced by productions:

PointerOpt:
        /* empty */  // Case 0
|       Pointer      // Case 1
Example (Case0)
fmt.Println(exampleAST(156, "\U00100001 (") == (*PointerOpt)(nil))
Output:

true
Example (Case1)
fmt.Println(exampleAST(157, "\U00100001 * ("))
Output:

&cc.PointerOpt{
· Pointer: &cc.Pointer{
· · Token: '*',
· },
}

func (*PointerOpt) Pos

func (n *PointerOpt) Pos() token.Pos

Pos reports the position of the first component of n or zero if it's empty.

func (*PointerOpt) String

func (n *PointerOpt) String() string

String implements fmt.Stringer.

type PointerType

type PointerType struct {
	Item Type
}

PointerType represents a pointer type.

func (*PointerType) Equal

func (t *PointerType) Equal(u Type) bool

Equal implements Type.

func (*PointerType) IsArithmeticType

func (t *PointerType) IsArithmeticType() bool

IsArithmeticType implements Type.

func (*PointerType) IsCompatible

func (t *PointerType) IsCompatible(u Type) bool

IsCompatible implements Type.

func (*PointerType) IsIntegerType

func (t *PointerType) IsIntegerType() bool

IsIntegerType implements Type.

func (*PointerType) IsPointerType

func (t *PointerType) IsPointerType() bool

IsPointerType implements Type.

func (*PointerType) IsScalarType

func (t *PointerType) IsScalarType() bool

IsScalarType implements Type.

func (*PointerType) IsUnsigned

func (t *PointerType) IsUnsigned() bool

IsUnsigned implements Type.

func (*PointerType) IsVoidPointerType

func (t *PointerType) IsVoidPointerType() bool

IsVoidPointerType implements Type.

func (*PointerType) Kind

func (t *PointerType) Kind() TypeKind

Kind implements Type.

func (*PointerType) String

func (t *PointerType) String() string

type Scope

type Scope struct {
	EnumTags   map[int]*EnumSpecifier // name ID: *EnumSpecifier
	Idents     map[int]Node           // name ID: Node in {*Declarator, EnumerationConstant}
	Labels     map[int]*LabeledStmt   // name ID: label
	Parent     *Scope
	StructTags map[int]*StructOrUnionSpecifier // name ID: *StructOrUnionSpecifier
	// contains filtered or unexported fields
}

Scope binds names to declarations.

func (*Scope) LookupIdent

func (s *Scope) LookupIdent(nm int) Node

LookupIdent will return the Node associated with name ID nm.

func (*Scope) LookupLabel

func (s *Scope) LookupLabel(nm int) Node

LookupLabel will return the Node associated with label ID nm.

func (*Scope) String

func (s *Scope) String() string

type SelectionStmt

type SelectionStmt struct {
	Cases    []*LabeledStmt
	SwitchOp Operand // Promoted switch operand
	Case     SelectionStmtCase
	ExprList *ExprList
	Stmt     *Stmt
	Stmt2    *Stmt
	Token    xc.Token
	Token2   xc.Token
	Token3   xc.Token
	Token4   xc.Token
}

SelectionStmt represents data reduced by productions:

SelectionStmt:
        "if" '(' ExprList ')' Stmt "else" Stmt  // Case SelectionStmtIfElse
|       "if" '(' ExprList ')' Stmt              // Case SelectionStmtIf
|       "switch" '(' ExprList ')' Stmt          // Case SelectionStmtSwitch
Example (If)
fmt.Println(exampleAST(223, "\U00100001 a { if ( 'b' ) ; !"))
Output:

&cc.SelectionStmt{
· Case: 1,
· ExprList: &cc.ExprList{
· · Expr: &cc.Expr{
· · · Case: ExprChar,
· · · Token: CHARCONST "'b'",
· · },
· },
· Stmt: &cc.Stmt{
· · Case: 1,
· · ExprStmt: &cc.ExprStmt{
· · · Token: ';',
· · },
· },
· Token: IF "if",
· Token2: '(',
· Token3: ')',
}
Example (IfElse)
fmt.Println(exampleAST(222, "\U00100001 a { if ( 'b' ) ; else ; !"))
Output:

&cc.SelectionStmt{
· ExprList: &cc.ExprList{
· · Expr: &cc.Expr{
· · · Case: ExprChar,
· · · Token: CHARCONST "'b'",
· · },
· },
· Stmt: &cc.Stmt{
· · Case: 1,
· · ExprStmt: &cc.ExprStmt{
· · · Token: ';',
· · },
· },
· Stmt2: &cc.Stmt{
· · Case: 1,
· · ExprStmt: &cc.ExprStmt{
· · · Token: ';',
· · },
· },
· Token: IF "if",
· Token2: '(',
· Token3: ')',
· Token4: ELSE "else",
}
Example (Switch)
fmt.Println(exampleAST(224, "\U00100001 a { switch ( 'b' ) ; !"))
Output:

&cc.SelectionStmt{
· Case: 2,
· ExprList: &cc.ExprList{
· · Expr: &cc.Expr{
· · · Case: ExprChar,
· · · Token: CHARCONST "'b'",
· · },
· },
· Stmt: &cc.Stmt{
· · Case: 1,
· · ExprStmt: &cc.ExprStmt{
· · · Token: ';',
· · },
· },
· Token: SWITCH "switch",
· Token2: '(',
· Token3: ')',
}

func (*SelectionStmt) Pos

func (n *SelectionStmt) Pos() token.Pos

Pos reports the position of the first component of n or zero if it's empty.

func (*SelectionStmt) String

func (n *SelectionStmt) String() string

String implements fmt.Stringer.

type SelectionStmtCase

type SelectionStmtCase int

SelectionStmtCase represents case numbers of production SelectionStmt

const (
	SelectionStmtIfElse SelectionStmtCase = iota
	SelectionStmtIf
	SelectionStmtSwitch
)

Values of type SelectionStmtCase

func (SelectionStmtCase) String

func (n SelectionStmtCase) String() string

String implements fmt.Stringer

type Source

type Source interface {
	Cache([]uint32)                     // Optionally cache the encoded source. Can be a no-operation.
	Cached() []uint32                   // Return nil or the optionally encoded source cached by earlier call to Cache.
	Name() string                       // Result will be used in reporting source code positions.
	ReadCloser() (io.ReadCloser, error) // Where to read the source from
	Size() (int64, error)               // Report the size of the source in bytes.
	String() string
}

Source represents parser's input.

func Builtin

func Builtin() (Source, error)

Builtin returns the Source for built-in and predefined stuff or an error, if any.

func Crt0

func Crt0() (Source, error)

Crt0 returns the Source for program initialization code.

func MustBuiltin

func MustBuiltin() Source

MustBuiltin is like Builtin but panics on error.

func MustCrt0

func MustCrt0() Source

MustCrt0 is like Crt0 but panics on error.

type SpecifierQualifierList

type SpecifierQualifierList struct {
	Case                      SpecifierQualifierListCase
	SpecifierQualifierListOpt *SpecifierQualifierListOpt
	TypeQualifier             *TypeQualifier
	TypeSpecifier             *TypeSpecifier
}

SpecifierQualifierList represents data reduced by productions:

SpecifierQualifierList:
        TypeQualifier SpecifierQualifierListOpt  // Case SpecifierQualifierListQualifier
|       TypeSpecifier SpecifierQualifierListOpt  // Case SpecifierQualifierListSpecifier
Example (Qualifier)
fmt.Println(exampleAST(121, "\U00100000 ( const ("))
Output:

&cc.SpecifierQualifierList{
· TypeQualifier: &cc.TypeQualifier{
· · Token: CONST "const",
· },
}
Example (Specifier)
fmt.Println(exampleAST(122, "\U00100000 ( _Bool ("))
Output:

&cc.SpecifierQualifierList{
· Case: 1,
· TypeSpecifier: &cc.TypeSpecifier{
· · Token: BOOL "_Bool",
· },
}

func (*SpecifierQualifierList) Pos

func (n *SpecifierQualifierList) Pos() token.Pos

Pos reports the position of the first component of n or zero if it's empty.

func (*SpecifierQualifierList) String

func (n *SpecifierQualifierList) String() string

String implements fmt.Stringer.

type SpecifierQualifierListCase

type SpecifierQualifierListCase int

SpecifierQualifierListCase represents case numbers of production SpecifierQualifierList

const (
	SpecifierQualifierListQualifier SpecifierQualifierListCase = iota
	SpecifierQualifierListSpecifier
)

Values of type SpecifierQualifierListCase

func (SpecifierQualifierListCase) String

String implements fmt.Stringer

type SpecifierQualifierListOpt

type SpecifierQualifierListOpt struct {
	SpecifierQualifierList *SpecifierQualifierList
}

SpecifierQualifierListOpt represents data reduced by productions:

SpecifierQualifierListOpt:
        /* empty */             // Case 0
|       SpecifierQualifierList  // Case 1
Example (Case0)
fmt.Println(exampleAST(123, "\U00100000 ( const (") == (*SpecifierQualifierListOpt)(nil))
Output:

true
Example (Case1)
fmt.Println(exampleAST(124, "\U00100000 ( const _Bool ("))
Output:

&cc.SpecifierQualifierListOpt{
· SpecifierQualifierList: &cc.SpecifierQualifierList{
· · Case: 1,
· · TypeSpecifier: &cc.TypeSpecifier{
· · · Token: BOOL "_Bool",
· · },
· },
}

func (*SpecifierQualifierListOpt) Pos

Pos reports the position of the first component of n or zero if it's empty.

func (*SpecifierQualifierListOpt) String

func (n *SpecifierQualifierListOpt) String() string

String implements fmt.Stringer.

type Stmt

type Stmt struct {
	Case          StmtCase
	CompoundStmt  *CompoundStmt
	ExprStmt      *ExprStmt
	IterationStmt *IterationStmt
	JumpStmt      *JumpStmt
	LabeledStmt   *LabeledStmt
	SelectionStmt *SelectionStmt
}

Stmt represents data reduced by productions:

Stmt:
        CompoundStmt   // Case StmtBlock
|       ExprStmt       // Case StmtExpr
|       IterationStmt  // Case StmtIter
|       JumpStmt       // Case StmtJump
|       LabeledStmt    // Case StmtLabeled
|       SelectionStmt  // Case StmtSelect
Example (Block)
fmt.Println(exampleAST(203, "\U00100001 a { { } !"))
Output:

&cc.Stmt{
· CompoundStmt: &cc.CompoundStmt{
· · Token: '{',
· · Token2: '}',
· },
}
Example (Expr)
fmt.Println(exampleAST(204, "\U00100001 a { ; !"))
Output:

&cc.Stmt{
· Case: 1,
· ExprStmt: &cc.ExprStmt{
· · Token: ';',
· },
}
Example (Iter)
fmt.Println(exampleAST(205, "\U00100001 a { while ( 'b' ) ; !"))
Output:

&cc.Stmt{
· Case: 2,
· IterationStmt: &cc.IterationStmt{
· · Case: 3,
· · ExprList: &cc.ExprList{
· · · Expr: &cc.Expr{
· · · · Case: ExprChar,
· · · · Token: CHARCONST "'b'",
· · · },
· · },
· · Stmt: &cc.Stmt{
· · · Case: 1,
· · · ExprStmt: &cc.ExprStmt{
· · · · Token: ';',
· · · },
· · },
· · Token: WHILE "while",
· · Token2: '(',
· · Token3: ')',
· },
}
Example (Jump)
fmt.Println(exampleAST(206, "\U00100001 a { break ; !"))
Output:

&cc.Stmt{
· Case: 3,
· JumpStmt: &cc.JumpStmt{
· · Token: BREAK "break",
· · Token2: ';',
· },
}
Example (Labeled)
fmt.Println(exampleAST(207, "\U00100001 a { default : ; !"))
Output:

&cc.Stmt{
· Case: 4,
· LabeledStmt: &cc.LabeledStmt{
· · Case: 1,
· · Stmt: &cc.Stmt{
· · · Case: 1,
· · · ExprStmt: &cc.ExprStmt{
· · · · Token: ';',
· · · },
· · },
· · Token: DEFAULT "default",
· · Token2: ':',
· },
}
Example (Select)
fmt.Println(exampleAST(208, "\U00100001 a { if ( 'b' ) ; !"))
Output:

&cc.Stmt{
· Case: 5,
· SelectionStmt: &cc.SelectionStmt{
· · Case: 1,
· · ExprList: &cc.ExprList{
· · · Expr: &cc.Expr{
· · · · Case: ExprChar,
· · · · Token: CHARCONST "'b'",
· · · },
· · },
· · Stmt: &cc.Stmt{
· · · Case: 1,
· · · ExprStmt: &cc.ExprStmt{
· · · · Token: ';',
· · · },
· · },
· · Token: IF "if",
· · Token2: '(',
· · Token3: ')',
· },
}

func (*Stmt) Pos

func (n *Stmt) Pos() token.Pos

Pos reports the position of the first component of n or zero if it's empty.

func (*Stmt) String

func (n *Stmt) String() string

String implements fmt.Stringer.

type StmtCase

type StmtCase int

StmtCase represents case numbers of production Stmt

const (
	StmtBlock StmtCase = iota
	StmtExpr
	StmtIter
	StmtJump
	StmtLabeled
	StmtSelect
)

Values of type StmtCase

func (StmtCase) String

func (n StmtCase) String() string

String implements fmt.Stringer

type StorageClassSpecifier

type StorageClassSpecifier struct {
	Case  StorageClassSpecifierCase
	Token xc.Token
}

StorageClassSpecifier represents data reduced by productions:

StorageClassSpecifier:
        "auto"      // Case StorageClassSpecifierAuto
|       "extern"    // Case StorageClassSpecifierExtern
|       "register"  // Case StorageClassSpecifierRegister
|       "static"    // Case StorageClassSpecifierStatic
|       "typedef"   // Case StorageClassSpecifierTypedef
Example (Auto)
fmt.Println(exampleAST(88, "\U00100001 auto ("))
Output:

&cc.StorageClassSpecifier{
· Token: AUTO "auto",
}
Example (Extern)
fmt.Println(exampleAST(89, "\U00100001 extern ("))
Output:

&cc.StorageClassSpecifier{
· Case: 1,
· Token: EXTERN "extern",
}
Example (Register)
fmt.Println(exampleAST(90, "\U00100001 register ("))
Output:

&cc.StorageClassSpecifier{
· Case: 2,
· Token: REGISTER "register",
}
Example (Static)
fmt.Println(exampleAST(91, "\U00100001 static ("))
Output:

&cc.StorageClassSpecifier{
· Case: 3,
· Token: STATIC "static",
}
Example (Typedef)
fmt.Println(exampleAST(92, "\U00100001 typedef ("))
Output:

&cc.StorageClassSpecifier{
· Case: 4,
· Token: TYPEDEF "typedef",
}

func (*StorageClassSpecifier) Pos

func (n *StorageClassSpecifier) Pos() token.Pos

Pos reports the position of the first component of n or zero if it's empty.

func (*StorageClassSpecifier) String

func (n *StorageClassSpecifier) String() string

String implements fmt.Stringer.

type StorageClassSpecifierCase

type StorageClassSpecifierCase int

StorageClassSpecifierCase represents case numbers of production StorageClassSpecifier

const (
	StorageClassSpecifierAuto StorageClassSpecifierCase = iota
	StorageClassSpecifierExtern
	StorageClassSpecifierRegister
	StorageClassSpecifierStatic
	StorageClassSpecifierTypedef
)

Values of type StorageClassSpecifierCase

func (StorageClassSpecifierCase) String

func (n StorageClassSpecifierCase) String() string

String implements fmt.Stringer

type StorageDuration

type StorageDuration int

StorageDuration describes lifetime of an object, [0]6.2.4.

const (
	StorageDurationAutomatic StorageDuration = iota
	StorageDurationStatic
)

Values of StorageDuration

func (StorageDuration) String

func (i StorageDuration) String() string

type StringSource

type StringSource struct {
	*strings.Reader
	// contains filtered or unexported fields
}

StringSource is a Source reading from a string.

func NewStringSource

func NewStringSource(name, src string) *StringSource

NewStringSource returns a newly created *StringSource reading from src and having the presumed name.

func (*StringSource) Cache

func (s *StringSource) Cache(a []uint32)

Cache implements Source.

func (*StringSource) Cached

func (s *StringSource) Cached() (r []uint32)

Cached implements Source.

func (*StringSource) Close

func (s *StringSource) Close() error

Close implements io.ReadCloser.

func (*StringSource) Name

func (s *StringSource) Name() string

Name implements Source.

func (*StringSource) ReadCloser

func (s *StringSource) ReadCloser() (io.ReadCloser, error)

ReadCloser implements Source.

func (*StringSource) Size

func (s *StringSource) Size() (int64, error)

Size implements Source.

func (*StringSource) String

func (s *StringSource) String() string

type StructDeclaration

type StructDeclaration struct {
	Case                   StructDeclarationCase
	SpecifierQualifierList *SpecifierQualifierList
	StructDeclaratorList   *StructDeclaratorList
	Token                  xc.Token
}

StructDeclaration represents data reduced by productions:

StructDeclaration:
        SpecifierQualifierList StructDeclaratorList ';'  // Case StructDeclarationBase
|       SpecifierQualifierList ';'                       // Case StructDeclarationAnon
Example (Anon)
fmt.Println(exampleAST(120, "\U00100001 struct { _Bool ; }"))
Output:

&cc.StructDeclaration{
· Case: 1,
· SpecifierQualifierList: &cc.SpecifierQualifierList{
· · Case: 1,
· · TypeSpecifier: &cc.TypeSpecifier{
· · · Token: BOOL "_Bool",
· · },
· },
· Token: ';',
}
Example (Base)
fmt.Println(exampleAST(119, "\U00100001 struct { _Bool a ; }"))
Output:

&cc.StructDeclaration{
· SpecifierQualifierList: &cc.SpecifierQualifierList{
· · Case: 1,
· · TypeSpecifier: &cc.TypeSpecifier{
· · · Token: BOOL "_Bool",
· · },
· },
· StructDeclaratorList: &cc.StructDeclaratorList{
· · StructDeclarator: &cc.StructDeclarator{
· · · Declarator: &cc.Declarator{
· · · · Linkage: LinkageNone,
· · · · Scope: &cc.Scope{
· · · · },
· · · · StorageDuration: StorageDurationAutomatic,
· · · · DirectDeclarator: &cc.DirectDeclarator{
· · · · · Case: DirectDeclaratorIdent,
· · · · · Token: IDENTIFIER "a",
· · · · },
· · · },
· · },
· },
· Token: ';',
}

func (*StructDeclaration) Pos

func (n *StructDeclaration) Pos() token.Pos

Pos reports the position of the first component of n or zero if it's empty.

func (*StructDeclaration) String

func (n *StructDeclaration) String() string

String implements fmt.Stringer.

type StructDeclarationCase

type StructDeclarationCase int

StructDeclarationCase represents case numbers of production StructDeclaration

const (
	StructDeclarationBase StructDeclarationCase = iota
	StructDeclarationAnon
)

Values of type StructDeclarationCase

func (StructDeclarationCase) String

func (n StructDeclarationCase) String() string

String implements fmt.Stringer

type StructDeclarationList

type StructDeclarationList struct {
	Case                  int
	StructDeclaration     *StructDeclaration
	StructDeclarationList *StructDeclarationList
}

StructDeclarationList represents data reduced by productions:

StructDeclarationList:
        StructDeclaration                        // Case 0
|       StructDeclarationList StructDeclaration  // Case 1
Example (Case0)
fmt.Println(exampleAST(117, "\U00100001 struct { _Bool ; }"))
Output:

&cc.StructDeclarationList{
· StructDeclaration: &cc.StructDeclaration{
· · Case: 1,
· · SpecifierQualifierList: &cc.SpecifierQualifierList{
· · · Case: 1,
· · · TypeSpecifier: &cc.TypeSpecifier{
· · · · Token: BOOL "_Bool",
· · · },
· · },
· · Token: ';',
· },
}
Example (Case1)
fmt.Println(exampleAST(118, "\U00100001 struct { _Bool ; _Bool ; }"))
Output:

&cc.StructDeclarationList{
· StructDeclaration: &cc.StructDeclaration{
· · Case: 1,
· · SpecifierQualifierList: &cc.SpecifierQualifierList{
· · · Case: 1,
· · · TypeSpecifier: &cc.TypeSpecifier{
· · · · Token: BOOL "_Bool",
· · · },
· · },
· · Token: ';',
· },
· StructDeclarationList: &cc.StructDeclarationList{
· · Case: 1,
· · StructDeclaration: &cc.StructDeclaration{
· · · Case: 1,
· · · SpecifierQualifierList: &cc.SpecifierQualifierList{
· · · · Case: 1,
· · · · TypeSpecifier: &cc.TypeSpecifier{
· · · · · Token: BOOL "_Bool",
· · · · },
· · · },
· · · Token: ';',
· · },
· },
}

func (*StructDeclarationList) Pos

func (n *StructDeclarationList) Pos() token.Pos

Pos reports the position of the first component of n or zero if it's empty.

func (*StructDeclarationList) String

func (n *StructDeclarationList) String() string

String implements fmt.Stringer.

type StructDeclarator

type StructDeclarator struct {
	Bits          int
	Case          StructDeclaratorCase
	ConstExpr     *ConstExpr
	Declarator    *Declarator
	DeclaratorOpt *DeclaratorOpt
	Token         xc.Token
}

StructDeclarator represents data reduced by productions:

StructDeclarator:
        Declarator                   // Case StructDeclaratorBase
|       DeclaratorOpt ':' ConstExpr  // Case StructDeclaratorBits
Example (Base)
fmt.Println(exampleAST(127, "\U00100001 struct { _Bool a ,"))
Output:

&cc.StructDeclarator{
· Declarator: &cc.Declarator{
· · Linkage: LinkageNone,
· · Scope: &cc.Scope{
· · },
· · StorageDuration: StorageDurationAutomatic,
· · DirectDeclarator: &cc.DirectDeclarator{
· · · Case: DirectDeclaratorIdent,
· · · Token: IDENTIFIER "a",
· · },
· },
}
Example (Bits)
fmt.Println(exampleAST(128, "\U00100001 struct { _Bool : 'a' ,"))
Output:

&cc.StructDeclarator{
· Case: 1,
· ConstExpr: &cc.ConstExpr{
· · Expr: &cc.Expr{
· · · Case: ExprChar,
· · · Token: CHARCONST "'a'",
· · },
· },
· Token: ':',
}

func (*StructDeclarator) Pos

func (n *StructDeclarator) Pos() token.Pos

Pos reports the position of the first component of n or zero if it's empty.

func (*StructDeclarator) String

func (n *StructDeclarator) String() string

String implements fmt.Stringer.

type StructDeclaratorCase

type StructDeclaratorCase int

StructDeclaratorCase represents case numbers of production StructDeclarator

const (
	StructDeclaratorBase StructDeclaratorCase = iota
	StructDeclaratorBits
)

Values of type StructDeclaratorCase

func (StructDeclaratorCase) String

func (n StructDeclaratorCase) String() string

String implements fmt.Stringer

type StructDeclaratorList

type StructDeclaratorList struct {
	Case                 int
	StructDeclarator     *StructDeclarator
	StructDeclaratorList *StructDeclaratorList
	Token                xc.Token
}

StructDeclaratorList represents data reduced by productions:

StructDeclaratorList:
        StructDeclarator                           // Case 0
|       StructDeclaratorList ',' StructDeclarator  // Case 1
Example (Case0)
fmt.Println(exampleAST(125, "\U00100001 struct { _Bool a ,"))
Output:

&cc.StructDeclaratorList{
· StructDeclarator: &cc.StructDeclarator{
· · Declarator: &cc.Declarator{
· · · Linkage: LinkageNone,
· · · Scope: &cc.Scope{
· · · },
· · · StorageDuration: StorageDurationAutomatic,
· · · DirectDeclarator: &cc.DirectDeclarator{
· · · · Case: DirectDeclaratorIdent,
· · · · Token: IDENTIFIER "a",
· · · },
· · },
· },
}
Example (Case1)
fmt.Println(exampleAST(126, "\U00100001 struct { _Bool a , b ,"))
Output:

&cc.StructDeclaratorList{
· StructDeclarator: &cc.StructDeclarator{
· · Declarator: &cc.Declarator{
· · · Linkage: LinkageNone,
· · · Scope: &cc.Scope{
· · · },
· · · StorageDuration: StorageDurationAutomatic,
· · · DirectDeclarator: &cc.DirectDeclarator{
· · · · Case: DirectDeclaratorIdent,
· · · · Token: IDENTIFIER "a",
· · · },
· · },
· },
· StructDeclaratorList: &cc.StructDeclaratorList{
· · Case: 1,
· · StructDeclarator: &cc.StructDeclarator{
· · · Declarator: &cc.Declarator{
· · · · Linkage: LinkageNone,
· · · · Scope: &cc.Scope{ /* recursive/repetitive pointee not shown */ },
· · · · StorageDuration: StorageDurationAutomatic,
· · · · DirectDeclarator: &cc.DirectDeclarator{
· · · · · Case: DirectDeclaratorIdent,
· · · · · Token: IDENTIFIER "b",
· · · · },
· · · },
· · },
· · Token: ',',
· },
}

func (*StructDeclaratorList) Pos

func (n *StructDeclaratorList) Pos() token.Pos

Pos reports the position of the first component of n or zero if it's empty.

func (*StructDeclaratorList) String

func (n *StructDeclaratorList) String() string

String implements fmt.Stringer.

type StructOrUnion

type StructOrUnion struct {
	Case  StructOrUnionCase
	Token xc.Token
}

StructOrUnion represents data reduced by productions:

StructOrUnion:
        "struct"  // Case StructOrUnionStruct
|       "union"   // Case StructOrUnionUnion
Example (Struct)
fmt.Println(exampleAST(115, "\U00100001 struct {"))
Output:

&cc.StructOrUnion{
· Token: STRUCT "struct",
}
Example (Union)
fmt.Println(exampleAST(116, "\U00100001 union {"))
Output:

&cc.StructOrUnion{
· Case: 1,
· Token: UNION "union",
}

func (*StructOrUnion) Pos

func (n *StructOrUnion) Pos() token.Pos

Pos reports the position of the first component of n or zero if it's empty.

func (*StructOrUnion) String

func (n *StructOrUnion) String() string

String implements fmt.Stringer.

type StructOrUnionCase

type StructOrUnionCase int

StructOrUnionCase represents case numbers of production StructOrUnion

const (
	StructOrUnionStruct StructOrUnionCase = iota
	StructOrUnionUnion
)

Values of type StructOrUnionCase

func (StructOrUnionCase) String

func (n StructOrUnionCase) String() string

String implements fmt.Stringer

type StructOrUnionSpecifier

type StructOrUnionSpecifier struct {
	Case                  StructOrUnionSpecifierCase
	IdentifierOpt         *IdentifierOpt
	StructDeclarationList *StructDeclarationList
	StructOrUnion         *StructOrUnion
	Token                 xc.Token
	Token2                xc.Token
	// contains filtered or unexported fields
}

StructOrUnionSpecifier represents data reduced by productions:

StructOrUnionSpecifier:
        StructOrUnion IDENTIFIER                                   // Case StructOrUnionSpecifierTag
|       StructOrUnion IdentifierOpt '{' '}'                        // Case StructOrUnionSpecifierEmpty
|       StructOrUnion IdentifierOpt '{' StructDeclarationList '}'  // Case StructOrUnionSpecifierDefine
Example (Define)
fmt.Println(exampleAST(114, "\U00100001 struct { _Bool ; } ("))
Output:

&cc.StructOrUnionSpecifier{
· Case: 2,
· StructDeclarationList: &cc.StructDeclarationList{
· · StructDeclaration: &cc.StructDeclaration{
· · · Case: 1,
· · · SpecifierQualifierList: &cc.SpecifierQualifierList{
· · · · Case: 1,
· · · · TypeSpecifier: &cc.TypeSpecifier{
· · · · · Token: BOOL "_Bool",
· · · · },
· · · },
· · · Token: ';',
· · },
· },
· StructOrUnion: &cc.StructOrUnion{
· · Token: STRUCT "struct",
· },
· Token: '{',
· Token2: '}',
}
Example (Empty)
fmt.Println(exampleAST(111, "\U00100001 struct { } ("))
Output:

&cc.StructOrUnionSpecifier{
· Case: 1,
· StructOrUnion: &cc.StructOrUnion{
· · Token: STRUCT "struct",
· },
· Token: '{',
· Token2: '}',
}
Example (Tag)
fmt.Println(exampleAST(109, "\U00100001 struct a ("))
Output:

&cc.StructOrUnionSpecifier{
· StructOrUnion: &cc.StructOrUnion{
· · Token: STRUCT "struct",
· },
· Token: IDENTIFIER "a",
}

func (*StructOrUnionSpecifier) Pos

func (n *StructOrUnionSpecifier) Pos() token.Pos

Pos reports the position of the first component of n or zero if it's empty.

func (*StructOrUnionSpecifier) String

func (n *StructOrUnionSpecifier) String() string

String implements fmt.Stringer.

type StructOrUnionSpecifierCase

type StructOrUnionSpecifierCase int

StructOrUnionSpecifierCase represents case numbers of production StructOrUnionSpecifier

const (
	StructOrUnionSpecifierTag StructOrUnionSpecifierCase = iota
	StructOrUnionSpecifierEmpty
	StructOrUnionSpecifierDefine
)

Values of type StructOrUnionSpecifierCase

func (StructOrUnionSpecifierCase) String

String implements fmt.Stringer

type StructType

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

StructType represents a struct type.

func (*StructType) Equal

func (t *StructType) Equal(u Type) bool

Equal implements Type.

func (*StructType) Field

func (t *StructType) Field(nm int) *FieldProperties

Field returns the properties of field nm or nil if the field does not exist.

func (*StructType) IsArithmeticType

func (t *StructType) IsArithmeticType() bool

IsArithmeticType implements Type.

func (*StructType) IsCompatible

func (t *StructType) IsCompatible(u Type) bool

IsCompatible implements Type.

func (*StructType) IsIntegerType

func (t *StructType) IsIntegerType() bool

IsIntegerType implements Type.

func (*StructType) IsPointerType

func (t *StructType) IsPointerType() bool

IsPointerType implements Type.

func (*StructType) IsScalarType

func (t *StructType) IsScalarType() bool

IsScalarType implements Type.

func (*StructType) IsUnsigned

func (t *StructType) IsUnsigned() bool

IsUnsigned implements Type.

func (*StructType) IsVoidPointerType

func (t *StructType) IsVoidPointerType() bool

IsVoidPointerType implements Type.

func (*StructType) Kind

func (t *StructType) Kind() TypeKind

Kind implements Type.

func (*StructType) String

func (t *StructType) String() string

type TaggedEnumType

type TaggedEnumType struct {
	Tag  int
	Type Type
	// contains filtered or unexported fields
}

TaggedEnumType represents an enum type described by a tag name.

func (*TaggedEnumType) Equal

func (t *TaggedEnumType) Equal(u Type) bool

Equal implements Type.

func (*TaggedEnumType) IsArithmeticType

func (t *TaggedEnumType) IsArithmeticType() bool

IsArithmeticType implements Type.

func (*TaggedEnumType) IsCompatible

func (t *TaggedEnumType) IsCompatible(u Type) bool

IsCompatible implements Type.

func (*TaggedEnumType) IsIntegerType

func (t *TaggedEnumType) IsIntegerType() bool

IsIntegerType implements Type.

func (*TaggedEnumType) IsPointerType

func (t *TaggedEnumType) IsPointerType() bool

IsPointerType implements Type.

func (*TaggedEnumType) IsScalarType

func (t *TaggedEnumType) IsScalarType() bool

IsScalarType implements Type.

func (*TaggedEnumType) IsUnsigned

func (t *TaggedEnumType) IsUnsigned() bool

IsUnsigned implements Type.

func (*TaggedEnumType) IsVoidPointerType

func (t *TaggedEnumType) IsVoidPointerType() bool

IsVoidPointerType implements Type.

func (*TaggedEnumType) Kind

func (t *TaggedEnumType) Kind() TypeKind

Kind implements Type.

func (*TaggedEnumType) String

func (t *TaggedEnumType) String() string

type TaggedStructType

type TaggedStructType struct {
	Tag  int
	Type Type
	// contains filtered or unexported fields
}

TaggedStructType represents a struct type described by a tag name.

func (*TaggedStructType) Equal

func (t *TaggedStructType) Equal(u Type) bool

Equal implements Type.

func (*TaggedStructType) IsArithmeticType

func (t *TaggedStructType) IsArithmeticType() bool

IsArithmeticType implements Type.

func (*TaggedStructType) IsCompatible

func (t *TaggedStructType) IsCompatible(u Type) bool

IsCompatible implements Type.

func (*TaggedStructType) IsIntegerType

func (t *TaggedStructType) IsIntegerType() bool

IsIntegerType implements Type.

func (*TaggedStructType) IsPointerType

func (t *TaggedStructType) IsPointerType() bool

IsPointerType implements Type.

func (*TaggedStructType) IsScalarType

func (t *TaggedStructType) IsScalarType() bool

IsScalarType implements Type.

func (*TaggedStructType) IsUnsigned

func (t *TaggedStructType) IsUnsigned() bool

IsUnsigned implements Type.

func (*TaggedStructType) IsVoidPointerType

func (t *TaggedStructType) IsVoidPointerType() bool

IsVoidPointerType implements Type.

func (*TaggedStructType) Kind

func (t *TaggedStructType) Kind() TypeKind

Kind implements Type.

func (*TaggedStructType) String

func (t *TaggedStructType) String() string

type TaggedUnionType

type TaggedUnionType struct {
	Tag  int
	Type Type
	// contains filtered or unexported fields
}

TaggedUnionType represents a struct type described by a tag name.

func (*TaggedUnionType) Equal

func (t *TaggedUnionType) Equal(u Type) bool

Equal implements Type.

func (*TaggedUnionType) IsArithmeticType

func (t *TaggedUnionType) IsArithmeticType() bool

IsArithmeticType implements Type.

func (*TaggedUnionType) IsCompatible

func (t *TaggedUnionType) IsCompatible(u Type) bool

IsCompatible implements Type.

func (*TaggedUnionType) IsIntegerType

func (t *TaggedUnionType) IsIntegerType() bool

IsIntegerType implements Type.

func (*TaggedUnionType) IsPointerType

func (t *TaggedUnionType) IsPointerType() bool

IsPointerType implements Type.

func (*TaggedUnionType) IsScalarType

func (t *TaggedUnionType) IsScalarType() bool

IsScalarType implements Type.

func (*TaggedUnionType) IsUnsigned

func (t *TaggedUnionType) IsUnsigned() bool

IsUnsigned implements Type.

func (*TaggedUnionType) IsVoidPointerType

func (t *TaggedUnionType) IsVoidPointerType() bool

IsVoidPointerType implements Type.

func (*TaggedUnionType) Kind

func (t *TaggedUnionType) Kind() TypeKind

Kind implements Type.

func (*TaggedUnionType) String

func (t *TaggedUnionType) String() string

type TranslationUnit

type TranslationUnit struct {
	ExternalDeclarationList *ExternalDeclarationList
	FileScope               *Scope
	FileSet                 *token.FileSet
	IncludePaths            []string
	Macros                  map[int]*Macro
	Model                   Model
	SysIncludePaths         []string
}

TranslationUnit represents a translation unit, see [0]6.9.

func Translate

func Translate(tweaks *Tweaks, includePaths, sysIncludePaths []string, sources ...Source) (tu *TranslationUnit, err error)

Translate preprocesses, parses and type checks a translation unit using fset to record node and error positions, includePaths and sysIncludePaths for looking for "foo.h" and <foo.h> files. A special path "@" is interpretted as 'the same directory as where the file with the #include is'. The input consists of sources which must include any predefined/builtin stuff.

The returned scope is the file scope of the Translation unit.

func (*TranslationUnit) Pos

func (n *TranslationUnit) Pos() token.Pos

Pos implements Node.

type Tweaks

type Tweaks struct {
	TrackExpand   func(string)
	TrackIncludes func(string)

	DefinesOnly                 bool // like in CC -E -dM foo.c
	EnableAnonymousStructFields bool // struct{int;}
	EnableBinaryLiterals        bool // 0b101010 == 42
	EnableEmptyStructs          bool // struct{}
	EnableImplicitBuiltins      bool // Undefined printf becomes __builtin_printf.
	EnableImplicitDeclarations  bool // eg. using exit(1) w/o #include <stdlib.h>
	EnableOmitFuncDeclSpec      bool // foo() { ... } == int foo() { ... }
	EnablePointerCompatibility  bool // All pointers are assignment compatible.
	EnableReturnExprInVoidFunc  bool // void f() { return 1; }
	EnableTrigraphs             bool
	EnableUnionCasts            bool // (union foo)0
	IgnoreUnknownPragmas        bool // #pragma
	InjectFinalNL               bool // Specs want the source to always end in a newline.
	PreprocessOnly              bool // like in CC -E foo.c
	// contains filtered or unexported fields
}

Tweaks amend the behavior of the parser.

type Type

type Type interface {
	Equal(Type) bool
	IsArithmeticType() bool
	IsCompatible(Type) bool // [0]6.2.7
	IsIntegerType() bool
	IsPointerType() bool
	IsScalarType() bool
	IsUnsigned() bool
	IsVoidPointerType() bool
	Kind() TypeKind
	String() string
	// contains filtered or unexported methods
}

Type represents a C type.

func AdjustedParameterType

func AdjustedParameterType(t Type) Type

AdjustedParameterType returns the type of an expression when used as an argument of a function, see [0]6.9.1-10.

func UnderlyingType

func UnderlyingType(t Type) Type

UnderlyingType returns the concrete type of t, if posible.

type TypeKind

type TypeKind int

TypeKind represents a particular type kind.

const (
	Bool TypeKind
	Char
	Int
	Long
	LongLong
	SChar
	Short
	UChar
	UInt
	ULong
	ULongLong
	UShort

	Float
	Double
	LongDouble

	FloatComplex
	DoubleComplex
	LongDoubleComplex

	Array
	Enum
	EnumTag
	Function
	Ptr
	Struct
	StructTag
	TypedefName
	Union
	UnionTag
	Void
)

TypeKind values.

func Unsigned

func Unsigned(t Type) TypeKind

func (TypeKind) Equal

func (t TypeKind) Equal(u Type) bool

Equal implements Type.

func (TypeKind) IsArithmeticType

func (t TypeKind) IsArithmeticType() bool

IsArithmeticType implements Type.

func (TypeKind) IsCompatible

func (t TypeKind) IsCompatible(u Type) bool

IsCompatible implements Type.

func (TypeKind) IsIntegerType

func (t TypeKind) IsIntegerType() bool

IsIntegerType implements Type.

func (TypeKind) IsPointerType

func (t TypeKind) IsPointerType() bool

IsPointerType implements Type.

func (TypeKind) IsScalarType

func (t TypeKind) IsScalarType() bool

IsScalarType implements Type.

func (TypeKind) IsUnsigned

func (t TypeKind) IsUnsigned() bool

IsUnsigned implements Type.

func (TypeKind) IsVoidPointerType

func (t TypeKind) IsVoidPointerType() bool

IsVoidPointerType implements Type.

func (TypeKind) Kind

func (t TypeKind) Kind() TypeKind

Kind implements Type.

func (TypeKind) String

func (t TypeKind) String() string

type TypeName

type TypeName struct {
	Type                   Type
	AbstractDeclaratorOpt  *AbstractDeclaratorOpt
	SpecifierQualifierList *SpecifierQualifierList
}

TypeName represents data reduced by production:

TypeName:
        SpecifierQualifierList AbstractDeclaratorOpt  // Case 0
Example (Case0)
fmt.Println(exampleAST(176, "\U00100000 ( _Bool )"))
Output:

&cc.TypeName{
· SpecifierQualifierList: &cc.SpecifierQualifierList{
· · Case: 1,
· · TypeSpecifier: &cc.TypeSpecifier{
· · · Token: BOOL "_Bool",
· · },
· },
}

func (*TypeName) Pos

func (n *TypeName) Pos() token.Pos

Pos reports the position of the first component of n or zero if it's empty.

func (*TypeName) String

func (n *TypeName) String() string

String implements fmt.Stringer.

type TypeQualifier

type TypeQualifier struct {
	Case  TypeQualifierCase
	Token xc.Token
}

TypeQualifier represents data reduced by productions:

TypeQualifier:
        "const"     // Case TypeQualifierConst
|       "restrict"  // Case TypeQualifierRestrict
|       "volatile"  // Case TypeQualifierVolatile
Example (Const)
fmt.Println(exampleAST(137, "\U00100001 const !"))
Output:

&cc.TypeQualifier{
· Token: CONST "const",
}
Example (Restrict)
fmt.Println(exampleAST(138, "\U00100001 restrict !"))
Output:

&cc.TypeQualifier{
· Case: 1,
· Token: RESTRICT "restrict",
}
Example (Volatile)
fmt.Println(exampleAST(139, "\U00100001 volatile !"))
Output:

&cc.TypeQualifier{
· Case: 2,
· Token: VOLATILE "volatile",
}

func (*TypeQualifier) Pos

func (n *TypeQualifier) Pos() token.Pos

Pos reports the position of the first component of n or zero if it's empty.

func (*TypeQualifier) String

func (n *TypeQualifier) String() string

String implements fmt.Stringer.

type TypeQualifierCase

type TypeQualifierCase int

TypeQualifierCase represents case numbers of production TypeQualifier

const (
	TypeQualifierConst TypeQualifierCase = iota
	TypeQualifierRestrict
	TypeQualifierVolatile
)

Values of type TypeQualifierCase

func (TypeQualifierCase) String

func (n TypeQualifierCase) String() string

String implements fmt.Stringer

type TypeQualifierList

type TypeQualifierList struct {
	Case              int
	TypeQualifier     *TypeQualifier
	TypeQualifierList *TypeQualifierList
}

TypeQualifierList represents data reduced by productions:

TypeQualifierList:
        TypeQualifier                    // Case 0
|       TypeQualifierList TypeQualifier  // Case 1
Example (Case0)
fmt.Println(exampleAST(158, "\U00100001 * const !"))
Output:

&cc.TypeQualifierList{
· TypeQualifier: &cc.TypeQualifier{
· · Token: CONST "const",
· },
}
Example (Case1)
fmt.Println(exampleAST(159, "\U00100001 * const const !"))
Output:

&cc.TypeQualifierList{
· TypeQualifier: &cc.TypeQualifier{
· · Token: CONST "const",
· },
· TypeQualifierList: &cc.TypeQualifierList{
· · Case: 1,
· · TypeQualifier: &cc.TypeQualifier{
· · · Token: CONST "const",
· · },
· },
}

func (*TypeQualifierList) Pos

func (n *TypeQualifierList) Pos() token.Pos

Pos reports the position of the first component of n or zero if it's empty.

func (*TypeQualifierList) String

func (n *TypeQualifierList) String() string

String implements fmt.Stringer.

type TypeQualifierListOpt

type TypeQualifierListOpt struct {
	TypeQualifierList *TypeQualifierList
}

TypeQualifierListOpt represents data reduced by productions:

TypeQualifierListOpt:
        /* empty */        // Case 0
|       TypeQualifierList  // Case 1
Example (Case0)
fmt.Println(exampleAST(160, "\U00100001 * (") == (*TypeQualifierListOpt)(nil))
Output:

true
Example (Case1)
fmt.Println(exampleAST(161, "\U00100001 * const !"))
Output:

&cc.TypeQualifierListOpt{
· TypeQualifierList: &cc.TypeQualifierList{
· · TypeQualifier: &cc.TypeQualifier{
· · · Token: CONST "const",
· · },
· },
}

func (*TypeQualifierListOpt) Pos

func (n *TypeQualifierListOpt) Pos() token.Pos

Pos reports the position of the first component of n or zero if it's empty.

func (*TypeQualifierListOpt) String

func (n *TypeQualifierListOpt) String() string

String implements fmt.Stringer.

type TypeSpecifier

type TypeSpecifier struct {
	Case                   TypeSpecifierCase
	EnumSpecifier          *EnumSpecifier
	Expr                   *Expr
	StructOrUnionSpecifier *StructOrUnionSpecifier
	Token                  xc.Token
	Token2                 xc.Token
	Token3                 xc.Token
	TypeName               *TypeName
	// contains filtered or unexported fields
}

TypeSpecifier represents data reduced by productions:

TypeSpecifier:
        "_Bool"                    // Case TypeSpecifierBool
|       "_Complex"                 // Case TypeSpecifierComplex
|       "char"                     // Case TypeSpecifierChar
|       "double"                   // Case TypeSpecifierDouble
|       "float"                    // Case TypeSpecifierFloat
|       "int"                      // Case TypeSpecifierInt
|       "long"                     // Case TypeSpecifierLong
|       "short"                    // Case TypeSpecifierShort
|       "signed"                   // Case TypeSpecifierSigned
|       "unsigned"                 // Case TypeSpecifierUnsigned
|       "void"                     // Case TypeSpecifierVoid
|       EnumSpecifier              // Case TypeSpecifierEnum
|       StructOrUnionSpecifier     // Case TypeSpecifierStruct
|       TYPEDEF_NAME               // Case TypeSpecifierName
|       "typeof" '(' Expr ')'      // Case TypeSpecifierTypeofExpr
|       "typeof" '(' TypeName ')'  // Case TypeSpecifierTypeof
Example (Bool)
fmt.Println(exampleAST(93, "\U00100001 _Bool ("))
Output:

&cc.TypeSpecifier{
· Token: BOOL "_Bool",
}
Example (Char)
fmt.Println(exampleAST(95, "\U00100001 char ("))
Output:

&cc.TypeSpecifier{
· Case: 2,
· Token: CHAR "char",
}
Example (Complex)
fmt.Println(exampleAST(94, "\U00100001 _Complex ("))
Output:

&cc.TypeSpecifier{
· Case: 1,
· Token: COMPLEX "_Complex",
}
Example (Double)
fmt.Println(exampleAST(96, "\U00100001 double ("))
Output:

&cc.TypeSpecifier{
· Case: 3,
· Token: DOUBLE "double",
}
Example (Enum)
fmt.Println(exampleAST(104, "\U00100001 enum a ("))
Output:

&cc.TypeSpecifier{
· Case: 11,
· EnumSpecifier: &cc.EnumSpecifier{
· · Token: ENUM "enum",
· · Token2: IDENTIFIER "a",
· },
}
Example (Float)
fmt.Println(exampleAST(97, "\U00100001 float ("))
Output:

&cc.TypeSpecifier{
· Case: 4,
· Token: FLOAT "float",
}
Example (Int)
fmt.Println(exampleAST(98, "\U00100001 int ("))
Output:

&cc.TypeSpecifier{
· Case: 5,
· Token: INT "int",
}
Example (Long)
fmt.Println(exampleAST(99, "\U00100001 long ("))
Output:

&cc.TypeSpecifier{
· Case: 6,
· Token: LONG "long",
}
Example (Name)
fmt.Println(exampleAST(106, "\U00100001 typedef int foo; foo bar;"))
Output:

&cc.TypeSpecifier{
· Case: 13,
· Token: TYPEDEF_NAME "foo",
}
Example (Short)
fmt.Println(exampleAST(100, "\U00100001 short ("))
Output:

&cc.TypeSpecifier{
· Case: 7,
· Token: SHORT "short",
}
Example (Signed)
fmt.Println(exampleAST(101, "\U00100001 signed ("))
Output:

&cc.TypeSpecifier{
· Case: 8,
· Token: SIGNED "signed",
}
Example (Struct)
fmt.Println(exampleAST(105, "\U00100001 struct a ("))
Output:

&cc.TypeSpecifier{
· Case: 12,
· StructOrUnionSpecifier: &cc.StructOrUnionSpecifier{
· · StructOrUnion: &cc.StructOrUnion{
· · · Token: STRUCT "struct",
· · },
· · Token: IDENTIFIER "a",
· },
}
Example (Typeof)
fmt.Println(exampleAST(108, "\U00100001 typeof ( _Bool ) ("))
Output:

&cc.TypeSpecifier{
· Case: 15,
· Token: TYPEOF "typeof",
· Token2: '(',
· Token3: ')',
· TypeName: &cc.TypeName{
· · SpecifierQualifierList: &cc.SpecifierQualifierList{
· · · Case: 1,
· · · TypeSpecifier: &cc.TypeSpecifier{
· · · · Token: BOOL "_Bool",
· · · },
· · },
· },
}
Example (TypeofExpr)
fmt.Println(exampleAST(107, "\U00100001 typeof ( 'a' ) ("))
Output:

&cc.TypeSpecifier{
· Case: 14,
· Expr: &cc.Expr{
· · Case: ExprChar,
· · Token: CHARCONST "'a'",
· },
· Token: TYPEOF "typeof",
· Token2: '(',
· Token3: ')',
}
Example (Unsigned)
fmt.Println(exampleAST(102, "\U00100001 unsigned ("))
Output:

&cc.TypeSpecifier{
· Case: 9,
· Token: UNSIGNED "unsigned",
}
Example (Void)
fmt.Println(exampleAST(103, "\U00100001 void ("))
Output:

&cc.TypeSpecifier{
· Case: 10,
· Token: VOID "void",
}

func (*TypeSpecifier) Pos

func (n *TypeSpecifier) Pos() token.Pos

Pos reports the position of the first component of n or zero if it's empty.

func (*TypeSpecifier) String

func (n *TypeSpecifier) String() string

String implements fmt.Stringer.

type TypeSpecifierCase

type TypeSpecifierCase int

TypeSpecifierCase represents case numbers of production TypeSpecifier

const (
	TypeSpecifierBool TypeSpecifierCase = iota
	TypeSpecifierComplex
	TypeSpecifierChar
	TypeSpecifierDouble
	TypeSpecifierFloat
	TypeSpecifierInt
	TypeSpecifierLong
	TypeSpecifierShort
	TypeSpecifierSigned
	TypeSpecifierUnsigned
	TypeSpecifierVoid
	TypeSpecifierEnum
	TypeSpecifierStruct
	TypeSpecifierName
	TypeSpecifierTypeofExpr
	TypeSpecifierTypeof
)

Values of type TypeSpecifierCase

func (TypeSpecifierCase) String

func (n TypeSpecifierCase) String() string

String implements fmt.Stringer

type UnionType

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

UnionType represents a union type.

func (*UnionType) Equal

func (t *UnionType) Equal(u Type) bool

Equal implements Type.

func (*UnionType) Field

func (t *UnionType) Field(nm int) *FieldProperties

Field returns the properties of field nm or nil if the field does not exist.

func (*UnionType) IsArithmeticType

func (t *UnionType) IsArithmeticType() bool

IsArithmeticType implements Type.

func (*UnionType) IsCompatible

func (t *UnionType) IsCompatible(u Type) bool

IsCompatible implements Type.

func (*UnionType) IsIntegerType

func (t *UnionType) IsIntegerType() bool

IsIntegerType implements Type.

func (*UnionType) IsPointerType

func (t *UnionType) IsPointerType() bool

IsPointerType implements Type.

func (*UnionType) IsScalarType

func (t *UnionType) IsScalarType() bool

IsScalarType implements Type.

func (*UnionType) IsUnsigned

func (t *UnionType) IsUnsigned() bool

IsUnsigned implements Type.

func (*UnionType) IsVoidPointerType

func (t *UnionType) IsVoidPointerType() bool

IsVoidPointerType implements Type.

func (*UnionType) Kind

func (t *UnionType) Kind() TypeKind

Kind implements Type.

func (*UnionType) String

func (t *UnionType) String() string

type VolatileOpt

type VolatileOpt struct {
	Token xc.Token
}

VolatileOpt represents data reduced by productions:

VolatileOpt:
        /* empty */  // Case 0
|       "volatile"   // Case 1

func (*VolatileOpt) Pos

func (n *VolatileOpt) Pos() token.Pos

Pos reports the position of the first component of n or zero if it's empty.

func (*VolatileOpt) String

func (n *VolatileOpt) String() string

String implements fmt.Stringer.

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL