Documentation ¶
Overview ¶
Package cc is a C99 compiler front end.
Index ¶
- Constants
- func IsArithmeticType(t Type) bool
- func IsIntType(t Type) bool
- func PrettyString(v interface{}) string
- func TokSrc(t xc.Token) string
- type AbstractDeclarator
- type AbstractDeclaratorOpt
- type ArgumentExpressionList
- type ArgumentExpressionListOpt
- type Binding
- type Bindings
- type BlockItem
- type BlockItemList
- type BlockItemListOpt
- type CommaOpt
- type CompoundStatement
- type ConstantExpression
- type ControlLine
- type Declaration
- type DeclarationList
- type DeclarationListOpt
- type DeclarationSpecifiers
- type DeclarationSpecifiersOpt
- type Declarator
- type DeclaratorOpt
- type Designation
- type DesignationOpt
- type Designator
- type DesignatorList
- type DirectAbstractDeclarator
- type DirectAbstractDeclaratorOpt
- type DirectDeclarator
- type ElifGroup
- type ElifGroupList
- type ElifGroupListOpt
- type ElseGroup
- type ElseGroupOpt
- type EndifLine
- type EnumConstant
- type EnumSpecifier
- type EnumerationConstant
- type Enumerator
- type EnumeratorList
- type Expression
- type ExpressionList
- type ExpressionListOpt
- type ExpressionOpt
- type ExpressionStatement
- type ExternalDeclaration
- type FunctionDefinition
- type FunctionSpecifier
- type GroupList
- type GroupListOpt
- type IdentifierList
- type IdentifierListOpt
- type IdentifierOpt
- type IfGroup
- type IfSection
- type InitDeclarator
- type InitDeclaratorList
- type InitDeclaratorListOpt
- type Initializer
- type InitializerList
- type IterationStatement
- type JumpStatement
- type Kind
- type LabeledStatement
- type Linkage
- type LongStringLitID
- type Macro
- type Member
- type Model
- type ModelItem
- type Namespace
- type Node
- type Opt
- func Cpp(f func([]xc.Token)) Opt
- func CrashOnError() Opt
- func EnableAnonymousStructFields() Opt
- func EnableDefineOmitCommaBeforeDDD() Opt
- func EnableDlrInIdentifiers() Opt
- func EnableEmptyDefine() Opt
- func EnableIncludeNext() Opt
- func EnableTypeOf() Opt
- func EnableUndefExtraTokens() Opt
- func ErrLimit(n int) Opt
- func IncludeLastTokenInfoInErrors() Opt
- func IncludePaths(paths []string) Opt
- func SysIncludePaths(paths []string) Opt
- func Trigraphs() Opt
- func YyDebug(n int) Opt
- type PPTokenList
- type Parameter
- type ParameterDeclaration
- type ParameterList
- type ParameterTypeList
- type ParameterTypeListOpt
- type Pointer
- type PointerOpt
- type PreprocessingFile
- type Scope
- type SelectionStatement
- type Specifier
- type SpecifierQualifierList
- type SpecifierQualifierListOpt
- type Statement
- type StorageClassSpecifier
- type StringLitID
- type StructDeclaration
- type StructDeclarationList
- type StructDeclarator
- type StructDeclaratorList
- type StructOrUnion
- type StructOrUnionSpecifier
- type TranslationUnit
- type Type
- type TypeName
- type TypeQualifier
- type TypeQualifierList
- type TypeQualifierListOpt
- type TypeSpecifier
Examples ¶
- AbstractDeclarator
- AbstractDeclarator (Case1)
- AbstractDeclaratorOpt
- AbstractDeclaratorOpt (Case1)
- ArgumentExpressionList
- ArgumentExpressionList (Case1)
- ArgumentExpressionListOpt
- ArgumentExpressionListOpt (Case1)
- BlockItem
- BlockItem (Case1)
- BlockItemList
- BlockItemList (Case1)
- BlockItemListOpt
- BlockItemListOpt (Case1)
- CommaOpt
- CommaOpt (Case1)
- CompoundStatement
- ConstantExpression
- ControlLine
- ControlLine (Case01)
- ControlLine (Case02)
- ControlLine (Case03)
- ControlLine (Case04)
- ControlLine (Case05)
- ControlLine (Case06)
- ControlLine (Case07)
- ControlLine (Case08)
- ControlLine (Case09)
- ControlLine (Case10)
- ControlLine (Case11)
- ControlLine (Case12)
- ControlLine (Case13)
- ControlLine (Case14)
- Declaration
- DeclarationList
- DeclarationList (Case1)
- DeclarationListOpt
- DeclarationListOpt (Case1)
- DeclarationSpecifiers
- DeclarationSpecifiers (Case1)
- DeclarationSpecifiers (Case2)
- DeclarationSpecifiers (Case3)
- DeclarationSpecifiersOpt
- DeclarationSpecifiersOpt (Case1)
- Declarator
- DeclaratorOpt
- DeclaratorOpt (Case1)
- Designation
- DesignationOpt
- DesignationOpt (Case1)
- Designator
- Designator (Case1)
- DesignatorList
- DesignatorList (Case1)
- DirectAbstractDeclarator
- DirectAbstractDeclarator (Case1)
- DirectAbstractDeclarator (Case2)
- DirectAbstractDeclarator (Case3)
- DirectAbstractDeclarator (Case4)
- DirectAbstractDeclarator (Case5)
- DirectAbstractDeclarator (Case6)
- DirectAbstractDeclarator (Case7)
- DirectAbstractDeclaratorOpt
- DirectAbstractDeclaratorOpt (Case1)
- DirectDeclarator
- DirectDeclarator (Case1)
- DirectDeclarator (Case2)
- DirectDeclarator (Case3)
- DirectDeclarator (Case4)
- DirectDeclarator (Case5)
- DirectDeclarator (Case6)
- DirectDeclarator (Case7)
- ElifGroup
- ElifGroupList
- ElifGroupList (Case1)
- ElifGroupListOpt
- ElifGroupListOpt (Case1)
- ElseGroup
- ElseGroupOpt
- ElseGroupOpt (Case1)
- EndifLine
- EnumSpecifier
- EnumSpecifier (Case1)
- EnumerationConstant
- Enumerator
- Enumerator (Case1)
- EnumeratorList
- EnumeratorList (Case1)
- Expression
- Expression (Case01)
- Expression (Case02)
- Expression (Case03)
- Expression (Case04)
- Expression (Case05)
- Expression (Case06)
- Expression (Case07)
- Expression (Case08)
- Expression (Case09)
- Expression (Case10)
- Expression (Case11)
- Expression (Case12)
- Expression (Case13)
- Expression (Case14)
- Expression (Case15)
- Expression (Case16)
- Expression (Case17)
- Expression (Case18)
- Expression (Case19)
- Expression (Case20)
- Expression (Case21)
- Expression (Case22)
- Expression (Case23)
- Expression (Case24)
- Expression (Case25)
- Expression (Case26)
- Expression (Case27)
- Expression (Case28)
- Expression (Case29)
- Expression (Case30)
- Expression (Case31)
- Expression (Case32)
- Expression (Case33)
- Expression (Case34)
- Expression (Case35)
- Expression (Case36)
- Expression (Case37)
- Expression (Case38)
- Expression (Case39)
- Expression (Case40)
- Expression (Case41)
- Expression (Case42)
- Expression (Case43)
- Expression (Case44)
- Expression (Case45)
- Expression (Case46)
- Expression (Case47)
- Expression (Case48)
- Expression (Case49)
- Expression (Case50)
- Expression (Case51)
- Expression (Case52)
- Expression (Case53)
- Expression (Case54)
- Expression (Case55)
- ExpressionList
- ExpressionList (Case1)
- ExpressionListOpt
- ExpressionListOpt (Case1)
- ExpressionOpt
- ExpressionOpt (Case1)
- ExpressionStatement
- ExternalDeclaration
- ExternalDeclaration (Case1)
- FunctionDefinition
- FunctionSpecifier
- GroupList
- GroupList (Case1)
- GroupListOpt
- GroupListOpt (Case1)
- IdentifierList
- IdentifierList (Case1)
- IdentifierListOpt
- IdentifierListOpt (Case1)
- IdentifierOpt
- IdentifierOpt (Case1)
- IfGroup
- IfGroup (Case1)
- IfGroup (Case2)
- IfSection
- InitDeclarator
- InitDeclarator (Case1)
- InitDeclaratorList
- InitDeclaratorList (Case1)
- InitDeclaratorListOpt
- InitDeclaratorListOpt (Case1)
- Initializer
- Initializer (Case1)
- InitializerList
- InitializerList (Case1)
- IterationStatement
- IterationStatement (Case1)
- IterationStatement (Case2)
- IterationStatement (Case3)
- JumpStatement
- JumpStatement (Case1)
- JumpStatement (Case2)
- JumpStatement (Case3)
- LabeledStatement
- LabeledStatement (Case1)
- LabeledStatement (Case2)
- ParameterDeclaration
- ParameterDeclaration (Case1)
- ParameterList
- ParameterList (Case1)
- ParameterTypeList
- ParameterTypeList (Case1)
- ParameterTypeListOpt
- ParameterTypeListOpt (Case1)
- Pointer
- Pointer (Case1)
- PointerOpt
- PointerOpt (Case1)
- PreprocessingFile
- SelectionStatement
- SelectionStatement (Case1)
- SelectionStatement (Case2)
- SpecifierQualifierList
- SpecifierQualifierList (Case1)
- SpecifierQualifierListOpt
- SpecifierQualifierListOpt (Case1)
- Statement
- Statement (Case1)
- Statement (Case2)
- Statement (Case3)
- Statement (Case4)
- Statement (Case5)
- StorageClassSpecifier
- StorageClassSpecifier (Case1)
- StorageClassSpecifier (Case2)
- StorageClassSpecifier (Case3)
- StorageClassSpecifier (Case4)
- StructDeclaration
- StructDeclaration (Case1)
- StructDeclarationList
- StructDeclarationList (Case1)
- StructDeclarator
- StructDeclarator (Case1)
- StructDeclaratorList
- StructDeclaratorList (Case1)
- StructOrUnion
- StructOrUnion (Case1)
- StructOrUnionSpecifier
- StructOrUnionSpecifier (Case1)
- TranslationUnit
- TranslationUnit (Case1)
- TypeName
- TypeQualifier
- TypeQualifier (Case1)
- TypeQualifier (Case2)
- TypeQualifierList
- TypeQualifierList (Case1)
- TypeQualifierListOpt
- TypeQualifierListOpt (Case1)
- TypeSpecifier
- TypeSpecifier (Case01)
- TypeSpecifier (Case02)
- TypeSpecifier (Case03)
- TypeSpecifier (Case04)
- TypeSpecifier (Case05)
- TypeSpecifier (Case06)
- TypeSpecifier (Case07)
- TypeSpecifier (Case08)
- TypeSpecifier (Case09)
- TypeSpecifier (Case10)
- TypeSpecifier (Case11)
- TypeSpecifier (Case12)
- TypeSpecifier (Case13)
- TypeSpecifier (Case14)
- TypeSpecifier (Case15)
Constants ¶
const ( ADDASSIGN = 57346 ANDAND = 57347 ANDASSIGN = 57348 ARROW = 57349 AUTO = 57350 BOOL = 57351 BREAK = 57352 CASE = 57353 CAST = 57354 CHAR = 57355 CHARCONST = 57356 COMPLEX = 57357 CONST = 57358 CONSTANT_EXPRESSION = 1048577 CONTINUE = 57359 DDD = 57360 DEC = 57361 DEFAULT = 57362 DIVASSIGN = 57363 DO = 57364 DOUBLE = 57365 ELSE = 57366 ENUM = 57367 EQ = 57368 EXTERN = 57369 FLOAT = 57370 FLOATCONST = 57371 FOR = 57372 GEQ = 57373 GOTO = 57374 IDENTIFIER = 57375 IDENTIFIER_LPAREN = 57376 IDENTIFIER_NONREPL = 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 ORASSIGN = 57393 OROR = 57394 PPDEFINE = 57395 PPELIF = 57396 PPELSE = 57397 PPENDIF = 57398 PPERROR = 57399 PPHASH_NL = 57400 PPHEADER_NAME = 57401 PPIF = 57402 PPIFDEF = 57403 PPIFNDEF = 57404 PPINCLUDE = 57405 PPINCLUDE_NEXT = 57406 PPLINE = 57407 PPNONDIRECTIVE = 57408 PPNUMBER = 57409 PPOTHER = 57410 PPPASTE = 57411 PPPRAGMA = 57412 PPUNDEF = 57413 PREPROCESSING_FILE = 1048576 REGISTER = 57414 RESTRICT = 57415 RETURN = 57416 RSH = 57417 RSHASSIGN = 57418 SHORT = 57419 SIGNED = 57420 SIZEOF = 57421 STATIC = 57422 STRINGLITERAL = 57423 STRUCT = 57424 SUBASSIGN = 57425 SWITCH = 57426 TRANSLATION_UNIT = 1048578 TYPEDEF = 57427 TYPEDEFNAME = 57428 TYPEOF = 57429 UNARY = 57430 UNION = 57431 UNSIGNED = 57432 VOID = 57433 VOLATILE = 57434 WHILE = 57435 XORASSIGN = 57436 )
Variables ¶
This section is empty.
Functions ¶
func IsArithmeticType ¶
IsArithmeticType reports wheter t.Kind() is one of UintPtr, Char, SChar, UChar, Short, UShort, Int, UInt, Long, ULong, LongLong, ULongLong, Float, Double, LongDouble, FloatComplex, DoubleComplex or LongDoubleComplex.
func IsIntType ¶
IsIntType reports t.Kind() is one of Char, SChar, UChar, Short, UShort, Int, UInt, Long, ULong, LongLong, ULongLong or Enum.
func PrettyString ¶
func PrettyString(v interface{}) string
PrettyString pretty prints things produced by this package.
Types ¶
type AbstractDeclarator ¶
type AbstractDeclarator struct { Case int DirectAbstractDeclarator *DirectAbstractDeclarator Pointer *Pointer PointerOpt *PointerOpt // contains filtered or unexported fields }
AbstractDeclarator represents data reduced by productions:
AbstractDeclarator: Pointer | PointerOpt DirectAbstractDeclarator // Case 1
Example ¶
fmt.Println(exampleAST(178, "\U00100001 ( _Bool * )"))
Output: &cc.AbstractDeclarator{ · Pointer: &cc.Pointer{ · · Token: example178.c:1:14: '*', · }, }
Example (Case1) ¶
fmt.Println(exampleAST(179, "\U00100001 ( _Bool ( ) )"))
Output: &cc.AbstractDeclarator{ · Case: 1, · DirectAbstractDeclarator: &cc.DirectAbstractDeclarator{ · · Case: 6, · · Token: example179.c:1:14: '(', · · Token2: example179.c:1:16: ')', · }, }
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 AbstractDeclaratorOpt ¶
type AbstractDeclaratorOpt struct {
AbstractDeclarator *AbstractDeclarator
}
AbstractDeclaratorOpt represents data reduced by productions:
AbstractDeclaratorOpt: /* empty */ | AbstractDeclarator // Case 1
Example ¶
fmt.Println(exampleAST(180, "\U00100001 ( _Bool )") == (*AbstractDeclaratorOpt)(nil))
Output: true
Example (Case1) ¶
fmt.Println(exampleAST(181, "\U00100001 ( _Bool * )"))
Output: &cc.AbstractDeclaratorOpt{ · AbstractDeclarator: &cc.AbstractDeclarator{ · · Pointer: &cc.Pointer{ · · · Token: example181.c:1:14: '*', · · }, · }, }
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 ArgumentExpressionList ¶
type ArgumentExpressionList struct { ArgumentExpressionList *ArgumentExpressionList Case int Expression *Expression Token xc.Token }
ArgumentExpressionList represents data reduced by productions:
ArgumentExpressionList: Expression | ArgumentExpressionList ',' Expression // Case 1
Example ¶
fmt.Println(exampleAST(8, "\U00100001 'a' ( 'b' )"))
Output: &cc.ArgumentExpressionList{ · Expression: &cc.Expression{ · · Case: 1, · · Token: example8.c:1:12: CHARCONST "'b'", · }, }
Example (Case1) ¶
fmt.Println(exampleAST(9, "\U00100001 'a' ( 'b' , 'c' )"))
Output: &cc.ArgumentExpressionList{ · ArgumentExpressionList: &cc.ArgumentExpressionList{ · · Case: 1, · · Expression: &cc.Expression{ · · · Case: 1, · · · Token: example9.c:1:18: CHARCONST "'c'", · · }, · · Token: example9.c:1:16: ',', · }, · Expression: &cc.Expression{ · · Case: 1, · · Token: example9.c:1:12: CHARCONST "'b'", · }, }
func (*ArgumentExpressionList) Pos ¶
func (n *ArgumentExpressionList) Pos() token.Pos
Pos reports the position of the first component of n or zero if it's empty.
func (*ArgumentExpressionList) String ¶
func (n *ArgumentExpressionList) String() string
String implements fmt.Stringer.
type ArgumentExpressionListOpt ¶
type ArgumentExpressionListOpt struct {
ArgumentExpressionList *ArgumentExpressionList
}
ArgumentExpressionListOpt represents data reduced by productions:
ArgumentExpressionListOpt: /* empty */ | ArgumentExpressionList // Case 1
Example ¶
fmt.Println(exampleAST(10, "\U00100001 'a' ( )") == (*ArgumentExpressionListOpt)(nil))
Output: true
Example (Case1) ¶
fmt.Println(exampleAST(11, "\U00100001 'a' ( 'b' )"))
Output: &cc.ArgumentExpressionListOpt{ · ArgumentExpressionList: &cc.ArgumentExpressionList{ · · Expression: &cc.Expression{ · · · Case: 1, · · · Token: example11.c:1:12: CHARCONST "'b'", · · }, · }, }
func (*ArgumentExpressionListOpt) Pos ¶
func (n *ArgumentExpressionListOpt) Pos() token.Pos
Pos reports the position of the first component of n or zero if it's empty.
func (*ArgumentExpressionListOpt) String ¶
func (n *ArgumentExpressionListOpt) String() string
String implements fmt.Stringer.
type Binding ¶
type Binding struct { Node Node // contains filtered or unexported fields }
Binding records the declaration Node of a declared name.
In the NSIdentifiers namespace the dynamic type of Node for deckared names is always *DirectDeclarator. The *Declarator associated with the direct declarator is available via (*DirectDeclarator).TopDeclarator().
int* p;
In the NSTags namespace the dynamic type of Node is xc.Token when a tag is declared:
struct foo; enum bar;
When a tag is defined, the dynamic type of Node is *EnumSpecifier or *StructOrUnionSpecifier:
struct foo { int i; }; enum bar { a = 1 };
type Bindings ¶
type Bindings struct { Identifiers map[int]Binding // NSIdentifiers name space bindings. Tags map[int]Binding // NSTags name space bindings. // contains filtered or unexported fields }
Bindings record names declared in a scope.
func (*Bindings) Lookup ¶
Lookup returns the Binding of id in ns or any of its parents. If id is undeclared, the returned Binding has its Node field set to nil.
type BlockItem ¶
type BlockItem struct { Case int Declaration *Declaration Statement *Statement }
BlockItem represents data reduced by productions:
BlockItem: Declaration | Statement // Case 1
Example ¶
fmt.Println(exampleAST(220, "\U00100002 auto a { auto ; !"))
Output: &cc.BlockItem{ · Declaration: &cc.Declaration{ · · DeclarationSpecifiers: &cc.DeclarationSpecifiers{ · · · StorageClassSpecifier: &cc.StorageClassSpecifier{ · · · · Case: 3, · · · · Token: example220.c:1:15: AUTO "auto", · · · }, · · }, · · Token: example220.c:1:20: ';', · }, }
Example (Case1) ¶
fmt.Println(exampleAST(221, "\U00100002 auto a { ; !"))
Output: &cc.BlockItem{ · Case: 1, · Statement: &cc.Statement{ · · Case: 2, · · ExpressionStatement: &cc.ExpressionStatement{ · · · Token: example221.c:1:15: ';', · · }, · }, }
type BlockItemList ¶
type BlockItemList struct { BlockItem *BlockItem BlockItemList *BlockItemList Case int }
BlockItemList represents data reduced by productions:
BlockItemList: BlockItem | BlockItemList BlockItem // Case 1
Example ¶
fmt.Println(exampleAST(216, "\U00100002 auto a { ; !"))
Output: &cc.BlockItemList{ · BlockItem: &cc.BlockItem{ · · Case: 1, · · Statement: &cc.Statement{ · · · Case: 2, · · · ExpressionStatement: &cc.ExpressionStatement{ · · · · Token: example216.c:1:15: ';', · · · }, · · }, · }, }
Example (Case1) ¶
fmt.Println(exampleAST(217, "\U00100002 auto a { ; ; !"))
Output: &cc.BlockItemList{ · BlockItem: &cc.BlockItem{ · · Case: 1, · · Statement: &cc.Statement{ · · · Case: 2, · · · ExpressionStatement: &cc.ExpressionStatement{ · · · · Token: example217.c:1:15: ';', · · · }, · · }, · }, · BlockItemList: &cc.BlockItemList{ · · BlockItem: &cc.BlockItem{ · · · Case: 1, · · · Statement: &cc.Statement{ · · · · Case: 2, · · · · ExpressionStatement: &cc.ExpressionStatement{ · · · · · Token: example217.c:1:17: ';', · · · · }, · · · }, · · }, · · 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 */ | BlockItemList // Case 1
Example ¶
fmt.Println(exampleAST(218, "\U00100002 auto a { }") == (*BlockItemListOpt)(nil))
Output: true
Example (Case1) ¶
fmt.Println(exampleAST(219, "\U00100002 auto a { ; }"))
Output: &cc.BlockItemListOpt{ · BlockItemList: &cc.BlockItemList{ · · BlockItem: &cc.BlockItem{ · · · Case: 1, · · · Statement: &cc.Statement{ · · · · Case: 2, · · · · ExpressionStatement: &cc.ExpressionStatement{ · · · · · Token: example219.c:1:15: ';', · · · · }, · · · }, · · }, · }, }
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 ¶
CommaOpt represents data reduced by productions:
CommaOpt: /* empty */ | ',' // Case 1
Example ¶
fmt.Println(exampleAST(129, "\U00100002 enum { a }") == (*CommaOpt)(nil))
Output: true
Example (Case1) ¶
fmt.Println(exampleAST(130, "\U00100001 ( _Bool ) { 'a' , }"))
Output: &cc.CommaOpt{ · Token: example130.c:1:22: ',', }
type CompoundStatement ¶
type CompoundStatement struct { BlockItemListOpt *BlockItemListOpt Token xc.Token Token2 xc.Token // contains filtered or unexported fields }
CompoundStatement represents data reduced by production:
CompoundStatement: '{' BlockItemListOpt '}'
Example ¶
fmt.Println(exampleAST(215, "\U00100002 auto a { }"))
Output: &cc.CompoundStatement{ · Token: example215.c:1:13: '{', · Token2: example215.c:1:15: '}', }
func (*CompoundStatement) Pos ¶
func (n *CompoundStatement) Pos() token.Pos
Pos reports the position of the first component of n or zero if it's empty.
func (*CompoundStatement) Scope ¶
func (n *CompoundStatement) Scope() *Bindings
Scope returns n's scope.
func (*CompoundStatement) String ¶
func (n *CompoundStatement) String() string
String implements fmt.Stringer.
type ConstantExpression ¶
type ConstantExpression struct { Type Type // Type of expression. Value interface{} // Non nil for certain constant expressions. Expression *Expression // contains filtered or unexported fields }
ConstantExpression represents data reduced by production:
ConstantExpression: Expression
Example ¶
fmt.Println(exampleAST(75, "\U00100001 'a'"))
Output: &cc.ConstantExpression{ · Type: int, · Value: 97, · Expression: &cc.Expression{ · · Type: int, · · Value: 97, · · Case: 1, · · Token: example75.c:1:6: CHARCONST "'a'", · }, }
func (*ConstantExpression) Pos ¶
func (n *ConstantExpression) Pos() token.Pos
Pos reports the position of the first component of n or zero if it's empty.
func (*ConstantExpression) String ¶
func (n *ConstantExpression) String() string
String implements fmt.Stringer.
type ControlLine ¶
type ControlLine struct { Case int IdentifierList *IdentifierList IdentifierListOpt *IdentifierListOpt PPTokenList PPTokenList PPTokenListOpt PPTokenList ReplacementList PPTokenList Token xc.Token Token2 xc.Token Token3 xc.Token Token4 xc.Token Token5 xc.Token Token6 xc.Token }
ControlLine represents data reduced by productions:
ControlLine: PPDEFINE IDENTIFIER ReplacementList | PPDEFINE IDENTIFIER_LPAREN "..." ')' ReplacementList // Case 1 | PPDEFINE IDENTIFIER_LPAREN IdentifierList ',' "..." ')' ReplacementList // Case 2 | PPDEFINE IDENTIFIER_LPAREN IdentifierListOpt ')' ReplacementList // Case 3 | PPERROR PPTokenListOpt // Case 4 | PPHASH_NL // Case 5 | PPINCLUDE PPTokenList '\n' // Case 6 | PPLINE PPTokenList '\n' // Case 7 | PPPRAGMA PPTokenListOpt // Case 8 | PPUNDEF IDENTIFIER '\n' // Case 9 | PPDEFINE IDENTIFIER_LPAREN IDENTIFIER "..." ')' ReplacementList // Case 10 | PPDEFINE IDENTIFIER_LPAREN IdentifierList ',' IDENTIFIER "..." ')' ReplacementList // Case 11 | PPDEFINE '\n' // Case 12 | PPUNDEF IDENTIFIER PPTokenList '\n' // Case 13 | PPINCLUDE_NEXT PPTokenList '\n' // Case 14
Example ¶
fmt.Println(exampleAST(267, "\U00100000 \n#define a "))
Output: &cc.ControlLine{ · ReplacementList: []xc.Token{ // len 1 · · 0: example267.c:2:10: ' ', · }, · Token: example267.c:2:2: PPDEFINE, · Token2: example267.c:2:9: IDENTIFIER "a", }
Example (Case01) ¶
fmt.Println(exampleAST(268, "\U00100000 \n#define a( ... ) "))
Output: &cc.ControlLine{ · Case: 1, · ReplacementList: []xc.Token{ // len 1 · · 0: example268.c:2:17: ' ', · }, · Token: example268.c:2:2: PPDEFINE, · Token2: example268.c:2:9: IDENTIFIER_LPAREN "a(", · Token3: example268.c:2:12: DDD, · Token4: example268.c:2:16: ')', }
Example (Case02) ¶
fmt.Println(exampleAST(269, "\U00100000 \n#define a( b , ... ) "))
Output: &cc.ControlLine{ · Case: 2, · IdentifierList: &cc.IdentifierList{ · · Token: example269.c:2:12: IDENTIFIER "b", · }, · ReplacementList: []xc.Token{ // len 1 · · 0: example269.c:2:21: ' ', · }, · Token: example269.c:2:2: PPDEFINE, · Token2: example269.c:2:9: IDENTIFIER_LPAREN "a(", · Token3: example269.c:2:14: ',', · Token4: example269.c:2:16: DDD, · Token5: example269.c:2:20: ')', }
Example (Case03) ¶
fmt.Println(exampleAST(270, "\U00100000 \n#define a( ) "))
Output: &cc.ControlLine{ · Case: 3, · ReplacementList: []xc.Token{ // len 1 · · 0: example270.c:2:13: ' ', · }, · Token: example270.c:2:2: PPDEFINE, · Token2: example270.c:2:9: IDENTIFIER_LPAREN "a(", · Token3: example270.c:2:12: ')', }
Example (Case04) ¶
fmt.Println(exampleAST(271, "\U00100000 \n#error "))
Output: &cc.ControlLine{ · Case: 4, · PPTokenListOpt: []xc.Token{ // len 1 · · 0: example271.c:2:7: ' ', · }, · Token: example271.c:2:2: PPERROR, }
Example (Case05) ¶
fmt.Println(exampleAST(272, "\U00100000 \n#"))
Output: &cc.ControlLine{ · Case: 5, · Token: example272.c:2:2: PPHASH_NL, }
Example (Case06) ¶
fmt.Println(exampleAST(273, "\U00100000 \n#include other_a "))
Output: &cc.ControlLine{ · Case: 6, · PPTokenList: []xc.Token{ // len 3 · · 0: example273.c:2:9: ' ', · · 1: example273.c:2:10: IDENTIFIER "other_a", · · 2: example273.c:2:17: ' ', · }, · Token: example273.c:2:2: PPINCLUDE, · Token2: example273.c:2:18: '\n', }
Example (Case07) ¶
fmt.Println(exampleAST(274, "\U00100000 \n#line other_a "))
Output: &cc.ControlLine{ · Case: 7, · PPTokenList: []xc.Token{ // len 3 · · 0: example274.c:2:6: ' ', · · 1: example274.c:2:7: IDENTIFIER "other_a", · · 2: example274.c:2:14: ' ', · }, · Token: example274.c:2:2: PPLINE, · Token2: example274.c:2:15: '\n', }
Example (Case08) ¶
fmt.Println(exampleAST(275, "\U00100000 \n#pragma "))
Output: &cc.ControlLine{ · Case: 8, · PPTokenListOpt: []xc.Token{ // len 1 · · 0: example275.c:2:8: ' ', · }, · Token: example275.c:2:2: PPPRAGMA, }
Example (Case09) ¶
fmt.Println(exampleAST(276, "\U00100000 \n#undef foo"))
Output: &cc.ControlLine{ · Case: 9, · Token: example276.c:2:2: PPUNDEF, · Token2: example276.c:2:8: IDENTIFIER "foo", · Token3: example276.c:2:11: '\n', }
Example (Case10) ¶
fmt.Println(exampleAST(277, "\U00100000 \n#define a( b ... ) "))
Output: &cc.ControlLine{ · Case: 10, · ReplacementList: []xc.Token{ // len 1 · · 0: example277.c:2:19: ' ', · }, · Token: example277.c:2:2: PPDEFINE, · Token2: example277.c:2:9: IDENTIFIER_LPAREN "a(", · Token3: example277.c:2:12: IDENTIFIER "b", · Token4: example277.c:2:14: DDD, · Token5: example277.c:2:18: ')', }
Example (Case11) ¶
fmt.Println(exampleAST(278, "\U00100000 \n#define a( b , c ... ) "))
Output: &cc.ControlLine{ · Case: 11, · IdentifierList: &cc.IdentifierList{ · · Token: example278.c:2:12: IDENTIFIER "b", · }, · ReplacementList: []xc.Token{ // len 1 · · 0: example278.c:2:23: ' ', · }, · Token: example278.c:2:2: PPDEFINE, · Token2: example278.c:2:9: IDENTIFIER_LPAREN "a(", · Token3: example278.c:2:14: ',', · Token4: example278.c:2:16: IDENTIFIER "c", · Token5: example278.c:2:18: DDD, · Token6: example278.c:2:22: ')', }
Example (Case12) ¶
fmt.Println(exampleAST(279, "\U00100000 \n#define "))
Output: &cc.ControlLine{ · Case: 12, · Token: example279.c:2:2: PPDEFINE, · Token2: example279.c:2:9: '\n', }
Example (Case13) ¶
fmt.Println(exampleAST(280, "\U00100000 \n#undef foo(bar)"))
Output: &cc.ControlLine{ · Case: 13, · PPTokenList: []xc.Token{ // len 3 · · 0: example280.c:2:11: '(', · · 1: example280.c:2:12: IDENTIFIER "bar", · · 2: example280.c:2:15: ')', · }, · Token: example280.c:2:2: PPUNDEF, · Token2: example280.c:2:8: IDENTIFIER "foo", · Token3: example280.c:2:16: '\n', }
Example (Case14) ¶
fmt.Println(exampleAST(281, "\U00100000 \n#include_next other_a "))
Output: &cc.ControlLine{ · Case: 14, · PPTokenList: []xc.Token{ // len 3 · · 0: example281.c:2:14: ' ', · · 1: example281.c:2:15: IDENTIFIER "other_a", · · 2: example281.c:2:22: ' ', · }, · Token: example281.c:2:2: PPINCLUDE_NEXT, · Token2: example281.c:2:23: '\n', }
func (*ControlLine) Pos ¶
func (n *ControlLine) Pos() token.Pos
Pos reports the position of the first component of n or zero if it's empty.
type Declaration ¶
type Declaration struct { DeclarationSpecifiers *DeclarationSpecifiers InitDeclaratorListOpt *InitDeclaratorListOpt Token xc.Token // contains filtered or unexported fields }
Declaration represents data reduced by production:
Declaration: DeclarationSpecifiers InitDeclaratorListOpt ';'
Example ¶
fmt.Println(exampleAST(76, "\U00100002 auto ;"))
Output: &cc.Declaration{ · DeclarationSpecifiers: &cc.DeclarationSpecifiers{ · · StorageClassSpecifier: &cc.StorageClassSpecifier{ · · · Case: 3, · · · Token: example76.c:1:6: AUTO "auto", · · }, · }, · Token: example76.c:1:11: ';', }
func (*Declaration) Declarator ¶
func (n *Declaration) Declarator() *Declarator
Declarator returns a synthetic Declarator when n.InitDeclaratorListOpt is nil.
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.
type DeclarationList ¶
type DeclarationList struct { Case int Declaration *Declaration DeclarationList *DeclarationList }
DeclarationList represents data reduced by productions:
DeclarationList: Declaration | DeclarationList Declaration // Case 1
Example ¶
fmt.Println(exampleAST(240, "\U00100002 auto a auto ; {"))
Output: &cc.DeclarationList{ · Declaration: &cc.Declaration{ · · DeclarationSpecifiers: &cc.DeclarationSpecifiers{ · · · StorageClassSpecifier: &cc.StorageClassSpecifier{ · · · · Case: 3, · · · · Token: example240.c:1:13: AUTO "auto", · · · }, · · }, · · Token: example240.c:1:18: ';', · }, }
Example (Case1) ¶
fmt.Println(exampleAST(241, "\U00100002 auto a auto ; auto ; {"))
Output: &cc.DeclarationList{ · Declaration: &cc.Declaration{ · · DeclarationSpecifiers: &cc.DeclarationSpecifiers{ · · · StorageClassSpecifier: &cc.StorageClassSpecifier{ · · · · Case: 3, · · · · Token: example241.c:1:13: AUTO "auto", · · · }, · · }, · · Token: example241.c:1:18: ';', · }, · DeclarationList: &cc.DeclarationList{ · · Case: 1, · · Declaration: &cc.Declaration{ · · · DeclarationSpecifiers: &cc.DeclarationSpecifiers{ · · · · StorageClassSpecifier: &cc.StorageClassSpecifier{ · · · · · Case: 3, · · · · · Token: example241.c:1:20: AUTO "auto", · · · · }, · · · }, · · · Token: example241.c:1:25: ';', · · }, · }, }
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 // contains filtered or unexported fields }
DeclarationListOpt represents data reduced by productions:
DeclarationListOpt: /* empty */ | DeclarationList // Case 1
Example ¶
fmt.Println(exampleAST(242, "\U00100002 auto a {") == (*DeclarationListOpt)(nil))
Output: true
Example (Case1) ¶
fmt.Println(exampleAST(244, "\U00100002 auto a auto ; {"))
Output: &cc.DeclarationListOpt{ · DeclarationList: &cc.DeclarationList{ · · Declaration: &cc.Declaration{ · · · DeclarationSpecifiers: &cc.DeclarationSpecifiers{ · · · · StorageClassSpecifier: &cc.StorageClassSpecifier{ · · · · · Case: 3, · · · · · Token: example244.c:1:13: AUTO "auto", · · · · }, · · · }, · · · Token: example244.c:1:18: ';', · · }, · }, }
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 DeclarationSpecifiers ¶
type DeclarationSpecifiers struct { Case int DeclarationSpecifiersOpt *DeclarationSpecifiersOpt FunctionSpecifier *FunctionSpecifier StorageClassSpecifier *StorageClassSpecifier TypeQualifier *TypeQualifier TypeSpecifier *TypeSpecifier // contains filtered or unexported fields }
DeclarationSpecifiers represents data reduced by productions:
DeclarationSpecifiers: StorageClassSpecifier DeclarationSpecifiersOpt | TypeSpecifier DeclarationSpecifiersOpt // Case 1 | TypeQualifier DeclarationSpecifiersOpt // Case 2 | FunctionSpecifier DeclarationSpecifiersOpt // Case 3
Example ¶
fmt.Println(exampleAST(77, "\U00100002 auto ("))
Output: &cc.DeclarationSpecifiers{ · StorageClassSpecifier: &cc.StorageClassSpecifier{ · · Case: 3, · · Token: example77.c:1:6: AUTO "auto", · }, }
Example (Case1) ¶
fmt.Println(exampleAST(78, "\U00100002 _Bool ("))
Output: &cc.DeclarationSpecifiers{ · Case: 1, · TypeSpecifier: &cc.TypeSpecifier{ · · Case: 9, · · Token: example78.c:1:6: BOOL "_Bool", · }, }
Example (Case2) ¶
fmt.Println(exampleAST(79, "\U00100002 const ("))
Output: &cc.DeclarationSpecifiers{ · Case: 2, · TypeQualifier: &cc.TypeQualifier{ · · Token: example79.c:1:6: CONST "const", · }, }
Example (Case3) ¶
fmt.Println(exampleAST(80, "\U00100002 inline ("))
Output: &cc.DeclarationSpecifiers{ · Case: 3, · FunctionSpecifier: &cc.FunctionSpecifier{ · · Token: example80.c:1:6: INLINE "inline", · }, }
func (*DeclarationSpecifiers) IsConst ¶
func (n *DeclarationSpecifiers) IsConst() bool
IsConst returns whether n includes the 'const' type qualifier.
func (*DeclarationSpecifiers) IsStatic ¶
func (n *DeclarationSpecifiers) IsStatic() bool
IsStatic implements specifier.
func (*DeclarationSpecifiers) IsTypedef ¶
func (n *DeclarationSpecifiers) IsTypedef() bool
IsTypedef implements specifier.
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.
func (*DeclarationSpecifiers) TypedefName ¶
func (n *DeclarationSpecifiers) TypedefName() int
TypedefName implements Specifier.
type DeclarationSpecifiersOpt ¶
type DeclarationSpecifiersOpt struct { DeclarationSpecifiers *DeclarationSpecifiers // contains filtered or unexported fields }
DeclarationSpecifiersOpt represents data reduced by productions:
DeclarationSpecifiersOpt: /* empty */ | DeclarationSpecifiers // Case 1
Example ¶
fmt.Println(exampleAST(81, "\U00100002 auto (") == (*DeclarationSpecifiersOpt)(nil))
Output: true
Example (Case1) ¶
fmt.Println(exampleAST(82, "\U00100002 inline auto ("))
Output: &cc.DeclarationSpecifiersOpt{ · DeclarationSpecifiers: &cc.DeclarationSpecifiers{ · · StorageClassSpecifier: &cc.StorageClassSpecifier{ · · · Case: 3, · · · Token: example82.c:1:13: AUTO "auto", · · }, · }, }
func (*DeclarationSpecifiersOpt) Pos ¶
func (n *DeclarationSpecifiersOpt) Pos() token.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 { Linkage Linkage Type Type DirectDeclarator *DirectDeclarator PointerOpt *PointerOpt // contains filtered or unexported fields }
Declarator represents data reduced by production:
Declarator: PointerOpt DirectDeclarator
Example ¶
fmt.Println(exampleAST(142, "\U00100002 auto a )"))
Output: &cc.Declarator{ · Linkage: None, · DirectDeclarator: &cc.DirectDeclarator{ · · Token: example142.c:1:11: IDENTIFIER "a", · }, }
func (*Declarator) Identifier ¶
func (n *Declarator) Identifier() (int, *Bindings)
Identifier returns the ID of the name declared by n and the scope the name is declared in.
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) RawSpecifier ¶
func (n *Declarator) RawSpecifier() Specifier
RawSpecifier returns the raw Specifier associated with n before expanding typedefs. The effective Specifier is accessible via the Type field of n.
type DeclaratorOpt ¶
type DeclaratorOpt struct {
Declarator *Declarator
}
DeclaratorOpt represents data reduced by productions:
DeclaratorOpt: /* empty */ | Declarator // Case 1
Example ¶
fmt.Println(exampleAST(143, "\U00100002 struct { _Bool :") == (*DeclaratorOpt)(nil))
Output: true
Example (Case1) ¶
fmt.Println(exampleAST(144, "\U00100002 struct { _Bool a :"))
Output: &cc.DeclaratorOpt{ · Declarator: &cc.Declarator{ · · Linkage: None, · · DirectDeclarator: &cc.DirectDeclarator{ · · · Token: example144.c:1:21: 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 { DesignatorList *DesignatorList Token xc.Token }
Designation represents data reduced by production:
Designation: DesignatorList '='
Example ¶
fmt.Println(exampleAST(198, "\U00100001 ( _Bool ) { . a = !"))
Output: &cc.Designation{ · DesignatorList: &cc.DesignatorList{ · · Designator: &cc.Designator{ · · · Case: 1, · · · Token: example198.c:1:18: '.', · · · Token2: example198.c:1:20: IDENTIFIER "a", · · }, · }, · Token: example198.c:1:22: '=', }
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.
type DesignationOpt ¶
type DesignationOpt struct {
Designation *Designation
}
DesignationOpt represents data reduced by productions:
DesignationOpt: /* empty */ | Designation // Case 1
Example ¶
fmt.Println(exampleAST(199, "\U00100001 ( _Bool ) { !") == (*DesignationOpt)(nil))
Output: true
Example (Case1) ¶
fmt.Println(exampleAST(200, "\U00100001 ( _Bool ) { . a = !"))
Output: &cc.DesignationOpt{ · Designation: &cc.Designation{ · · DesignatorList: &cc.DesignatorList{ · · · Designator: &cc.Designator{ · · · · Case: 1, · · · · Token: example200.c:1:18: '.', · · · · Token2: example200.c:1:20: IDENTIFIER "a", · · · }, · · }, · · Token: example200.c:1:22: '=', · }, }
func (*DesignationOpt) Pos ¶
func (n *DesignationOpt) Pos() token.Pos
Pos reports the position of the first component of n or zero if it's empty.
func (*DesignationOpt) String ¶
func (n *DesignationOpt) String() string
String implements fmt.Stringer.
type Designator ¶
type Designator struct { Case int ConstantExpression *ConstantExpression Token xc.Token Token2 xc.Token }
Designator represents data reduced by productions:
Designator: '[' ConstantExpression ']' | '.' IDENTIFIER // Case 1
Example ¶
fmt.Println(exampleAST(203, "\U00100001 ( _Bool ) { [ 'a' ] ."))
Output: &cc.Designator{ · ConstantExpression: &cc.ConstantExpression{ · · Type: int, · · Value: 97, · · Expression: &cc.Expression{ · · · Type: int, · · · Value: 97, · · · Case: 1, · · · Token: example203.c:1:20: CHARCONST "'a'", · · }, · }, · Token: example203.c:1:18: '[', · Token2: example203.c:1:24: ']', }
Example (Case1) ¶
fmt.Println(exampleAST(204, "\U00100001 ( _Bool ) { . a ."))
Output: &cc.Designator{ · Case: 1, · Token: example204.c:1:18: '.', · Token2: example204.c:1:20: IDENTIFIER "a", }
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.
type DesignatorList ¶
type DesignatorList struct { Case int Designator *Designator DesignatorList *DesignatorList }
DesignatorList represents data reduced by productions:
DesignatorList: Designator | DesignatorList Designator // Case 1
Example ¶
fmt.Println(exampleAST(201, "\U00100001 ( _Bool ) { . a ."))
Output: &cc.DesignatorList{ · Designator: &cc.Designator{ · · Case: 1, · · Token: example201.c:1:18: '.', · · Token2: example201.c:1:20: IDENTIFIER "a", · }, }
Example (Case1) ¶
fmt.Println(exampleAST(202, "\U00100001 ( _Bool ) { . a . b ."))
Output: &cc.DesignatorList{ · Designator: &cc.Designator{ · · Case: 1, · · Token: example202.c:1:18: '.', · · Token2: example202.c:1:20: IDENTIFIER "a", · }, · DesignatorList: &cc.DesignatorList{ · · Case: 1, · · Designator: &cc.Designator{ · · · Case: 1, · · · Token: example202.c:1:22: '.', · · · Token2: example202.c:1:24: 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 int DirectAbstractDeclarator *DirectAbstractDeclarator DirectAbstractDeclaratorOpt *DirectAbstractDeclaratorOpt Expression *Expression ExpressionOpt *ExpressionOpt ParameterTypeListOpt *ParameterTypeListOpt Token xc.Token Token2 xc.Token Token3 xc.Token TypeQualifierList *TypeQualifierList TypeQualifierListOpt *TypeQualifierListOpt // contains filtered or unexported fields }
DirectAbstractDeclarator represents data reduced by productions:
DirectAbstractDeclarator: '(' AbstractDeclarator ')' | DirectAbstractDeclaratorOpt '[' ExpressionOpt ']' // Case 1 | DirectAbstractDeclaratorOpt '[' TypeQualifierList ExpressionOpt ']' // Case 2 | DirectAbstractDeclaratorOpt '[' "static" TypeQualifierListOpt Expression ']' // Case 3 | DirectAbstractDeclaratorOpt '[' TypeQualifierList "static" Expression ']' // Case 4 | DirectAbstractDeclaratorOpt '[' '*' ']' // Case 5 | '(' ParameterTypeListOpt ')' // Case 6 | DirectAbstractDeclarator '(' ParameterTypeListOpt ')' // Case 7
Example ¶
fmt.Println(exampleAST(182, "\U00100001 ( _Bool ( * ) ("))
Output: &cc.DirectAbstractDeclarator{ · AbstractDeclarator: &cc.AbstractDeclarator{ · · Pointer: &cc.Pointer{ · · · Token: example182.c:1:16: '*', · · }, · }, · Token: example182.c:1:14: '(', · Token2: example182.c:1:18: ')', }
Example (Case1) ¶
fmt.Println(exampleAST(183, "\U00100001 ( _Bool [ ] ("))
Output: &cc.DirectAbstractDeclarator{ · Case: 1, · Token: example183.c:1:14: '[', · Token2: example183.c:1:16: ']', }
Example (Case2) ¶
fmt.Println(exampleAST(184, "\U00100001 ( _Bool [ const ] ("))
Output: &cc.DirectAbstractDeclarator{ · Case: 2, · Token: example184.c:1:14: '[', · Token2: example184.c:1:22: ']', · TypeQualifierList: &cc.TypeQualifierList{ · · TypeQualifier: &cc.TypeQualifier{ · · · Token: example184.c:1:16: CONST "const", · · }, · }, }
Example (Case3) ¶
fmt.Println(exampleAST(185, "\U00100001 ( _Bool [ static 'a' ] ("))
Output: &cc.DirectAbstractDeclarator{ · Case: 3, · Expression: &cc.Expression{ · · Type: int, · · Value: 97, · · Case: 1, · · Token: example185.c:1:23: CHARCONST "'a'", · }, · Token: example185.c:1:14: '[', · Token2: example185.c:1:16: STATIC "static", · Token3: example185.c:1:27: ']', }
Example (Case4) ¶
fmt.Println(exampleAST(186, "\U00100001 ( _Bool [ const static 'a' ] ("))
Output: &cc.DirectAbstractDeclarator{ · Case: 4, · Expression: &cc.Expression{ · · Type: int, · · Value: 97, · · Case: 1, · · Token: example186.c:1:29: CHARCONST "'a'", · }, · Token: example186.c:1:14: '[', · Token2: example186.c:1:22: STATIC "static", · Token3: example186.c:1:33: ']', · TypeQualifierList: &cc.TypeQualifierList{ · · TypeQualifier: &cc.TypeQualifier{ · · · Token: example186.c:1:16: CONST "const", · · }, · }, }
Example (Case5) ¶
fmt.Println(exampleAST(187, "\U00100001 ( _Bool [ * ] ("))
Output: &cc.DirectAbstractDeclarator{ · Case: 5, · Token: example187.c:1:14: '[', · Token2: example187.c:1:16: '*', · Token3: example187.c:1:18: ']', }
Example (Case6) ¶
fmt.Println(exampleAST(189, "\U00100001 ( _Bool ( ) ("))
Output: &cc.DirectAbstractDeclarator{ · Case: 6, · Token: example189.c:1:14: '(', · Token2: example189.c:1:16: ')', }
Example (Case7) ¶
fmt.Println(exampleAST(191, "\U00100001 ( _Bool ( ) ( ) ("))
Output: &cc.DirectAbstractDeclarator{ · Case: 7, · DirectAbstractDeclarator: &cc.DirectAbstractDeclarator{ · · Case: 6, · · Token: example191.c:1:14: '(', · · Token2: example191.c:1:16: ')', · }, · Token: example191.c:1:18: '(', · Token2: example191.c:1:20: ')', }
func (*DirectAbstractDeclarator) Pos ¶
func (n *DirectAbstractDeclarator) Pos() token.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 DirectAbstractDeclaratorOpt ¶
type DirectAbstractDeclaratorOpt struct {
DirectAbstractDeclarator *DirectAbstractDeclarator
}
DirectAbstractDeclaratorOpt represents data reduced by productions:
DirectAbstractDeclaratorOpt: /* empty */ | DirectAbstractDeclarator // Case 1
Example ¶
fmt.Println(exampleAST(192, "\U00100001 ( _Bool [") == (*DirectAbstractDeclaratorOpt)(nil))
Output: true
Example (Case1) ¶
fmt.Println(exampleAST(193, "\U00100001 ( _Bool ( ) ["))
Output: &cc.DirectAbstractDeclaratorOpt{ · DirectAbstractDeclarator: &cc.DirectAbstractDeclarator{ · · Case: 6, · · Token: example193.c:1:14: '(', · · Token2: example193.c:1:16: ')', · }, }
func (*DirectAbstractDeclaratorOpt) Pos ¶
func (n *DirectAbstractDeclaratorOpt) Pos() token.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 { EnumVal interface{} // Non nil if DD declares an enumeration constant. Case int Declarator *Declarator DirectDeclarator *DirectDeclarator Expression *Expression ExpressionOpt *ExpressionOpt 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: IDENTIFIER | '(' Declarator ')' // Case 1 | DirectDeclarator '[' TypeQualifierListOpt ExpressionOpt ']' // Case 2 | DirectDeclarator '[' "static" TypeQualifierListOpt Expression ']' // Case 3 | DirectDeclarator '[' TypeQualifierList "static" Expression ']' // Case 4 | DirectDeclarator '[' TypeQualifierListOpt '*' ']' // Case 5 | DirectDeclarator '(' ParameterTypeList ')' // Case 6 | DirectDeclarator '(' IdentifierListOpt ')' // Case 7
Example ¶
fmt.Println(exampleAST(145, "\U00100002 auto a ("))
Output: &cc.DirectDeclarator{ · Token: example145.c:1:11: IDENTIFIER "a", }
Example (Case1) ¶
fmt.Println(exampleAST(146, "\U00100002 auto ( a ) ("))
Output: &cc.DirectDeclarator{ · Case: 1, · Declarator: &cc.Declarator{ · · Linkage: None, · · DirectDeclarator: &cc.DirectDeclarator{ · · · Token: example146.c:1:13: IDENTIFIER "a", · · }, · }, · Token: example146.c:1:11: '(', · Token2: example146.c:1:15: ')', }
Example (Case2) ¶
fmt.Println(exampleAST(147, "\U00100002 auto a [ ] ("))
Output: &cc.DirectDeclarator{ · Case: 2, · DirectDeclarator: &cc.DirectDeclarator{ · · Token: example147.c:1:11: IDENTIFIER "a", · }, · Token: example147.c:1:13: '[', · Token2: example147.c:1:15: ']', }
Example (Case3) ¶
fmt.Println(exampleAST(148, "\U00100002 auto a [ static 'b' ] ("))
Output: &cc.DirectDeclarator{ · Case: 3, · DirectDeclarator: &cc.DirectDeclarator{ · · Token: example148.c:1:11: IDENTIFIER "a", · }, · Expression: &cc.Expression{ · · Type: int, · · Value: 98, · · Case: 1, · · Token: example148.c:1:22: CHARCONST "'b'", · }, · Token: example148.c:1:13: '[', · Token2: example148.c:1:15: STATIC "static", · Token3: example148.c:1:26: ']', }
Example (Case4) ¶
fmt.Println(exampleAST(149, "\U00100002 auto a [ const static 'b' ] ("))
Output: &cc.DirectDeclarator{ · Case: 4, · DirectDeclarator: &cc.DirectDeclarator{ · · Token: example149.c:1:11: IDENTIFIER "a", · }, · Expression: &cc.Expression{ · · Type: int, · · Value: 98, · · Case: 1, · · Token: example149.c:1:28: CHARCONST "'b'", · }, · Token: example149.c:1:13: '[', · Token2: example149.c:1:21: STATIC "static", · Token3: example149.c:1:32: ']', · TypeQualifierList: &cc.TypeQualifierList{ · · TypeQualifier: &cc.TypeQualifier{ · · · Token: example149.c:1:15: CONST "const", · · }, · }, }
Example (Case5) ¶
fmt.Println(exampleAST(150, "\U00100002 auto a [ * ] ("))
Output: &cc.DirectDeclarator{ · Case: 5, · DirectDeclarator: &cc.DirectDeclarator{ · · Token: example150.c:1:11: IDENTIFIER "a", · }, · Token: example150.c:1:13: '[', · Token2: example150.c:1:15: '*', · Token3: example150.c:1:17: ']', }
Example (Case6) ¶
fmt.Println(exampleAST(152, "\U00100002 auto a ( auto ) ("))
Output: &cc.DirectDeclarator{ · Case: 6, · DirectDeclarator: &cc.DirectDeclarator{ · · Token: example152.c:1:11: IDENTIFIER "a", · }, · ParameterTypeList: &cc.ParameterTypeList{ · · ParameterList: &cc.ParameterList{ · · · ParameterDeclaration: &cc.ParameterDeclaration{ · · · · Case: 1, · · · · DeclarationSpecifiers: &cc.DeclarationSpecifiers{ · · · · · StorageClassSpecifier: &cc.StorageClassSpecifier{ · · · · · · Case: 3, · · · · · · Token: example152.c:1:15: AUTO "auto", · · · · · }, · · · · }, · · · }, · · }, · }, · Token: example152.c:1:13: '(', · Token2: example152.c:1:20: ')', }
Example (Case7) ¶
fmt.Println(exampleAST(153, "\U00100002 auto a ( ) ("))
Output: &cc.DirectDeclarator{ · Case: 7, · DirectDeclarator: &cc.DirectDeclarator{ · · Token: example153.c:1:11: IDENTIFIER "a", · }, · Token: example153.c:1:13: '(', · Token2: example153.c:1:15: ')', }
func (*DirectDeclarator) DeclarationScope ¶
func (n *DirectDeclarator) DeclarationScope() *Bindings
DeclarationScope returns the scope a name declared by n is in. If n does not declare a name or n declares a name of a built in type, DeclarationScope returns nil.
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.
func (*DirectDeclarator) TopDeclarator ¶
func (n *DirectDeclarator) TopDeclarator() *Declarator
TopDeclarator returns the top level Declarator associated with n.
type ElifGroup ¶
type ElifGroup struct { GroupListOpt *GroupListOpt PPTokenList PPTokenList Token xc.Token Token2 xc.Token }
ElifGroup represents data reduced by production:
ElifGroup: PPELIF PPTokenList '\n' GroupListOpt
Example ¶
fmt.Println(exampleAST(262, "\U00100000 \n#if other_a \n#elif other_b \n#elif"))
Output: &cc.ElifGroup{ · PPTokenList: []xc.Token{ // len 3 · · 0: example262.c:3:6: ' ', · · 1: example262.c:3:7: IDENTIFIER "other_b", · · 2: example262.c:3:14: ' ', · }, · Token: example262.c:3:2: PPELIF, · Token2: example262.c:3:16: '\n', }
type ElifGroupList ¶
type ElifGroupList struct { Case int ElifGroup *ElifGroup ElifGroupList *ElifGroupList }
ElifGroupList represents data reduced by productions:
ElifGroupList: ElifGroup | ElifGroupList ElifGroup // Case 1
Example ¶
fmt.Println(exampleAST(258, "\U00100000 \n#if other_a \n#elif other_b \n#elif"))
Output: &cc.ElifGroupList{ · ElifGroup: &cc.ElifGroup{ · · PPTokenList: []xc.Token{ // len 3 · · · 0: example258.c:3:6: ' ', · · · 1: example258.c:3:7: IDENTIFIER "other_b", · · · 2: example258.c:3:14: ' ', · · }, · · Token: example258.c:3:2: PPELIF, · · Token2: example258.c:3:16: '\n', · }, }
Example (Case1) ¶
fmt.Println(exampleAST(259, "\U00100000 \n#if other_a \n#elif other_b \n#elif other_c \n#elif"))
Output: &cc.ElifGroupList{ · ElifGroup: &cc.ElifGroup{ · · PPTokenList: []xc.Token{ // len 3 · · · 0: example259.c:3:6: ' ', · · · 1: example259.c:3:7: IDENTIFIER "other_b", · · · 2: example259.c:3:14: ' ', · · }, · · Token: example259.c:3:2: PPELIF, · · Token2: example259.c:3:16: '\n', · }, · ElifGroupList: &cc.ElifGroupList{ · · Case: 1, · · ElifGroup: &cc.ElifGroup{ · · · PPTokenList: []xc.Token{ // len 3 · · · · 0: example259.c:4:6: ' ', · · · · 1: example259.c:4:7: IDENTIFIER "other_c", · · · · 2: example259.c:4:14: ' ', · · · }, · · · Token: example259.c:4:2: PPELIF, · · · Token2: example259.c:4:16: '\n', · · }, · }, }
func (*ElifGroupList) Pos ¶
func (n *ElifGroupList) Pos() token.Pos
Pos reports the position of the first component of n or zero if it's empty.
func (*ElifGroupList) String ¶
func (n *ElifGroupList) String() string
String implements fmt.Stringer.
type ElifGroupListOpt ¶
type ElifGroupListOpt struct {
ElifGroupList *ElifGroupList
}
ElifGroupListOpt represents data reduced by productions:
ElifGroupListOpt: /* empty */ | ElifGroupList // Case 1
Example ¶
fmt.Println(exampleAST(260, "\U00100000 \n#if other_a \n#else") == (*ElifGroupListOpt)(nil))
Output: true
Example (Case1) ¶
fmt.Println(exampleAST(261, "\U00100000 \n#if other_a \n#elif other_b \n#else"))
Output: &cc.ElifGroupListOpt{ · ElifGroupList: &cc.ElifGroupList{ · · ElifGroup: &cc.ElifGroup{ · · · PPTokenList: []xc.Token{ // len 3 · · · · 0: example261.c:3:6: ' ', · · · · 1: example261.c:3:7: IDENTIFIER "other_b", · · · · 2: example261.c:3:14: ' ', · · · }, · · · Token: example261.c:3:2: PPELIF, · · · Token2: example261.c:3:16: '\n', · · }, · }, }
func (*ElifGroupListOpt) Pos ¶
func (n *ElifGroupListOpt) Pos() token.Pos
Pos reports the position of the first component of n or zero if it's empty.
func (*ElifGroupListOpt) String ¶
func (n *ElifGroupListOpt) String() string
String implements fmt.Stringer.
type ElseGroup ¶
type ElseGroup struct { GroupListOpt *GroupListOpt Token xc.Token Token2 xc.Token }
ElseGroup represents data reduced by production:
ElseGroup: PPELSE '\n' GroupListOpt
Example ¶
fmt.Println(exampleAST(263, "\U00100000 \n#if other_a \n#else \n#endif"))
Output: &cc.ElseGroup{ · Token: example263.c:3:2: PPELSE, · Token2: example263.c:3:8: '\n', }
type ElseGroupOpt ¶
type ElseGroupOpt struct {
ElseGroup *ElseGroup
}
ElseGroupOpt represents data reduced by productions:
ElseGroupOpt: /* empty */ | ElseGroup // Case 1
Example ¶
fmt.Println(exampleAST(264, "\U00100000 \n#if other_a \n#endif") == (*ElseGroupOpt)(nil))
Output: true
Example (Case1) ¶
fmt.Println(exampleAST(265, "\U00100000 \n#if other_a \n#else \n#endif"))
Output: &cc.ElseGroupOpt{ · ElseGroup: &cc.ElseGroup{ · · Token: example265.c:3:2: PPELSE, · · Token2: example265.c:3:8: '\n', · }, }
func (*ElseGroupOpt) Pos ¶
func (n *ElseGroupOpt) Pos() token.Pos
Pos reports the position of the first component of n or zero if it's empty.
func (*ElseGroupOpt) String ¶
func (n *ElseGroupOpt) String() string
String implements fmt.Stringer.
type EndifLine ¶
EndifLine represents data reduced by production:
EndifLine: PPENDIF
Example ¶
fmt.Println(exampleAST(266, "\U00100000 \n#if other_a \n#endif"))
Output: &cc.EndifLine{ · Token: example266.c:3:2: PPENDIF, }
type EnumConstant ¶
type EnumConstant struct { DefTok xc.Token // Enumeration constant name definition token. Value interface{} // Value represented by name. Type of Value is C int. Tokens []xc.Token // The tokens the constant expression consists of. }
EnumConstant represents the name/value pair defined by an Enumerator.
type EnumSpecifier ¶
type EnumSpecifier struct { Case int CommaOpt *CommaOpt EnumeratorList *EnumeratorList IdentifierOpt *IdentifierOpt Token xc.Token Token2 xc.Token Token3 xc.Token }
EnumSpecifier represents data reduced by productions:
EnumSpecifier: "enum" IdentifierOpt '{' EnumeratorList CommaOpt '}' | "enum" IDENTIFIER // Case 1
Example ¶
fmt.Println(exampleAST(132, "\U00100002 enum { a } ("))
Output: &cc.EnumSpecifier{ · EnumeratorList: &cc.EnumeratorList{ · · Enumerator: &cc.Enumerator{ · · · EnumerationConstant: &cc.EnumerationConstant{ · · · · Token: example132.c:1:13: IDENTIFIER "a", · · · }, · · }, · }, · Token: example132.c:1:6: ENUM "enum", · Token2: example132.c:1:11: '{', · Token3: example132.c:1:15: '}', }
Example (Case1) ¶
fmt.Println(exampleAST(133, "\U00100002 enum a ("))
Output: &cc.EnumSpecifier{ · Case: 1, · Token: example133.c:1:6: ENUM "enum", · Token2: example133.c:1:11: 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 EnumerationConstant ¶
EnumerationConstant represents data reduced by production:
EnumerationConstant: IDENTIFIER
Example ¶
fmt.Println(exampleAST(7, "\U00100002 enum { a ,"))
Output: &cc.EnumerationConstant{ · Token: example7.c:1:13: 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 int ConstantExpression *ConstantExpression EnumerationConstant *EnumerationConstant Token xc.Token // contains filtered or unexported fields }
Enumerator represents data reduced by productions:
Enumerator: EnumerationConstant | EnumerationConstant '=' ConstantExpression // Case 1
Example ¶
fmt.Println(exampleAST(136, "\U00100002 enum { a ,"))
Output: &cc.Enumerator{ · EnumerationConstant: &cc.EnumerationConstant{ · · Token: example136.c:1:13: IDENTIFIER "a", · }, }
Example (Case1) ¶
fmt.Println(exampleAST(137, "\U00100002 enum { a = 'b' ,"))
Output: &cc.Enumerator{ · Case: 1, · ConstantExpression: &cc.ConstantExpression{ · · Type: int, · · Value: 98, · · Expression: &cc.Expression{ · · · Type: int, · · · Value: 98, · · · Case: 1, · · · Token: example137.c:1:17: CHARCONST "'b'", · · }, · }, · EnumerationConstant: &cc.EnumerationConstant{ · · Token: example137.c:1:13: IDENTIFIER "a", · }, · Token: example137.c:1:15: '=', }
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.
type EnumeratorList ¶
type EnumeratorList struct { Case int Enumerator *Enumerator EnumeratorList *EnumeratorList Token xc.Token }
EnumeratorList represents data reduced by productions:
EnumeratorList: Enumerator | EnumeratorList ',' Enumerator // Case 1
Example ¶
fmt.Println(exampleAST(134, "\U00100002 enum { a ,"))
Output: &cc.EnumeratorList{ · Enumerator: &cc.Enumerator{ · · EnumerationConstant: &cc.EnumerationConstant{ · · · Token: example134.c:1:13: IDENTIFIER "a", · · }, · }, }
Example (Case1) ¶
fmt.Println(exampleAST(135, "\U00100002 enum { a , b ,"))
Output: &cc.EnumeratorList{ · Enumerator: &cc.Enumerator{ · · EnumerationConstant: &cc.EnumerationConstant{ · · · Token: example135.c:1:13: IDENTIFIER "a", · · }, · }, · EnumeratorList: &cc.EnumeratorList{ · · Case: 1, · · Enumerator: &cc.Enumerator{ · · · EnumerationConstant: &cc.EnumerationConstant{ · · · · Token: example135.c:1:17: IDENTIFIER "b", · · · }, · · }, · · Token: example135.c:1:15: ',', · }, }
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 Expression ¶
type Expression struct { BinOpType Type // The type operands of binary expression are coerced into, if different from Type. Type Type // Type of expression. Value interface{} // Non nil for certain constant expressions. ArgumentExpressionListOpt *ArgumentExpressionListOpt Case int CommaOpt *CommaOpt Expression *Expression Expression2 *Expression ExpressionList *ExpressionList InitializerList *InitializerList Token xc.Token Token2 xc.Token Token3 xc.Token Token4 xc.Token TypeName *TypeName // contains filtered or unexported fields }
Expression represents data reduced by productions:
Expression: IDENTIFIER | CHARCONST // Case 1 | FLOATCONST // Case 2 | INTCONST // Case 3 | LONGCHARCONST // Case 4 | LONGSTRINGLITERAL // Case 5 | STRINGLITERAL // Case 6 | '(' ExpressionList ')' // Case 7 | Expression '[' ExpressionList ']' // Case 8 | Expression '(' ArgumentExpressionListOpt ')' // Case 9 | Expression '.' IDENTIFIER // Case 10 | Expression "->" IDENTIFIER // Case 11 | Expression "++" // Case 12 | Expression "--" // Case 13 | '(' TypeName ')' '{' InitializerList CommaOpt '}' // Case 14 | "++" Expression // Case 15 | "--" Expression // Case 16 | '&' Expression // Case 17 | '*' Expression // Case 18 | '+' Expression // Case 19 | '-' Expression // Case 20 | '~' Expression // Case 21 | '!' Expression // Case 22 | "sizeof" Expression // Case 23 | "sizeof" '(' TypeName ')' // Case 24 | '(' TypeName ')' Expression // Case 25 | Expression '*' Expression // Case 26 | Expression '/' Expression // Case 27 | Expression '%' Expression // Case 28 | Expression '+' Expression // Case 29 | Expression '-' Expression // Case 30 | Expression "<<" Expression // Case 31 | Expression ">>" Expression // Case 32 | Expression '<' Expression // Case 33 | Expression '>' Expression // Case 34 | Expression "<=" Expression // Case 35 | Expression ">=" Expression // Case 36 | Expression "==" Expression // Case 37 | Expression "!=" Expression // Case 38 | Expression '&' Expression // Case 39 | Expression '^' Expression // Case 40 | Expression '|' Expression // Case 41 | Expression "&&" Expression // Case 42 | Expression "||" Expression // Case 43 | Expression '?' ExpressionList ':' Expression // Case 44 | Expression '=' Expression // Case 45 | Expression "*=" Expression // Case 46 | Expression "/=" Expression // Case 47 | Expression "%=" Expression // Case 48 | Expression "+=" Expression // Case 49 | Expression "-=" Expression // Case 50 | Expression "<<=" Expression // Case 51 | Expression ">>=" Expression // Case 52 | Expression "&=" Expression // Case 53 | Expression "^=" Expression // Case 54 | Expression "|=" Expression // Case 55
Example ¶
fmt.Println(exampleAST(12, "\U00100001 a"))
Output: &cc.Expression{ · Token: example12.c:1:6: IDENTIFIER "a", }
Example (Case01) ¶
fmt.Println(exampleAST(13, "\U00100001 'a'"))
Output: &cc.Expression{ · Case: 1, · Token: example13.c:1:6: CHARCONST "'a'", }
Example (Case02) ¶
fmt.Println(exampleAST(14, "\U00100001 1.97"))
Output: &cc.Expression{ · Case: 2, · Token: example14.c:1:6: FLOATCONST "1.97", }
Example (Case03) ¶
fmt.Println(exampleAST(15, "\U00100001 97"))
Output: &cc.Expression{ · Case: 3, · Token: example15.c:1:6: INTCONST "97", }
Example (Case04) ¶
fmt.Println(exampleAST(16, "\U00100001 L'a'"))
Output: &cc.Expression{ · Case: 4, · Token: example16.c:1:6: LONGCHARCONST "L'a'", }
Example (Case05) ¶
fmt.Println(exampleAST(17, "\U00100001 L\"a\""))
Output: &cc.Expression{ · Case: 5, · Token: example17.c:1:6: LONGSTRINGLITERAL "L\"a\"", }
Example (Case06) ¶
fmt.Println(exampleAST(18, "\U00100001 \"a\""))
Output: &cc.Expression{ · Case: 6, · Token: example18.c:1:6: STRINGLITERAL "\"a\"", }
Example (Case07) ¶
fmt.Println(exampleAST(19, "\U00100001 ( 'a' )"))
Output: &cc.Expression{ · Case: 7, · ExpressionList: &cc.ExpressionList{ · · Expression: &cc.Expression{ · · · Case: 1, · · · Token: example19.c:1:8: CHARCONST "'a'", · · }, · }, · Token: example19.c:1:6: '(', · Token2: example19.c:1:12: ')', }
Example (Case08) ¶
fmt.Println(exampleAST(20, "\U00100001 'a' [ 'b' ]"))
Output: &cc.Expression{ · Case: 8, · Expression: &cc.Expression{ · · Case: 1, · · Token: example20.c:1:6: CHARCONST "'a'", · }, · ExpressionList: &cc.ExpressionList{ · · Expression: &cc.Expression{ · · · Case: 1, · · · Token: example20.c:1:12: CHARCONST "'b'", · · }, · }, · Token: example20.c:1:10: '[', · Token2: example20.c:1:16: ']', }
Example (Case09) ¶
fmt.Println(exampleAST(21, "\U00100001 'a' ( )"))
Output: &cc.Expression{ · Case: 9, · Expression: &cc.Expression{ · · Case: 1, · · Token: example21.c:1:6: CHARCONST "'a'", · }, · Token: example21.c:1:10: '(', · Token2: example21.c:1:12: ')', }
Example (Case10) ¶
fmt.Println(exampleAST(22, "\U00100001 'a' . b"))
Output: &cc.Expression{ · Case: 10, · Expression: &cc.Expression{ · · Case: 1, · · Token: example22.c:1:6: CHARCONST "'a'", · }, · Token: example22.c:1:10: '.', · Token2: example22.c:1:12: IDENTIFIER "b", }
Example (Case11) ¶
fmt.Println(exampleAST(23, "\U00100001 'a' -> b"))
Output: &cc.Expression{ · Case: 11, · Expression: &cc.Expression{ · · Case: 1, · · Token: example23.c:1:6: CHARCONST "'a'", · }, · Token: example23.c:1:10: ARROW, · Token2: example23.c:1:13: IDENTIFIER "b", }
Example (Case12) ¶
fmt.Println(exampleAST(24, "\U00100001 'a' ++"))
Output: &cc.Expression{ · Case: 12, · Expression: &cc.Expression{ · · Case: 1, · · Token: example24.c:1:6: CHARCONST "'a'", · }, · Token: example24.c:1:10: INC, }
Example (Case13) ¶
fmt.Println(exampleAST(25, "\U00100001 'a' --"))
Output: &cc.Expression{ · Case: 13, · Expression: &cc.Expression{ · · Case: 1, · · Token: example25.c:1:6: CHARCONST "'a'", · }, · Token: example25.c:1:10: DEC, }
Example (Case14) ¶
fmt.Println(exampleAST(26, "\U00100001 ( _Bool ) { 'a' }"))
Output: &cc.Expression{ · Case: 14, · InitializerList: &cc.InitializerList{ · · Initializer: &cc.Initializer{ · · · Expression: &cc.Expression{ · · · · Type: int, · · · · Value: 97, · · · · Case: 1, · · · · Token: example26.c:1:18: CHARCONST "'a'", · · · }, · · }, · }, · Token: example26.c:1:6: '(', · Token2: example26.c:1:14: ')', · Token3: example26.c:1:16: '{', · Token4: example26.c:1:22: '}', · TypeName: &cc.TypeName{ · · Type: bool, · · SpecifierQualifierList: &cc.SpecifierQualifierList{ · · · TypeSpecifier: &cc.TypeSpecifier{ · · · · Case: 9, · · · · Token: example26.c:1:8: BOOL "_Bool", · · · }, · · }, · }, }
Example (Case15) ¶
fmt.Println(exampleAST(27, "\U00100001 ++ 'a'"))
Output: &cc.Expression{ · Case: 15, · Expression: &cc.Expression{ · · Case: 1, · · Token: example27.c:1:9: CHARCONST "'a'", · }, · Token: example27.c:1:6: INC, }
Example (Case16) ¶
fmt.Println(exampleAST(28, "\U00100001 -- 'a'"))
Output: &cc.Expression{ · Case: 16, · Expression: &cc.Expression{ · · Case: 1, · · Token: example28.c:1:9: CHARCONST "'a'", · }, · Token: example28.c:1:6: DEC, }
Example (Case17) ¶
fmt.Println(exampleAST(29, "\U00100001 & 'a'"))
Output: &cc.Expression{ · Case: 17, · Expression: &cc.Expression{ · · Case: 1, · · Token: example29.c:1:8: CHARCONST "'a'", · }, · Token: example29.c:1:6: '&', }
Example (Case18) ¶
fmt.Println(exampleAST(30, "\U00100001 * 'a'"))
Output: &cc.Expression{ · Case: 18, · Expression: &cc.Expression{ · · Case: 1, · · Token: example30.c:1:8: CHARCONST "'a'", · }, · Token: example30.c:1:6: '*', }
Example (Case19) ¶
fmt.Println(exampleAST(31, "\U00100001 + 'a'"))
Output: &cc.Expression{ · Case: 19, · Expression: &cc.Expression{ · · Case: 1, · · Token: example31.c:1:8: CHARCONST "'a'", · }, · Token: example31.c:1:6: '+', }
Example (Case20) ¶
fmt.Println(exampleAST(32, "\U00100001 - 'a'"))
Output: &cc.Expression{ · Case: 20, · Expression: &cc.Expression{ · · Case: 1, · · Token: example32.c:1:8: CHARCONST "'a'", · }, · Token: example32.c:1:6: '-', }
Example (Case21) ¶
fmt.Println(exampleAST(33, "\U00100001 ~ 'a'"))
Output: &cc.Expression{ · Case: 21, · Expression: &cc.Expression{ · · Case: 1, · · Token: example33.c:1:8: CHARCONST "'a'", · }, · Token: example33.c:1:6: '~', }
Example (Case22) ¶
fmt.Println(exampleAST(34, "\U00100001 ! 'a'"))
Output: &cc.Expression{ · Case: 22, · Expression: &cc.Expression{ · · Case: 1, · · Token: example34.c:1:8: CHARCONST "'a'", · }, · Token: example34.c:1:6: '!', }
Example (Case23) ¶
fmt.Println(exampleAST(35, "\U00100001 sizeof 'a'"))
Output: &cc.Expression{ · Case: 23, · Expression: &cc.Expression{ · · Case: 1, · · Token: example35.c:1:13: CHARCONST "'a'", · }, · Token: example35.c:1:6: SIZEOF "sizeof", }
Example (Case24) ¶
fmt.Println(exampleAST(36, "\U00100001 sizeof ( _Bool )"))
Output: &cc.Expression{ · Case: 24, · Token: example36.c:1:6: SIZEOF "sizeof", · Token2: example36.c:1:13: '(', · Token3: example36.c:1:21: ')', · TypeName: &cc.TypeName{ · · Type: bool, · · SpecifierQualifierList: &cc.SpecifierQualifierList{ · · · TypeSpecifier: &cc.TypeSpecifier{ · · · · Case: 9, · · · · Token: example36.c:1:15: BOOL "_Bool", · · · }, · · }, · }, }
Example (Case25) ¶
fmt.Println(exampleAST(37, "\U00100001 ( _Bool ) 'a'"))
Output: &cc.Expression{ · Case: 25, · Expression: &cc.Expression{ · · Case: 1, · · Token: example37.c:1:16: CHARCONST "'a'", · }, · Token: example37.c:1:6: '(', · Token2: example37.c:1:14: ')', · TypeName: &cc.TypeName{ · · Type: bool, · · SpecifierQualifierList: &cc.SpecifierQualifierList{ · · · TypeSpecifier: &cc.TypeSpecifier{ · · · · Case: 9, · · · · Token: example37.c:1:8: BOOL "_Bool", · · · }, · · }, · }, }
Example (Case26) ¶
fmt.Println(exampleAST(38, "\U00100001 'a' * 'b'"))
Output: &cc.Expression{ · Case: 26, · Expression: &cc.Expression{ · · Case: 1, · · Token: example38.c:1:6: CHARCONST "'a'", · }, · Expression2: &cc.Expression{ · · Case: 1, · · Token: example38.c:1:12: CHARCONST "'b'", · }, · Token: example38.c:1:10: '*', }
Example (Case27) ¶
fmt.Println(exampleAST(39, "\U00100001 'a' / 'b'"))
Output: &cc.Expression{ · Case: 27, · Expression: &cc.Expression{ · · Case: 1, · · Token: example39.c:1:6: CHARCONST "'a'", · }, · Expression2: &cc.Expression{ · · Case: 1, · · Token: example39.c:1:12: CHARCONST "'b'", · }, · Token: example39.c:1:10: '/', }
Example (Case28) ¶
fmt.Println(exampleAST(40, "\U00100001 'a' % 'b'"))
Output: &cc.Expression{ · Case: 28, · Expression: &cc.Expression{ · · Case: 1, · · Token: example40.c:1:6: CHARCONST "'a'", · }, · Expression2: &cc.Expression{ · · Case: 1, · · Token: example40.c:1:12: CHARCONST "'b'", · }, · Token: example40.c:1:10: '%', }
Example (Case29) ¶
fmt.Println(exampleAST(41, "\U00100001 'a' + 'b'"))
Output: &cc.Expression{ · Case: 29, · Expression: &cc.Expression{ · · Case: 1, · · Token: example41.c:1:6: CHARCONST "'a'", · }, · Expression2: &cc.Expression{ · · Case: 1, · · Token: example41.c:1:12: CHARCONST "'b'", · }, · Token: example41.c:1:10: '+', }
Example (Case30) ¶
fmt.Println(exampleAST(42, "\U00100001 'a' - 'b'"))
Output: &cc.Expression{ · Case: 30, · Expression: &cc.Expression{ · · Case: 1, · · Token: example42.c:1:6: CHARCONST "'a'", · }, · Expression2: &cc.Expression{ · · Case: 1, · · Token: example42.c:1:12: CHARCONST "'b'", · }, · Token: example42.c:1:10: '-', }
Example (Case31) ¶
fmt.Println(exampleAST(43, "\U00100001 'a' << 'b'"))
Output: &cc.Expression{ · Case: 31, · Expression: &cc.Expression{ · · Case: 1, · · Token: example43.c:1:6: CHARCONST "'a'", · }, · Expression2: &cc.Expression{ · · Case: 1, · · Token: example43.c:1:13: CHARCONST "'b'", · }, · Token: example43.c:1:10: LSH, }
Example (Case32) ¶
fmt.Println(exampleAST(44, "\U00100001 'a' >> 'b'"))
Output: &cc.Expression{ · Case: 32, · Expression: &cc.Expression{ · · Case: 1, · · Token: example44.c:1:6: CHARCONST "'a'", · }, · Expression2: &cc.Expression{ · · Case: 1, · · Token: example44.c:1:13: CHARCONST "'b'", · }, · Token: example44.c:1:10: RSH, }
Example (Case33) ¶
fmt.Println(exampleAST(45, "\U00100001 'a' < 'b'"))
Output: &cc.Expression{ · Case: 33, · Expression: &cc.Expression{ · · Case: 1, · · Token: example45.c:1:6: CHARCONST "'a'", · }, · Expression2: &cc.Expression{ · · Case: 1, · · Token: example45.c:1:12: CHARCONST "'b'", · }, · Token: example45.c:1:10: '<', }
Example (Case34) ¶
fmt.Println(exampleAST(46, "\U00100001 'a' > 'b'"))
Output: &cc.Expression{ · Case: 34, · Expression: &cc.Expression{ · · Case: 1, · · Token: example46.c:1:6: CHARCONST "'a'", · }, · Expression2: &cc.Expression{ · · Case: 1, · · Token: example46.c:1:12: CHARCONST "'b'", · }, · Token: example46.c:1:10: '>', }
Example (Case35) ¶
fmt.Println(exampleAST(47, "\U00100001 'a' <= 'b'"))
Output: &cc.Expression{ · Case: 35, · Expression: &cc.Expression{ · · Case: 1, · · Token: example47.c:1:6: CHARCONST "'a'", · }, · Expression2: &cc.Expression{ · · Case: 1, · · Token: example47.c:1:13: CHARCONST "'b'", · }, · Token: example47.c:1:10: LEQ, }
Example (Case36) ¶
fmt.Println(exampleAST(48, "\U00100001 'a' >= 'b'"))
Output: &cc.Expression{ · Case: 36, · Expression: &cc.Expression{ · · Case: 1, · · Token: example48.c:1:6: CHARCONST "'a'", · }, · Expression2: &cc.Expression{ · · Case: 1, · · Token: example48.c:1:13: CHARCONST "'b'", · }, · Token: example48.c:1:10: GEQ, }
Example (Case37) ¶
fmt.Println(exampleAST(49, "\U00100001 'a' == 'b'"))
Output: &cc.Expression{ · Case: 37, · Expression: &cc.Expression{ · · Case: 1, · · Token: example49.c:1:6: CHARCONST "'a'", · }, · Expression2: &cc.Expression{ · · Case: 1, · · Token: example49.c:1:13: CHARCONST "'b'", · }, · Token: example49.c:1:10: EQ, }
Example (Case38) ¶
fmt.Println(exampleAST(50, "\U00100001 'a' != 'b'"))
Output: &cc.Expression{ · Case: 38, · Expression: &cc.Expression{ · · Case: 1, · · Token: example50.c:1:6: CHARCONST "'a'", · }, · Expression2: &cc.Expression{ · · Case: 1, · · Token: example50.c:1:13: CHARCONST "'b'", · }, · Token: example50.c:1:10: NEQ, }
Example (Case39) ¶
fmt.Println(exampleAST(51, "\U00100001 'a' & 'b'"))
Output: &cc.Expression{ · Case: 39, · Expression: &cc.Expression{ · · Case: 1, · · Token: example51.c:1:6: CHARCONST "'a'", · }, · Expression2: &cc.Expression{ · · Case: 1, · · Token: example51.c:1:12: CHARCONST "'b'", · }, · Token: example51.c:1:10: '&', }
Example (Case40) ¶
fmt.Println(exampleAST(52, "\U00100001 'a' ^ 'b'"))
Output: &cc.Expression{ · Case: 40, · Expression: &cc.Expression{ · · Case: 1, · · Token: example52.c:1:6: CHARCONST "'a'", · }, · Expression2: &cc.Expression{ · · Case: 1, · · Token: example52.c:1:12: CHARCONST "'b'", · }, · Token: example52.c:1:10: '^', }
Example (Case41) ¶
fmt.Println(exampleAST(53, "\U00100001 'a' | 'b'"))
Output: &cc.Expression{ · Case: 41, · Expression: &cc.Expression{ · · Case: 1, · · Token: example53.c:1:6: CHARCONST "'a'", · }, · Expression2: &cc.Expression{ · · Case: 1, · · Token: example53.c:1:12: CHARCONST "'b'", · }, · Token: example53.c:1:10: '|', }
Example (Case42) ¶
fmt.Println(exampleAST(54, "\U00100001 'a' && 'b'"))
Output: &cc.Expression{ · Case: 42, · Expression: &cc.Expression{ · · Case: 1, · · Token: example54.c:1:6: CHARCONST "'a'", · }, · Expression2: &cc.Expression{ · · Case: 1, · · Token: example54.c:1:13: CHARCONST "'b'", · }, · Token: example54.c:1:10: ANDAND, }
Example (Case43) ¶
fmt.Println(exampleAST(55, "\U00100001 'a' || 'b'"))
Output: &cc.Expression{ · Case: 43, · Expression: &cc.Expression{ · · Case: 1, · · Token: example55.c:1:6: CHARCONST "'a'", · }, · Expression2: &cc.Expression{ · · Case: 1, · · Token: example55.c:1:13: CHARCONST "'b'", · }, · Token: example55.c:1:10: OROR, }
Example (Case44) ¶
fmt.Println(exampleAST(56, "\U00100001 'a' ? 'b' : 'c'"))
Output: &cc.Expression{ · Case: 44, · Expression: &cc.Expression{ · · Case: 1, · · Token: example56.c:1:6: CHARCONST "'a'", · }, · Expression2: &cc.Expression{ · · Case: 1, · · Token: example56.c:1:18: CHARCONST "'c'", · }, · ExpressionList: &cc.ExpressionList{ · · Expression: &cc.Expression{ · · · Case: 1, · · · Token: example56.c:1:12: CHARCONST "'b'", · · }, · }, · Token: example56.c:1:10: '?', · Token2: example56.c:1:16: ':', }
Example (Case45) ¶
fmt.Println(exampleAST(57, "\U00100001 'a' = 'b'"))
Output: &cc.Expression{ · Case: 45, · Expression: &cc.Expression{ · · Case: 1, · · Token: example57.c:1:6: CHARCONST "'a'", · }, · Expression2: &cc.Expression{ · · Case: 1, · · Token: example57.c:1:12: CHARCONST "'b'", · }, · Token: example57.c:1:10: '=', }
Example (Case46) ¶
fmt.Println(exampleAST(58, "\U00100001 'a' *= 'b'"))
Output: &cc.Expression{ · Case: 46, · Expression: &cc.Expression{ · · Case: 1, · · Token: example58.c:1:6: CHARCONST "'a'", · }, · Expression2: &cc.Expression{ · · Case: 1, · · Token: example58.c:1:13: CHARCONST "'b'", · }, · Token: example58.c:1:10: MULASSIGN, }
Example (Case47) ¶
fmt.Println(exampleAST(59, "\U00100001 'a' /= 'b'"))
Output: &cc.Expression{ · Case: 47, · Expression: &cc.Expression{ · · Case: 1, · · Token: example59.c:1:6: CHARCONST "'a'", · }, · Expression2: &cc.Expression{ · · Case: 1, · · Token: example59.c:1:13: CHARCONST "'b'", · }, · Token: example59.c:1:10: DIVASSIGN, }
Example (Case48) ¶
fmt.Println(exampleAST(60, "\U00100001 'a' %= 'b'"))
Output: &cc.Expression{ · Case: 48, · Expression: &cc.Expression{ · · Case: 1, · · Token: example60.c:1:6: CHARCONST "'a'", · }, · Expression2: &cc.Expression{ · · Case: 1, · · Token: example60.c:1:13: CHARCONST "'b'", · }, · Token: example60.c:1:10: MODASSIGN, }
Example (Case49) ¶
fmt.Println(exampleAST(61, "\U00100001 'a' += 'b'"))
Output: &cc.Expression{ · Case: 49, · Expression: &cc.Expression{ · · Case: 1, · · Token: example61.c:1:6: CHARCONST "'a'", · }, · Expression2: &cc.Expression{ · · Case: 1, · · Token: example61.c:1:13: CHARCONST "'b'", · }, · Token: example61.c:1:10: ADDASSIGN, }
Example (Case50) ¶
fmt.Println(exampleAST(62, "\U00100001 'a' -= 'b'"))
Output: &cc.Expression{ · Case: 50, · Expression: &cc.Expression{ · · Case: 1, · · Token: example62.c:1:6: CHARCONST "'a'", · }, · Expression2: &cc.Expression{ · · Case: 1, · · Token: example62.c:1:13: CHARCONST "'b'", · }, · Token: example62.c:1:10: SUBASSIGN, }
Example (Case51) ¶
fmt.Println(exampleAST(63, "\U00100001 'a' <<= 'b'"))
Output: &cc.Expression{ · Case: 51, · Expression: &cc.Expression{ · · Case: 1, · · Token: example63.c:1:6: CHARCONST "'a'", · }, · Expression2: &cc.Expression{ · · Case: 1, · · Token: example63.c:1:14: CHARCONST "'b'", · }, · Token: example63.c:1:10: LSHASSIGN, }
Example (Case52) ¶
fmt.Println(exampleAST(64, "\U00100001 'a' >>= 'b'"))
Output: &cc.Expression{ · Case: 52, · Expression: &cc.Expression{ · · Case: 1, · · Token: example64.c:1:6: CHARCONST "'a'", · }, · Expression2: &cc.Expression{ · · Case: 1, · · Token: example64.c:1:14: CHARCONST "'b'", · }, · Token: example64.c:1:10: RSHASSIGN, }
Example (Case53) ¶
fmt.Println(exampleAST(65, "\U00100001 'a' &= 'b'"))
Output: &cc.Expression{ · Case: 53, · Expression: &cc.Expression{ · · Case: 1, · · Token: example65.c:1:6: CHARCONST "'a'", · }, · Expression2: &cc.Expression{ · · Case: 1, · · Token: example65.c:1:13: CHARCONST "'b'", · }, · Token: example65.c:1:10: ANDASSIGN, }
Example (Case54) ¶
fmt.Println(exampleAST(66, "\U00100001 'a' ^= 'b'"))
Output: &cc.Expression{ · Case: 54, · Expression: &cc.Expression{ · · Case: 1, · · Token: example66.c:1:6: CHARCONST "'a'", · }, · Expression2: &cc.Expression{ · · Case: 1, · · Token: example66.c:1:13: CHARCONST "'b'", · }, · Token: example66.c:1:10: XORASSIGN, }
Example (Case55) ¶
fmt.Println(exampleAST(67, "\U00100001 'a' |= 'b'"))
Output: &cc.Expression{ · Case: 55, · Expression: &cc.Expression{ · · Case: 1, · · Token: example67.c:1:6: CHARCONST "'a'", · }, · Expression2: &cc.Expression{ · · Case: 1, · · Token: example67.c:1:13: CHARCONST "'b'", · }, · Token: example67.c:1:10: ORASSIGN, }
func (*Expression) IdentResolutionScope ¶
func (n *Expression) IdentResolutionScope() *Bindings
IdentResolutionScope returns the scope an identifier is resolved in. If n is not an identifier (n.Case == 0), IdentResolutionScope returns nil.
func (*Expression) Pos ¶
func (n *Expression) Pos() token.Pos
Pos reports the position of the first component of n or zero if it's empty.
type ExpressionList ¶
type ExpressionList struct { Type Type // Type of expression. Value interface{} // Non nil for certain constant expressions. Case int Expression *Expression ExpressionList *ExpressionList Token xc.Token }
ExpressionList represents data reduced by productions:
ExpressionList: Expression | ExpressionList ',' Expression // Case 1
Example ¶
fmt.Println(exampleAST(70, "\U00100001 ( 'a' )"))
Output: &cc.ExpressionList{ · Expression: &cc.Expression{ · · Case: 1, · · Token: example70.c:1:8: CHARCONST "'a'", · }, }
Example (Case1) ¶
fmt.Println(exampleAST(71, "\U00100001 ( 'a' , 'b' )"))
Output: &cc.ExpressionList{ · Expression: &cc.Expression{ · · Case: 1, · · Token: example71.c:1:8: CHARCONST "'a'", · }, · ExpressionList: &cc.ExpressionList{ · · Case: 1, · · Expression: &cc.Expression{ · · · Case: 1, · · · Token: example71.c:1:14: CHARCONST "'b'", · · }, · · Token: example71.c:1:12: ',', · }, }
func (*ExpressionList) Len ¶
func (n *ExpressionList) Len() (r int)
Len returns the number of items in n.
func (*ExpressionList) Pos ¶
func (n *ExpressionList) Pos() token.Pos
Pos reports the position of the first component of n or zero if it's empty.
func (*ExpressionList) String ¶
func (n *ExpressionList) String() string
String implements fmt.Stringer.
type ExpressionListOpt ¶
type ExpressionListOpt struct {
ExpressionList *ExpressionList
}
ExpressionListOpt represents data reduced by productions:
ExpressionListOpt: /* empty */ | ExpressionList // Case 1
Example ¶
fmt.Println(exampleAST(72, "\U00100002 auto a { ;") == (*ExpressionListOpt)(nil))
Output: true
Example (Case1) ¶
fmt.Println(exampleAST(73, "\U00100002 auto a { 'b' )"))
Output: &cc.ExpressionListOpt{ · ExpressionList: &cc.ExpressionList{ · · Type: int, · · Value: 98, · · Expression: &cc.Expression{ · · · Type: int, · · · Value: 98, · · · Case: 1, · · · Token: example73.c:1:15: CHARCONST "'b'", · · }, · }, }
func (*ExpressionListOpt) Pos ¶
func (n *ExpressionListOpt) Pos() token.Pos
Pos reports the position of the first component of n or zero if it's empty.
func (*ExpressionListOpt) String ¶
func (n *ExpressionListOpt) String() string
String implements fmt.Stringer.
type ExpressionOpt ¶
type ExpressionOpt struct {
Expression *Expression
}
ExpressionOpt represents data reduced by productions:
ExpressionOpt: /* empty */ | Expression // Case 1
Example ¶
fmt.Println(exampleAST(68, "\U00100001 ( _Bool [ ]") == (*ExpressionOpt)(nil))
Output: true
Example (Case1) ¶
fmt.Println(exampleAST(69, "\U00100001 ( _Bool [ 'a' ]"))
Output: &cc.ExpressionOpt{ · Expression: &cc.Expression{ · · Type: int, · · Value: 97, · · Case: 1, · · Token: example69.c:1:16: CHARCONST "'a'", · }, }
func (*ExpressionOpt) Pos ¶
func (n *ExpressionOpt) Pos() token.Pos
Pos reports the position of the first component of n or zero if it's empty.
func (*ExpressionOpt) String ¶
func (n *ExpressionOpt) String() string
String implements fmt.Stringer.
type ExpressionStatement ¶
type ExpressionStatement struct { ExpressionListOpt *ExpressionListOpt Token xc.Token }
ExpressionStatement represents data reduced by production:
ExpressionStatement: ExpressionListOpt ';'
Example ¶
fmt.Println(exampleAST(222, "\U00100002 auto a { ; !"))
Output: &cc.ExpressionStatement{ · Token: example222.c:1:15: ';', }
func (*ExpressionStatement) Pos ¶
func (n *ExpressionStatement) Pos() token.Pos
Pos reports the position of the first component of n or zero if it's empty.
func (*ExpressionStatement) String ¶
func (n *ExpressionStatement) String() string
String implements fmt.Stringer.
type ExternalDeclaration ¶
type ExternalDeclaration struct { Case int Declaration *Declaration FunctionDefinition *FunctionDefinition }
ExternalDeclaration represents data reduced by productions:
ExternalDeclaration: FunctionDefinition | Declaration // Case 1
Example ¶
fmt.Println(exampleAST(236, "\U00100002 auto a { }"))
Output: &cc.ExternalDeclaration{ · FunctionDefinition: &cc.FunctionDefinition{ · · CompoundStatement: &cc.CompoundStatement{ · · · Token: example236.c:1:13: '{', · · · Token2: example236.c:1:15: '}', · · }, · · DeclarationSpecifiers: &cc.DeclarationSpecifiers{ · · · StorageClassSpecifier: &cc.StorageClassSpecifier{ · · · · Case: 3, · · · · Token: example236.c:1:6: AUTO "auto", · · · }, · · }, · · Declarator: &cc.Declarator{ · · · Linkage: None, · · · Type: auto undefined, · · · DirectDeclarator: &cc.DirectDeclarator{ · · · · Token: example236.c:1:11: IDENTIFIER "a", · · · }, · · }, · }, }
Example (Case1) ¶
fmt.Println(exampleAST(237, "\U00100002 auto ;"))
Output: &cc.ExternalDeclaration{ · Case: 1, · Declaration: &cc.Declaration{ · · DeclarationSpecifiers: &cc.DeclarationSpecifiers{ · · · StorageClassSpecifier: &cc.StorageClassSpecifier{ · · · · Case: 3, · · · · Token: example237.c:1:6: AUTO "auto", · · · }, · · }, · · Token: example237.c:1:11: ';', · }, }
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 FunctionDefinition ¶
type FunctionDefinition struct { CompoundStatement *CompoundStatement DeclarationListOpt *DeclarationListOpt DeclarationSpecifiers *DeclarationSpecifiers Declarator *Declarator }
FunctionDefinition represents data reduced by production:
FunctionDefinition: DeclarationSpecifiers Declarator DeclarationListOpt CompoundStatement
Example ¶
fmt.Println(exampleAST(239, "\U00100002 auto a { }"))
Output: &cc.FunctionDefinition{ · CompoundStatement: &cc.CompoundStatement{ · · Token: example239.c:1:13: '{', · · Token2: example239.c:1:15: '}', · }, · DeclarationSpecifiers: &cc.DeclarationSpecifiers{ · · StorageClassSpecifier: &cc.StorageClassSpecifier{ · · · Case: 3, · · · Token: example239.c:1:6: AUTO "auto", · · }, · }, · Declarator: &cc.Declarator{ · · Linkage: None, · · Type: auto undefined, · · DirectDeclarator: &cc.DirectDeclarator{ · · · Token: example239.c:1:11: IDENTIFIER "a", · · }, · }, }
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 FunctionSpecifier ¶
FunctionSpecifier represents data reduced by production:
FunctionSpecifier: "inline"
Example ¶
fmt.Println(exampleAST(141, "\U00100002 inline ("))
Output: &cc.FunctionSpecifier{ · Token: example141.c:1:6: 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 GroupList ¶
GroupList represents data reduced by productions:
GroupList: GroupPart | GroupList GroupPart // Case 1
Example ¶
fmt.Println(exampleAST(246, "\U00100000 "))
Output: &cc.GroupList{ }
Example (Case1) ¶
fmt.Println(exampleAST(247, "\U00100000int\nf() {}"))
Output: &cc.GroupList{ · GroupList: &cc.GroupList{ · · Case: 1, · · GroupPart: []xc.Token{ // len 6 · · · 0: example247.c:2:1: IDENTIFIER "f", · · · 1: example247.c:2:2: '(', · · · 2: example247.c:2:3: ')', · · · 3: example247.c:2:4: ' ', · · · 4: example247.c:2:5: '{', · · · 5: example247.c:2:6: '}', · · }, · }, · GroupPart: []xc.Token{ // len 1 · · 0: example247.c:1:5: IDENTIFIER "int", · }, }
type GroupListOpt ¶
type GroupListOpt struct {
GroupList *GroupList
}
GroupListOpt represents data reduced by productions:
GroupListOpt: /* empty */ | GroupList // Case 1
Example ¶
fmt.Println(exampleAST(248, "\U00100000 \n#ifndef a \n#elif") == (*GroupListOpt)(nil))
Output: true
Example (Case1) ¶
fmt.Println(exampleAST(249, "\U00100000 \n#ifndef a\nb\n#elif"))
Output: &cc.GroupListOpt{ · GroupList: &cc.GroupList{ · · GroupPart: []xc.Token{ // len 1 · · · 0: example249.c:3:1: IDENTIFIER "b", · · }, · }, }
func (*GroupListOpt) Pos ¶
func (n *GroupListOpt) Pos() token.Pos
Pos reports the position of the first component of n or zero if it's empty.
func (*GroupListOpt) String ¶
func (n *GroupListOpt) String() string
String implements fmt.Stringer.
type IdentifierList ¶
type IdentifierList struct { Case int IdentifierList *IdentifierList Token xc.Token Token2 xc.Token }
IdentifierList represents data reduced by productions:
IdentifierList: IDENTIFIER | IdentifierList ',' IDENTIFIER // Case 1
Example ¶
fmt.Println(exampleAST(170, "\U00100002 auto a ( b )"))
Output: &cc.IdentifierList{ · Token: example170.c:1:15: IDENTIFIER "b", }
Example (Case1) ¶
fmt.Println(exampleAST(171, "\U00100002 auto a ( b , c )"))
Output: &cc.IdentifierList{ · IdentifierList: &cc.IdentifierList{ · · Case: 1, · · Token: example171.c:1:17: ',', · · Token2: example171.c:1:19: IDENTIFIER "c", · }, · Token: example171.c:1:15: 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 // contains filtered or unexported fields }
IdentifierListOpt represents data reduced by productions:
IdentifierListOpt: /* empty */ | IdentifierList // Case 1
Example ¶
fmt.Println(exampleAST(172, "\U00100002 auto a ( )") == (*IdentifierListOpt)(nil))
Output: true
Example (Case1) ¶
fmt.Println(exampleAST(173, "\U00100002 auto a ( b )"))
Output: &cc.IdentifierListOpt{ · IdentifierList: &cc.IdentifierList{ · · Token: example173.c:1:15: 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 ¶
IdentifierOpt represents data reduced by productions:
IdentifierOpt: /* empty */ | IDENTIFIER // Case 1
Example ¶
fmt.Println(exampleAST(174, "\U00100002 struct {") == (*IdentifierOpt)(nil))
Output: true
Example (Case1) ¶
fmt.Println(exampleAST(175, "\U00100002 enum a {"))
Output: &cc.IdentifierOpt{ · Token: example175.c:1:11: 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 IfGroup ¶
type IfGroup struct { Case int GroupListOpt *GroupListOpt PPTokenList PPTokenList Token xc.Token Token2 xc.Token Token3 xc.Token }
IfGroup represents data reduced by productions:
IfGroup: PPIF PPTokenList '\n' GroupListOpt | PPIFDEF IDENTIFIER '\n' GroupListOpt // Case 1 | PPIFNDEF IDENTIFIER '\n' GroupListOpt // Case 2
Example ¶
fmt.Println(exampleAST(255, "\U00100000 \n#if other_a \n#elif"))
Output: &cc.IfGroup{ · PPTokenList: []xc.Token{ // len 3 · · 0: example255.c:2:4: ' ', · · 1: example255.c:2:5: IDENTIFIER "other_a", · · 2: example255.c:2:12: ' ', · }, · Token: example255.c:2:2: PPIF, · Token2: example255.c:2:14: '\n', }
Example (Case1) ¶
fmt.Println(exampleAST(256, "\U00100000 \n#ifdef a \n#elif"))
Output: &cc.IfGroup{ · Case: 1, · Token: example256.c:2:2: PPIFDEF, · Token2: example256.c:2:8: IDENTIFIER "a", · Token3: example256.c:2:11: '\n', }
Example (Case2) ¶
fmt.Println(exampleAST(257, "\U00100000 \n#ifndef a \n#elif"))
Output: &cc.IfGroup{ · Case: 2, · Token: example257.c:2:2: PPIFNDEF, · Token2: example257.c:2:9: IDENTIFIER "a", · Token3: example257.c:2:12: '\n', }
type IfSection ¶
type IfSection struct { ElifGroupListOpt *ElifGroupListOpt ElseGroupOpt *ElseGroupOpt EndifLine *EndifLine IfGroup *IfGroup }
IfSection represents data reduced by production:
IfSection: IfGroup ElifGroupListOpt ElseGroupOpt EndifLine
Example ¶
fmt.Println(exampleAST(254, "\U00100000 \n#if other_a \n#endif"))
Output: &cc.IfSection{ · EndifLine: &cc.EndifLine{ · · Token: example254.c:3:2: PPENDIF, · }, · IfGroup: &cc.IfGroup{ · · PPTokenList: []xc.Token{ // len 3 · · · 0: example254.c:2:4: ' ', · · · 1: example254.c:2:5: IDENTIFIER "other_a", · · · 2: example254.c:2:12: ' ', · · }, · · Token: example254.c:2:2: PPIF, · · Token2: example254.c:2:14: '\n', · }, }
type InitDeclarator ¶
type InitDeclarator struct { Case int Declarator *Declarator Initializer *Initializer Token xc.Token }
InitDeclarator represents data reduced by productions:
InitDeclarator: Declarator | Declarator '=' Initializer // Case 1
Example ¶
fmt.Println(exampleAST(87, "\U00100002 auto a ,"))
Output: &cc.InitDeclarator{ · Declarator: &cc.Declarator{ · · Linkage: None, · · Type: auto undefined, · · DirectDeclarator: &cc.DirectDeclarator{ · · · Token: example87.c:1:11: IDENTIFIER "a", · · }, · }, }
Example (Case1) ¶
fmt.Println(exampleAST(89, "\U00100002 auto a = 'b' ,"))
Output: &cc.InitDeclarator{ · Case: 1, · Declarator: &cc.Declarator{ · · Linkage: None, · · Type: auto undefined, · · DirectDeclarator: &cc.DirectDeclarator{ · · · Token: example89.c:1:11: IDENTIFIER "a", · · }, · }, · Initializer: &cc.Initializer{ · · Expression: &cc.Expression{ · · · Type: int, · · · Value: 98, · · · Case: 1, · · · Token: example89.c:1:15: CHARCONST "'b'", · · }, · }, · Token: example89.c:1:13: '=', }
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 InitDeclaratorList ¶
type InitDeclaratorList struct { Case int InitDeclarator *InitDeclarator InitDeclaratorList *InitDeclaratorList Token xc.Token }
InitDeclaratorList represents data reduced by productions:
InitDeclaratorList: InitDeclarator | InitDeclaratorList ',' InitDeclarator // Case 1
Example ¶
fmt.Println(exampleAST(83, "\U00100002 auto a ,"))
Output: &cc.InitDeclaratorList{ · InitDeclarator: &cc.InitDeclarator{ · · Declarator: &cc.Declarator{ · · · Linkage: None, · · · Type: auto undefined, · · · DirectDeclarator: &cc.DirectDeclarator{ · · · · Token: example83.c:1:11: IDENTIFIER "a", · · · }, · · }, · }, }
Example (Case1) ¶
fmt.Println(exampleAST(84, "\U00100002 auto a , b ,"))
Output: &cc.InitDeclaratorList{ · InitDeclarator: &cc.InitDeclarator{ · · Declarator: &cc.Declarator{ · · · Linkage: None, · · · Type: auto undefined, · · · DirectDeclarator: &cc.DirectDeclarator{ · · · · Token: example84.c:1:11: IDENTIFIER "a", · · · }, · · }, · }, · InitDeclaratorList: &cc.InitDeclaratorList{ · · Case: 1, · · InitDeclarator: &cc.InitDeclarator{ · · · Declarator: &cc.Declarator{ · · · · Linkage: None, · · · · Type: auto undefined, · · · · DirectDeclarator: &cc.DirectDeclarator{ · · · · · Token: example84.c:1:15: IDENTIFIER "b", · · · · }, · · · }, · · }, · · Token: example84.c:1:13: ',', · }, }
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 */ | InitDeclaratorList // Case 1
Example ¶
fmt.Println(exampleAST(85, "\U00100002 auto ;") == (*InitDeclaratorListOpt)(nil))
Output: true
Example (Case1) ¶
fmt.Println(exampleAST(86, "\U00100002 auto a ;"))
Output: &cc.InitDeclaratorListOpt{ · InitDeclaratorList: &cc.InitDeclaratorList{ · · InitDeclarator: &cc.InitDeclarator{ · · · Declarator: &cc.Declarator{ · · · · Linkage: None, · · · · Type: auto undefined, · · · · DirectDeclarator: &cc.DirectDeclarator{ · · · · · Token: example86.c:1:11: 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 int CommaOpt *CommaOpt Expression *Expression InitializerList *InitializerList Token xc.Token Token2 xc.Token }
Initializer represents data reduced by productions:
Initializer: Expression | '{' InitializerList CommaOpt '}' // Case 1
Example ¶
fmt.Println(exampleAST(194, "\U00100002 auto a = 'b' ,"))
Output: &cc.Initializer{ · Expression: &cc.Expression{ · · Type: int, · · Value: 98, · · Case: 1, · · Token: example194.c:1:15: CHARCONST "'b'", · }, }
Example (Case1) ¶
fmt.Println(exampleAST(195, "\U00100002 auto a = { 'b' } ,"))
Output: &cc.Initializer{ · Case: 1, · InitializerList: &cc.InitializerList{ · · Initializer: &cc.Initializer{ · · · Expression: &cc.Expression{ · · · · Type: int, · · · · Value: 98, · · · · Case: 1, · · · · Token: example195.c:1:17: CHARCONST "'b'", · · · }, · · }, · }, · Token: example195.c:1:15: '{', · Token2: example195.c:1:21: '}', }
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.
type InitializerList ¶
type InitializerList struct { Case int DesignationOpt *DesignationOpt Initializer *Initializer InitializerList *InitializerList Token xc.Token }
InitializerList represents data reduced by productions:
InitializerList: DesignationOpt Initializer | InitializerList ',' DesignationOpt Initializer // Case 1
Example ¶
fmt.Println(exampleAST(196, "\U00100001 ( _Bool ) { 'a' ,"))
Output: &cc.InitializerList{ · Initializer: &cc.Initializer{ · · Expression: &cc.Expression{ · · · Type: int, · · · Value: 97, · · · Case: 1, · · · Token: example196.c:1:18: CHARCONST "'a'", · · }, · }, }
Example (Case1) ¶
fmt.Println(exampleAST(197, "\U00100001 ( _Bool ) { 'a' , 'b' ,"))
Output: &cc.InitializerList{ · Initializer: &cc.Initializer{ · · Expression: &cc.Expression{ · · · Type: int, · · · Value: 97, · · · Case: 1, · · · Token: example197.c:1:18: CHARCONST "'a'", · · }, · }, · InitializerList: &cc.InitializerList{ · · Case: 1, · · Initializer: &cc.Initializer{ · · · Expression: &cc.Expression{ · · · · Type: int, · · · · Value: 98, · · · · Case: 1, · · · · Token: example197.c:1:24: CHARCONST "'b'", · · · }, · · }, · · Token: example197.c:1:22: ',', · }, }
func (*InitializerList) Len ¶
func (n *InitializerList) Len() (r int)
Len returns the number of items in n.
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 IterationStatement ¶
type IterationStatement struct { Case int Declaration *Declaration ExpressionList *ExpressionList ExpressionListOpt *ExpressionListOpt ExpressionListOpt2 *ExpressionListOpt ExpressionListOpt3 *ExpressionListOpt Statement *Statement Token xc.Token Token2 xc.Token Token3 xc.Token Token4 xc.Token Token5 xc.Token }
IterationStatement represents data reduced by productions:
IterationStatement: "while" '(' ExpressionList ')' Statement | "do" Statement "while" '(' ExpressionList ')' ';' // Case 1 | "for" '(' ExpressionListOpt ';' ExpressionListOpt ';' ExpressionListOpt ')' Statement // Case 2 | "for" '(' Declaration ExpressionListOpt ';' ExpressionListOpt ')' Statement // Case 3
Example ¶
fmt.Println(exampleAST(226, "\U00100002 auto a { while ( 'b' ) ; !"))
Output: &cc.IterationStatement{ · ExpressionList: &cc.ExpressionList{ · · Type: int, · · Value: 98, · · Expression: &cc.Expression{ · · · Type: int, · · · Value: 98, · · · Case: 1, · · · Token: example226.c:1:23: CHARCONST "'b'", · · }, · }, · Statement: &cc.Statement{ · · Case: 2, · · ExpressionStatement: &cc.ExpressionStatement{ · · · Token: example226.c:1:29: ';', · · }, · }, · Token: example226.c:1:15: WHILE "while", · Token2: example226.c:1:21: '(', · Token3: example226.c:1:27: ')', }
Example (Case1) ¶
fmt.Println(exampleAST(227, "\U00100002 auto a { do ; while ( 'b' ) ; !"))
Output: &cc.IterationStatement{ · Case: 1, · ExpressionList: &cc.ExpressionList{ · · Type: int, · · Value: 98, · · Expression: &cc.Expression{ · · · Type: int, · · · Value: 98, · · · Case: 1, · · · Token: example227.c:1:28: CHARCONST "'b'", · · }, · }, · Statement: &cc.Statement{ · · Case: 2, · · ExpressionStatement: &cc.ExpressionStatement{ · · · Token: example227.c:1:18: ';', · · }, · }, · Token: example227.c:1:15: DO "do", · Token2: example227.c:1:20: WHILE "while", · Token3: example227.c:1:26: '(', · Token4: example227.c:1:32: ')', · Token5: example227.c:1:34: ';', }
Example (Case2) ¶
fmt.Println(exampleAST(228, "\U00100002 auto a { for ( ; ; ) ; !"))
Output: &cc.IterationStatement{ · Case: 2, · Statement: &cc.Statement{ · · Case: 2, · · ExpressionStatement: &cc.ExpressionStatement{ · · · Token: example228.c:1:27: ';', · · }, · }, · Token: example228.c:1:15: FOR "for", · Token2: example228.c:1:19: '(', · Token3: example228.c:1:21: ';', · Token4: example228.c:1:23: ';', · Token5: example228.c:1:25: ')', }
Example (Case3) ¶
fmt.Println(exampleAST(229, "\U00100002 auto a { for ( auto ; ; ) ; !"))
Output: &cc.IterationStatement{ · Case: 3, · Declaration: &cc.Declaration{ · · DeclarationSpecifiers: &cc.DeclarationSpecifiers{ · · · StorageClassSpecifier: &cc.StorageClassSpecifier{ · · · · Case: 3, · · · · Token: example229.c:1:21: AUTO "auto", · · · }, · · }, · · Token: example229.c:1:26: ';', · }, · Statement: &cc.Statement{ · · Case: 2, · · ExpressionStatement: &cc.ExpressionStatement{ · · · Token: example229.c:1:32: ';', · · }, · }, · Token: example229.c:1:15: FOR "for", · Token2: example229.c:1:19: '(', · Token3: example229.c:1:28: ';', · Token4: example229.c:1:30: ')', }
func (*IterationStatement) Pos ¶
func (n *IterationStatement) Pos() token.Pos
Pos reports the position of the first component of n or zero if it's empty.
func (*IterationStatement) String ¶
func (n *IterationStatement) String() string
String implements fmt.Stringer.
type JumpStatement ¶
type JumpStatement struct { Case int ExpressionListOpt *ExpressionListOpt Token xc.Token Token2 xc.Token Token3 xc.Token }
JumpStatement represents data reduced by productions:
JumpStatement: "goto" IDENTIFIER ';' | "continue" ';' // Case 1 | "break" ';' // Case 2 | "return" ExpressionListOpt ';' // Case 3
Example ¶
fmt.Println(exampleAST(230, "\U00100002 auto a { goto b ; !"))
Output: &cc.JumpStatement{ · Token: example230.c:1:15: GOTO "goto", · Token2: example230.c:1:20: IDENTIFIER "b", · Token3: example230.c:1:22: ';', }
Example (Case1) ¶
fmt.Println(exampleAST(231, "\U00100002 auto a { continue ; !"))
Output: &cc.JumpStatement{ · Case: 1, · Token: example231.c:1:15: CONTINUE "continue", · Token2: example231.c:1:24: ';', }
Example (Case2) ¶
fmt.Println(exampleAST(232, "\U00100002 auto a { break ; !"))
Output: &cc.JumpStatement{ · Case: 2, · Token: example232.c:1:15: BREAK "break", · Token2: example232.c:1:21: ';', }
Example (Case3) ¶
fmt.Println(exampleAST(233, "\U00100002 auto a { return ; !"))
Output: &cc.JumpStatement{ · Case: 3, · Token: example233.c:1:15: RETURN "return", · Token2: example233.c:1:22: ';', }
func (*JumpStatement) Pos ¶
func (n *JumpStatement) Pos() token.Pos
Pos reports the position of the first component of n or zero if it's empty.
func (*JumpStatement) String ¶
func (n *JumpStatement) String() string
String implements fmt.Stringer.
type Kind ¶
type Kind int
Kind is a type category. Kind formally implements Type the only method returning a non nil value is Kind.
type LabeledStatement ¶
type LabeledStatement struct { Case int ConstantExpression *ConstantExpression Statement *Statement Token xc.Token Token2 xc.Token }
LabeledStatement represents data reduced by productions:
LabeledStatement: IDENTIFIER ':' Statement | "case" ConstantExpression ':' Statement // Case 1 | "default" ':' Statement // Case 2
Example ¶
fmt.Println(exampleAST(211, "\U00100002 auto a { b : ; !"))
Output: &cc.LabeledStatement{ · Statement: &cc.Statement{ · · Case: 2, · · ExpressionStatement: &cc.ExpressionStatement{ · · · Token: example211.c:1:19: ';', · · }, · }, · Token: example211.c:1:15: IDENTIFIER "b", · Token2: example211.c:1:17: ':', }
Example (Case1) ¶
fmt.Println(exampleAST(212, "\U00100002 auto a { case 'b' : ; !"))
Output: &cc.LabeledStatement{ · Case: 1, · ConstantExpression: &cc.ConstantExpression{ · · Type: int, · · Value: 98, · · Expression: &cc.Expression{ · · · Type: int, · · · Value: 98, · · · Case: 1, · · · Token: example212.c:1:20: CHARCONST "'b'", · · }, · }, · Statement: &cc.Statement{ · · Case: 2, · · ExpressionStatement: &cc.ExpressionStatement{ · · · Token: example212.c:1:26: ';', · · }, · }, · Token: example212.c:1:15: CASE "case", · Token2: example212.c:1:24: ':', }
Example (Case2) ¶
fmt.Println(exampleAST(213, "\U00100002 auto a { default : ; !"))
Output: &cc.LabeledStatement{ · Case: 2, · Statement: &cc.Statement{ · · Case: 2, · · ExpressionStatement: &cc.ExpressionStatement{ · · · Token: example213.c:1:25: ';', · · }, · }, · Token: example213.c:1:15: DEFAULT "default", · Token2: example213.c:1:23: ':', }
func (*LabeledStatement) Pos ¶
func (n *LabeledStatement) Pos() token.Pos
Pos reports the position of the first component of n or zero if it's empty.
func (*LabeledStatement) String ¶
func (n *LabeledStatement) String() string
String implements fmt.Stringer.
type LongStringLitID ¶
type LongStringLitID int
LongStringLitID is the type of an Expression.Value representing the numeric ID of a long string literal.
type Macro ¶
type Macro struct { Args []int // Numeric IDs of argument identifiers. DefTok xc.Token // Macro name definition token. IsFnLike bool // Whether the macro is function like. Type Type // Non nil if macro expands to a constant expression. Value interface{} // Non nil if macro expands to a constant expression. // contains filtered or unexported fields }
Macro represents a C preprocessor macro.
func (*Macro) ReplacementToks ¶
ReplacementToks returns the tokens that replace m.
type Member ¶
type Member struct { BitFieldType Type BitFieldGroup int // Ordinal number of the packed bits field. BitOffsetOf int // Bit field starting bit. Bits int // Size in bits for bit fields, 0 otherwise. Declarator *Declarator // Possibly nil for bit fields. Name int OffsetOf int Padding int // Number of unused bytes added to the end of the field to force proper alignment requirements. Type Type }
Member describes a member of a struct or union.
BitFieldGroup represents the ordinal number of the packed bit fields:
struct foo { int i; int j:1; // BitFieldGroup: 0 int k:2; // BitFieldGroup: 0 double l; int m:1; // BitFieldGroup: 1 int n:2; // BitFieldGroup: 1 }
type Model ¶
type Model struct { Items map[Kind]ModelItem BoolType Type CharType Type DoubleType Type FloatType Type IntType Type LongDoubleType Type LongLongType Type LongType Type ShortType Type UCharType Type UIntType Type ULongLongType Type ULongType Type UShortType Type UintPtrType Type VoidType Type // contains filtered or unexported fields }
Model describes size and align requirements of predeclared types.
func (*Model) MustConvert ¶
MustConvert returns v converted to the type of typ. If the conversion is impossible, the method panics.
Conversion an integer type to any pointer type yields an uintptr.
type ModelItem ¶
type ModelItem struct { Size int // Size of the entity in bytes. Align int // Alignment of the entity when it's not a struct field. Cannot be smaller than Size. StructAlign int // Alignment of the entity when it's a struct field. Can be smaller than Size. More interface{} // Optional user data. }
ModelItem is a single item of a model.
Note about StructAlign: To provide GCC ABI compatibility set, for example, Align of Double to 8 and StructAlign of Double to 4.
type Opt ¶
type Opt func(*lexer)
Opt is a configuration/setup function that can be passed to the Parser function.
func Cpp ¶
Cpp registers a preprocessor hook function which is called for every line, or group of lines the preprocessor produces before it is consumed by the parser. The token slice must not be modified by the hook.
func EnableAnonymousStructFields ¶
func EnableAnonymousStructFields() Opt
EnableAnonymousStructFields makes the parser accept non standard
struct { int i; struct { int j; }; int k; };
func EnableDefineOmitCommaBeforeDDD ¶
func EnableDefineOmitCommaBeforeDDD() Opt
EnableDefineOmitCommaBeforeDDD makes the parser accept non standard
#define foo(a, b...)
func EnableDlrInIdentifiers ¶
func EnableDlrInIdentifiers() Opt
EnableDlrInIdentifiers makes the parser accept non standard
int foo$bar
func EnableEmptyDefine ¶
func EnableEmptyDefine() Opt
EnableEmptyDefine makes the parser accept non standard
#define
func EnableIncludeNext ¶
func EnableIncludeNext() Opt
EnableIncludeNext makes the parser accept non standard
#include_next "foo.h"
func EnableTypeOf ¶
func EnableTypeOf() Opt
EnableTypeOf enables recognizing the reserved word typeof.
func EnableUndefExtraTokens ¶
func EnableUndefExtraTokens() Opt
EnableUndefExtraTokens makes the parser accept non standard
#undef foo(bar)
func ErrLimit ¶
ErrLimit limits the number of calls to the error reporting methods. After the limit is reached, all errors are reported using log.Print and then log.Fatal() is called with a message about too many errors. To disable error limit, set ErrLimit to value less or equal zero. Default value is 10.
func IncludeLastTokenInfoInErrors ¶
func IncludeLastTokenInfoInErrors() Opt
IncludeLastTokenInfoInErrors extends error messages with information about the last lexer token.
func IncludePaths ¶
IncludePaths option configures where to search for include files (eg. "name.h"). Multiple IncludePaths options may be used, the resulting search path list is the produce by appending the option arguments in order of appearance.
func SysIncludePaths ¶
SysIncludePaths option configures where to search for system include files (eg. <name.h>). Multiple SysIncludePaths options may be used, the resulting search path list is produced by appending the option arguments in order of appearance.
type PPTokenList ¶
type PPTokenList int
PPTokenList represents a sequence of tokens.
func (PPTokenList) Pos ¶
func (p PPTokenList) Pos() token.Pos
type Parameter ¶
type Parameter struct { Declarator *Declarator Name int Type Type }
Parameter describes a function argument.
type ParameterDeclaration ¶
type ParameterDeclaration struct { AbstractDeclaratorOpt *AbstractDeclaratorOpt Case int DeclarationSpecifiers *DeclarationSpecifiers Declarator *Declarator // contains filtered or unexported fields }
ParameterDeclaration represents data reduced by productions:
ParameterDeclaration: DeclarationSpecifiers Declarator | DeclarationSpecifiers AbstractDeclaratorOpt // Case 1
Example ¶
fmt.Println(exampleAST(168, "\U00100001 ( _Bool ( auto a )"))
Output: &cc.ParameterDeclaration{ · DeclarationSpecifiers: &cc.DeclarationSpecifiers{ · · StorageClassSpecifier: &cc.StorageClassSpecifier{ · · · Case: 3, · · · Token: example168.c:1:16: AUTO "auto", · · }, · }, · Declarator: &cc.Declarator{ · · Linkage: None, · · Type: auto undefined, · · DirectDeclarator: &cc.DirectDeclarator{ · · · Token: example168.c:1:21: IDENTIFIER "a", · · }, · }, }
Example (Case1) ¶
fmt.Println(exampleAST(169, "\U00100001 ( _Bool ( auto )"))
Output: &cc.ParameterDeclaration{ · Case: 1, · DeclarationSpecifiers: &cc.DeclarationSpecifiers{ · · StorageClassSpecifier: &cc.StorageClassSpecifier{ · · · Case: 3, · · · Token: example169.c:1:16: AUTO "auto", · · }, · }, }
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 ParameterList ¶
type ParameterList struct { Case int ParameterDeclaration *ParameterDeclaration ParameterList *ParameterList Token xc.Token }
ParameterList represents data reduced by productions:
ParameterList: ParameterDeclaration | ParameterList ',' ParameterDeclaration // Case 1
Example ¶
fmt.Println(exampleAST(166, "\U00100001 ( _Bool ( auto )"))
Output: &cc.ParameterList{ · ParameterDeclaration: &cc.ParameterDeclaration{ · · Case: 1, · · DeclarationSpecifiers: &cc.DeclarationSpecifiers{ · · · StorageClassSpecifier: &cc.StorageClassSpecifier{ · · · · Case: 3, · · · · Token: example166.c:1:16: AUTO "auto", · · · }, · · }, · }, }
Example (Case1) ¶
fmt.Println(exampleAST(167, "\U00100001 ( _Bool ( auto , auto )"))
Output: &cc.ParameterList{ · ParameterDeclaration: &cc.ParameterDeclaration{ · · Case: 1, · · DeclarationSpecifiers: &cc.DeclarationSpecifiers{ · · · StorageClassSpecifier: &cc.StorageClassSpecifier{ · · · · Case: 3, · · · · Token: example167.c:1:16: AUTO "auto", · · · }, · · }, · }, · ParameterList: &cc.ParameterList{ · · Case: 1, · · ParameterDeclaration: &cc.ParameterDeclaration{ · · · Case: 1, · · · DeclarationSpecifiers: &cc.DeclarationSpecifiers{ · · · · StorageClassSpecifier: &cc.StorageClassSpecifier{ · · · · · Case: 3, · · · · · Token: example167.c:1:23: AUTO "auto", · · · · }, · · · }, · · }, · · Token: example167.c:1:21: ',', · }, }
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 int ParameterList *ParameterList Token xc.Token Token2 xc.Token // contains filtered or unexported fields }
ParameterTypeList represents data reduced by productions:
ParameterTypeList: ParameterList | ParameterList ',' "..." // Case 1
Example ¶
fmt.Println(exampleAST(162, "\U00100001 ( _Bool ( auto )"))
Output: &cc.ParameterTypeList{ · ParameterList: &cc.ParameterList{ · · ParameterDeclaration: &cc.ParameterDeclaration{ · · · Case: 1, · · · DeclarationSpecifiers: &cc.DeclarationSpecifiers{ · · · · StorageClassSpecifier: &cc.StorageClassSpecifier{ · · · · · Case: 3, · · · · · Token: example162.c:1:16: AUTO "auto", · · · · }, · · · }, · · }, · }, }
Example (Case1) ¶
fmt.Println(exampleAST(163, "\U00100001 ( _Bool ( auto , ... )"))
Output: &cc.ParameterTypeList{ · Case: 1, · ParameterList: &cc.ParameterList{ · · ParameterDeclaration: &cc.ParameterDeclaration{ · · · Case: 1, · · · DeclarationSpecifiers: &cc.DeclarationSpecifiers{ · · · · StorageClassSpecifier: &cc.StorageClassSpecifier{ · · · · · Case: 3, · · · · · Token: example163.c:1:16: AUTO "auto", · · · · }, · · · }, · · }, · }, · Token: example163.c:1:21: ',', · Token2: example163.c:1:23: 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 ParameterTypeListOpt ¶
type ParameterTypeListOpt struct {
ParameterTypeList *ParameterTypeList
}
ParameterTypeListOpt represents data reduced by productions:
ParameterTypeListOpt: /* empty */ | ParameterTypeList // Case 1
Example ¶
fmt.Println(exampleAST(164, "\U00100001 ( _Bool ( )") == (*ParameterTypeListOpt)(nil))
Output: true
Example (Case1) ¶
fmt.Println(exampleAST(165, "\U00100001 ( _Bool ( auto )"))
Output: &cc.ParameterTypeListOpt{ · ParameterTypeList: &cc.ParameterTypeList{ · · ParameterList: &cc.ParameterList{ · · · ParameterDeclaration: &cc.ParameterDeclaration{ · · · · Case: 1, · · · · DeclarationSpecifiers: &cc.DeclarationSpecifiers{ · · · · · StorageClassSpecifier: &cc.StorageClassSpecifier{ · · · · · · Case: 3, · · · · · · Token: example165.c:1:16: 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 int Pointer *Pointer Token xc.Token TypeQualifierListOpt *TypeQualifierListOpt }
Pointer represents data reduced by productions:
Pointer: '*' TypeQualifierListOpt | '*' TypeQualifierListOpt Pointer // Case 1
Example ¶
fmt.Println(exampleAST(154, "\U00100002 auto * ("))
Output: &cc.Pointer{ · Token: example154.c:1:11: '*', }
Example (Case1) ¶
fmt.Println(exampleAST(155, "\U00100002 auto * * ("))
Output: &cc.Pointer{ · Case: 1, · Pointer: &cc.Pointer{ · · Token: example155.c:1:13: '*', · }, · Token: example155.c:1:11: '*', }
type PointerOpt ¶
type PointerOpt struct {
Pointer *Pointer
}
PointerOpt represents data reduced by productions:
PointerOpt: /* empty */ | Pointer // Case 1
Example ¶
fmt.Println(exampleAST(156, "\U00100002 auto (") == (*PointerOpt)(nil))
Output: true
Example (Case1) ¶
fmt.Println(exampleAST(157, "\U00100001 ( _Bool * ("))
Output: &cc.PointerOpt{ · Pointer: &cc.Pointer{ · · Token: example157.c:1:14: '*', · }, }
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.
type PreprocessingFile ¶
type PreprocessingFile struct { GroupList *GroupList // contains filtered or unexported fields }
PreprocessingFile represents data reduced by production:
PreprocessingFile: GroupList
Example ¶
fmt.Println(exampleAST(245, "\U00100000 "))
Output: &cc.PreprocessingFile{ · GroupList: &cc.GroupList{ · }, }
func (*PreprocessingFile) Pos ¶
func (n *PreprocessingFile) Pos() token.Pos
Pos reports the position of the first component of n or zero if it's empty.
func (*PreprocessingFile) String ¶
func (n *PreprocessingFile) String() string
String implements fmt.Stringer.
type SelectionStatement ¶
type SelectionStatement struct { Case int ExpressionList *ExpressionList Statement *Statement Statement2 *Statement Token xc.Token Token2 xc.Token Token3 xc.Token Token4 xc.Token }
SelectionStatement represents data reduced by productions:
SelectionStatement: "if" '(' ExpressionList ')' Statement | "if" '(' ExpressionList ')' Statement "else" Statement // Case 1 | "switch" '(' ExpressionList ')' Statement // Case 2
Example ¶
fmt.Println(exampleAST(223, "\U00100002 auto a { if ( 'b' ) ; !"))
Output: &cc.SelectionStatement{ · ExpressionList: &cc.ExpressionList{ · · Type: int, · · Value: 98, · · Expression: &cc.Expression{ · · · Type: int, · · · Value: 98, · · · Case: 1, · · · Token: example223.c:1:20: CHARCONST "'b'", · · }, · }, · Statement: &cc.Statement{ · · Case: 2, · · ExpressionStatement: &cc.ExpressionStatement{ · · · Token: example223.c:1:26: ';', · · }, · }, · Token: example223.c:1:15: IF "if", · Token2: example223.c:1:18: '(', · Token3: example223.c:1:24: ')', }
Example (Case1) ¶
fmt.Println(exampleAST(224, "\U00100002 auto a { if ( 'b' ) ; else ; !"))
Output: &cc.SelectionStatement{ · Case: 1, · ExpressionList: &cc.ExpressionList{ · · Type: int, · · Value: 98, · · Expression: &cc.Expression{ · · · Type: int, · · · Value: 98, · · · Case: 1, · · · Token: example224.c:1:20: CHARCONST "'b'", · · }, · }, · Statement: &cc.Statement{ · · Case: 2, · · ExpressionStatement: &cc.ExpressionStatement{ · · · Token: example224.c:1:26: ';', · · }, · }, · Statement2: &cc.Statement{ · · Case: 2, · · ExpressionStatement: &cc.ExpressionStatement{ · · · Token: example224.c:1:33: ';', · · }, · }, · Token: example224.c:1:15: IF "if", · Token2: example224.c:1:18: '(', · Token3: example224.c:1:24: ')', · Token4: example224.c:1:28: ELSE "else", }
Example (Case2) ¶
fmt.Println(exampleAST(225, "\U00100002 auto a { switch ( 'b' ) ; !"))
Output: &cc.SelectionStatement{ · Case: 2, · ExpressionList: &cc.ExpressionList{ · · Type: int, · · Value: 98, · · Expression: &cc.Expression{ · · · Type: int, · · · Value: 98, · · · Case: 1, · · · Token: example225.c:1:24: CHARCONST "'b'", · · }, · }, · Statement: &cc.Statement{ · · Case: 2, · · ExpressionStatement: &cc.ExpressionStatement{ · · · Token: example225.c:1:30: ';', · · }, · }, · Token: example225.c:1:15: SWITCH "switch", · Token2: example225.c:1:22: '(', · Token3: example225.c:1:28: ')', }
func (*SelectionStatement) Pos ¶
func (n *SelectionStatement) Pos() token.Pos
Pos reports the position of the first component of n or zero if it's empty.
func (*SelectionStatement) String ¶
func (n *SelectionStatement) String() string
String implements fmt.Stringer.
type Specifier ¶
type Specifier interface { IsStatic() bool // StorageClassSpecifier "static" present. IsTypedef() bool // StorageClassSpecifier "typedef" present. TypedefName() int // TypedefName returns the typedef name ID used, if any, zero otherwise. IsConst() bool // TypeQualifier "const" present. // contains filtered or unexported methods }
Specifier describes a combination of {Function,StorageClass,Type}Specifiers and TypeQualifiers.
type SpecifierQualifierList ¶
type SpecifierQualifierList struct { Case int SpecifierQualifierListOpt *SpecifierQualifierListOpt TypeQualifier *TypeQualifier TypeSpecifier *TypeSpecifier // contains filtered or unexported fields }
SpecifierQualifierList represents data reduced by productions:
SpecifierQualifierList: TypeSpecifier SpecifierQualifierListOpt | TypeQualifier SpecifierQualifierListOpt // Case 1
Example ¶
fmt.Println(exampleAST(121, "\U00100001 ( _Bool ("))
Output: &cc.SpecifierQualifierList{ · TypeSpecifier: &cc.TypeSpecifier{ · · Case: 9, · · Token: example121.c:1:8: BOOL "_Bool", · }, }
Example (Case1) ¶
fmt.Println(exampleAST(122, "\U00100001 ( const ("))
Output: &cc.SpecifierQualifierList{ · Case: 1, · TypeQualifier: &cc.TypeQualifier{ · · Token: example122.c:1:8: CONST "const", · }, }
func (*SpecifierQualifierList) IsConst ¶
func (n *SpecifierQualifierList) IsConst() bool
IsConst returns whether n includes the 'const' type qualifier.
func (*SpecifierQualifierList) IsStatic ¶
func (n *SpecifierQualifierList) IsStatic() bool
IsStatic implements specifier.
func (*SpecifierQualifierList) IsTypedef ¶
func (n *SpecifierQualifierList) IsTypedef() bool
IsTypedef implements specifier.
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.
func (*SpecifierQualifierList) TypedefName ¶
func (n *SpecifierQualifierList) TypedefName() int
TypedefName implements Specifier.
type SpecifierQualifierListOpt ¶
type SpecifierQualifierListOpt struct { SpecifierQualifierList *SpecifierQualifierList // contains filtered or unexported fields }
SpecifierQualifierListOpt represents data reduced by productions:
SpecifierQualifierListOpt: /* empty */ | SpecifierQualifierList // Case 1
Example ¶
fmt.Println(exampleAST(123, "\U00100001 ( _Bool (") == (*SpecifierQualifierListOpt)(nil))
Output: true
Example (Case1) ¶
fmt.Println(exampleAST(124, "\U00100001 ( const _Bool ("))
Output: &cc.SpecifierQualifierListOpt{ · SpecifierQualifierList: &cc.SpecifierQualifierList{ · · TypeSpecifier: &cc.TypeSpecifier{ · · · Case: 9, · · · Token: example124.c:1:14: BOOL "_Bool", · · }, · }, }
func (*SpecifierQualifierListOpt) Pos ¶
func (n *SpecifierQualifierListOpt) Pos() token.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 Statement ¶
type Statement struct { Case int CompoundStatement *CompoundStatement ExpressionStatement *ExpressionStatement IterationStatement *IterationStatement JumpStatement *JumpStatement LabeledStatement *LabeledStatement SelectionStatement *SelectionStatement }
Statement represents data reduced by productions:
Statement: LabeledStatement | CompoundStatement // Case 1 | ExpressionStatement // Case 2 | SelectionStatement // Case 3 | IterationStatement // Case 4 | JumpStatement // Case 5
Example ¶
fmt.Println(exampleAST(205, "\U00100002 auto a { default : ; !"))
Output: &cc.Statement{ · LabeledStatement: &cc.LabeledStatement{ · · Case: 2, · · Statement: &cc.Statement{ · · · Case: 2, · · · ExpressionStatement: &cc.ExpressionStatement{ · · · · Token: example205.c:1:25: ';', · · · }, · · }, · · Token: example205.c:1:15: DEFAULT "default", · · Token2: example205.c:1:23: ':', · }, }
Example (Case1) ¶
fmt.Println(exampleAST(206, "\U00100002 auto a { { } !"))
Output: &cc.Statement{ · Case: 1, · CompoundStatement: &cc.CompoundStatement{ · · Token: example206.c:1:15: '{', · · Token2: example206.c:1:17: '}', · }, }
Example (Case2) ¶
fmt.Println(exampleAST(207, "\U00100002 auto a { ; !"))
Output: &cc.Statement{ · Case: 2, · ExpressionStatement: &cc.ExpressionStatement{ · · Token: example207.c:1:15: ';', · }, }
Example (Case3) ¶
fmt.Println(exampleAST(208, "\U00100002 auto a { if ( 'b' ) ; !"))
Output: &cc.Statement{ · Case: 3, · SelectionStatement: &cc.SelectionStatement{ · · ExpressionList: &cc.ExpressionList{ · · · Type: int, · · · Value: 98, · · · Expression: &cc.Expression{ · · · · Type: int, · · · · Value: 98, · · · · Case: 1, · · · · Token: example208.c:1:20: CHARCONST "'b'", · · · }, · · }, · · Statement: &cc.Statement{ · · · Case: 2, · · · ExpressionStatement: &cc.ExpressionStatement{ · · · · Token: example208.c:1:26: ';', · · · }, · · }, · · Token: example208.c:1:15: IF "if", · · Token2: example208.c:1:18: '(', · · Token3: example208.c:1:24: ')', · }, }
Example (Case4) ¶
fmt.Println(exampleAST(209, "\U00100002 auto a { while ( 'b' ) ; !"))
Output: &cc.Statement{ · Case: 4, · IterationStatement: &cc.IterationStatement{ · · ExpressionList: &cc.ExpressionList{ · · · Type: int, · · · Value: 98, · · · Expression: &cc.Expression{ · · · · Type: int, · · · · Value: 98, · · · · Case: 1, · · · · Token: example209.c:1:23: CHARCONST "'b'", · · · }, · · }, · · Statement: &cc.Statement{ · · · Case: 2, · · · ExpressionStatement: &cc.ExpressionStatement{ · · · · Token: example209.c:1:29: ';', · · · }, · · }, · · Token: example209.c:1:15: WHILE "while", · · Token2: example209.c:1:21: '(', · · Token3: example209.c:1:27: ')', · }, }
Example (Case5) ¶
fmt.Println(exampleAST(210, "\U00100002 auto a { break ; !"))
Output: &cc.Statement{ · Case: 5, · JumpStatement: &cc.JumpStatement{ · · Case: 2, · · Token: example210.c:1:15: BREAK "break", · · Token2: example210.c:1:21: ';', · }, }
type StorageClassSpecifier ¶
type StorageClassSpecifier struct { Case int Token xc.Token // contains filtered or unexported fields }
StorageClassSpecifier represents data reduced by productions:
StorageClassSpecifier: "typedef" | "extern" // Case 1 | "static" // Case 2 | "auto" // Case 3 | "register" // Case 4
Example ¶
fmt.Println(exampleAST(90, "\U00100002 typedef ("))
Output: &cc.StorageClassSpecifier{ · Token: example90.c:1:6: TYPEDEF "typedef", }
Example (Case1) ¶
fmt.Println(exampleAST(91, "\U00100002 extern ("))
Output: &cc.StorageClassSpecifier{ · Case: 1, · Token: example91.c:1:6: EXTERN "extern", }
Example (Case2) ¶
fmt.Println(exampleAST(92, "\U00100002 static ("))
Output: &cc.StorageClassSpecifier{ · Case: 2, · Token: example92.c:1:6: STATIC "static", }
Example (Case3) ¶
fmt.Println(exampleAST(93, "\U00100002 auto ("))
Output: &cc.StorageClassSpecifier{ · Case: 3, · Token: example93.c:1:6: AUTO "auto", }
Example (Case4) ¶
fmt.Println(exampleAST(94, "\U00100002 register ("))
Output: &cc.StorageClassSpecifier{ · Case: 4, · Token: example94.c:1:6: REGISTER "register", }
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 StringLitID ¶
type StringLitID int
StringLitID is the type of an Expression.Value representing the numeric ID of a string literal.
type StructDeclaration ¶
type StructDeclaration struct { Case int SpecifierQualifierList *SpecifierQualifierList StructDeclaratorList *StructDeclaratorList Token xc.Token }
StructDeclaration represents data reduced by productions:
StructDeclaration: SpecifierQualifierList StructDeclaratorList ';' | SpecifierQualifierList ';' // Case 1
Example ¶
fmt.Println(exampleAST(119, "\U00100002 struct { _Bool a ; }"))
Output: &cc.StructDeclaration{ · SpecifierQualifierList: &cc.SpecifierQualifierList{ · · TypeSpecifier: &cc.TypeSpecifier{ · · · Case: 9, · · · Token: example119.c:1:15: BOOL "_Bool", · · }, · }, · StructDeclaratorList: &cc.StructDeclaratorList{ · · StructDeclarator: &cc.StructDeclarator{ · · · Declarator: &cc.Declarator{ · · · · Linkage: None, · · · · Type: bool, · · · · DirectDeclarator: &cc.DirectDeclarator{ · · · · · Token: example119.c:1:21: IDENTIFIER "a", · · · · }, · · · }, · · }, · }, · Token: example119.c:1:23: ';', }
Example (Case1) ¶
fmt.Println(exampleAST(120, "\U00100002 struct { _Bool ; }"))
Output: &cc.StructDeclaration{ · Case: 1, · SpecifierQualifierList: &cc.SpecifierQualifierList{ · · TypeSpecifier: &cc.TypeSpecifier{ · · · Case: 9, · · · Token: example120.c:1:15: BOOL "_Bool", · · }, · }, · Token: example120.c:1:21: ';', }
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 StructDeclarationList ¶
type StructDeclarationList struct { Case int StructDeclaration *StructDeclaration StructDeclarationList *StructDeclarationList }
StructDeclarationList represents data reduced by productions:
StructDeclarationList: StructDeclaration | StructDeclarationList StructDeclaration // Case 1
Example ¶
fmt.Println(exampleAST(117, "\U00100002 struct { _Bool ; }"))
Output: &cc.StructDeclarationList{ · StructDeclaration: &cc.StructDeclaration{ · · Case: 1, · · SpecifierQualifierList: &cc.SpecifierQualifierList{ · · · TypeSpecifier: &cc.TypeSpecifier{ · · · · Case: 9, · · · · Token: example117.c:1:15: BOOL "_Bool", · · · }, · · }, · · Token: example117.c:1:21: ';', · }, }
Example (Case1) ¶
fmt.Println(exampleAST(118, "\U00100002 struct { _Bool ; _Bool ; }"))
Output: &cc.StructDeclarationList{ · StructDeclaration: &cc.StructDeclaration{ · · Case: 1, · · SpecifierQualifierList: &cc.SpecifierQualifierList{ · · · TypeSpecifier: &cc.TypeSpecifier{ · · · · Case: 9, · · · · Token: example118.c:1:15: BOOL "_Bool", · · · }, · · }, · · Token: example118.c:1:21: ';', · }, · StructDeclarationList: &cc.StructDeclarationList{ · · Case: 1, · · StructDeclaration: &cc.StructDeclaration{ · · · Case: 1, · · · SpecifierQualifierList: &cc.SpecifierQualifierList{ · · · · TypeSpecifier: &cc.TypeSpecifier{ · · · · · Case: 9, · · · · · Token: example118.c:1:23: BOOL "_Bool", · · · · }, · · · }, · · · Token: example118.c:1:29: ';', · · }, · }, }
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 { Case int ConstantExpression *ConstantExpression Declarator *Declarator DeclaratorOpt *DeclaratorOpt Token xc.Token }
StructDeclarator represents data reduced by productions:
StructDeclarator: Declarator | DeclaratorOpt ':' ConstantExpression // Case 1
Example ¶
fmt.Println(exampleAST(127, "\U00100002 struct { _Bool a ,"))
Output: &cc.StructDeclarator{ · Declarator: &cc.Declarator{ · · Linkage: None, · · Type: bool, · · DirectDeclarator: &cc.DirectDeclarator{ · · · Token: example127.c:1:21: IDENTIFIER "a", · · }, · }, }
Example (Case1) ¶
fmt.Println(exampleAST(128, "\U00100002 struct { _Bool : 'a' ,"))
Output: &cc.StructDeclarator{ · Case: 1, · ConstantExpression: &cc.ConstantExpression{ · · Type: int, · · Value: 97, · · Expression: &cc.Expression{ · · · Type: int, · · · Value: 97, · · · Case: 1, · · · Token: example128.c:1:23: CHARCONST "'a'", · · }, · }, · Token: example128.c:1:21: ':', }
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 StructDeclaratorList ¶
type StructDeclaratorList struct { Case int StructDeclarator *StructDeclarator StructDeclaratorList *StructDeclaratorList Token xc.Token }
StructDeclaratorList represents data reduced by productions:
StructDeclaratorList: StructDeclarator | StructDeclaratorList ',' StructDeclarator // Case 1
Example ¶
fmt.Println(exampleAST(125, "\U00100002 struct { _Bool a ,"))
Output: &cc.StructDeclaratorList{ · StructDeclarator: &cc.StructDeclarator{ · · Declarator: &cc.Declarator{ · · · Linkage: None, · · · Type: bool, · · · DirectDeclarator: &cc.DirectDeclarator{ · · · · Token: example125.c:1:21: IDENTIFIER "a", · · · }, · · }, · }, }
Example (Case1) ¶
fmt.Println(exampleAST(126, "\U00100002 struct { _Bool a , b ,"))
Output: &cc.StructDeclaratorList{ · StructDeclarator: &cc.StructDeclarator{ · · Declarator: &cc.Declarator{ · · · Linkage: None, · · · Type: bool, · · · DirectDeclarator: &cc.DirectDeclarator{ · · · · Token: example126.c:1:21: IDENTIFIER "a", · · · }, · · }, · }, · StructDeclaratorList: &cc.StructDeclaratorList{ · · Case: 1, · · StructDeclarator: &cc.StructDeclarator{ · · · Declarator: &cc.Declarator{ · · · · Linkage: None, · · · · Type: bool, · · · · DirectDeclarator: &cc.DirectDeclarator{ · · · · · Token: example126.c:1:25: IDENTIFIER "b", · · · · }, · · · }, · · }, · · Token: example126.c:1:23: ',', · }, }
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 ¶
StructOrUnion represents data reduced by productions:
StructOrUnion: "struct" | "union" // Case 1
Example ¶
fmt.Println(exampleAST(115, "\U00100002 struct {"))
Output: &cc.StructOrUnion{ · Token: example115.c:1:6: STRUCT "struct", }
Example (Case1) ¶
fmt.Println(exampleAST(116, "\U00100002 union {"))
Output: &cc.StructOrUnion{ · Case: 1, · Token: example116.c:1:6: 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 StructOrUnionSpecifier ¶
type StructOrUnionSpecifier struct { Case int 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 IdentifierOpt '{' StructDeclarationList '}' | StructOrUnion IDENTIFIER // Case 1
Example ¶
fmt.Println(exampleAST(113, "\U00100002 struct { int i; } ("))
Output: &cc.StructOrUnionSpecifier{ · StructDeclarationList: &cc.StructDeclarationList{ · · StructDeclaration: &cc.StructDeclaration{ · · · SpecifierQualifierList: &cc.SpecifierQualifierList{ · · · · TypeSpecifier: &cc.TypeSpecifier{ · · · · · Case: 3, · · · · · Token: example113.c:1:15: INT "int", · · · · }, · · · }, · · · StructDeclaratorList: &cc.StructDeclaratorList{ · · · · StructDeclarator: &cc.StructDeclarator{ · · · · · Declarator: &cc.Declarator{ · · · · · · Linkage: None, · · · · · · Type: int, · · · · · · DirectDeclarator: &cc.DirectDeclarator{ · · · · · · · Token: example113.c:1:19: IDENTIFIER "i", · · · · · · }, · · · · · }, · · · · }, · · · }, · · · Token: example113.c:1:20: ';', · · }, · }, · StructOrUnion: &cc.StructOrUnion{ · · Token: example113.c:1:6: STRUCT "struct", · }, · Token: example113.c:1:13: '{', · Token2: example113.c:1:22: '}', }
Example (Case1) ¶
fmt.Println(exampleAST(114, "\U00100002 struct a ("))
Output: &cc.StructOrUnionSpecifier{ · Case: 1, · StructOrUnion: &cc.StructOrUnion{ · · Token: example114.c:1:6: STRUCT "struct", · }, · Token: example114.c:1:13: IDENTIFIER "a", }
func (*StructOrUnionSpecifier) Declarator ¶
func (n *StructOrUnionSpecifier) Declarator() *Declarator
Declarator returns a synthetic Declarator when a tagged struc/union type is defined inline a declaration.
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 TranslationUnit ¶
type TranslationUnit struct { Declarations *Bindings Macros map[int]*Macro // Ident ID -> preprocessor macro defined by ident. Model *Model // Model used to parse the TranslationUnit. Case int ExternalDeclaration *ExternalDeclaration TranslationUnit *TranslationUnit }
TranslationUnit represents data reduced by productions:
TranslationUnit: ExternalDeclaration | TranslationUnit ExternalDeclaration // Case 1
Example ¶
fmt.Println(exampleAST(234, "\U00100002 auto ;"))
Output: &cc.TranslationUnit{ · ExternalDeclaration: &cc.ExternalDeclaration{ · · Case: 1, · · Declaration: &cc.Declaration{ · · · DeclarationSpecifiers: &cc.DeclarationSpecifiers{ · · · · StorageClassSpecifier: &cc.StorageClassSpecifier{ · · · · · Case: 3, · · · · · Token: example234.c:1:6: AUTO "auto", · · · · }, · · · }, · · · Token: example234.c:1:11: ';', · · }, · }, }
Example (Case1) ¶
fmt.Println(exampleAST(235, "\U00100002 auto ; auto ;"))
Output: &cc.TranslationUnit{ · ExternalDeclaration: &cc.ExternalDeclaration{ · · Case: 1, · · Declaration: &cc.Declaration{ · · · DeclarationSpecifiers: &cc.DeclarationSpecifiers{ · · · · StorageClassSpecifier: &cc.StorageClassSpecifier{ · · · · · Case: 3, · · · · · Token: example235.c:1:6: AUTO "auto", · · · · }, · · · }, · · · Token: example235.c:1:11: ';', · · }, · }, · TranslationUnit: &cc.TranslationUnit{ · · Case: 1, · · ExternalDeclaration: &cc.ExternalDeclaration{ · · · Case: 1, · · · Declaration: &cc.Declaration{ · · · · DeclarationSpecifiers: &cc.DeclarationSpecifiers{ · · · · · StorageClassSpecifier: &cc.StorageClassSpecifier{ · · · · · · Case: 3, · · · · · · Token: example235.c:1:13: AUTO "auto", · · · · · }, · · · · }, · · · · Token: example235.c:1:18: ';', · · · }, · · }, · }, }
func Parse ¶
Parse defines any macros in predefine. Then Parse preprocesses and parses the translation unit consisting of files in paths. The m communicates the scalar types model and opts allow to amend parser behavior. m cannot be reused and passed to Parse again.
func (*TranslationUnit) Pos ¶
func (n *TranslationUnit) Pos() token.Pos
Pos reports the position of the first component of n or zero if it's empty.
func (*TranslationUnit) String ¶
func (n *TranslationUnit) String() string
String implements fmt.Stringer.
type Type ¶
type Type interface { // AlignOf returns the alignment in bytes of a value of this type when // allocated in memory not as a struct field. Incomplete struct types // have no alignment and the value returned will be < 0. AlignOf() int // CanAssignTo returns whether this type can be assigned to dst. CanAssignTo(dst Type) bool // Declarator returns the full Declarator which defined an entity of // this type. The returned declarator is possibly artificial. Declarator() *Declarator // Element returns the type this Ptr type points to or the element type // of an Array type. Element() Type // Elements returns the number of elements an Array type has. The // returned value is < 0 if this type is not an Array or if the array // is not of a constant size. Elements() int // EnumeratorList returns the enumeration constants defined by an Enum // type, if any. EnumeratorList() []EnumConstant // Kind returns one of Ptr, Void, Int, ... Kind() Kind // Member returns the type of a member of this Struct or Union type, // having numeric name identifier nm. Member(nm int) (*Member, error) // Members returns the members of a Struct or Union type in declaration // order. Returned members are valid iff non nil. // // Note: Non nil members of length 0 means the struct/union has no // members or the type is incomplete, which is indicated by the // isIncomplete return value. // // Note 2: C99 standard does not allow empty structs/unions, but GCC // supports that as an extension. Members() (members []Member, isIncomplete bool) // Parameters returns the parameters of a Function type in declaration // order. Result is valid iff params is not nil. // // Note: len(params) == 0 is fine and just means the function has no // parameters. Parameters() (params []Parameter, isVariadic bool) // Pointer returns a type that points to this type. Pointer() Type // Result returns the result type of a Function type. Result() Type // Sizeof returns the number of bytes needed to store a value of this // type. Incomplete struct types have no size and the value returned // will be < 0. SizeOf() int // Specifier returns the Specifier of this type. Specifier() Specifier // String returns a C-like type specifier of this type. String() string // StructAlignOf returns the alignment in bytes of a value of this type // when allocated in memory as a struct field. Incomplete struct types // have no alignment and the value returned will be < 0. StructAlignOf() int // Tag returns the ID of a tag of a Struct, Union or Enum type, if any. // Otherwise the returned value is zero. Tag() int }
Type decribes properties of a C type.
type TypeName ¶
type TypeName struct { Type Type AbstractDeclaratorOpt *AbstractDeclaratorOpt SpecifierQualifierList *SpecifierQualifierList // contains filtered or unexported fields }
TypeName represents data reduced by production:
TypeName: SpecifierQualifierList AbstractDeclaratorOpt
Example ¶
fmt.Println(exampleAST(177, "\U00100001 ( _Bool )"))
Output: &cc.TypeName{ · Type: bool, · SpecifierQualifierList: &cc.SpecifierQualifierList{ · · TypeSpecifier: &cc.TypeSpecifier{ · · · Case: 9, · · · Token: example177.c:1:8: BOOL "_Bool", · · }, · }, }
type TypeQualifier ¶
TypeQualifier represents data reduced by productions:
TypeQualifier: "const" | "restrict" // Case 1 | "volatile" // Case 2
Example ¶
fmt.Println(exampleAST(138, "\U00100002 const !"))
Output: &cc.TypeQualifier{ · Token: example138.c:1:6: CONST "const", }
Example (Case1) ¶
fmt.Println(exampleAST(139, "\U00100002 restrict !"))
Output: &cc.TypeQualifier{ · Case: 1, · Token: example139.c:1:6: RESTRICT "restrict", }
Example (Case2) ¶
fmt.Println(exampleAST(140, "\U00100002 volatile !"))
Output: &cc.TypeQualifier{ · Case: 2, · Token: example140.c:1:6: 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 TypeQualifierList ¶
type TypeQualifierList struct { Case int TypeQualifier *TypeQualifier TypeQualifierList *TypeQualifierList // contains filtered or unexported fields }
TypeQualifierList represents data reduced by productions:
TypeQualifierList: TypeQualifier | TypeQualifierList TypeQualifier // Case 1
Example ¶
fmt.Println(exampleAST(158, "\U00100002 auto * const !"))
Output: &cc.TypeQualifierList{ · TypeQualifier: &cc.TypeQualifier{ · · Token: example158.c:1:13: CONST "const", · }, }
Example (Case1) ¶
fmt.Println(exampleAST(159, "\U00100002 auto * const const !"))
Output: &cc.TypeQualifierList{ · TypeQualifier: &cc.TypeQualifier{ · · Token: example159.c:1:13: CONST "const", · }, · TypeQualifierList: &cc.TypeQualifierList{ · · Case: 1, · · TypeQualifier: &cc.TypeQualifier{ · · · Token: example159.c:1:19: 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 */ | TypeQualifierList // Case 1
Example ¶
fmt.Println(exampleAST(160, "\U00100002 auto * (") == (*TypeQualifierListOpt)(nil))
Output: true
Example (Case1) ¶
fmt.Println(exampleAST(161, "\U00100002 auto * const !"))
Output: &cc.TypeQualifierListOpt{ · TypeQualifierList: &cc.TypeQualifierList{ · · TypeQualifier: &cc.TypeQualifier{ · · · Token: example161.c:1:13: 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 { Type Type // Type of typeof. Case int EnumSpecifier *EnumSpecifier Expression *Expression 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: "void" | "char" // Case 1 | "short" // Case 2 | "int" // Case 3 | "long" // Case 4 | "float" // Case 5 | "double" // Case 6 | "signed" // Case 7 | "unsigned" // Case 8 | "_Bool" // Case 9 | "_Complex" // Case 10 | StructOrUnionSpecifier // Case 11 | EnumSpecifier // Case 12 | TYPEDEFNAME // Case 13 | "typeof" '(' Expression ')' // Case 14 | "typeof" '(' TypeName ')' // Case 15
Example ¶
fmt.Println(exampleAST(95, "\U00100002 void ("))
Output: &cc.TypeSpecifier{ · Token: example95.c:1:6: VOID "void", }
Example (Case01) ¶
fmt.Println(exampleAST(96, "\U00100002 char ("))
Output: &cc.TypeSpecifier{ · Case: 1, · Token: example96.c:1:6: CHAR "char", }
Example (Case02) ¶
fmt.Println(exampleAST(97, "\U00100002 short ("))
Output: &cc.TypeSpecifier{ · Case: 2, · Token: example97.c:1:6: SHORT "short", }
Example (Case03) ¶
fmt.Println(exampleAST(98, "\U00100002 int ("))
Output: &cc.TypeSpecifier{ · Case: 3, · Token: example98.c:1:6: INT "int", }
Example (Case04) ¶
fmt.Println(exampleAST(99, "\U00100002 long ("))
Output: &cc.TypeSpecifier{ · Case: 4, · Token: example99.c:1:6: LONG "long", }
Example (Case05) ¶
fmt.Println(exampleAST(100, "\U00100002 float ("))
Output: &cc.TypeSpecifier{ · Case: 5, · Token: example100.c:1:6: FLOAT "float", }
Example (Case06) ¶
fmt.Println(exampleAST(101, "\U00100002 double ("))
Output: &cc.TypeSpecifier{ · Case: 6, · Token: example101.c:1:6: DOUBLE "double", }
Example (Case07) ¶
fmt.Println(exampleAST(102, "\U00100002 signed ("))
Output: &cc.TypeSpecifier{ · Case: 7, · Token: example102.c:1:6: SIGNED "signed", }
Example (Case08) ¶
fmt.Println(exampleAST(103, "\U00100002 unsigned ("))
Output: &cc.TypeSpecifier{ · Case: 8, · Token: example103.c:1:6: UNSIGNED "unsigned", }
Example (Case09) ¶
fmt.Println(exampleAST(104, "\U00100002 _Bool ("))
Output: &cc.TypeSpecifier{ · Case: 9, · Token: example104.c:1:6: BOOL "_Bool", }
Example (Case10) ¶
fmt.Println(exampleAST(105, "\U00100002 _Complex ("))
Output: &cc.TypeSpecifier{ · Case: 10, · Token: example105.c:1:6: COMPLEX "_Complex", }
Example (Case11) ¶
fmt.Println(exampleAST(106, "\U00100002 struct a ("))
Output: &cc.TypeSpecifier{ · Case: 11, · StructOrUnionSpecifier: &cc.StructOrUnionSpecifier{ · · Case: 1, · · StructOrUnion: &cc.StructOrUnion{ · · · Token: example106.c:1:6: STRUCT "struct", · · }, · · Token: example106.c:1:13: IDENTIFIER "a", · }, }
Example (Case12) ¶
fmt.Println(exampleAST(107, "\U00100002 enum a ("))
Output: &cc.TypeSpecifier{ · Case: 12, · EnumSpecifier: &cc.EnumSpecifier{ · · Case: 1, · · Token: example107.c:1:6: ENUM "enum", · · Token2: example107.c:1:11: IDENTIFIER "a", · }, }
Example (Case13) ¶
fmt.Println(exampleAST(108, "\U00100002 typedef int i; i j;"))
Output: &cc.TypeSpecifier{ · Case: 13, · Token: example108.c:1:21: TYPEDEFNAME "i", }
Example (Case14) ¶
fmt.Println(exampleAST(109, "\U00100002 typeof ( 'a' ) ("))
Output: &cc.TypeSpecifier{ · Type: int, · Case: 14, · Expression: &cc.Expression{ · · Type: int, · · Value: 97, · · Case: 1, · · Token: example109.c:1:15: CHARCONST "'a'", · }, · Token: example109.c:1:6: TYPEOF "typeof", · Token2: example109.c:1:13: '(', · Token3: example109.c:1:19: ')', }
Example (Case15) ¶
fmt.Println(exampleAST(110, "\U00100002 typeof ( _Bool ) ("))
Output: &cc.TypeSpecifier{ · Type: bool, · Case: 15, · Token: example110.c:1:6: TYPEOF "typeof", · Token2: example110.c:1:13: '(', · Token3: example110.c:1:21: ')', · TypeName: &cc.TypeName{ · · Type: bool, · · SpecifierQualifierList: &cc.SpecifierQualifierList{ · · · TypeSpecifier: &cc.TypeSpecifier{ · · · · Case: 9, · · · · Token: example110.c:1:15: BOOL "_Bool", · · · }, · · }, · }, }
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.