cc

package module
v1.0.1 Latest Latest
Warning

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

 Go to latest Published: Feb 23, 2021 License: BSD-3-Clause Imports: 21 Imported by: 34

README

cc

2020-07-13 This package is no longer maintained. Please see the v3 version at

https://modernc.org/cc/v3

Package CC is a C99 compiler front end.

Installation

$ go get modernc.org/cc

Documentation: godoc.org/modernc.org/cc

Building with make requires indent(1) and the following Go packages

  • github.com/golang/lint/golint
  • github.com/mdempsky/maligned
  • github.com/mdempsky/unconvert
  • honnef.co/go/tools/cmd/unused

Documentation

Overview

Package cc is a C99 compiler front end.

Changelog

2020-07-13 This package is no longer maintained. Please see the v3 version at 

https://modernc.org/cc/v3

Index

Examples

Constants

View Source 
const (
	ADDASSIGN           = 57346
	ALIGNOF             = 57347
	ANDAND              = 57348
	ANDASSIGN           = 57349
	ARROW               = 57350
	ASM                 = 57351
	AUTO                = 57352
	BOOL                = 57353
	BREAK               = 57354
	CASE                = 57355
	CAST                = 57356
	CHAR                = 57357
	CHARCONST           = 57358
	COMPLEX             = 57359
	CONST               = 57360
	CONSTANT_EXPRESSION = 1048577
	CONTINUE            = 57361
	DDD                 = 57362
	DEC                 = 57363
	DEFAULT             = 57364
	DIVASSIGN           = 57365
	DO                  = 57366
	DOUBLE              = 57367
	ELSE                = 57368
	ENUM                = 57369
	EQ                  = 57370
	EXTERN              = 57371
	FLOAT               = 57372
	FLOATCONST          = 57373
	FOR                 = 57374
	GEQ                 = 57375
	GOTO                = 57376
	IDENTIFIER          = 57377
	IDENTIFIER_LPAREN   = 57378
	IDENTIFIER_NONREPL  = 57379
	IF                  = 57380
	INC                 = 57381
	INLINE              = 57382
	INT                 = 57383
	INTCONST            = 57384
	LEQ                 = 57385
	LONG                = 57386
	LONGCHARCONST       = 57387
	LONGSTRINGLITERAL   = 57388
	LSH                 = 57389
	LSHASSIGN           = 57390
	MODASSIGN           = 57391
	MULASSIGN           = 57392
	NEQ                 = 57393
	NOELSE              = 57394
	NORETURN            = 57395
	NOSEMI              = 57396
	ORASSIGN            = 57397
	OROR                = 57398
	PPDEFINE            = 57399
	PPELIF              = 57400
	PPELSE              = 57401
	PPENDIF             = 57402
	PPERROR             = 57403
	PPHASH_NL           = 57404
	PPHEADER_NAME       = 57405
	PPIF                = 57406
	PPIFDEF             = 57407
	PPIFNDEF            = 57408
	PPINCLUDE           = 57409
	PPINCLUDE_NEXT      = 57410
	PPLINE              = 57411
	PPNONDIRECTIVE      = 57412
	PPNUMBER            = 57413
	PPOTHER             = 57414
	PPPASTE             = 57415
	PPPRAGMA            = 57416
	PPUNDEF             = 57417
	PREPROCESSING_FILE  = 1048576
	REGISTER            = 57418
	RESTRICT            = 57419
	RETURN              = 57420
	RSH                 = 57421
	RSHASSIGN           = 57422
	SHORT               = 57423
	SIGNED              = 57424
	SIZEOF              = 57425
	STATIC              = 57426
	STATIC_ASSERT       = 57427
	STRINGLITERAL       = 57428
	STRUCT              = 57429
	SUBASSIGN           = 57430
	SWITCH              = 57431
	TRANSLATION_UNIT    = 1048578
	TYPEDEF             = 57432
	TYPEDEFNAME         = 57433
	TYPEOF              = 57434
	UNARY               = 57435
	UNION               = 57436
	UNSIGNED            = 57437
	VOID                = 57438
	VOLATILE            = 57439
	WHILE               = 57440
	XORASSIGN           = 57441
)

Variables

This section is empty.

Functions

func HostConfig 

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

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

func HostCppConfig 

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

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

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

func ImportPath 

func ImportPath() (string, error)

ImportPath returns the import path of this package or an error, if any.

func IsArithmeticType 

func IsArithmeticType(t Type) bool

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, LongDoubleComplex, Bool or Enum.

func IsIntType 

func IsIntType(t Type) bool

IsIntType reports t.Kind() is one of Char, SChar, UChar, Short, UShort, Int, UInt, Long, ULong, LongLong, ULongLong, Bool or Enum.

func PrettyString 

func PrettyString(v interface{}) string

PrettyString pretty prints things produced by this package.

func TokSrc 

func TokSrc(t xc.Token) string

TokSrc returns t in its source form.

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(185, "\U00100001 ( _Bool * )"))

Output:

&cc.AbstractDeclarator{
· Pointer: &cc.Pointer{
· · Token: example185.c:1:10: '*',
· },
}
Example (Case1) 
fmt.Println(exampleAST(186, "\U00100001 ( _Bool ( ) )"))

Output:

&cc.AbstractDeclarator{
· Case: 1,
· DirectAbstractDeclarator: &cc.DirectAbstractDeclarator{
· · Case: 6,
· · Token: example186.c:1:10: '(',
· · Token2: example186.c:1:12: ')',
· },
}

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(187, "\U00100001 ( _Bool )") == (*AbstractDeclaratorOpt)(nil))

Output:

true
Example (Case1) 
fmt.Println(exampleAST(188, "\U00100001 ( _Bool * )"))

Output:

&cc.AbstractDeclaratorOpt{
· AbstractDeclarator: &cc.AbstractDeclarator{
· · Pointer: &cc.Pointer{
· · · Token: example188.c:1:10: '*',
· · },
· },
}

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:8: 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:14: CHARCONST "'c'",
· · },
· · Token: example9.c:1:12: ',',
· },
· Expression: &cc.Expression{
· · Case: 1,
· · Token: example9.c:1:8: 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:8: 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 AssemblerInstructions 

type AssemblerInstructions struct {
	AssemblerInstructions *AssemblerInstructions
	Case                  int
	Token                 xc.Token
}

AssemblerInstructions represents data reduced by productions: 

AssemblerInstructions:
        STRINGLITERAL
|       AssemblerInstructions STRINGLITERAL  // Case 1
Example 
fmt.Println(exampleAST(265, "\U00100002 asm ( \"a\" )"))

Output:

&cc.AssemblerInstructions{
· Token: example265.c:1:8: STRINGLITERAL "\"a\"",
}
Example (Case1) 
fmt.Println(exampleAST(266, "\U00100002 asm ( \"a\" \"b\" )"))

Output:

&cc.AssemblerInstructions{
· AssemblerInstructions: &cc.AssemblerInstructions{
· · Case: 1,
· · Token: example266.c:1:12: STRINGLITERAL "\"b\"",
· },
· Token: example266.c:1:8: STRINGLITERAL "\"a\"",
}

func (*AssemblerInstructions) Pos 

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

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

func (*AssemblerInstructions) String 

func (n *AssemblerInstructions) String() string

String implements fmt.Stringer.

type AssemblerOperand 

type AssemblerOperand struct {
	AssemblerSymbolicNameOpt *AssemblerSymbolicNameOpt
	Expression               *Expression
	Token                    xc.Token
	Token2                   xc.Token
	Token3                   xc.Token
}

AssemblerOperand represents data reduced by production: 

AssemblerOperand:
        AssemblerSymbolicNameOpt STRINGLITERAL '(' Expression ')'
Example 
fmt.Println(exampleAST(270, "\U00100002 a asm ( \"b\" : \"c\" ( 'd' ) )"))

Output:

&cc.AssemblerOperand{
· Expression: &cc.Expression{
· · Case: 1,
· · Token: example270.c:1:22: CHARCONST "'d'",
· },
· Token: example270.c:1:16: STRINGLITERAL "\"c\"",
· Token2: example270.c:1:20: '(',
· Token3: example270.c:1:26: ')',
}

func (*AssemblerOperand) Pos 

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

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

func (*AssemblerOperand) String 

func (n *AssemblerOperand) String() string

String implements fmt.Stringer.

type AssemblerOperands 

type AssemblerOperands struct {
	AssemblerOperand  *AssemblerOperand
	AssemblerOperands *AssemblerOperands
	Case              int
	Token             xc.Token
}

AssemblerOperands represents data reduced by productions: 

AssemblerOperands:
        AssemblerOperand
|       AssemblerOperands ',' AssemblerOperand  // Case 1
Example 
fmt.Println(exampleAST(271, "\U00100002 a asm ( \"b\" : \"c\" ( 'd' ) )"))

Output:

&cc.AssemblerOperands{
· AssemblerOperand: &cc.AssemblerOperand{
· · Expression: &cc.Expression{
· · · Case: 1,
· · · Token: example271.c:1:22: CHARCONST "'d'",
· · },
· · Token: example271.c:1:16: STRINGLITERAL "\"c\"",
· · Token2: example271.c:1:20: '(',
· · Token3: example271.c:1:26: ')',
· },
}
Example (Case1) 
fmt.Println(exampleAST(272, "\U00100002 a asm ( \"b\" : \"c\" ( 'd' ) , \"e\" ( 'f' ) )"))

Output:

&cc.AssemblerOperands{
· AssemblerOperand: &cc.AssemblerOperand{
· · Expression: &cc.Expression{
· · · Case: 1,
· · · Token: example272.c:1:22: CHARCONST "'d'",
· · },
· · Token: example272.c:1:16: STRINGLITERAL "\"c\"",
· · Token2: example272.c:1:20: '(',
· · Token3: example272.c:1:26: ')',
· },
· AssemblerOperands: &cc.AssemblerOperands{
· · AssemblerOperand: &cc.AssemblerOperand{
· · · Expression: &cc.Expression{
· · · · Case: 1,
· · · · Token: example272.c:1:36: CHARCONST "'f'",
· · · },
· · · Token: example272.c:1:30: STRINGLITERAL "\"e\"",
· · · Token2: example272.c:1:34: '(',
· · · Token3: example272.c:1:40: ')',
· · },
· · Case: 1,
· · Token: example272.c:1:28: ',',
· },
}

func (*AssemblerOperands) Pos 

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

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

func (*AssemblerOperands) String 

func (n *AssemblerOperands) String() string

String implements fmt.Stringer.

type AssemblerStatement 

type AssemblerStatement struct {
	AssemblerInstructions   *AssemblerInstructions
	AssemblerOperands       *AssemblerOperands
	AssemblerOperands2      *AssemblerOperands
	BasicAssemblerStatement *BasicAssemblerStatement
	Case                    int
	Clobbers                *Clobbers
	IdentifierList          *IdentifierList
	Token                   xc.Token
	Token2                  xc.Token
	Token3                  xc.Token
	Token4                  xc.Token
	Token5                  xc.Token
	Token6                  xc.Token
	Token7                  xc.Token
	Token8                  xc.Token
	VolatileOpt             *VolatileOpt
}

AssemblerStatement represents data reduced by productions: 

AssemblerStatement:
        BasicAssemblerStatement
|       "asm" VolatileOpt '(' AssemblerInstructions ':' AssemblerOperands ')'                                             // Case 1
|       "asm" VolatileOpt '(' AssemblerInstructions ':' AssemblerOperands ':' AssemblerOperands ')'                       // Case 2
|       "asm" VolatileOpt '(' AssemblerInstructions ':' AssemblerOperands ':' AssemblerOperands ':' Clobbers ')'          // Case 3
|       "asm" VolatileOpt "goto" '(' AssemblerInstructions ':' ':' AssemblerOperands ':' Clobbers ':' IdentifierList ')'  // Case 4
|       "asm" VolatileOpt '(' AssemblerInstructions ':' ')'                                                               // Case 5
|       "asm" VolatileOpt '(' AssemblerInstructions ':' ':' AssemblerOperands ')'                                         // Case 6
Example 
fmt.Println(exampleAST(277, "\U00100002 a asm ( \"b\" ) !"))

Output:

&cc.AssemblerStatement{
· BasicAssemblerStatement: &cc.BasicAssemblerStatement{
· · AssemblerInstructions: &cc.AssemblerInstructions{
· · · Token: example277.c:1:10: STRINGLITERAL "\"b\"",
· · },
· · Token: example277.c:1:4: ASM "asm",
· · Token2: example277.c:1:8: '(',
· · Token3: example277.c:1:14: ')',
· },
}
Example (Case1) 
fmt.Println(exampleAST(278, "\U00100002 a asm ( \"b\" : \"c\" ( 'd' ) ) !"))

Output:

&cc.AssemblerStatement{
· AssemblerInstructions: &cc.AssemblerInstructions{
· · Token: example278.c:1:10: STRINGLITERAL "\"b\"",
· },
· AssemblerOperands: &cc.AssemblerOperands{
· · AssemblerOperand: &cc.AssemblerOperand{
· · · Expression: &cc.Expression{
· · · · Case: 1,
· · · · Token: example278.c:1:22: CHARCONST "'d'",
· · · },
· · · Token: example278.c:1:16: STRINGLITERAL "\"c\"",
· · · Token2: example278.c:1:20: '(',
· · · Token3: example278.c:1:26: ')',
· · },
· },
· Case: 1,
· Token: example278.c:1:4: ASM "asm",
· Token2: example278.c:1:8: '(',
· Token3: example278.c:1:14: ':',
· Token4: example278.c:1:28: ')',
}
Example (Case2) 
fmt.Println(exampleAST(279, "\U00100002 a asm ( \"b\" : \"c\" ( 'd' ) : \"e\" ( 'f' ) ) !"))

Output:

&cc.AssemblerStatement{
· AssemblerInstructions: &cc.AssemblerInstructions{
· · Token: example279.c:1:10: STRINGLITERAL "\"b\"",
· },
· AssemblerOperands: &cc.AssemblerOperands{
· · AssemblerOperand: &cc.AssemblerOperand{
· · · Expression: &cc.Expression{
· · · · Case: 1,
· · · · Token: example279.c:1:22: CHARCONST "'d'",
· · · },
· · · Token: example279.c:1:16: STRINGLITERAL "\"c\"",
· · · Token2: example279.c:1:20: '(',
· · · Token3: example279.c:1:26: ')',
· · },
· },
· AssemblerOperands2: &cc.AssemblerOperands{
· · AssemblerOperand: &cc.AssemblerOperand{
· · · Expression: &cc.Expression{
· · · · Case: 1,
· · · · Token: example279.c:1:36: CHARCONST "'f'",
· · · },
· · · Token: example279.c:1:30: STRINGLITERAL "\"e\"",
· · · Token2: example279.c:1:34: '(',
· · · Token3: example279.c:1:40: ')',
· · },
· },
· Case: 2,
· Token: example279.c:1:4: ASM "asm",
· Token2: example279.c:1:8: '(',
· Token3: example279.c:1:14: ':',
· Token4: example279.c:1:28: ':',
· Token5: example279.c:1:42: ')',
}
Example (Case3) 
fmt.Println(exampleAST(280, "\U00100002 a asm ( \"b\" : \"c\" ( 'd' ) : \"e\" ( 'f' ) : \"g\" ) !"))

Output:

&cc.AssemblerStatement{
· AssemblerInstructions: &cc.AssemblerInstructions{
· · Token: example280.c:1:10: STRINGLITERAL "\"b\"",
· },
· AssemblerOperands: &cc.AssemblerOperands{
· · AssemblerOperand: &cc.AssemblerOperand{
· · · Expression: &cc.Expression{
· · · · Case: 1,
· · · · Token: example280.c:1:22: CHARCONST "'d'",
· · · },
· · · Token: example280.c:1:16: STRINGLITERAL "\"c\"",
· · · Token2: example280.c:1:20: '(',
· · · Token3: example280.c:1:26: ')',
· · },
· },
· AssemblerOperands2: &cc.AssemblerOperands{
· · AssemblerOperand: &cc.AssemblerOperand{
· · · Expression: &cc.Expression{
· · · · Case: 1,
· · · · Token: example280.c:1:36: CHARCONST "'f'",
· · · },
· · · Token: example280.c:1:30: STRINGLITERAL "\"e\"",
· · · Token2: example280.c:1:34: '(',
· · · Token3: example280.c:1:40: ')',
· · },
· },
· Case: 3,
· Clobbers: &cc.Clobbers{
· · Token: example280.c:1:44: STRINGLITERAL "\"g\"",
· },
· Token: example280.c:1:4: ASM "asm",
· Token2: example280.c:1:8: '(',
· Token3: example280.c:1:14: ':',
· Token4: example280.c:1:28: ':',
· Token5: example280.c:1:42: ':',
· Token6: example280.c:1:48: ')',
}
Example (Case4) 
fmt.Println(exampleAST(281, "\U00100002 a asm goto ( \"b\" : : \"c\" ( 'd' ) : \"e\" : f ) !"))

Output:

&cc.AssemblerStatement{
· AssemblerInstructions: &cc.AssemblerInstructions{
· · Token: example281.c:1:15: STRINGLITERAL "\"b\"",
· },
· AssemblerOperands: &cc.AssemblerOperands{
· · AssemblerOperand: &cc.AssemblerOperand{
· · · Expression: &cc.Expression{
· · · · Case: 1,
· · · · Token: example281.c:1:29: CHARCONST "'d'",
· · · },
· · · Token: example281.c:1:23: STRINGLITERAL "\"c\"",
· · · Token2: example281.c:1:27: '(',
· · · Token3: example281.c:1:33: ')',
· · },
· },
· Case: 4,
· Clobbers: &cc.Clobbers{
· · Token: example281.c:1:37: STRINGLITERAL "\"e\"",
· },
· IdentifierList: &cc.IdentifierList{
· · Token: example281.c:1:43: IDENTIFIER "f",
· },
· Token: example281.c:1:4: ASM "asm",
· Token2: example281.c:1:8: GOTO "goto",
· Token3: example281.c:1:13: '(',
· Token4: example281.c:1:19: ':',
· Token5: example281.c:1:21: ':',
· Token6: example281.c:1:35: ':',
· Token7: example281.c:1:41: ':',
· Token8: example281.c:1:45: ')',
}
Example (Case5) 
fmt.Println(exampleAST(282, "\U00100002 a asm ( \"b\" : ) !"))

Output:

&cc.AssemblerStatement{
· AssemblerInstructions: &cc.AssemblerInstructions{
· · Token: example282.c:1:10: STRINGLITERAL "\"b\"",
· },
· Case: 5,
· Token: example282.c:1:4: ASM "asm",
· Token2: example282.c:1:8: '(',
· Token3: example282.c:1:14: ':',
· Token4: example282.c:1:16: ')',
}
Example (Case6) 
fmt.Println(exampleAST(283, "\U00100002 a asm ( \"b\" : : \"c\" ( 'd' ) ) !"))

Output:

&cc.AssemblerStatement{
· AssemblerInstructions: &cc.AssemblerInstructions{
· · Token: example283.c:1:10: STRINGLITERAL "\"b\"",
· },
· AssemblerOperands: &cc.AssemblerOperands{
· · AssemblerOperand: &cc.AssemblerOperand{
· · · Expression: &cc.Expression{
· · · · Case: 1,
· · · · Token: example283.c:1:24: CHARCONST "'d'",
· · · },
· · · Token: example283.c:1:18: STRINGLITERAL "\"c\"",
· · · Token2: example283.c:1:22: '(',
· · · Token3: example283.c:1:28: ')',
· · },
· },
· Case: 6,
· Token: example283.c:1:4: ASM "asm",
· Token2: example283.c:1:8: '(',
· Token3: example283.c:1:14: ':',
· Token4: example283.c:1:16: ':',
· Token5: example283.c:1:30: ')',
}

func (*AssemblerStatement) Pos 

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

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

func (*AssemblerStatement) String 

func (n *AssemblerStatement) String() string

String implements fmt.Stringer.

type AssemblerSymbolicNameOpt 

type AssemblerSymbolicNameOpt struct {
	Token  xc.Token
	Token2 xc.Token
	Token3 xc.Token
}

AssemblerSymbolicNameOpt represents data reduced by productions: 

AssemblerSymbolicNameOpt:
        /* empty */
|       '[' IDENTIFIER ']'  // Case 1
Example 
fmt.Println(exampleAST(273, "\U00100002 a asm goto ( \"b\" : : \"c\"") == (*AssemblerSymbolicNameOpt)(nil))

Output:

true
Example (Case1) 
fmt.Println(exampleAST(274, "\U00100002 a asm ( \"b\" : [ c ] \"d\""))

Output:

&cc.AssemblerSymbolicNameOpt{
· Token: example274.c:1:16: '[',
· Token2: example274.c:1:18: IDENTIFIER "c",
· Token3: example274.c:1:20: ']',
}

func (*AssemblerSymbolicNameOpt) Pos 

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

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

func (*AssemblerSymbolicNameOpt) String 

func (n *AssemblerSymbolicNameOpt) String() string

String implements fmt.Stringer.

type BasicAssemblerStatement 

type BasicAssemblerStatement struct {
	AssemblerInstructions *AssemblerInstructions
	Token                 xc.Token
	Token2                xc.Token
	Token3                xc.Token
	VolatileOpt           *VolatileOpt
}

BasicAssemblerStatement represents data reduced by production: 

BasicAssemblerStatement:
        "asm" VolatileOpt '(' AssemblerInstructions ')'
Example 
fmt.Println(exampleAST(267, "\U00100002 asm ( \"a\" ) !"))

Output:

&cc.BasicAssemblerStatement{
· AssemblerInstructions: &cc.AssemblerInstructions{
· · Token: example267.c:1:8: STRINGLITERAL "\"a\"",
· },
· Token: example267.c:1:2: ASM "asm",
· Token2: example267.c:1:6: '(',
· Token3: example267.c:1:12: ')',
}

func (*BasicAssemblerStatement) Pos 

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

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

func (*BasicAssemblerStatement) String 

func (n *BasicAssemblerStatement) 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 declared 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.

	Parent *Bindings // Parent scope or nil for ScopeFile.
	// contains filtered or unexported fields
}

Bindings record names declared in a scope.

func (*Bindings) Lookup 

func (b *Bindings) Lookup(ns Namespace, id int) Binding

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.

func (*Bindings) Lookup2 

func (b *Bindings) Lookup2(ns Namespace, id int) (Binding, *Bindings)

Lookup2 is like Lookup but addionally it returns also the scope in which id was found.

func (*Bindings) Scope 

func (b *Bindings) Scope() Scope

Scope retuns the kind of b.

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(230, "\U00100001 ( { auto ; !"))

Output:

&cc.BlockItem{
· Declaration: &cc.Declaration{
· · DeclarationSpecifiers: &cc.DeclarationSpecifiers{
· · · StorageClassSpecifier: &cc.StorageClassSpecifier{
· · · · Case: 3,
· · · · Token: example230.c:1:6: AUTO "auto",
· · · },
· · },
· · Token: example230.c:1:11: ';',
· },
}
Example (Case1) 
fmt.Println(exampleAST(231, "\U00100001 ( { ; !"))

Output:

&cc.BlockItem{
· Case: 1,
· Statement: &cc.Statement{
· · Case: 2,
· · ExpressionStatement: &cc.ExpressionStatement{
· · · Token: example231.c:1:6: ';',
· · },
· },
}

func (*BlockItem) Pos 

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

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

func (*BlockItem) String 

func (n *BlockItem) String() string

String implements fmt.Stringer.

type 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(226, "\U00100001 ( { ; !"))

Output:

&cc.BlockItemList{
· BlockItem: &cc.BlockItem{
· · Case: 1,
· · Statement: &cc.Statement{
· · · Case: 2,
· · · ExpressionStatement: &cc.ExpressionStatement{
· · · · Token: example226.c:1:6: ';',
· · · },
· · },
· },
}
Example (Case1) 
fmt.Println(exampleAST(227, "\U00100001 ( { ; ; !"))

Output:

&cc.BlockItemList{
· BlockItem: &cc.BlockItem{
· · Case: 1,
· · Statement: &cc.Statement{
· · · Case: 2,
· · · ExpressionStatement: &cc.ExpressionStatement{
· · · · Token: example227.c:1:6: ';',
· · · },
· · },
· },
· BlockItemList: &cc.BlockItemList{
· · BlockItem: &cc.BlockItem{
· · · Case: 1,
· · · Statement: &cc.Statement{
· · · · Case: 2,
· · · · ExpressionStatement: &cc.ExpressionStatement{
· · · · · Token: example227.c:1:8: ';',
· · · · },
· · · },
· · },
· · 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(228, "\U00100001 ( { }") == (*BlockItemListOpt)(nil))

Output:

true
Example (Case1) 
fmt.Println(exampleAST(229, "\U00100001 ( { ; }"))

Output:

&cc.BlockItemListOpt{
· BlockItemList: &cc.BlockItemList{
· · BlockItem: &cc.BlockItem{
· · · Case: 1,
· · · Statement: &cc.Statement{
· · · · Case: 2,
· · · · ExpressionStatement: &cc.ExpressionStatement{
· · · · · Token: example229.c:1:6: ';',
· · · · },
· · · },
· · },
· },
}

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 Clobbers 

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

Clobbers represents data reduced by productions: 

Clobbers:
        STRINGLITERAL
|       Clobbers ',' STRINGLITERAL  // Case 1
Example 
fmt.Println(exampleAST(275, "\U00100002 a asm goto ( \"b\" : : \"c\" ( 'd' ) : \"e\" )"))

Output:

&cc.Clobbers{
· Token: example275.c:1:37: STRINGLITERAL "\"e\"",
}
Example (Case1) 
fmt.Println(exampleAST(276, "\U00100002 a asm goto ( \"b\" : : \"c\" ( 'd' ) : \"e\" , \"f\" )"))

Output:

&cc.Clobbers{
· Clobbers: &cc.Clobbers{
· · Case: 1,
· · Token: example276.c:1:41: ',',
· · Token2: example276.c:1:43: STRINGLITERAL "\"f\"",
· },
· Token: example276.c:1:37: STRINGLITERAL "\"e\"",
}

func (*Clobbers) Pos 

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

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

func (*Clobbers) String 

func (n *Clobbers) String() string

String implements fmt.Stringer.

type CommaOpt 

type CommaOpt struct {
	Token xc.Token
}

CommaOpt represents data reduced by productions: 

CommaOpt:
        /* empty */
|       ','          // Case 1
Example 
fmt.Println(exampleAST(135, "\U00100002 auto a = { }") == (*CommaOpt)(nil))

Output:

true
Example (Case1) 
fmt.Println(exampleAST(136, "\U00100002 auto a = { , }"))

Output:

&cc.CommaOpt{
· Token: example136.c:1:13: ',',
}

func (*CommaOpt) Pos 

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

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

func (*CommaOpt) String 

func (n *CommaOpt) String() string

String implements fmt.Stringer.

type 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(225, "\U00100001 ( { }"))

Output:

&cc.CompoundStatement{
· Token: example225.c:1:4: '{',
· Token2: example225.c:1:6: '}',
}

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 ComputedGotoID 

type ComputedGotoID int

StringLitID is the type of an Expression.Value representing the numeric ID of a label name used in &&label.

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(79, "\U00100001 'a'"))

Output:

&cc.ConstantExpression{
· Type: int,
· Value: 97,
· Expression: &cc.Expression{
· · Type: int,
· · Value: 97,
· · Case: 1,
· · Token: example79.c:1:2: 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
}

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 IdentifierList "..." ')' ReplacementList      // Case 10
|       PPDEFINE '\n'                                                            // Case 11
|       PPUNDEF IDENTIFIER PPTokenList '\n'                                      // Case 12
|       PPINCLUDE_NEXT PPTokenList '\n'                                          // Case 13
Example 
fmt.Println(exampleAST(307, "\U00100000 \n#define a "))

Output:

&cc.ControlLine{
· ReplacementList: []xc.Token{ // len 1
· · 0: example307.c:2:10: ' ',
· },
· Token: example307.c:2:2: PPDEFINE,
· Token2: example307.c:2:9: IDENTIFIER "a",
}
Example (Case01) 
fmt.Println(exampleAST(308, "\U00100000 \n#define a( ... ) "))

Output:

&cc.ControlLine{
· Case: 1,
· ReplacementList: []xc.Token{ // len 1
· · 0: example308.c:2:17: ' ',
· },
· Token: example308.c:2:2: PPDEFINE,
· Token2: example308.c:2:9: IDENTIFIER_LPAREN "a(",
· Token3: example308.c:2:12: DDD,
· Token4: example308.c:2:16: ')',
}
Example (Case02) 
fmt.Println(exampleAST(309, "\U00100000 \n#define a( b , ... ) "))

Output:

&cc.ControlLine{
· Case: 2,
· IdentifierList: &cc.IdentifierList{
· · Token: example309.c:2:12: IDENTIFIER "b",
· },
· ReplacementList: []xc.Token{ // len 1
· · 0: example309.c:2:21: ' ',
· },
· Token: example309.c:2:2: PPDEFINE,
· Token2: example309.c:2:9: IDENTIFIER_LPAREN "a(",
· Token3: example309.c:2:14: ',',
· Token4: example309.c:2:16: DDD,
· Token5: example309.c:2:20: ')',
}
Example (Case03) 
fmt.Println(exampleAST(310, "\U00100000 \n#define a( ) "))

Output:

&cc.ControlLine{
· Case: 3,
· ReplacementList: []xc.Token{ // len 1
· · 0: example310.c:2:13: ' ',
· },
· Token: example310.c:2:2: PPDEFINE,
· Token2: example310.c:2:9: IDENTIFIER_LPAREN "a(",
· Token3: example310.c:2:12: ')',
}
Example (Case04) 
fmt.Println(exampleAST(311, "\U00100000 \n#error "))

Output:

&cc.ControlLine{
· Case: 4,
· PPTokenListOpt: []xc.Token{ // len 1
· · 0: example311.c:2:7: ' ',
· },
· Token: example311.c:2:2: PPERROR,
}
Example (Case05) 
fmt.Println(exampleAST(312, "\U00100000 \n#"))

Output:

&cc.ControlLine{
· Case: 5,
· Token: example312.c:2:2: PPHASH_NL,
}
Example (Case06) 
fmt.Println(exampleAST(313, "\U00100000 \n#include other_a "))

Output:

&cc.ControlLine{
· Case: 6,
· PPTokenList: []xc.Token{ // len 3
· · 0: example313.c:2:9: ' ',
· · 1: example313.c:2:10: IDENTIFIER "other_a",
· · 2: example313.c:2:17: ' ',
· },
· Token: example313.c:2:2: PPINCLUDE,
· Token2: example313.c:2:18: '\n',
}
Example (Case07) 
fmt.Println(exampleAST(314, "\U00100000 \n#line other_a "))

Output:

&cc.ControlLine{
· Case: 7,
· PPTokenList: []xc.Token{ // len 3
· · 0: example314.c:2:6: ' ',
· · 1: example314.c:2:7: IDENTIFIER "other_a",
· · 2: example314.c:2:14: ' ',
· },
· Token: example314.c:2:2: PPLINE,
· Token2: example314.c:2:15: '\n',
}
Example (Case08) 
fmt.Println(exampleAST(315, "\U00100000 \n#pragma "))

Output:

&cc.ControlLine{
· Case: 8,
· PPTokenListOpt: []xc.Token{ // len 1
· · 0: example315.c:2:8: ' ',
· },
· Token: example315.c:2:2: PPPRAGMA,
}
Example (Case09) 
fmt.Println(exampleAST(316, "\U00100000 \n#undef foo"))

Output:

&cc.ControlLine{
· Case: 9,
· Token: example316.c:2:2: PPUNDEF,
· Token2: example316.c:2:8: IDENTIFIER "foo",
· Token3: example316.c:2:11: '\n',
}
Example (Case10) 
fmt.Println(exampleAST(317, "\U00100000 \n#define a( b ... ) "))

Output:

&cc.ControlLine{
· Case: 10,
· IdentifierList: &cc.IdentifierList{
· · Token: example317.c:2:12: IDENTIFIER "b",
· },
· ReplacementList: []xc.Token{ // len 1
· · 0: example317.c:2:19: ' ',
· },
· Token: example317.c:2:2: PPDEFINE,
· Token2: example317.c:2:9: IDENTIFIER_LPAREN "a(",
· Token3: example317.c:2:14: DDD,
· Token4: example317.c:2:18: ')',
}
Example (Case11) 
fmt.Println(exampleAST(318, "\U00100000 \n#define "))

Output:

&cc.ControlLine{
· Case: 11,
· Token: example318.c:2:2: PPDEFINE,
· Token2: example318.c:2:9: '\n',
}
Example (Case12) 
fmt.Println(exampleAST(319, "\U00100000 \n#undef foo(bar)"))

Output:

&cc.ControlLine{
· Case: 12,
· PPTokenList: []xc.Token{ // len 3
· · 0: example319.c:2:11: '(',
· · 1: example319.c:2:12: IDENTIFIER "bar",
· · 2: example319.c:2:15: ')',
· },
· Token: example319.c:2:2: PPUNDEF,
· Token2: example319.c:2:8: IDENTIFIER "foo",
· Token3: example319.c:2:16: '\n',
}
Example (Case13) 
fmt.Println(exampleAST(320, "\U00100000 \n#include_next other_a "))

Output:

&cc.ControlLine{
· Case: 13,
· PPTokenList: []xc.Token{ // len 3
· · 0: example320.c:2:14: ' ',
· · 1: example320.c:2:15: IDENTIFIER "other_a",
· · 2: example320.c:2:22: ' ',
· },
· Token: example320.c:2:2: PPINCLUDE_NEXT,
· Token2: example320.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.

func (*ControlLine) String 

func (n *ControlLine) String() string

String implements fmt.Stringer.

type Declaration 

type Declaration struct {
	Case                    int
	DeclarationSpecifiers   *DeclarationSpecifiers
	InitDeclaratorListOpt   *InitDeclaratorListOpt
	StaticAssertDeclaration *StaticAssertDeclaration
	Token                   xc.Token
	// contains filtered or unexported fields
}

Declaration represents data reduced by productions: 

Declaration:
        DeclarationSpecifiers InitDeclaratorListOpt ';'
|       StaticAssertDeclaration                          // Case 1
Example 
fmt.Println(exampleAST(80, "\U00100002 auto ;"))

Output:

&cc.Declaration{
· DeclarationSpecifiers: &cc.DeclarationSpecifiers{
· · StorageClassSpecifier: &cc.StorageClassSpecifier{
· · · Case: 3,
· · · Token: example80.c:1:2: AUTO "auto",
· · },
· },
· Token: example80.c:1:7: ';',
}
Example (Case1) 
fmt.Println(exampleAST(81, "\U00100002 _Static_assert ( 'a' , \"b\" ) ;"))

Output:

&cc.Declaration{
· Case: 1,
· StaticAssertDeclaration: &cc.StaticAssertDeclaration{
· · ConstantExpression: &cc.ConstantExpression{
· · · Type: int,
· · · Value: 97,
· · · Expression: &cc.Expression{
· · · · Type: int,
· · · · Value: 97,
· · · · Case: 1,
· · · · Token: example81.c:1:19: CHARCONST "'a'",
· · · },
· · },
· · Token: example81.c:1:2: STATIC_ASSERT "_Static_assert",
· · Token2: example81.c:1:17: '(',
· · Token3: example81.c:1:23: ',',
· · Token4: example81.c:1:25: STRINGLITERAL "\"b\"",
· · Token5: example81.c:1:29: ')',
· · Token6: example81.c:1:31: ';',
· },
}

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.

func (*Declaration) String 

func (n *Declaration) String() string

String implements fmt.Stringer.

type DeclarationList 

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

DeclarationList represents data reduced by productions: 

DeclarationList:
        Declaration
|       DeclarationList Declaration  // Case 1
Example 
fmt.Println(exampleAST(260, "\U00100002 a auto ; {"))

Output:

&cc.DeclarationList{
· Declaration: &cc.Declaration{
· · DeclarationSpecifiers: &cc.DeclarationSpecifiers{
· · · StorageClassSpecifier: &cc.StorageClassSpecifier{
· · · · Case: 3,
· · · · Token: example260.c:1:4: AUTO "auto",
· · · },
· · },
· · Token: example260.c:1:9: ';',
· },
}
Example (Case1) 
fmt.Println(exampleAST(261, "\U00100002 a auto ; auto ; {"))

Output:

&cc.DeclarationList{
· Declaration: &cc.Declaration{
· · DeclarationSpecifiers: &cc.DeclarationSpecifiers{
· · · StorageClassSpecifier: &cc.StorageClassSpecifier{
· · · · Case: 3,
· · · · Token: example261.c:1:4: AUTO "auto",
· · · },
· · },
· · Token: example261.c:1:9: ';',
· },
· DeclarationList: &cc.DeclarationList{
· · Case: 1,
· · Declaration: &cc.Declaration{
· · · DeclarationSpecifiers: &cc.DeclarationSpecifiers{
· · · · StorageClassSpecifier: &cc.StorageClassSpecifier{
· · · · · Case: 3,
· · · · · Token: example261.c:1:11: AUTO "auto",
· · · · },
· · · },
· · · Token: example261.c:1:16: ';',
· · },
· },
}

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(262, "\U00100002 a {") == (*DeclarationListOpt)(nil))

Output:

true
Example (Case1) 
fmt.Println(exampleAST(264, "\U00100002 a auto ; {"))

Output:

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

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(82, "\U00100002 auto ("))

Output:

&cc.DeclarationSpecifiers{
· StorageClassSpecifier: &cc.StorageClassSpecifier{
· · Case: 3,
· · Token: example82.c:1:2: AUTO "auto",
· },
}
Example (Case1) 
fmt.Println(exampleAST(83, "\U00100002 _Bool ("))

Output:

&cc.DeclarationSpecifiers{
· Case: 1,
· TypeSpecifier: &cc.TypeSpecifier{
· · Case: 9,
· · Token: example83.c:1:2: BOOL "_Bool",
· },
}
Example (Case2) 
fmt.Println(exampleAST(84, "\U00100002 const ("))

Output:

&cc.DeclarationSpecifiers{
· Case: 2,
· TypeQualifier: &cc.TypeQualifier{
· · Token: example84.c:1:2: CONST "const",
· },
}
Example (Case3) 
fmt.Println(exampleAST(85, "\U00100002 inline ("))

Output:

&cc.DeclarationSpecifiers{
· Case: 3,
· FunctionSpecifier: &cc.FunctionSpecifier{
· · Token: example85.c:1:2: INLINE "inline",
· },
}

func (*DeclarationSpecifiers) IsAuto 

func (n *DeclarationSpecifiers) IsAuto() bool

IsAuto implements specifier.

func (*DeclarationSpecifiers) IsConst 

func (n *DeclarationSpecifiers) IsConst() bool

IsConst returns whether n includes the 'const' type qualifier.

func (*DeclarationSpecifiers) IsExtern 

func (n *DeclarationSpecifiers) IsExtern() bool

IsExtern implements specifier.

func (*DeclarationSpecifiers) IsInline 

func (n *DeclarationSpecifiers) IsInline() bool

IsInline implements specifier.

func (*DeclarationSpecifiers) IsRegister 

func (n *DeclarationSpecifiers) IsRegister() bool

IsRegister implements specifier.

func (*DeclarationSpecifiers) IsRestrict 

func (n *DeclarationSpecifiers) IsRestrict() bool

IsRestrict implements specifier.

func (*DeclarationSpecifiers) IsStatic 

func (n *DeclarationSpecifiers) IsStatic() bool

IsStatic implements specifier.

func (*DeclarationSpecifiers) IsTypedef 

func (n *DeclarationSpecifiers) IsTypedef() bool

IsTypedef implements specifier.

func (*DeclarationSpecifiers) IsVolatile 

func (n *DeclarationSpecifiers) IsVolatile() bool

IsVolatile 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(86, "\U00100002 auto (") == (*DeclarationSpecifiersOpt)(nil))

Output:

true
Example (Case1) 
fmt.Println(exampleAST(87, "\U00100002 auto auto ("))

Output:

&cc.DeclarationSpecifiersOpt{
· DeclarationSpecifiers: &cc.DeclarationSpecifiers{
· · StorageClassSpecifier: &cc.StorageClassSpecifier{
· · · Case: 3,
· · · Token: example87.c:1:7: 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(149, "\U00100002 a )"))

Output:

&cc.Declarator{
· Linkage: None,
· DirectDeclarator: &cc.DirectDeclarator{
· · Token: example149.c:1:2: 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.

func (*Declarator) String 

func (n *Declarator) String() string

String implements fmt.Stringer.

type DeclaratorOpt 

type DeclaratorOpt struct {
	Declarator *Declarator
}

DeclaratorOpt represents data reduced by productions: 

DeclaratorOpt:
        /* empty */
|       Declarator   // Case 1
Example 
fmt.Println(exampleAST(150, "\U00100002 struct { _Bool :") == (*DeclaratorOpt)(nil))

Output:

true
Example (Case1) 
fmt.Println(exampleAST(151, "\U00100002 struct { _Bool a :"))

Output:

&cc.DeclaratorOpt{
· Declarator: &cc.Declarator{
· · Linkage: None,
· · DirectDeclarator: &cc.DirectDeclarator{
· · · Token: example151.c:1:17: 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(207, "\U00100002 auto a = { . b = !"))

Output:

&cc.Designation{
· DesignatorList: &cc.DesignatorList{
· · Designator: &cc.Designator{
· · · Case: 1,
· · · Token: example207.c:1:13: '.',
· · · Token2: example207.c:1:15: IDENTIFIER "b",
· · },
· },
· Token: example207.c:1:17: '=',
}

func (*Designation) Pos 

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

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

func (*Designation) String 

func (n *Designation) String() string

String implements fmt.Stringer.

type DesignationOpt 

type DesignationOpt struct {
	Designation *Designation
}

DesignationOpt represents data reduced by productions: 

DesignationOpt:
        /* empty */
|       Designation  // Case 1
Example 
fmt.Println(exampleAST(208, "\U00100002 auto a = { !") == (*DesignationOpt)(nil))

Output:

true
Example (Case1) 
fmt.Println(exampleAST(209, "\U00100002 auto a = { . b = !"))

Output:

&cc.DesignationOpt{
· Designation: &cc.Designation{
· · DesignatorList: &cc.DesignatorList{
· · · Designator: &cc.Designator{
· · · · Case: 1,
· · · · Token: example209.c:1:13: '.',
· · · · Token2: example209.c:1:15: IDENTIFIER "b",
· · · },
· · },
· · Token: example209.c:1:17: '=',
· },
}

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(212, "\U00100002 auto a = { [ 'b' ] ."))

Output:

&cc.Designator{
· ConstantExpression: &cc.ConstantExpression{
· · Type: int,
· · Value: 98,
· · Expression: &cc.Expression{
· · · Type: int,
· · · Value: 98,
· · · Case: 1,
· · · Token: example212.c:1:15: CHARCONST "'b'",
· · },
· },
· Token: example212.c:1:13: '[',
· Token2: example212.c:1:19: ']',
}
Example (Case1) 
fmt.Println(exampleAST(213, "\U00100002 auto a = { . b ."))

Output:

&cc.Designator{
· Case: 1,
· Token: example213.c:1:13: '.',
· Token2: example213.c:1:15: IDENTIFIER "b",
}

func (*Designator) Pos 

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

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

func (*Designator) String 

func (n *Designator) String() string

String implements fmt.Stringer.

type 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(210, "\U00100002 auto a = { . b ."))

Output:

&cc.DesignatorList{
· Designator: &cc.Designator{
· · Case: 1,
· · Token: example210.c:1:13: '.',
· · Token2: example210.c:1:15: IDENTIFIER "b",
· },
}
Example (Case1) 
fmt.Println(exampleAST(211, "\U00100002 auto a = { . b . c ."))

Output:

&cc.DesignatorList{
· Designator: &cc.Designator{
· · Case: 1,
· · Token: example211.c:1:13: '.',
· · Token2: example211.c:1:15: IDENTIFIER "b",
· },
· DesignatorList: &cc.DesignatorList{
· · Case: 1,
· · Designator: &cc.Designator{
· · · Case: 1,
· · · Token: example211.c:1:17: '.',
· · · Token2: example211.c:1:19: IDENTIFIER "c",
· · },
· },
}

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(189, "\U00100001 ( _Bool ( * ) ("))

Output:

&cc.DirectAbstractDeclarator{
· AbstractDeclarator: &cc.AbstractDeclarator{
· · Pointer: &cc.Pointer{
· · · Token: example189.c:1:12: '*',
· · },
· },
· Token: example189.c:1:10: '(',
· Token2: example189.c:1:14: ')',
}
Example (Case1) 
fmt.Println(exampleAST(190, "\U00100001 ( _Bool [ ] ("))

Output:

&cc.DirectAbstractDeclarator{
· Case: 1,
· Token: example190.c:1:10: '[',
· Token2: example190.c:1:12: ']',
}
Example (Case2) 
fmt.Println(exampleAST(191, "\U00100001 ( _Bool [ const ] ("))

Output:

&cc.DirectAbstractDeclarator{
· Case: 2,
· Token: example191.c:1:10: '[',
· Token2: example191.c:1:18: ']',
· TypeQualifierList: &cc.TypeQualifierList{
· · TypeQualifier: &cc.TypeQualifier{
· · · Token: example191.c:1:12: CONST "const",
· · },
· },
}
Example (Case3) 
fmt.Println(exampleAST(192, "\U00100001 ( _Bool [ static 'a' ] ("))

Output:

&cc.DirectAbstractDeclarator{
· Case: 3,
· Expression: &cc.Expression{
· · Type: int,
· · Value: 97,
· · Case: 1,
· · Token: example192.c:1:19: CHARCONST "'a'",
· },
· Token: example192.c:1:10: '[',
· Token2: example192.c:1:12: STATIC "static",
· Token3: example192.c:1:23: ']',
}
Example (Case4) 
fmt.Println(exampleAST(193, "\U00100001 ( _Bool [ const static 'a' ] ("))

Output:

&cc.DirectAbstractDeclarator{
· Case: 4,
· Expression: &cc.Expression{
· · Type: int,
· · Value: 97,
· · Case: 1,
· · Token: example193.c:1:25: CHARCONST "'a'",
· },
· Token: example193.c:1:10: '[',
· Token2: example193.c:1:18: STATIC "static",
· Token3: example193.c:1:29: ']',
· TypeQualifierList: &cc.TypeQualifierList{
· · TypeQualifier: &cc.TypeQualifier{
· · · Token: example193.c:1:12: CONST "const",
· · },
· },
}
Example (Case5) 
fmt.Println(exampleAST(194, "\U00100001 ( _Bool [ * ] ("))

Output:

&cc.DirectAbstractDeclarator{
· Case: 5,
· Token: example194.c:1:10: '[',
· Token2: example194.c:1:12: '*',
· Token3: example194.c:1:14: ']',
}
Example (Case6) 
fmt.Println(exampleAST(196, "\U00100001 ( _Bool ( ) ("))

Output:

&cc.DirectAbstractDeclarator{
· Case: 6,
· Token: example196.c:1:10: '(',
· Token2: example196.c:1:12: ')',
}
Example (Case7) 
fmt.Println(exampleAST(198, "\U00100001 ( _Bool ( ) ( ) ("))

Output:

&cc.DirectAbstractDeclarator{
· Case: 7,
· DirectAbstractDeclarator: &cc.DirectAbstractDeclarator{
· · Case: 6,
· · Token: example198.c:1:10: '(',
· · Token2: example198.c:1:12: ')',
· },
· Token: example198.c:1:14: '(',
· Token2: example198.c:1:16: ')',
}

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(199, "\U00100001 ( _Bool [") == (*DirectAbstractDeclaratorOpt)(nil))

Output:

true
Example (Case1) 
fmt.Println(exampleAST(200, "\U00100001 ( _Bool ( ) ["))

Output:

&cc.DirectAbstractDeclaratorOpt{
· DirectAbstractDeclarator: &cc.DirectAbstractDeclarator{
· · Case: 6,
· · Token: example200.c:1:10: '(',
· · Token2: example200.c:1:12: ')',
· },
}

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(152, "\U00100002 a ("))

Output:

&cc.DirectDeclarator{
· Token: example152.c:1:2: IDENTIFIER "a",
}
Example (Case1) 
fmt.Println(exampleAST(153, "\U00100002 ( a ) ("))

Output:

&cc.DirectDeclarator{
· Case: 1,
· Declarator: &cc.Declarator{
· · Linkage: None,
· · DirectDeclarator: &cc.DirectDeclarator{
· · · Token: example153.c:1:4: IDENTIFIER "a",
· · },
· },
· Token: example153.c:1:2: '(',
· Token2: example153.c:1:6: ')',
}
Example (Case2) 
fmt.Println(exampleAST(154, "\U00100002 a [ ] ("))

Output:

&cc.DirectDeclarator{
· Case: 2,
· DirectDeclarator: &cc.DirectDeclarator{
· · Token: example154.c:1:2: IDENTIFIER "a",
· },
· Token: example154.c:1:4: '[',
· Token2: example154.c:1:6: ']',
}
Example (Case3) 
fmt.Println(exampleAST(155, "\U00100002 a [ static 'b' ] ("))

Output:

&cc.DirectDeclarator{
· Case: 3,
· DirectDeclarator: &cc.DirectDeclarator{
· · Token: example155.c:1:2: IDENTIFIER "a",
· },
· Expression: &cc.Expression{
· · Type: int,
· · Value: 98,
· · Case: 1,
· · Token: example155.c:1:13: CHARCONST "'b'",
· },
· Token: example155.c:1:4: '[',
· Token2: example155.c:1:6: STATIC "static",
· Token3: example155.c:1:17: ']',
}
Example (Case4) 
fmt.Println(exampleAST(156, "\U00100002 a [ const static 'b' ] ("))

Output:

&cc.DirectDeclarator{
· Case: 4,
· DirectDeclarator: &cc.DirectDeclarator{
· · Token: example156.c:1:2: IDENTIFIER "a",
· },
· Expression: &cc.Expression{
· · Type: int,
· · Value: 98,
· · Case: 1,
· · Token: example156.c:1:19: CHARCONST "'b'",
· },
· Token: example156.c:1:4: '[',
· Token2: example156.c:1:12: STATIC "static",
· Token3: example156.c:1:23: ']',
· TypeQualifierList: &cc.TypeQualifierList{
· · TypeQualifier: &cc.TypeQualifier{
· · · Token: example156.c:1:6: CONST "const",
· · },
· },
}
Example (Case5) 
fmt.Println(exampleAST(157, "\U00100002 a [ * ] ("))

Output:

&cc.DirectDeclarator{
· Case: 5,
· DirectDeclarator: &cc.DirectDeclarator{
· · Token: example157.c:1:2: IDENTIFIER "a",
· },
· Token: example157.c:1:4: '[',
· Token2: example157.c:1:6: '*',
· Token3: example157.c:1:8: ']',
}
Example (Case6) 
fmt.Println(exampleAST(159, "\U00100002 a ( auto ) ("))

Output:

&cc.DirectDeclarator{
· Case: 6,
· DirectDeclarator: &cc.DirectDeclarator{
· · Token: example159.c:1:2: IDENTIFIER "a",
· },
· ParameterTypeList: &cc.ParameterTypeList{
· · ParameterList: &cc.ParameterList{
· · · ParameterDeclaration: &cc.ParameterDeclaration{
· · · · Case: 1,
· · · · DeclarationSpecifiers: &cc.DeclarationSpecifiers{
· · · · · StorageClassSpecifier: &cc.StorageClassSpecifier{
· · · · · · Case: 3,
· · · · · · Token: example159.c:1:6: AUTO "auto",
· · · · · },
· · · · },
· · · },
· · },
· },
· Token: example159.c:1:4: '(',
· Token2: example159.c:1:11: ')',
}
Example (Case7) 
fmt.Println(exampleAST(160, "\U00100002 a ( ) ("))

Output:

&cc.DirectDeclarator{
· Case: 7,
· DirectDeclarator: &cc.DirectDeclarator{
· · Token: example160.c:1:2: IDENTIFIER "a",
· },
· Token: example160.c:1:4: '(',
· Token2: example160.c:1:6: ')',
}

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(302, "\U00100000 \n#if other_a  \n#elif other_b  \n#elif"))

Output:

&cc.ElifGroup{
· PPTokenList: []xc.Token{ // len 4
· · 0: example302.c:3:6: ' ',
· · 1: example302.c:3:7: IDENTIFIER "other_b",
· · 2: example302.c:3:14: ' ',
· · 3: example302.c:3:16: ' ',
· },
· Token: example302.c:3:2: PPELIF,
· Token2: example302.c:3:16: '\n',
}

func (*ElifGroup) Pos 

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

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

func (*ElifGroup) String 

func (n *ElifGroup) String() string

String implements fmt.Stringer.

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(298, "\U00100000 \n#if other_a  \n#elif other_b  \n#elif"))

Output:

&cc.ElifGroupList{
· ElifGroup: &cc.ElifGroup{
· · PPTokenList: []xc.Token{ // len 4
· · · 0: example298.c:3:6: ' ',
· · · 1: example298.c:3:7: IDENTIFIER "other_b",
· · · 2: example298.c:3:14: ' ',
· · · 3: example298.c:3:16: ' ',
· · },
· · Token: example298.c:3:2: PPELIF,
· · Token2: example298.c:3:16: '\n',
· },
}
Example (Case1) 
fmt.Println(exampleAST(299, "\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 4
· · · 0: example299.c:3:6: ' ',
· · · 1: example299.c:3:7: IDENTIFIER "other_b",
· · · 2: example299.c:3:14: ' ',
· · · 3: example299.c:3:16: ' ',
· · },
· · Token: example299.c:3:2: PPELIF,
· · Token2: example299.c:3:16: '\n',
· },
· ElifGroupList: &cc.ElifGroupList{
· · Case: 1,
· · ElifGroup: &cc.ElifGroup{
· · · PPTokenList: []xc.Token{ // len 4
· · · · 0: example299.c:4:6: ' ',
· · · · 1: example299.c:4:7: IDENTIFIER "other_c",
· · · · 2: example299.c:4:14: ' ',
· · · · 3: example299.c:4:16: ' ',
· · · },
· · · Token: example299.c:4:2: PPELIF,
· · · Token2: example299.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(300, "\U00100000 \n#if other_a  \n#else") == (*ElifGroupListOpt)(nil))

Output:

true
Example (Case1) 
fmt.Println(exampleAST(301, "\U00100000 \n#if other_a  \n#elif other_b  \n#else"))

Output:

&cc.ElifGroupListOpt{
· ElifGroupList: &cc.ElifGroupList{
· · ElifGroup: &cc.ElifGroup{
· · · PPTokenList: []xc.Token{ // len 4
· · · · 0: example301.c:3:6: ' ',
· · · · 1: example301.c:3:7: IDENTIFIER "other_b",
· · · · 2: example301.c:3:14: ' ',
· · · · 3: example301.c:3:16: ' ',
· · · },
· · · Token: example301.c:3:2: PPELIF,
· · · Token2: example301.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(303, "\U00100000 \n#if other_a  \n#else  \n#endif"))

Output:

&cc.ElseGroup{
· Token: example303.c:3:2: PPELSE,
· Token2: example303.c:3:8: '\n',
}

func (*ElseGroup) Pos 

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

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

func (*ElseGroup) String 

func (n *ElseGroup) String() string

String implements fmt.Stringer.

type ElseGroupOpt 

type ElseGroupOpt struct {
	ElseGroup *ElseGroup
}

ElseGroupOpt represents data reduced by productions: 

ElseGroupOpt:
        /* empty */
|       ElseGroup    // Case 1
Example 
fmt.Println(exampleAST(304, "\U00100000 \n#if other_a  \n#endif") == (*ElseGroupOpt)(nil))

Output:

true
Example (Case1) 
fmt.Println(exampleAST(305, "\U00100000 \n#if other_a  \n#else  \n#endif"))

Output:

&cc.ElseGroupOpt{
· ElseGroup: &cc.ElseGroup{
· · Token: example305.c:3:2: PPELSE,
· · Token2: example305.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 

type EndifLine struct {
	Token xc.Token
}

EndifLine represents data reduced by production: 

EndifLine:
        PPENDIF
Example 
fmt.Println(exampleAST(306, "\U00100000 \n#if other_a  \n#endif"))

Output:

&cc.EndifLine{
· Token: example306.c:3:2: PPENDIF,
}

func (*EndifLine) Pos 

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

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

func (*EndifLine) String 

func (n *EndifLine) String() string

String implements fmt.Stringer.

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
	// contains filtered or unexported fields
}

EnumSpecifier represents data reduced by productions: 

EnumSpecifier:
        "enum" IdentifierOpt '{' EnumeratorList CommaOpt '}'
|       "enum" IDENTIFIER                                     // Case 1
Example 
fmt.Println(exampleAST(138, "\U00100002 enum { a } ("))

Output:

&cc.EnumSpecifier{
· EnumeratorList: &cc.EnumeratorList{
· · Enumerator: &cc.Enumerator{
· · · EnumerationConstant: &cc.EnumerationConstant{
· · · · Token: example138.c:1:9: IDENTIFIER "a",
· · · },
· · },
· },
· Token: example138.c:1:2: ENUM "enum",
· Token2: example138.c:1:7: '{',
· Token3: example138.c:1:11: '}',
}
Example (Case1) 
fmt.Println(exampleAST(139, "\U00100002 enum a ("))

Output:

&cc.EnumSpecifier{
· Case: 1,
· Token: example139.c:1:2: ENUM "enum",
· Token2: example139.c:1:7: 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 

type EnumerationConstant struct {
	Token xc.Token
}

EnumerationConstant represents data reduced by production: 

EnumerationConstant:
        IDENTIFIER
Example 
fmt.Println(exampleAST(7, "\U00100002 enum { a ,"))

Output:

&cc.EnumerationConstant{
· Token: example7.c:1:9: 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 {
	Value               interface{} // Enumerator's value.
	Case                int
	ConstantExpression  *ConstantExpression
	EnumerationConstant *EnumerationConstant
	Token               xc.Token
}

Enumerator represents data reduced by productions: 

Enumerator:
        EnumerationConstant
|       EnumerationConstant '=' ConstantExpression  // Case 1
Example 
fmt.Println(exampleAST(142, "\U00100002 enum { a ,"))

Output:

&cc.Enumerator{
· EnumerationConstant: &cc.EnumerationConstant{
· · Token: example142.c:1:9: IDENTIFIER "a",
· },
}
Example (Case1) 
fmt.Println(exampleAST(143, "\U00100002 enum { a = 'b' ,"))

Output:

&cc.Enumerator{
· Value: 98,
· Case: 1,
· ConstantExpression: &cc.ConstantExpression{
· · Type: int,
· · Value: 98,
· · Expression: &cc.Expression{
· · · Type: int,
· · · Value: 98,
· · · Case: 1,
· · · Token: example143.c:1:13: CHARCONST "'b'",
· · },
· },
· EnumerationConstant: &cc.EnumerationConstant{
· · Token: example143.c:1:9: IDENTIFIER "a",
· },
· Token: example143.c:1:11: '=',
}

func (*Enumerator) Pos 

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

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

func (*Enumerator) String 

func (n *Enumerator) String() string

String implements fmt.Stringer.

type 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(140, "\U00100002 enum { a ,"))

Output:

&cc.EnumeratorList{
· Enumerator: &cc.Enumerator{
· · EnumerationConstant: &cc.EnumerationConstant{
· · · Token: example140.c:1:9: IDENTIFIER "a",
· · },
· },
}
Example (Case1) 
fmt.Println(exampleAST(141, "\U00100002 enum { a , b ,"))

Output:

&cc.EnumeratorList{
· Enumerator: &cc.Enumerator{
· · EnumerationConstant: &cc.EnumerationConstant{
· · · Token: example141.c:1:9: IDENTIFIER "a",
· · },
· },
· EnumeratorList: &cc.EnumeratorList{
· · Case: 1,
· · Enumerator: &cc.Enumerator{
· · · Value: 1,
· · · EnumerationConstant: &cc.EnumerationConstant{
· · · · Token: example141.c:1:13: IDENTIFIER "b",
· · · },
· · },
· · Token: example141.c:1:11: ',',
· },
}

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
	CompoundStatement         *CompoundStatement
	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
|       "_Alignof" '(' TypeName ')'                        // Case 56
|       '(' CompoundStatement ')'                          // Case 57
|       "&&" IDENTIFIER                                    // Case 58
|       Expression '?' ':' Expression                      // Case 59
Example 
fmt.Println(exampleAST(12, "\U00100001 a"))

Output:

&cc.Expression{
· Token: example12.c:1:2: IDENTIFIER "a",
}
Example (Case01) 
fmt.Println(exampleAST(13, "\U00100001 'a'"))

Output:

&cc.Expression{
· Case: 1,
· Token: example13.c:1:2: CHARCONST "'a'",
}
Example (Case02) 
fmt.Println(exampleAST(14, "\U00100001 1.97"))

Output:

&cc.Expression{
· Case: 2,
· Token: example14.c:1:2: FLOATCONST "1.97",
}
Example (Case03) 
fmt.Println(exampleAST(15, "\U00100001 97"))

Output:

&cc.Expression{
· Case: 3,
· Token: example15.c:1:2: INTCONST "97",
}
Example (Case04) 
fmt.Println(exampleAST(16, "\U00100001 L'a'"))

Output:

&cc.Expression{
· Case: 4,
· Token: example16.c:1:2: LONGCHARCONST "L'a'",
}
Example (Case05) 
fmt.Println(exampleAST(17, "\U00100001 L\"a\""))

Output:

&cc.Expression{
· Case: 5,
· Token: example17.c:1:2: LONGSTRINGLITERAL "L\"a\"",
}
Example (Case06) 
fmt.Println(exampleAST(18, "\U00100001 \"a\""))

Output:

&cc.Expression{
· Case: 6,
· Token: example18.c:1:2: 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:4: CHARCONST "'a'",
· · },
· },
· Token: example19.c:1:2: '(',
· Token2: example19.c:1:8: ')',
}
Example (Case08) 
fmt.Println(exampleAST(20, "\U00100001 'a' [ 'b' ]"))

Output:

&cc.Expression{
· Case: 8,
· Expression: &cc.Expression{
· · Case: 1,
· · Token: example20.c:1:2: CHARCONST "'a'",
· },
· ExpressionList: &cc.ExpressionList{
· · Expression: &cc.Expression{
· · · Case: 1,
· · · Token: example20.c:1:8: CHARCONST "'b'",
· · },
· },
· Token: example20.c:1:6: '[',
· Token2: example20.c:1:12: ']',
}
Example (Case09) 
fmt.Println(exampleAST(21, "\U00100001 'a' ( )"))

Output:

&cc.Expression{
· Case: 9,
· Expression: &cc.Expression{
· · Case: 1,
· · Token: example21.c:1:2: CHARCONST "'a'",
· },
· Token: example21.c:1:6: '(',
· Token2: example21.c:1:8: ')',
}
Example (Case10) 
fmt.Println(exampleAST(22, "\U00100001 'a' . b"))

Output:

&cc.Expression{
· Case: 10,
· Expression: &cc.Expression{
· · Case: 1,
· · Token: example22.c:1:2: CHARCONST "'a'",
· },
· Token: example22.c:1:6: '.',
· Token2: example22.c:1:8: 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:2: CHARCONST "'a'",
· },
· Token: example23.c:1:6: ARROW,
· Token2: example23.c:1:9: IDENTIFIER "b",
}
Example (Case12) 
fmt.Println(exampleAST(24, "\U00100001 'a' ++"))

Output:

&cc.Expression{
· Case: 12,
· Expression: &cc.Expression{
· · Case: 1,
· · Token: example24.c:1:2: CHARCONST "'a'",
· },
· Token: example24.c:1:6: INC,
}
Example (Case13) 
fmt.Println(exampleAST(25, "\U00100001 'a' --"))

Output:

&cc.Expression{
· Case: 13,
· Expression: &cc.Expression{
· · Case: 1,
· · Token: example25.c:1:2: CHARCONST "'a'",
· },
· Token: example25.c:1:6: DEC,
}
Example (Case14) 
fmt.Println(exampleAST(26, "\U00100001 ( _Bool ) { }"))

Output:

&cc.Expression{
· Case: 14,
· Token: example26.c:1:2: '(',
· Token2: example26.c:1:10: ')',
· Token3: example26.c:1:12: '{',
· Token4: example26.c:1:14: '}',
· TypeName: &cc.TypeName{
· · Type: bool,
· · SpecifierQualifierList: &cc.SpecifierQualifierList{
· · · TypeSpecifier: &cc.TypeSpecifier{
· · · · Case: 9,
· · · · Token: example26.c:1:4: BOOL "_Bool",
· · · },
· · },
· },
}
Example (Case15) 
fmt.Println(exampleAST(27, "\U00100001 ++ 'a'"))

Output:

&cc.Expression{
· Case: 15,
· Expression: &cc.Expression{
· · Case: 1,
· · Token: example27.c:1:5: CHARCONST "'a'",
· },
· Token: example27.c:1:2: INC,
}
Example (Case16) 
fmt.Println(exampleAST(28, "\U00100001 -- 'a'"))

Output:

&cc.Expression{
· Case: 16,
· Expression: &cc.Expression{
· · Case: 1,
· · Token: example28.c:1:5: CHARCONST "'a'",
· },
· Token: example28.c:1:2: DEC,
}
Example (Case17) 
fmt.Println(exampleAST(29, "\U00100001 & 'a'"))

Output:

&cc.Expression{
· Case: 17,
· Expression: &cc.Expression{
· · Case: 1,
· · Token: example29.c:1:4: CHARCONST "'a'",
· },
· Token: example29.c:1:2: '&',
}
Example (Case18) 
fmt.Println(exampleAST(30, "\U00100001 * 'a'"))

Output:

&cc.Expression{
· Case: 18,
· Expression: &cc.Expression{
· · Case: 1,
· · Token: example30.c:1:4: CHARCONST "'a'",
· },
· Token: example30.c:1:2: '*',
}
Example (Case19) 
fmt.Println(exampleAST(31, "\U00100001 + 'a'"))

Output:

&cc.Expression{
· Case: 19,
· Expression: &cc.Expression{
· · Case: 1,
· · Token: example31.c:1:4: CHARCONST "'a'",
· },
· Token: example31.c:1:2: '+',
}
Example (Case20) 
fmt.Println(exampleAST(32, "\U00100001 - 'a'"))

Output:

&cc.Expression{
· Case: 20,
· Expression: &cc.Expression{
· · Case: 1,
· · Token: example32.c:1:4: CHARCONST "'a'",
· },
· Token: example32.c:1:2: '-',
}
Example (Case21) 
fmt.Println(exampleAST(33, "\U00100001 ~ 'a'"))

Output:

&cc.Expression{
· Case: 21,
· Expression: &cc.Expression{
· · Case: 1,
· · Token: example33.c:1:4: CHARCONST "'a'",
· },
· Token: example33.c:1:2: '~',
}
Example (Case22) 
fmt.Println(exampleAST(34, "\U00100001 ! 'a'"))

Output:

&cc.Expression{
· Case: 22,
· Expression: &cc.Expression{
· · Case: 1,
· · Token: example34.c:1:4: CHARCONST "'a'",
· },
· Token: example34.c:1:2: '!',
}
Example (Case23) 
fmt.Println(exampleAST(35, "\U00100001 sizeof 'a'"))

Output:

&cc.Expression{
· Case: 23,
· Expression: &cc.Expression{
· · Case: 1,
· · Token: example35.c:1:9: CHARCONST "'a'",
· },
· Token: example35.c:1:2: SIZEOF "sizeof",
}
Example (Case24) 
fmt.Println(exampleAST(36, "\U00100001 sizeof ( _Bool )"))

Output:

&cc.Expression{
· Case: 24,
· Token: example36.c:1:2: SIZEOF "sizeof",
· Token2: example36.c:1:9: '(',
· Token3: example36.c:1:17: ')',
· TypeName: &cc.TypeName{
· · Type: bool,
· · SpecifierQualifierList: &cc.SpecifierQualifierList{
· · · TypeSpecifier: &cc.TypeSpecifier{
· · · · Case: 9,
· · · · Token: example36.c:1:11: 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:12: CHARCONST "'a'",
· },
· Token: example37.c:1:2: '(',
· Token2: example37.c:1:10: ')',
· TypeName: &cc.TypeName{
· · Type: bool,
· · SpecifierQualifierList: &cc.SpecifierQualifierList{
· · · TypeSpecifier: &cc.TypeSpecifier{
· · · · Case: 9,
· · · · Token: example37.c:1:4: 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:2: CHARCONST "'a'",
· },
· Expression2: &cc.Expression{
· · Case: 1,
· · Token: example38.c:1:8: CHARCONST "'b'",
· },
· Token: example38.c:1:6: '*',
}
Example (Case27) 
fmt.Println(exampleAST(39, "\U00100001 'a' / 'b'"))

Output:

&cc.Expression{
· Case: 27,
· Expression: &cc.Expression{
· · Case: 1,
· · Token: example39.c:1:2: CHARCONST "'a'",
· },
· Expression2: &cc.Expression{
· · Case: 1,
· · Token: example39.c:1:8: CHARCONST "'b'",
· },
· Token: example39.c:1:6: '/',
}
Example (Case28) 
fmt.Println(exampleAST(40, "\U00100001 'a' % 'b'"))

Output:

&cc.Expression{
· Case: 28,
· Expression: &cc.Expression{
· · Case: 1,
· · Token: example40.c:1:2: CHARCONST "'a'",
· },
· Expression2: &cc.Expression{
· · Case: 1,
· · Token: example40.c:1:8: CHARCONST "'b'",
· },
· Token: example40.c:1:6: '%',
}
Example (Case29) 
fmt.Println(exampleAST(41, "\U00100001 'a' + 'b'"))

Output:

&cc.Expression{
· Case: 29,
· Expression: &cc.Expression{
· · Case: 1,
· · Token: example41.c:1:2: CHARCONST "'a'",
· },
· Expression2: &cc.Expression{
· · Case: 1,
· · Token: example41.c:1:8: CHARCONST "'b'",
· },
· Token: example41.c:1:6: '+',
}
Example (Case30) 
fmt.Println(exampleAST(42, "\U00100001 'a' - 'b'"))

Output:

&cc.Expression{
· Case: 30,
· Expression: &cc.Expression{
· · Case: 1,
· · Token: example42.c:1:2: CHARCONST "'a'",
· },
· Expression2: &cc.Expression{
· · Case: 1,
· · Token: example42.c:1:8: CHARCONST "'b'",
· },
· Token: example42.c:1:6: '-',
}
Example (Case31) 
fmt.Println(exampleAST(43, "\U00100001 'a' << 'b'"))

Output:

&cc.Expression{
· Case: 31,
· Expression: &cc.Expression{
· · Case: 1,
· · Token: example43.c:1:2: CHARCONST "'a'",
· },
· Expression2: &cc.Expression{
· · Case: 1,
· · Token: example43.c:1:9: CHARCONST "'b'",
· },
· Token: example43.c:1:6: LSH,
}
Example (Case32) 
fmt.Println(exampleAST(44, "\U00100001 'a' >> 'b'"))

Output:

&cc.Expression{
· Case: 32,
· Expression: &cc.Expression{
· · Case: 1,
· · Token: example44.c:1:2: CHARCONST "'a'",
· },
· Expression2: &cc.Expression{
· · Case: 1,
· · Token: example44.c:1:9: CHARCONST "'b'",
· },
· Token: example44.c:1:6: RSH,
}
Example (Case33) 
fmt.Println(exampleAST(45, "\U00100001 'a' < 'b'"))

Output:

&cc.Expression{
· Case: 33,
· Expression: &cc.Expression{
· · Case: 1,
· · Token: example45.c:1:2: CHARCONST "'a'",
· },
· Expression2: &cc.Expression{
· · Case: 1,
· · Token: example45.c:1:8: CHARCONST "'b'",
· },
· Token: example45.c:1:6: '<',
}
Example (Case34) 
fmt.Println(exampleAST(46, "\U00100001 'a' > 'b'"))

Output:

&cc.Expression{
· Case: 34,
· Expression: &cc.Expression{
· · Case: 1,
· · Token: example46.c:1:2: CHARCONST "'a'",
· },
· Expression2: &cc.Expression{
· · Case: 1,
· · Token: example46.c:1:8: CHARCONST "'b'",
· },
· Token: example46.c:1:6: '>',
}
Example (Case35) 
fmt.Println(exampleAST(47, "\U00100001 'a' <= 'b'"))

Output:

&cc.Expression{
· Case: 35,
· Expression: &cc.Expression{
· · Case: 1,
· · Token: example47.c:1:2: CHARCONST "'a'",
· },
· Expression2: &cc.Expression{
· · Case: 1,
· · Token: example47.c:1:9: CHARCONST "'b'",
· },
· Token: example47.c:1:6: LEQ,
}
Example (Case36) 
fmt.Println(exampleAST(48, "\U00100001 'a' >= 'b'"))

Output:

&cc.Expression{
· Case: 36,
· Expression: &cc.Expression{
· · Case: 1,
· · Token: example48.c:1:2: CHARCONST "'a'",
· },
· Expression2: &cc.Expression{
· · Case: 1,
· · Token: example48.c:1:9: CHARCONST "'b'",
· },
· Token: example48.c:1:6: GEQ,
}
Example (Case37) 
fmt.Println(exampleAST(49, "\U00100001 'a' == 'b'"))

Output:

&cc.Expression{
· Case: 37,
· Expression: &cc.Expression{
· · Case: 1,
· · Token: example49.c:1:2: CHARCONST "'a'",
· },
· Expression2: &cc.Expression{
· · Case: 1,
· · Token: example49.c:1:9: CHARCONST "'b'",
· },
· Token: example49.c:1:6: EQ,
}
Example (Case38) 
fmt.Println(exampleAST(50, "\U00100001 'a' != 'b'"))

Output:

&cc.Expression{
· Case: 38,
· Expression: &cc.Expression{
· · Case: 1,
· · Token: example50.c:1:2: CHARCONST "'a'",
· },
· Expression2: &cc.Expression{
· · Case: 1,
· · Token: example50.c:1:9: CHARCONST "'b'",
· },
· Token: example50.c:1:6: NEQ,
}
Example (Case39) 
fmt.Println(exampleAST(51, "\U00100001 'a' & 'b'"))

Output:

&cc.Expression{
· Case: 39,
· Expression: &cc.Expression{
· · Case: 1,
· · Token: example51.c:1:2: CHARCONST "'a'",
· },
· Expression2: &cc.Expression{
· · Case: 1,
· · Token: example51.c:1:8: CHARCONST "'b'",
· },
· Token: example51.c:1:6: '&',
}
Example (Case40) 
fmt.Println(exampleAST(52, "\U00100001 'a' ^ 'b'"))

Output:

&cc.Expression{
· Case: 40,
· Expression: &cc.Expression{
· · Case: 1,
· · Token: example52.c:1:2: CHARCONST "'a'",
· },
· Expression2: &cc.Expression{
· · Case: 1,
· · Token: example52.c:1:8: CHARCONST "'b'",
· },
· Token: example52.c:1:6: '^',
}
Example (Case41) 
fmt.Println(exampleAST(53, "\U00100001 'a' | 'b'"))

Output:

&cc.Expression{
· Case: 41,
· Expression: &cc.Expression{
· · Case: 1,
· · Token: example53.c:1:2: CHARCONST "'a'",
· },
· Expression2: &cc.Expression{
· · Case: 1,
· · Token: example53.c:1:8: CHARCONST "'b'",
· },
· Token: example53.c:1:6: '|',
}
Example (Case42) 
fmt.Println(exampleAST(54, "\U00100001 'a' && 'b'"))

Output:

&cc.Expression{
· Case: 42,
· Expression: &cc.Expression{
· · Case: 1,
· · Token: example54.c:1:2: CHARCONST "'a'",
· },
· Expression2: &cc.Expression{
· · Case: 1,
· · Token: example54.c:1:9: CHARCONST "'b'",
· },
· Token: example54.c:1:6: ANDAND,
}
Example (Case43) 
fmt.Println(exampleAST(55, "\U00100001 'a' || 'b'"))

Output:

&cc.Expression{
· Case: 43,
· Expression: &cc.Expression{
· · Case: 1,
· · Token: example55.c:1:2: CHARCONST "'a'",
· },
· Expression2: &cc.Expression{
· · Case: 1,
· · Token: example55.c:1:9: CHARCONST "'b'",
· },
· Token: example55.c:1:6: 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:2: CHARCONST "'a'",
· },
· Expression2: &cc.Expression{
· · Case: 1,
· · Token: example56.c:1:14: CHARCONST "'c'",
· },
· ExpressionList: &cc.ExpressionList{
· · Expression: &cc.Expression{
· · · Case: 1,
· · · Token: example56.c:1:8: CHARCONST "'b'",
· · },
· },
· Token: example56.c:1:6: '?',
· Token2: example56.c:1:12: ':',
}
Example (Case45) 
fmt.Println(exampleAST(57, "\U00100001 'a' = 'b'"))

Output:

&cc.Expression{
· Case: 45,
· Expression: &cc.Expression{
· · Case: 1,
· · Token: example57.c:1:2: CHARCONST "'a'",
· },
· Expression2: &cc.Expression{
· · Case: 1,
· · Token: example57.c:1:8: CHARCONST "'b'",
· },
· Token: example57.c:1:6: '=',
}
Example (Case46) 
fmt.Println(exampleAST(58, "\U00100001 'a' *= 'b'"))

Output:

&cc.Expression{
· Case: 46,
· Expression: &cc.Expression{
· · Case: 1,
· · Token: example58.c:1:2: CHARCONST "'a'",
· },
· Expression2: &cc.Expression{
· · Case: 1,
· · Token: example58.c:1:9: CHARCONST "'b'",
· },
· Token: example58.c:1:6: MULASSIGN,
}
Example (Case47) 
fmt.Println(exampleAST(59, "\U00100001 'a' /= 'b'"))

Output:

&cc.Expression{
· Case: 47,
· Expression: &cc.Expression{
· · Case: 1,
· · Token: example59.c:1:2: CHARCONST "'a'",
· },
· Expression2: &cc.Expression{
· · Case: 1,
· · Token: example59.c:1:9: CHARCONST "'b'",
· },
· Token: example59.c:1:6: DIVASSIGN,
}
Example (Case48) 
fmt.Println(exampleAST(60, "\U00100001 'a' %= 'b'"))

Output:

&cc.Expression{
· Case: 48,
· Expression: &cc.Expression{
· · Case: 1,
· · Token: example60.c:1:2: CHARCONST "'a'",
· },
· Expression2: &cc.Expression{
· · Case: 1,
· · Token: example60.c:1:9: CHARCONST "'b'",
· },
· Token: example60.c:1:6: MODASSIGN,
}
Example (Case49) 
fmt.Println(exampleAST(61, "\U00100001 'a' += 'b'"))

Output:

&cc.Expression{
· Case: 49,
· Expression: &cc.Expression{
· · Case: 1,
· · Token: example61.c:1:2: CHARCONST "'a'",
· },
· Expression2: &cc.Expression{
· · Case: 1,
· · Token: example61.c:1:9: CHARCONST "'b'",
· },
· Token: example61.c:1:6: ADDASSIGN,
}
Example (Case50) 
fmt.Println(exampleAST(62, "\U00100001 'a' -= 'b'"))

Output:

&cc.Expression{
· Case: 50,
· Expression: &cc.Expression{
· · Case: 1,
· · Token: example62.c:1:2: CHARCONST "'a'",
· },
· Expression2: &cc.Expression{
· · Case: 1,
· · Token: example62.c:1:9: CHARCONST "'b'",
· },
· Token: example62.c:1:6: SUBASSIGN,
}
Example (Case51) 
fmt.Println(exampleAST(63, "\U00100001 'a' <<= 'b'"))

Output:

&cc.Expression{
· Case: 51,
· Expression: &cc.Expression{
· · Case: 1,
· · Token: example63.c:1:2: CHARCONST "'a'",
· },
· Expression2: &cc.Expression{
· · Case: 1,
· · Token: example63.c:1:10: CHARCONST "'b'",
· },
· Token: example63.c:1:6: LSHASSIGN,
}
Example (Case52) 
fmt.Println(exampleAST(64, "\U00100001 'a' >>= 'b'"))

Output:

&cc.Expression{
· Case: 52,
· Expression: &cc.Expression{
· · Case: 1,
· · Token: example64.c:1:2: CHARCONST "'a'",
· },
· Expression2: &cc.Expression{
· · Case: 1,
· · Token: example64.c:1:10: CHARCONST "'b'",
· },
· Token: example64.c:1:6: RSHASSIGN,
}
Example (Case53) 
fmt.Println(exampleAST(65, "\U00100001 'a' &= 'b'"))

Output:

&cc.Expression{
· Case: 53,
· Expression: &cc.Expression{
· · Case: 1,
· · Token: example65.c:1:2: CHARCONST "'a'",
· },
· Expression2: &cc.Expression{
· · Case: 1,
· · Token: example65.c:1:9: CHARCONST "'b'",
· },
· Token: example65.c:1:6: ANDASSIGN,
}
Example (Case54) 
fmt.Println(exampleAST(66, "\U00100001 'a' ^= 'b'"))

Output:

&cc.Expression{
· Case: 54,
· Expression: &cc.Expression{
· · Case: 1,
· · Token: example66.c:1:2: CHARCONST "'a'",
· },
· Expression2: &cc.Expression{
· · Case: 1,
· · Token: example66.c:1:9: CHARCONST "'b'",
· },
· Token: example66.c:1:6: XORASSIGN,
}
Example (Case55) 
fmt.Println(exampleAST(67, "\U00100001 'a' |= 'b'"))

Output:

&cc.Expression{
· Case: 55,
· Expression: &cc.Expression{
· · Case: 1,
· · Token: example67.c:1:2: CHARCONST "'a'",
· },
· Expression2: &cc.Expression{
· · Case: 1,
· · Token: example67.c:1:9: CHARCONST "'b'",
· },
· Token: example67.c:1:6: ORASSIGN,
}
Example (Case56) 
fmt.Println(exampleAST(68, "\U00100001 _Alignof ( _Bool )"))

Output:

&cc.Expression{
· Case: 56,
· Token: example68.c:1:2: ALIGNOF "_Alignof",
· Token2: example68.c:1:11: '(',
· Token3: example68.c:1:19: ')',
· TypeName: &cc.TypeName{
· · Type: bool,
· · SpecifierQualifierList: &cc.SpecifierQualifierList{
· · · TypeSpecifier: &cc.TypeSpecifier{
· · · · Case: 9,
· · · · Token: example68.c:1:13: BOOL "_Bool",
· · · },
· · },
· },
}
Example (Case57) 
fmt.Println(exampleAST(69, "\U00100001 ( { } )"))

Output:

&cc.Expression{
· Case: 57,
· CompoundStatement: &cc.CompoundStatement{
· · Token: example69.c:1:4: '{',
· · Token2: example69.c:1:6: '}',
· },
· Token: example69.c:1:2: '(',
· Token2: example69.c:1:8: ')',
}
Example (Case58) 
fmt.Println(exampleAST(70, "\U00100001 && a"))

Output:

&cc.Expression{
· Case: 58,
· Token: example70.c:1:2: ANDAND,
· Token2: example70.c:1:5: IDENTIFIER "a",
}
Example (Case59) 
fmt.Println(exampleAST(71, "\U00100001 'a' ? : 'b'"))

Output:

&cc.Expression{
· Case: 59,
· Expression: &cc.Expression{
· · Case: 1,
· · Token: example71.c:1:2: CHARCONST "'a'",
· },
· Expression2: &cc.Expression{
· · Case: 1,
· · Token: example71.c:1:10: CHARCONST "'b'",
· },
· Token: example71.c:1:6: '?',
· Token2: example71.c:1:8: ':',
}

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.

func (*Expression) String 

func (n *Expression) String() string

String implements fmt.Stringer.

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(74, "\U00100001 ( 'a' )"))

Output:

&cc.ExpressionList{
· Expression: &cc.Expression{
· · Case: 1,
· · Token: example74.c:1:4: CHARCONST "'a'",
· },
}
Example (Case1) 
fmt.Println(exampleAST(75, "\U00100001 ( 'a' , 'b' )"))

Output:

&cc.ExpressionList{
· Expression: &cc.Expression{
· · Case: 1,
· · Token: example75.c:1:4: CHARCONST "'a'",
· },
· ExpressionList: &cc.ExpressionList{
· · Case: 1,
· · Expression: &cc.Expression{
· · · Case: 1,
· · · Token: example75.c:1:10: CHARCONST "'b'",
· · },
· · Token: example75.c:1:8: ',',
· },
}

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(76, "\U00100001 ( { ;") == (*ExpressionListOpt)(nil))

Output:

true
Example (Case1) 
fmt.Println(exampleAST(77, "\U00100001 ( { 'a' )"))

Output:

&cc.ExpressionListOpt{
· ExpressionList: &cc.ExpressionList{
· · Type: int,
· · Value: 97,
· · Expression: &cc.Expression{
· · · Type: int,
· · · Value: 97,
· · · Case: 1,
· · · Token: example77.c:1:6: CHARCONST "'a'",
· · },
· },
}

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(72, "\U00100001 ( _Bool [ ]") == (*ExpressionOpt)(nil))

Output:

true
Example (Case1) 
fmt.Println(exampleAST(73, "\U00100002 a [ 'b' ]"))

Output:

&cc.ExpressionOpt{
· Expression: &cc.Expression{
· · Type: int,
· · Value: 98,
· · Case: 1,
· · Token: example73.c:1:6: CHARCONST "'b'",
· },
}

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(232, "\U00100001 ( { ; !"))

Output:

&cc.ExpressionStatement{
· Token: example232.c:1:6: ';',
}

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 {
	BasicAssemblerStatement *BasicAssemblerStatement
	Case                    int
	Declaration             *Declaration
	FunctionDefinition      *FunctionDefinition
	Token                   xc.Token
}

ExternalDeclaration represents data reduced by productions: 

ExternalDeclaration:
        FunctionDefinition
|       Declaration                  // Case 1
|       BasicAssemblerStatement ';'  // Case 2
|       ';'                          // Case 3
Example 
fmt.Println(exampleAST(247, "\U00100002 a { }"))

Output:

&cc.ExternalDeclaration{
· FunctionDefinition: &cc.FunctionDefinition{
· · Case: 1,
· · Declarator: &cc.Declarator{
· · · Linkage: External,
· · · Type: int,
· · · DirectDeclarator: &cc.DirectDeclarator{
· · · · Token: example247.c:1:2: IDENTIFIER "a",
· · · },
· · },
· · FunctionBody: &cc.FunctionBody{
· · · CompoundStatement: &cc.CompoundStatement{
· · · · Token: example247.c:1:4: '{',
· · · · Token2: example247.c:1:6: '}',
· · · },
· · },
· },
}
Example (Case1) 
fmt.Println(exampleAST(248, "\U00100002 auto ;"))

Output:

&cc.ExternalDeclaration{
· Case: 1,
· Declaration: &cc.Declaration{
· · DeclarationSpecifiers: &cc.DeclarationSpecifiers{
· · · StorageClassSpecifier: &cc.StorageClassSpecifier{
· · · · Case: 3,
· · · · Token: example248.c:1:2: AUTO "auto",
· · · },
· · },
· · Token: example248.c:1:7: ';',
· },
}
Example (Case2) 
fmt.Println(exampleAST(249, "\U00100002 asm ( \"a\" ) ;"))

Output:

&cc.ExternalDeclaration{
· BasicAssemblerStatement: &cc.BasicAssemblerStatement{
· · AssemblerInstructions: &cc.AssemblerInstructions{
· · · Token: example249.c:1:8: STRINGLITERAL "\"a\"",
· · },
· · Token: example249.c:1:2: ASM "asm",
· · Token2: example249.c:1:6: '(',
· · Token3: example249.c:1:12: ')',
· },
· Case: 2,
· Token: example249.c:1:14: ';',
}
Example (Case3) 
fmt.Println(exampleAST(250, "\U00100002 ;"))

Output:

&cc.ExternalDeclaration{
· Case: 3,
· Token: example250.c:1:2: ';',
}

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 FunctionBody 

type FunctionBody struct {
	AssemblerStatement *AssemblerStatement
	Case               int
	CompoundStatement  *CompoundStatement
	Token              xc.Token
	// contains filtered or unexported fields
}

FunctionBody represents data reduced by productions: 

FunctionBody:
        CompoundStatement
|       AssemblerStatement ';'  // Case 1
Example 
fmt.Println(exampleAST(257, "\U00100002 a { }"))

Output:

&cc.FunctionBody{
· CompoundStatement: &cc.CompoundStatement{
· · Token: example257.c:1:4: '{',
· · Token2: example257.c:1:6: '}',
· },
}
Example (Case1) 
fmt.Println(exampleAST(259, "\U00100002 a asm ( \"b\" ) ;"))

Output:

&cc.FunctionBody{
· AssemblerStatement: &cc.AssemblerStatement{
· · BasicAssemblerStatement: &cc.BasicAssemblerStatement{
· · · AssemblerInstructions: &cc.AssemblerInstructions{
· · · · Token: example259.c:1:10: STRINGLITERAL "\"b\"",
· · · },
· · · Token: example259.c:1:4: ASM "asm",
· · · Token2: example259.c:1:8: '(',
· · · Token3: example259.c:1:14: ')',
· · },
· },
· Case: 1,
· Token: example259.c:1:16: ';',
}

func (*FunctionBody) Pos 

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

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

func (*FunctionBody) String 

func (n *FunctionBody) String() string

String implements fmt.Stringer.

type FunctionDefinition 

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

FunctionDefinition represents data reduced by productions: 

FunctionDefinition:
        DeclarationSpecifiers Declarator DeclarationListOpt FunctionBody
|       Declarator DeclarationListOpt FunctionBody                        // Case 1
Example 
fmt.Println(exampleAST(252, "\U00100002 auto a { }"))

Output:

&cc.FunctionDefinition{
· DeclarationSpecifiers: &cc.DeclarationSpecifiers{
· · StorageClassSpecifier: &cc.StorageClassSpecifier{
· · · Case: 3,
· · · Token: example252.c:1:2: AUTO "auto",
· · },
· },
· Declarator: &cc.Declarator{
· · Linkage: None,
· · Type: auto int,
· · DirectDeclarator: &cc.DirectDeclarator{
· · · Token: example252.c:1:7: IDENTIFIER "a",
· · },
· },
· FunctionBody: &cc.FunctionBody{
· · CompoundStatement: &cc.CompoundStatement{
· · · Token: example252.c:1:9: '{',
· · · Token2: example252.c:1:11: '}',
· · },
· },
}
Example (Case1) 
fmt.Println(exampleAST(255, "\U00100002 a { }"))

Output:

&cc.FunctionDefinition{
· Case: 1,
· Declarator: &cc.Declarator{
· · Linkage: External,
· · Type: int,
· · DirectDeclarator: &cc.DirectDeclarator{
· · · Token: example255.c:1:2: IDENTIFIER "a",
· · },
· },
· FunctionBody: &cc.FunctionBody{
· · CompoundStatement: &cc.CompoundStatement{
· · · Token: example255.c:1:4: '{',
· · · Token2: example255.c:1:6: '}',
· · },
· },
}

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 

type FunctionSpecifier struct {
	Case  int
	Token xc.Token
	// contains filtered or unexported fields
}

FunctionSpecifier represents data reduced by productions: 

FunctionSpecifier:
        "inline"
|       "_Noreturn"  // Case 1
Example 
fmt.Println(exampleAST(147, "\U00100002 inline ("))

Output:

&cc.FunctionSpecifier{
· Token: example147.c:1:2: INLINE "inline",
}
Example (Case1) 
fmt.Println(exampleAST(148, "\U00100002 _Noreturn ("))

Output:

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

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 

type GroupList struct {
	Case      int
	GroupList *GroupList
	GroupPart Node
}

GroupList represents data reduced by productions: 

GroupList:
        GroupPart
|       GroupList GroupPart  // Case 1
Example 
fmt.Println(exampleAST(286, "\U00100000 "))

Output:

&cc.GroupList{
}
Example (Case1) 
fmt.Println(exampleAST(287, "\U00100000int\nf() {}"))

Output:

&cc.GroupList{
· GroupList: &cc.GroupList{
· · Case: 1,
· · GroupPart: []xc.Token{ // len 6
· · · 0: example287.c:2:1: IDENTIFIER "f",
· · · 1: example287.c:2:2: '(',
· · · 2: example287.c:2:3: ')',
· · · 3: example287.c:2:4: ' ',
· · · 4: example287.c:2:5: '{',
· · · 5: example287.c:2:6: '}',
· · },
· },
· GroupPart: []xc.Token{ // len 2
· · 0: example287.c:1:1: IDENTIFIER "int",
· · 1: example287.c:1:4: ' ',
· },
}

func (*GroupList) Pos 

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

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

func (*GroupList) String 

func (n *GroupList) String() string

String implements fmt.Stringer.

type GroupListOpt 

type GroupListOpt struct {
	GroupList *GroupList
}

GroupListOpt represents data reduced by productions: 

GroupListOpt:
        /* empty */
|       GroupList    // Case 1
Example 
fmt.Println(exampleAST(288, "\U00100000 \n#ifndef a  \n#elif") == (*GroupListOpt)(nil))

Output:

true
Example (Case1) 
fmt.Println(exampleAST(289, "\U00100000 \n#ifndef a\nb\n#elif"))

Output:

&cc.GroupListOpt{
· GroupList: &cc.GroupList{
· · GroupPart: []xc.Token{ // len 2
· · · 0: example289.c:3:1: IDENTIFIER "b",
· · · 1: example289.c:3:2: ' ',
· · },
· },
}

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(177, "\U00100002 a ( b )"))

Output:

&cc.IdentifierList{
· Token: example177.c:1:6: IDENTIFIER "b",
}
Example (Case1) 
fmt.Println(exampleAST(178, "\U00100002 a ( b , c )"))

Output:

&cc.IdentifierList{
· IdentifierList: &cc.IdentifierList{
· · Case: 1,
· · Token: example178.c:1:8: ',',
· · Token2: example178.c:1:10: IDENTIFIER "c",
· },
· Token: example178.c:1:6: 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(179, "\U00100002 a ( )") == (*IdentifierListOpt)(nil))

Output:

true
Example (Case1) 
fmt.Println(exampleAST(180, "\U00100002 a ( b )"))

Output:

&cc.IdentifierListOpt{
· IdentifierList: &cc.IdentifierList{
· · Token: example180.c:1:6: IDENTIFIER "b",
· },
}

func (*IdentifierListOpt) Pos 

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

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

func (*IdentifierListOpt) String 

func (n *IdentifierListOpt) String() string

String implements fmt.Stringer.

type IdentifierOpt 

type IdentifierOpt struct {
	Token xc.Token
}

IdentifierOpt represents data reduced by productions: 

IdentifierOpt:
        /* empty */
|       IDENTIFIER   // Case 1
Example 
fmt.Println(exampleAST(181, "\U00100002 struct {") == (*IdentifierOpt)(nil))

Output:

true
Example (Case1) 
fmt.Println(exampleAST(182, "\U00100002 enum a {"))

Output:

&cc.IdentifierOpt{
· Token: example182.c:1:7: 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(295, "\U00100000 \n#if other_a  \n#elif"))

Output:

&cc.IfGroup{
· PPTokenList: []xc.Token{ // len 4
· · 0: example295.c:2:4: ' ',
· · 1: example295.c:2:5: IDENTIFIER "other_a",
· · 2: example295.c:2:12: ' ',
· · 3: example295.c:2:14: ' ',
· },
· Token: example295.c:2:2: PPIF,
· Token2: example295.c:2:14: '\n',
}
Example (Case1) 
fmt.Println(exampleAST(296, "\U00100000 \n#ifdef a  \n#elif"))

Output:

&cc.IfGroup{
· Case: 1,
· Token: example296.c:2:2: PPIFDEF,
· Token2: example296.c:2:8: IDENTIFIER "a",
· Token3: example296.c:2:11: '\n',
}
Example (Case2) 
fmt.Println(exampleAST(297, "\U00100000 \n#ifndef a  \n#elif"))

Output:

&cc.IfGroup{
· Case: 2,
· Token: example297.c:2:2: PPIFNDEF,
· Token2: example297.c:2:9: IDENTIFIER "a",
· Token3: example297.c:2:12: '\n',
}

func (*IfGroup) Pos 

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

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

func (*IfGroup) String 

func (n *IfGroup) String() string

String implements fmt.Stringer.

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(294, "\U00100000 \n#if other_a  \n#endif"))

Output:

&cc.IfSection{
· EndifLine: &cc.EndifLine{
· · Token: example294.c:3:2: PPENDIF,
· },
· IfGroup: &cc.IfGroup{
· · PPTokenList: []xc.Token{ // len 4
· · · 0: example294.c:2:4: ' ',
· · · 1: example294.c:2:5: IDENTIFIER "other_a",
· · · 2: example294.c:2:12: ' ',
· · · 3: example294.c:2:14: ' ',
· · },
· · Token: example294.c:2:2: PPIF,
· · Token2: example294.c:2:14: '\n',
· },
}

func (*IfSection) Pos 

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

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

func (*IfSection) String 

func (n *IfSection) String() string

String implements fmt.Stringer.

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(92, "\U00100002 a auto b ,"))

Output:

&cc.InitDeclarator{
· Declarator: &cc.Declarator{
· · Linkage: None,
· · Type: auto undefined,
· · DirectDeclarator: &cc.DirectDeclarator{
· · · Token: example92.c:1:9: IDENTIFIER "b",
· · },
· },
}
Example (Case1) 
fmt.Println(exampleAST(94, "\U00100002 auto a = 'b' ,"))

Output:

&cc.InitDeclarator{
· Case: 1,
· Declarator: &cc.Declarator{
· · Linkage: None,
· · Type: auto undefined,
· · DirectDeclarator: &cc.DirectDeclarator{
· · · Token: example94.c:1:7: IDENTIFIER "a",
· · },
· },
· Initializer: &cc.Initializer{
· · Expression: &cc.Expression{
· · · Type: int,
· · · Value: 98,
· · · Case: 1,
· · · Token: example94.c:1:11: CHARCONST "'b'",
· · },
· },
· Token: example94.c:1:9: '=',
}

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(88, "\U00100002 auto a ,"))

Output:

&cc.InitDeclaratorList{
· InitDeclarator: &cc.InitDeclarator{
· · Declarator: &cc.Declarator{
· · · Linkage: None,
· · · Type: auto undefined,
· · · DirectDeclarator: &cc.DirectDeclarator{
· · · · Token: example88.c:1:7: IDENTIFIER "a",
· · · },
· · },
· },
}
Example (Case1) 
fmt.Println(exampleAST(89, "\U00100002 auto a , b ,"))

Output:

&cc.InitDeclaratorList{
· InitDeclarator: &cc.InitDeclarator{
· · Declarator: &cc.Declarator{
· · · Linkage: None,
· · · Type: auto undefined,
· · · DirectDeclarator: &cc.DirectDeclarator{
· · · · Token: example89.c:1:7: IDENTIFIER "a",
· · · },
· · },
· },
· InitDeclaratorList: &cc.InitDeclaratorList{
· · Case: 1,
· · InitDeclarator: &cc.InitDeclarator{
· · · Declarator: &cc.Declarator{
· · · · Linkage: None,
· · · · Type: auto undefined,
· · · · DirectDeclarator: &cc.DirectDeclarator{
· · · · · Token: example89.c:1:11: IDENTIFIER "b",
· · · · },
· · · },
· · },
· · Token: example89.c:1:9: ',',
· },
}

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(90, "\U00100002 auto ;") == (*InitDeclaratorListOpt)(nil))

Output:

true
Example (Case1) 
fmt.Println(exampleAST(91, "\U00100002 auto a ;"))

Output:

&cc.InitDeclaratorListOpt{
· InitDeclaratorList: &cc.InitDeclaratorList{
· · InitDeclarator: &cc.InitDeclarator{
· · · Declarator: &cc.Declarator{
· · · · Linkage: None,
· · · · Type: auto undefined,
· · · · DirectDeclarator: &cc.DirectDeclarator{
· · · · · Token: example91.c:1:7: 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
	Initializer     *Initializer
	InitializerList *InitializerList
	Token           xc.Token
	Token2          xc.Token
}

Initializer represents data reduced by productions: 

Initializer:
        Expression
|       '{' InitializerList CommaOpt '}'  // Case 1
|       IDENTIFIER ':' Initializer        // Case 2
Example 
fmt.Println(exampleAST(201, "\U00100002 auto a = 'b' ,"))

Output:

&cc.Initializer{
· Expression: &cc.Expression{
· · Type: int,
· · Value: 98,
· · Case: 1,
· · Token: example201.c:1:11: CHARCONST "'b'",
· },
}
Example (Case1) 
fmt.Println(exampleAST(202, "\U00100002 auto a = { } ,"))

Output:

&cc.Initializer{
· Case: 1,
· Token: example202.c:1:11: '{',
· Token2: example202.c:1:13: '}',
}
Example (Case2) 
fmt.Println(exampleAST(203, "\U00100002 auto a = b : 'c' ,"))

Output:

&cc.Initializer{
· Case: 2,
· Initializer: &cc.Initializer{
· · Expression: &cc.Expression{
· · · Type: int,
· · · Value: 99,
· · · Case: 1,
· · · Token: example203.c:1:15: CHARCONST "'c'",
· · },
· },
· Token: example203.c:1:11: IDENTIFIER "b",
· Token2: example203.c:1:13: ':',
}

func (*Initializer) Pos 

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

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

func (*Initializer) String 

func (n *Initializer) String() string

String implements fmt.Stringer.

type 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
|       /* empty */                                     // Case 2
Example 
fmt.Println(exampleAST(204, "\U00100002 auto a = { 'b' ,"))

Output:

&cc.InitializerList{
· Initializer: &cc.Initializer{
· · Expression: &cc.Expression{
· · · Type: int,
· · · Value: 98,
· · · Case: 1,
· · · Token: example204.c:1:13: CHARCONST "'b'",
· · },
· },
}
Example (Case1) 
fmt.Println(exampleAST(205, "\U00100002 auto a = { , 'b' ,"))

Output:

&cc.InitializerList{
· Case: 1,
· Initializer: &cc.Initializer{
· · Expression: &cc.Expression{
· · · Type: int,
· · · Value: 98,
· · · Case: 1,
· · · Token: example205.c:1:15: CHARCONST "'b'",
· · },
· },
· Token: example205.c:1:13: ',',
}
Example (Case2) 
fmt.Println(exampleAST(206, "\U00100002 auto a = { ,") == (*InitializerList)(nil))

Output:

true

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(236, "\U00100001 ( { while ( 'a' ) ; !"))

Output:

&cc.IterationStatement{
· ExpressionList: &cc.ExpressionList{
· · Type: int,
· · Value: 97,
· · Expression: &cc.Expression{
· · · Type: int,
· · · Value: 97,
· · · Case: 1,
· · · Token: example236.c:1:14: CHARCONST "'a'",
· · },
· },
· Statement: &cc.Statement{
· · Case: 2,
· · ExpressionStatement: &cc.ExpressionStatement{
· · · Token: example236.c:1:20: ';',
· · },
· },
· Token: example236.c:1:6: WHILE "while",
· Token2: example236.c:1:12: '(',
· Token3: example236.c:1:18: ')',
}
Example (Case1) 
fmt.Println(exampleAST(237, "\U00100001 ( { do ; while ( 'a' ) ; !"))

Output:

&cc.IterationStatement{
· Case: 1,
· ExpressionList: &cc.ExpressionList{
· · Type: int,
· · Value: 97,
· · Expression: &cc.Expression{
· · · Type: int,
· · · Value: 97,
· · · Case: 1,
· · · Token: example237.c:1:19: CHARCONST "'a'",
· · },
· },
· Statement: &cc.Statement{
· · Case: 2,
· · ExpressionStatement: &cc.ExpressionStatement{
· · · Token: example237.c:1:9: ';',
· · },
· },
· Token: example237.c:1:6: DO "do",
· Token2: example237.c:1:11: WHILE "while",
· Token3: example237.c:1:17: '(',
· Token4: example237.c:1:23: ')',
· Token5: example237.c:1:25: ';',
}
Example (Case2) 
fmt.Println(exampleAST(238, "\U00100001 ( { for ( ; ; ) ; !"))

Output:

&cc.IterationStatement{
· Case: 2,
· Statement: &cc.Statement{
· · Case: 2,
· · ExpressionStatement: &cc.ExpressionStatement{
· · · Token: example238.c:1:18: ';',
· · },
· },
· Token: example238.c:1:6: FOR "for",
· Token2: example238.c:1:10: '(',
· Token3: example238.c:1:12: ';',
· Token4: example238.c:1:14: ';',
· Token5: example238.c:1:16: ')',
}
Example (Case3) 
fmt.Println(exampleAST(239, "\U00100001 ( { for ( auto ; ; ) ; !"))

Output:

&cc.IterationStatement{
· Case: 3,
· Declaration: &cc.Declaration{
· · DeclarationSpecifiers: &cc.DeclarationSpecifiers{
· · · StorageClassSpecifier: &cc.StorageClassSpecifier{
· · · · Case: 3,
· · · · Token: example239.c:1:12: AUTO "auto",
· · · },
· · },
· · Token: example239.c:1:17: ';',
· },
· Statement: &cc.Statement{
· · Case: 2,
· · ExpressionStatement: &cc.ExpressionStatement{
· · · Token: example239.c:1:23: ';',
· · },
· },
· Token: example239.c:1:6: FOR "for",
· Token2: example239.c:1:10: '(',
· Token3: example239.c:1:19: ';',
· Token4: example239.c:1:21: ')',
}

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
	Expression        *Expression
	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
|       "goto" Expression ';'           // Case 4
Example 
fmt.Println(exampleAST(240, "\U00100001 ( { goto a ; !"))

Output:

&cc.JumpStatement{
· Token: example240.c:1:6: GOTO "goto",
· Token2: example240.c:1:11: IDENTIFIER "a",
· Token3: example240.c:1:13: ';',
}
Example (Case1) 
fmt.Println(exampleAST(241, "\U00100001 ( { continue ; !"))

Output:

&cc.JumpStatement{
· Case: 1,
· Token: example241.c:1:6: CONTINUE "continue",
· Token2: example241.c:1:15: ';',
}
Example (Case2) 
fmt.Println(exampleAST(242, "\U00100001 ( { break ; !"))

Output:

&cc.JumpStatement{
· Case: 2,
· Token: example242.c:1:6: BREAK "break",
· Token2: example242.c:1:12: ';',
}
Example (Case3) 
fmt.Println(exampleAST(243, "\U00100001 ( { return ; !"))

Output:

&cc.JumpStatement{
· Case: 3,
· Token: example243.c:1:6: RETURN "return",
· Token2: example243.c:1:13: ';',
}
Example (Case4) 
fmt.Println(exampleAST(244, "\U00100001 ( { goto 'a' ; !"))

Output:

&cc.JumpStatement{
· Case: 4,
· Expression: &cc.Expression{
· · Type: int,
· · Value: 97,
· · Case: 1,
· · Token: example244.c:1:11: CHARCONST "'a'",
· },
· Token: example244.c:1:6: GOTO "goto",
· Token2: example244.c:1:15: ';',
}

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. 

const (
	Undefined Kind = iota
	Void
	Ptr
	UintPtr // Type used for pointer arithmetic.
	Char
	SChar
	UChar
	Short
	UShort
	Int
	UInt
	Long
	ULong
	LongLong
	ULongLong
	Float
	Double
	LongDouble
	Bool
	FloatComplex
	DoubleComplex
	LongDoubleComplex
	Struct
	Union
	Enum
	TypedefName
	Function
	Array
)

Values of type Kind.

func (Kind) CString 

func (k Kind) CString() string

func (Kind) String 

func (i Kind) String() string

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(221, "\U00100001 ( { a : ; !"))

Output:

&cc.LabeledStatement{
· Statement: &cc.Statement{
· · Case: 2,
· · ExpressionStatement: &cc.ExpressionStatement{
· · · Token: example221.c:1:10: ';',
· · },
· },
· Token: example221.c:1:6: IDENTIFIER "a",
· Token2: example221.c:1:8: ':',
}
Example (Case1) 
fmt.Println(exampleAST(222, "\U00100001 ( { case 'a' : ; !"))

Output:

&cc.LabeledStatement{
· Case: 1,
· ConstantExpression: &cc.ConstantExpression{
· · Type: int,
· · Value: 97,
· · Expression: &cc.Expression{
· · · Type: int,
· · · Value: 97,
· · · Case: 1,
· · · Token: example222.c:1:11: CHARCONST "'a'",
· · },
· },
· Statement: &cc.Statement{
· · Case: 2,
· · ExpressionStatement: &cc.ExpressionStatement{
· · · Token: example222.c:1:17: ';',
· · },
· },
· Token: example222.c:1:6: CASE "case",
· Token2: example222.c:1:15: ':',
}
Example (Case2) 
fmt.Println(exampleAST(223, "\U00100001 ( { default : ; !"))

Output:

&cc.LabeledStatement{
· Case: 2,
· Statement: &cc.Statement{
· · Case: 2,
· · ExpressionStatement: &cc.ExpressionStatement{
· · · Token: example223.c:1:16: ';',
· · },
· },
· Token: example223.c:1:6: DEFAULT "default",
· Token2: example223.c:1:14: ':',
}

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 Linkage 

type Linkage int

Linkage is a C linkage kind ([0], 6.2.2, p. 30) 

const (
	None Linkage = iota
	Internal
	External
)

Values of type Linkage.

func (Linkage) String 

func (i Linkage) String() string

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 

func (m *Macro) ReplacementToks() (r []xc.Token)

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
	DoubleComplexType     Type
	DoubleType            Type
	FloatComplexType      Type
	FloatType             Type
	IntType               Type
	LongDoubleComplexType Type
	LongDoubleType        Type
	LongLongType          Type
	LongType              Type
	ShortType             Type
	UCharType             Type
	UIntType              Type
	ULongLongType         Type
	ULongType             Type
	UShortType            Type
	UintPtrType           Type
	VoidType              Type

	Signed [kindMax]bool // Signed[Kind] reports whether Kind is a signed integer type.
	// contains filtered or unexported fields
}

Model describes size and align requirements of predeclared types.

func (*Model) BinOpType 

func (m *Model) BinOpType(a, b Type) Type

BinOpType returns the evaluation type of a binop b, ie. the type operands are converted to before performing the operation. Operands must be arithmetic types.

See [0], 6.3.1.8 - Usual arithmetic conversions.

func (*Model) MustConvert 

func (m *Model) MustConvert(v interface{}, typ Type) interface{}

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.
	StructAlign int         // Alignment of the entity when it's a struct field.
	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 Namespace 

type Namespace int

Namespace is a binding category. 

const (
	NSIdentifiers Namespace = iota
	NSTags
)

Values of type Namespace.

func (Namespace) String 

func (i Namespace) String() string

type Node 

type Node interface {
	Pos() token.Pos
}

Node represents an AST node.

type Opt 

type Opt func(*lexer)

Opt is a configuration/setup function that can be passed to the Parser function.

func AllowCompatibleTypedefRedefinitions 

func AllowCompatibleTypedefRedefinitions() Opt

AllowCompatibleTypedefRedefinitions makes the parser accept compatible typedef redefinitions. 

typedef int foo;
typedef int foo; // ok with this option.
typedef long int foo; // never ok.

func Cpp 

func Cpp(f func([]xc.Token)) Opt

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 CrashOnError 

func CrashOnError() Opt

CrashOnError is an debugging option.

func EnableAlignOf 

func EnableAlignOf() Opt

EnableAlignOf enables recognizing the reserved word _Alignof.

func EnableAlternateKeywords 

func EnableAlternateKeywords() Opt

EnableAlternateKeywords makes the parser accept, for example, non standard 

__asm__

as an equvalent of keyowrd asm (which first hast be permitted by EnableAsm).

func EnableAnonymousStructFields 

func EnableAnonymousStructFields() Opt

EnableAnonymousStructFields makes the parser accept non standard 

struct {
	int i;
	struct {
		int j;
	};
	int k;
};

func EnableAsm 

func EnableAsm() Opt

EnableAsm enables recognizing the reserved word asm.

func EnableBuiltinClassifyType 

func EnableBuiltinClassifyType() Opt

EnableBuiltinClassifyType makes the parser handle specially 

__builtin_constant_p(expr)

See https://gcc.gnu.org/onlinedocs/gccint/Varargs.html

func EnableBuiltinConstantP 

func EnableBuiltinConstantP() Opt

EnableBuiltinConstantP makes the parser handle specially 

__builtin_constant_p(expr)

See https://gcc.gnu.org/onlinedocs/gcc/Other-Builtins.html

func EnableComputedGotos 

func EnableComputedGotos() Opt

EnableComputedGotos makes the parser accept non standard 

variable = &&label;
goto *variable;

See https://gcc.gnu.org/onlinedocs/gcc-3.3/gcc/Labels-as-Values.html

func EnableDefineOmitCommaBeforeDDD 

func EnableDefineOmitCommaBeforeDDD() Opt

EnableDefineOmitCommaBeforeDDD makes the parser accept non standard 

#define foo(a, b...) // Note the missing comma after identifier list.

func EnableDlrInIdentifiers 

func EnableDlrInIdentifiers() Opt

EnableDlrInIdentifiers makes the parser accept non standard 

int foo$bar

func EnableEmptyDeclarations 

func EnableEmptyDeclarations() Opt

EnableEmptyDeclarations makes the parser accept non standard 

; // C++11 empty declaration

func EnableEmptyDefine 

func EnableEmptyDefine() Opt

EnableEmptyDefine makes the parser accept non standard 

#define

func EnableEmptyStructs 

func EnableEmptyStructs() Opt

EnableEmptyStructs makes the parser accept non standard 

struct foo {};

func EnableImaginarySuffix 

func EnableImaginarySuffix() Opt

EnableImaginarySuffix makes the parser accept non standard 

4.2i, 5.6j etc

See https://gcc.gnu.org/onlinedocs/gcc/Complex.html

func EnableImplicitFuncDef 

func EnableImplicitFuncDef() Opt

EnableImplicitFuncDef makes the parser accept non standard 

int f() {
	return g(); // g is undefined, but assumed to be returning int.
}

func EnableImplicitIntType 

func EnableImplicitIntType() Opt

EnableImplicitIntType makes the parser accept non standard omitting type specifier. For example 

static i;

becomes the same as 

static int i;

func EnableIncludeNext 

func EnableIncludeNext() Opt

EnableIncludeNext makes the parser accept non standard 

#include_next "foo.h"

func EnableLegacyDesignators 

func EnableLegacyDesignators() Opt

EnableLegacyDesignators makes the parser accept legacy designators 

{ a: 42 } // Obsolete since GCC 2.5, standard is { .a=42 }

See https://gcc.gnu.org/onlinedocs/gcc/Designated-Inits.html

func EnableNonConstStaticInitExpressions 

func EnableNonConstStaticInitExpressions() Opt

EnableNonConstStaticInitExpressions makes the parser accept non standard 

static int i = f();

[0], 6.7.8/4: All the expressions in an initializer for an object that has static storage duration shall be constant expressions or string literals.

func EnableNoreturn 

func EnableNoreturn() Opt

EnableNoreturn enables recognizing the reserved word _Noreturn.

func EnableOmitConditionalOperand 

func EnableOmitConditionalOperand() Opt

EnableOmitConditionalOperand makes the parser accept non standard 

x ? : y

See https://gcc.gnu.org/onlinedocs/gcc-4.7.0/gcc/Conditionals.html#Conditionals

func EnableOmitFuncArgTypes 

func EnableOmitFuncArgTypes() Opt

EnableOmitFuncArgTypes makes the parser accept non standard 

f(a) // Same as int f(int a).

func EnableOmitFuncRetType 

func EnableOmitFuncRetType() Opt

EnableOmitFuncRetType makes the parser accept non standard 

f() // Same as int f().

func EnableParenthesizedCompoundStatemen 

func EnableParenthesizedCompoundStatemen() Opt

EnableParenthesizedCompoundStatemen makes the parser accept non standard 

({ ... })

as an expression. See [3].

func EnableStaticAssert 

func EnableStaticAssert() Opt

EnableStaticAssert enables recognizing the reserved word _Static_assert.

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 EnableUnsignedEnums 

func EnableUnsignedEnums() Opt

EnableUnsignedEnums makes the parser handle choose unsigned int as the type of an enumeration with no negative members.

func EnableWideBitFieldTypes 

func EnableWideBitFieldTypes() Opt

EnableWideBitFieldTypes makes the parser accept non standard bitfield types (i.e, long long and unsigned long long). 

unsigned long long bits : 2;

func EnableWideEnumValues 

func EnableWideEnumValues() Opt

EnableWideEnumValues makes the parser accept non standard 

enum { v = X }; for X wider than 32 bits.

func ErrLimit 

func ErrLimit(n int) Opt

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 IncludePaths 

func IncludePaths(paths []string) Opt

IncludePaths option configures where to search for include files (eg. "name.h"). Multiple IncludePaths options may be used, the resulting search path list is produced by appending the option arguments in order of appearance.

func KeepComments 

func KeepComments() Opt

KeepComments makes the parser keep comments.

func Mode99c 

func Mode99c() Opt

Mode99c turns on support for the 99c compiler.

func SysIncludePaths 

func SysIncludePaths(paths []string) Opt

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.

func Trigraphs 

func Trigraphs() Opt

Trigraphs enables processing of trigraphs.

func YyDebug 

func YyDebug(n int) Opt

YyDebug sets the parser debug level.

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(175, "\U00100002 a ( auto b )"))

Output:

&cc.ParameterDeclaration{
· DeclarationSpecifiers: &cc.DeclarationSpecifiers{
· · StorageClassSpecifier: &cc.StorageClassSpecifier{
· · · Case: 3,
· · · Token: example175.c:1:6: AUTO "auto",
· · },
· },
· Declarator: &cc.Declarator{
· · Linkage: None,
· · Type: auto undefined,
· · DirectDeclarator: &cc.DirectDeclarator{
· · · Token: example175.c:1:11: IDENTIFIER "b",
· · },
· },
}
Example (Case1) 
fmt.Println(exampleAST(176, "\U00100002 a ( auto )"))

Output:

&cc.ParameterDeclaration{
· Case: 1,
· DeclarationSpecifiers: &cc.DeclarationSpecifiers{
· · StorageClassSpecifier: &cc.StorageClassSpecifier{
· · · Case: 3,
· · · Token: example176.c:1:6: 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(173, "\U00100002 a ( auto )"))

Output:

&cc.ParameterList{
· ParameterDeclaration: &cc.ParameterDeclaration{
· · Case: 1,
· · DeclarationSpecifiers: &cc.DeclarationSpecifiers{
· · · StorageClassSpecifier: &cc.StorageClassSpecifier{
· · · · Case: 3,
· · · · Token: example173.c:1:6: AUTO "auto",
· · · },
· · },
· },
}
Example (Case1) 
fmt.Println(exampleAST(174, "\U00100002 a ( auto , auto )"))

Output:

&cc.ParameterList{
· ParameterDeclaration: &cc.ParameterDeclaration{
· · Case: 1,
· · DeclarationSpecifiers: &cc.DeclarationSpecifiers{
· · · StorageClassSpecifier: &cc.StorageClassSpecifier{
· · · · Case: 3,
· · · · Token: example174.c:1:6: AUTO "auto",
· · · },
· · },
· },
· ParameterList: &cc.ParameterList{
· · Case: 1,
· · ParameterDeclaration: &cc.ParameterDeclaration{
· · · Case: 1,
· · · DeclarationSpecifiers: &cc.DeclarationSpecifiers{
· · · · StorageClassSpecifier: &cc.StorageClassSpecifier{
· · · · · Case: 3,
· · · · · Token: example174.c:1:13: AUTO "auto",
· · · · },
· · · },
· · },
· · Token: example174.c:1:11: ',',
· },
}

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(169, "\U00100002 a ( auto )"))

Output:

&cc.ParameterTypeList{
· ParameterList: &cc.ParameterList{
· · ParameterDeclaration: &cc.ParameterDeclaration{
· · · Case: 1,
· · · DeclarationSpecifiers: &cc.DeclarationSpecifiers{
· · · · StorageClassSpecifier: &cc.StorageClassSpecifier{
· · · · · Case: 3,
· · · · · Token: example169.c:1:6: AUTO "auto",
· · · · },
· · · },
· · },
· },
}
Example (Case1) 
fmt.Println(exampleAST(170, "\U00100002 a ( auto , ... )"))

Output:

&cc.ParameterTypeList{
· Case: 1,
· ParameterList: &cc.ParameterList{
· · ParameterDeclaration: &cc.ParameterDeclaration{
· · · Case: 1,
· · · DeclarationSpecifiers: &cc.DeclarationSpecifiers{
· · · · StorageClassSpecifier: &cc.StorageClassSpecifier{
· · · · · Case: 3,
· · · · · Token: example170.c:1:6: AUTO "auto",
· · · · },
· · · },
· · },
· },
· Token: example170.c:1:11: ',',
· Token2: example170.c:1:13: 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(171, "\U00100001 ( _Bool ( )") == (*ParameterTypeListOpt)(nil))

Output:

true
Example (Case1) 
fmt.Println(exampleAST(172, "\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: example172.c:1:12: 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(161, "\U00100002 * ("))

Output:

&cc.Pointer{
· Token: example161.c:1:2: '*',
}
Example (Case1) 
fmt.Println(exampleAST(162, "\U00100002 * * ("))

Output:

&cc.Pointer{
· Case: 1,
· Pointer: &cc.Pointer{
· · Token: example162.c:1:4: '*',
· },
· Token: example162.c:1:2: '*',
}

func (*Pointer) Pos 

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

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

func (*Pointer) String 

func (n *Pointer) String() string

String implements fmt.Stringer.

type PointerOpt 

type PointerOpt struct {
	Pointer *Pointer
}

PointerOpt represents data reduced by productions: 

PointerOpt:
        /* empty */
|       Pointer      // Case 1
Example 
fmt.Println(exampleAST(163, "\U00100002 auto (") == (*PointerOpt)(nil))

Output:

true
Example (Case1) 
fmt.Println(exampleAST(164, "\U00100001 ( _Bool * ("))

Output:

&cc.PointerOpt{
· Pointer: &cc.Pointer{
· · Token: example164.c:1:10: '*',
· },
}

func (*PointerOpt) Pos 

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

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

func (*PointerOpt) String 

func (n *PointerOpt) String() string

String implements fmt.Stringer.

type PreprocessingFile 

type PreprocessingFile struct {
	GroupList *GroupList
	// contains filtered or unexported fields
}

PreprocessingFile represents data reduced by production: 

PreprocessingFile:
        GroupList
Example 
fmt.Println(exampleAST(285, "\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 Scope 

type Scope int

Scope is a bindings category. 

const (
	ScopeFile Scope = iota
	ScopeBlock
	ScopeMembers
	ScopeParams
)

Values of type Scope

func (Scope) String 

func (i Scope) String() string

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(233, "\U00100001 ( { if ( 'a' ) ; !"))

Output:

&cc.SelectionStatement{
· ExpressionList: &cc.ExpressionList{
· · Type: int,
· · Value: 97,
· · Expression: &cc.Expression{
· · · Type: int,
· · · Value: 97,
· · · Case: 1,
· · · Token: example233.c:1:11: CHARCONST "'a'",
· · },
· },
· Statement: &cc.Statement{
· · Case: 2,
· · ExpressionStatement: &cc.ExpressionStatement{
· · · Token: example233.c:1:17: ';',
· · },
· },
· Token: example233.c:1:6: IF "if",
· Token2: example233.c:1:9: '(',
· Token3: example233.c:1:15: ')',
}
Example (Case1) 
fmt.Println(exampleAST(234, "\U00100001 ( { if ( 'a' ) ; else ; !"))

Output:

&cc.SelectionStatement{
· Case: 1,
· ExpressionList: &cc.ExpressionList{
· · Type: int,
· · Value: 97,
· · Expression: &cc.Expression{
· · · Type: int,
· · · Value: 97,
· · · Case: 1,
· · · Token: example234.c:1:11: CHARCONST "'a'",
· · },
· },
· Statement: &cc.Statement{
· · Case: 2,
· · ExpressionStatement: &cc.ExpressionStatement{
· · · Token: example234.c:1:17: ';',
· · },
· },
· Statement2: &cc.Statement{
· · Case: 2,
· · ExpressionStatement: &cc.ExpressionStatement{
· · · Token: example234.c:1:24: ';',
· · },
· },
· Token: example234.c:1:6: IF "if",
· Token2: example234.c:1:9: '(',
· Token3: example234.c:1:15: ')',
· Token4: example234.c:1:19: ELSE "else",
}
Example (Case2) 
fmt.Println(exampleAST(235, "\U00100001 ( { switch ( 'a' ) ; !"))

Output:

&cc.SelectionStatement{
· Case: 2,
· ExpressionList: &cc.ExpressionList{
· · Type: int,
· · Value: 97,
· · Expression: &cc.Expression{
· · · Type: int,
· · · Value: 97,
· · · Case: 1,
· · · Token: example235.c:1:15: CHARCONST "'a'",
· · },
· },
· Statement: &cc.Statement{
· · Case: 2,
· · ExpressionStatement: &cc.ExpressionStatement{
· · · Token: example235.c:1:21: ';',
· · },
· },
· Token: example235.c:1:6: SWITCH "switch",
· Token2: example235.c:1:13: '(',
· Token3: example235.c:1:19: ')',
}

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 {
	IsAuto() bool     // StorageClassSpecifier "auto" present.
	IsConst() bool    // TypeQualifier "const" present.
	IsExtern() bool   // StorageClassSpecifier "extern" present.
	IsInline() bool   // FunctionSpecifier "inline" present.
	IsRegister() bool // StorageClassSpecifier "register" present.
	IsRestrict() bool // TypeQualifier "restrict" present.
	IsStatic() bool   // StorageClassSpecifier "static" present.
	IsTypedef() bool  // StorageClassSpecifier "typedef" present.
	IsVolatile() bool // TypeQualifier "volatile" present.
	TypedefName() int // TypedefName returns the typedef name ID used, if any, zero otherwise.
	// 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(127, "\U00100001 ( _Bool ("))

Output:

&cc.SpecifierQualifierList{
· TypeSpecifier: &cc.TypeSpecifier{
· · Case: 9,
· · Token: example127.c:1:4: BOOL "_Bool",
· },
}
Example (Case1) 
fmt.Println(exampleAST(128, "\U00100001 ( const ("))

Output:

&cc.SpecifierQualifierList{
· Case: 1,
· TypeQualifier: &cc.TypeQualifier{
· · Token: example128.c:1:4: CONST "const",
· },
}

func (*SpecifierQualifierList) IsAuto 

func (n *SpecifierQualifierList) IsAuto() bool

IsAuto implements specifier.

func (*SpecifierQualifierList) IsConst 

func (n *SpecifierQualifierList) IsConst() bool

IsConst returns whether n includes the 'const' type qualifier.

func (*SpecifierQualifierList) IsExtern 

func (n *SpecifierQualifierList) IsExtern() bool

IsExtern implements specifier.

func (*SpecifierQualifierList) IsInline 

func (n *SpecifierQualifierList) IsInline() bool

IsInline implements specifier.

func (*SpecifierQualifierList) IsRegister 

func (n *SpecifierQualifierList) IsRegister() bool

IsRegister implements specifier.

func (*SpecifierQualifierList) IsRestrict 

func (n *SpecifierQualifierList) IsRestrict() bool

IsRestrict implements specifier.

func (*SpecifierQualifierList) IsStatic 

func (n *SpecifierQualifierList) IsStatic() bool

IsStatic implements specifier.

func (*SpecifierQualifierList) IsTypedef 

func (n *SpecifierQualifierList) IsTypedef() bool

IsTypedef implements specifier.

func (*SpecifierQualifierList) IsVolatile 

func (n *SpecifierQualifierList) IsVolatile() bool

IsVolatile 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(129, "\U00100001 ( _Bool (") == (*SpecifierQualifierListOpt)(nil))

Output:

true
Example (Case1) 
fmt.Println(exampleAST(130, "\U00100001 ( _Bool _Bool ("))

Output:

&cc.SpecifierQualifierListOpt{
· SpecifierQualifierList: &cc.SpecifierQualifierList{
· · TypeSpecifier: &cc.TypeSpecifier{
· · · Case: 9,
· · · Token: example130.c:1:10: 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 {
	AssemblerStatement  *AssemblerStatement
	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
|       AssemblerStatement   // Case 6
Example 
fmt.Println(exampleAST(214, "\U00100001 ( { default : ; !"))

Output:

&cc.Statement{
· LabeledStatement: &cc.LabeledStatement{
· · Case: 2,
· · Statement: &cc.Statement{
· · · Case: 2,
· · · ExpressionStatement: &cc.ExpressionStatement{
· · · · Token: example214.c:1:16: ';',
· · · },
· · },
· · Token: example214.c:1:6: DEFAULT "default",
· · Token2: example214.c:1:14: ':',
· },
}
Example (Case1) 
fmt.Println(exampleAST(215, "\U00100001 ( { { } !"))

Output:

&cc.Statement{
· Case: 1,
· CompoundStatement: &cc.CompoundStatement{
· · Token: example215.c:1:6: '{',
· · Token2: example215.c:1:8: '}',
· },
}
Example (Case2) 
fmt.Println(exampleAST(216, "\U00100001 ( { ; !"))

Output:

&cc.Statement{
· Case: 2,
· ExpressionStatement: &cc.ExpressionStatement{
· · Token: example216.c:1:6: ';',
· },
}
Example (Case3) 
fmt.Println(exampleAST(217, "\U00100001 ( { if ( 'a' ) ; !"))

Output:

&cc.Statement{
· Case: 3,
· SelectionStatement: &cc.SelectionStatement{
· · ExpressionList: &cc.ExpressionList{
· · · Type: int,
· · · Value: 97,
· · · Expression: &cc.Expression{
· · · · Type: int,
· · · · Value: 97,
· · · · Case: 1,
· · · · Token: example217.c:1:11: CHARCONST "'a'",
· · · },
· · },
· · Statement: &cc.Statement{
· · · Case: 2,
· · · ExpressionStatement: &cc.ExpressionStatement{
· · · · Token: example217.c:1:17: ';',
· · · },
· · },
· · Token: example217.c:1:6: IF "if",
· · Token2: example217.c:1:9: '(',
· · Token3: example217.c:1:15: ')',
· },
}
Example (Case4) 
fmt.Println(exampleAST(218, "\U00100001 ( { while ( 'a' ) ; !"))

Output:

&cc.Statement{
· Case: 4,
· IterationStatement: &cc.IterationStatement{
· · ExpressionList: &cc.ExpressionList{
· · · Type: int,
· · · Value: 97,
· · · Expression: &cc.Expression{
· · · · Type: int,
· · · · Value: 97,
· · · · Case: 1,
· · · · Token: example218.c:1:14: CHARCONST "'a'",
· · · },
· · },
· · Statement: &cc.Statement{
· · · Case: 2,
· · · ExpressionStatement: &cc.ExpressionStatement{
· · · · Token: example218.c:1:20: ';',
· · · },
· · },
· · Token: example218.c:1:6: WHILE "while",
· · Token2: example218.c:1:12: '(',
· · Token3: example218.c:1:18: ')',
· },
}
Example (Case5) 
fmt.Println(exampleAST(219, "\U00100001 ( { break ; !"))

Output:

&cc.Statement{
· Case: 5,
· JumpStatement: &cc.JumpStatement{
· · Case: 2,
· · Token: example219.c:1:6: BREAK "break",
· · Token2: example219.c:1:12: ';',
· },
}
Example (Case6) 
fmt.Println(exampleAST(220, "\U00100001 ( { asm ( \"a\" ) !"))

Output:

&cc.Statement{
· AssemblerStatement: &cc.AssemblerStatement{
· · BasicAssemblerStatement: &cc.BasicAssemblerStatement{
· · · AssemblerInstructions: &cc.AssemblerInstructions{
· · · · Token: example220.c:1:12: STRINGLITERAL "\"a\"",
· · · },
· · · Token: example220.c:1:6: ASM "asm",
· · · Token2: example220.c:1:10: '(',
· · · Token3: example220.c:1:16: ')',
· · },
· },
· Case: 6,
}

func (*Statement) Pos 

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

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

func (*Statement) String 

func (n *Statement) String() string

String implements fmt.Stringer.

type StaticAssertDeclaration 

type StaticAssertDeclaration struct {
	ConstantExpression *ConstantExpression
	Token              xc.Token
	Token2             xc.Token
	Token3             xc.Token
	Token4             xc.Token
	Token5             xc.Token
	Token6             xc.Token
}

StaticAssertDeclaration represents data reduced by production: 

StaticAssertDeclaration:
        "_Static_assert" '(' ConstantExpression ',' STRINGLITERAL ')' ';'
Example 
fmt.Println(exampleAST(284, "\U00100002 _Static_assert ( 'a' , \"b\" ) ;"))

Output:

&cc.StaticAssertDeclaration{
· ConstantExpression: &cc.ConstantExpression{
· · Type: int,
· · Value: 97,
· · Expression: &cc.Expression{
· · · Type: int,
· · · Value: 97,
· · · Case: 1,
· · · Token: example284.c:1:19: CHARCONST "'a'",
· · },
· },
· Token: example284.c:1:2: STATIC_ASSERT "_Static_assert",
· Token2: example284.c:1:17: '(',
· Token3: example284.c:1:23: ',',
· Token4: example284.c:1:25: STRINGLITERAL "\"b\"",
· Token5: example284.c:1:29: ')',
· Token6: example284.c:1:31: ';',
}

func (*StaticAssertDeclaration) Pos 

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

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

func (*StaticAssertDeclaration) String 

func (n *StaticAssertDeclaration) String() string

String implements fmt.Stringer.

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(95, "\U00100002 typedef ("))

Output:

&cc.StorageClassSpecifier{
· Token: example95.c:1:2: TYPEDEF "typedef",
}
Example (Case1) 
fmt.Println(exampleAST(96, "\U00100002 extern ("))

Output:

&cc.StorageClassSpecifier{
· Case: 1,
· Token: example96.c:1:2: EXTERN "extern",
}
Example (Case2) 
fmt.Println(exampleAST(97, "\U00100002 static ("))

Output:

&cc.StorageClassSpecifier{
· Case: 2,
· Token: example97.c:1:2: STATIC "static",
}
Example (Case3) 
fmt.Println(exampleAST(98, "\U00100002 auto ("))

Output:

&cc.StorageClassSpecifier{
· Case: 3,
· Token: example98.c:1:2: AUTO "auto",
}
Example (Case4) 
fmt.Println(exampleAST(99, "\U00100002 register ("))

Output:

&cc.StorageClassSpecifier{
· Case: 4,
· Token: example99.c:1:2: 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
	StaticAssertDeclaration *StaticAssertDeclaration
	StructDeclaratorList    *StructDeclaratorList
	Token                   xc.Token
}

StructDeclaration represents data reduced by productions: 

StructDeclaration:
        SpecifierQualifierList StructDeclaratorList ';'
|       SpecifierQualifierList ';'                       // Case 1
|       StaticAssertDeclaration                          // Case 2
Example 
fmt.Println(exampleAST(124, "\U00100002 struct { _Bool a ; }"))

Output:

&cc.StructDeclaration{
· SpecifierQualifierList: &cc.SpecifierQualifierList{
· · TypeSpecifier: &cc.TypeSpecifier{
· · · Case: 9,
· · · Token: example124.c:1:11: BOOL "_Bool",
· · },
· },
· StructDeclaratorList: &cc.StructDeclaratorList{
· · StructDeclarator: &cc.StructDeclarator{
· · · Declarator: &cc.Declarator{
· · · · Linkage: None,
· · · · Type: bool,
· · · · DirectDeclarator: &cc.DirectDeclarator{
· · · · · Token: example124.c:1:17: IDENTIFIER "a",
· · · · },
· · · },
· · },
· },
· Token: example124.c:1:19: ';',
}
Example (Case1) 
fmt.Println(exampleAST(125, "\U00100002 struct { _Bool ; }"))

Output:

&cc.StructDeclaration{
· Case: 1,
· SpecifierQualifierList: &cc.SpecifierQualifierList{
· · TypeSpecifier: &cc.TypeSpecifier{
· · · Case: 9,
· · · Token: example125.c:1:11: BOOL "_Bool",
· · },
· },
· Token: example125.c:1:17: ';',
}
Example (Case2) 
fmt.Println(exampleAST(126, "\U00100002 struct { _Static_assert ( 'a' , \"b\" ) ; }"))

Output:

&cc.StructDeclaration{
· Case: 2,
· StaticAssertDeclaration: &cc.StaticAssertDeclaration{
· · ConstantExpression: &cc.ConstantExpression{
· · · Type: int,
· · · Value: 97,
· · · Expression: &cc.Expression{
· · · · Type: int,
· · · · Value: 97,
· · · · Case: 1,
· · · · Token: example126.c:1:28: CHARCONST "'a'",
· · · },
· · },
· · Token: example126.c:1:11: STATIC_ASSERT "_Static_assert",
· · Token2: example126.c:1:26: '(',
· · Token3: example126.c:1:32: ',',
· · Token4: example126.c:1:34: STRINGLITERAL "\"b\"",
· · Token5: example126.c:1:38: ')',
· · Token6: example126.c:1:40: ';',
· },
}

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(122, "\U00100002 struct { _Bool ; }"))

Output:

&cc.StructDeclarationList{
· StructDeclaration: &cc.StructDeclaration{
· · Case: 1,
· · SpecifierQualifierList: &cc.SpecifierQualifierList{
· · · TypeSpecifier: &cc.TypeSpecifier{
· · · · Case: 9,
· · · · Token: example122.c:1:11: BOOL "_Bool",
· · · },
· · },
· · Token: example122.c:1:17: ';',
· },
}
Example (Case1) 
fmt.Println(exampleAST(123, "\U00100002 struct { _Bool ; _Bool ; }"))

Output:

&cc.StructDeclarationList{
· StructDeclaration: &cc.StructDeclaration{
· · Case: 1,
· · SpecifierQualifierList: &cc.SpecifierQualifierList{
· · · TypeSpecifier: &cc.TypeSpecifier{
· · · · Case: 9,
· · · · Token: example123.c:1:11: BOOL "_Bool",
· · · },
· · },
· · Token: example123.c:1:17: ';',
· },
· StructDeclarationList: &cc.StructDeclarationList{
· · Case: 1,
· · StructDeclaration: &cc.StructDeclaration{
· · · Case: 1,
· · · SpecifierQualifierList: &cc.SpecifierQualifierList{
· · · · TypeSpecifier: &cc.TypeSpecifier{
· · · · · Case: 9,
· · · · · Token: example123.c:1:19: BOOL "_Bool",
· · · · },
· · · },
· · · Token: example123.c:1:25: ';',
· · },
· },
}

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(133, "\U00100002 struct { _Bool a ,"))

Output:

&cc.StructDeclarator{
· Declarator: &cc.Declarator{
· · Linkage: None,
· · Type: bool,
· · DirectDeclarator: &cc.DirectDeclarator{
· · · Token: example133.c:1:17: IDENTIFIER "a",
· · },
· },
}
Example (Case1) 
fmt.Println(exampleAST(134, "\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: example134.c:1:19: CHARCONST "'a'",
· · },
· },
· Token: example134.c:1:17: ':',
}

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(131, "\U00100002 struct { _Bool a ,"))

Output:

&cc.StructDeclaratorList{
· StructDeclarator: &cc.StructDeclarator{
· · Declarator: &cc.Declarator{
· · · Linkage: None,
· · · Type: bool,
· · · DirectDeclarator: &cc.DirectDeclarator{
· · · · Token: example131.c:1:17: IDENTIFIER "a",
· · · },
· · },
· },
}
Example (Case1) 
fmt.Println(exampleAST(132, "\U00100002 struct { _Bool a , b ,"))

Output:

&cc.StructDeclaratorList{
· StructDeclarator: &cc.StructDeclarator{
· · Declarator: &cc.Declarator{
· · · Linkage: None,
· · · Type: bool,
· · · DirectDeclarator: &cc.DirectDeclarator{
· · · · Token: example132.c:1:17: IDENTIFIER "a",
· · · },
· · },
· },
· StructDeclaratorList: &cc.StructDeclaratorList{
· · Case: 1,
· · StructDeclarator: &cc.StructDeclarator{
· · · Declarator: &cc.Declarator{
· · · · Linkage: None,
· · · · Type: bool,
· · · · DirectDeclarator: &cc.DirectDeclarator{
· · · · · Token: example132.c:1:21: IDENTIFIER "b",
· · · · },
· · · },
· · },
· · Token: example132.c:1:19: ',',
· },
}

func (*StructDeclaratorList) Pos 

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

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

func (*StructDeclaratorList) String 

func (n *StructDeclaratorList) String() string

String implements fmt.Stringer.

type StructOrUnion 

type StructOrUnion struct {
	Case  int
	Token xc.Token
}

StructOrUnion represents data reduced by productions: 

StructOrUnion:
        "struct"
|       "union"   // Case 1
Example 
fmt.Println(exampleAST(120, "\U00100002 struct {"))

Output:

&cc.StructOrUnion{
· Token: example120.c:1:2: STRUCT "struct",
}
Example (Case1) 
fmt.Println(exampleAST(121, "\U00100002 union {"))

Output:

&cc.StructOrUnion{
· Case: 1,
· Token: example121.c:1:2: 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
|       StructOrUnion IdentifierOpt '{' '}'                        // Case 2
Example 
fmt.Println(exampleAST(117, "\U00100002 struct { int i; } ("))

Output:

&cc.StructOrUnionSpecifier{
· StructDeclarationList: &cc.StructDeclarationList{
· · StructDeclaration: &cc.StructDeclaration{
· · · SpecifierQualifierList: &cc.SpecifierQualifierList{
· · · · TypeSpecifier: &cc.TypeSpecifier{
· · · · · Case: 3,
· · · · · Token: example117.c:1:11: INT "int",
· · · · },
· · · },
· · · StructDeclaratorList: &cc.StructDeclaratorList{
· · · · StructDeclarator: &cc.StructDeclarator{
· · · · · Declarator: &cc.Declarator{
· · · · · · Linkage: None,
· · · · · · Type: int,
· · · · · · DirectDeclarator: &cc.DirectDeclarator{
· · · · · · · Token: example117.c:1:15: IDENTIFIER "i",
· · · · · · },
· · · · · },
· · · · },
· · · },
· · · Token: example117.c:1:16: ';',
· · },
· },
· StructOrUnion: &cc.StructOrUnion{
· · Token: example117.c:1:2: STRUCT "struct",
· },
· Token: example117.c:1:9: '{',
· Token2: example117.c:1:18: '}',
}
Example (Case1) 
fmt.Println(exampleAST(118, "\U00100002 struct a ("))

Output:

&cc.StructOrUnionSpecifier{
· Case: 1,
· StructOrUnion: &cc.StructOrUnion{
· · Token: example118.c:1:2: STRUCT "struct",
· },
· Token: example118.c:1:9: IDENTIFIER "a",
}
Example (Case2) 
fmt.Println(exampleAST(119, "\U00100002 struct { } ("))

Output:

&cc.StructOrUnionSpecifier{
· Case: 2,
· StructOrUnion: &cc.StructOrUnion{
· · Token: example119.c:1:2: STRUCT "struct",
· },
· Token: example119.c:1:9: '{',
· Token2: example119.c:1:11: '}',
}

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 {
	Comments            map[token.Pos]int // Position -> comment ID. Enable using the KeepComments option.
	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(245, "\U00100002 ;"))

Output:

&cc.TranslationUnit{
· ExternalDeclaration: &cc.ExternalDeclaration{
· · Case: 3,
· · Token: example245.c:1:2: ';',
· },
}
Example (Case1) 
fmt.Println(exampleAST(246, "\U00100002 ; ;"))

Output:

&cc.TranslationUnit{
· ExternalDeclaration: &cc.ExternalDeclaration{
· · Case: 3,
· · Token: example246.c:1:2: ';',
· },
· TranslationUnit: &cc.TranslationUnit{
· · Case: 1,
· · ExternalDeclaration: &cc.ExternalDeclaration{
· · · Case: 3,
· · · Token: example246.c:1:4: ';',
· · },
· },
}

func Parse 

func Parse(predefine string, paths []string, m *Model, opts ...Opt) (*TranslationUnit, error)

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

	// Bits returns the bit width of the type's value. For non integral
	// types the returned value will < 0.
	Bits() int

	// SetBits returns a type instance with the value Bits() will return
	// equal to n. SetBits panics for n < 0.
	SetBits(n int) Type

	// 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

	// RawDeclarator returns the typedef declarator associated with a type
	// if this type is a typedef name. Otherwise the normal declarator is
	// returned.
	RawDeclarator() *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
	// contains filtered or unexported methods
}

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(184, "\U00100001 ( _Bool )"))

Output:

&cc.TypeName{
· Type: bool,
· SpecifierQualifierList: &cc.SpecifierQualifierList{
· · TypeSpecifier: &cc.TypeSpecifier{
· · · Case: 9,
· · · Token: example184.c:1:4: BOOL "_Bool",
· · },
· },
}

func (*TypeName) Pos 

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

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

func (*TypeName) String 

func (n *TypeName) String() string

String implements fmt.Stringer.

type TypeQualifier 

type TypeQualifier struct {
	Case  int
	Token xc.Token
	// contains filtered or unexported fields
}

TypeQualifier represents data reduced by productions: 

TypeQualifier:
        "const"
|       "restrict"  // Case 1
|       "volatile"  // Case 2
Example 
fmt.Println(exampleAST(144, "\U00100002 const !"))

Output:

&cc.TypeQualifier{
· Token: example144.c:1:2: CONST "const",
}
Example (Case1) 
fmt.Println(exampleAST(145, "\U00100002 restrict !"))

Output:

&cc.TypeQualifier{
· Case: 1,
· Token: example145.c:1:2: RESTRICT "restrict",
}
Example (Case2) 
fmt.Println(exampleAST(146, "\U00100002 volatile !"))

Output:

&cc.TypeQualifier{
· Case: 2,
· Token: example146.c:1:2: 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(165, "\U00100002 * const !"))

Output:

&cc.TypeQualifierList{
· TypeQualifier: &cc.TypeQualifier{
· · Token: example165.c:1:4: CONST "const",
· },
}
Example (Case1) 
fmt.Println(exampleAST(166, "\U00100002 * const const !"))

Output:

&cc.TypeQualifierList{
· TypeQualifier: &cc.TypeQualifier{
· · Token: example166.c:1:4: CONST "const",
· },
· TypeQualifierList: &cc.TypeQualifierList{
· · Case: 1,
· · TypeQualifier: &cc.TypeQualifier{
· · · Token: example166.c:1:10: 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(167, "\U00100002 * (") == (*TypeQualifierListOpt)(nil))

Output:

true
Example (Case1) 
fmt.Println(exampleAST(168, "\U00100002 * const !"))

Output:

&cc.TypeQualifierListOpt{
· TypeQualifierList: &cc.TypeQualifierList{
· · TypeQualifier: &cc.TypeQualifier{
· · · Token: example168.c:1:4: 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(100, "\U00100002 void ("))

Output:

&cc.TypeSpecifier{
· Token: example100.c:1:2: VOID "void",
}
Example (Case01) 
fmt.Println(exampleAST(101, "\U00100002 char ("))

Output:

&cc.TypeSpecifier{
· Case: 1,
· Token: example101.c:1:2: CHAR "char",
}
Example (Case02) 
fmt.Println(exampleAST(102, "\U00100002 short ("))

Output:

&cc.TypeSpecifier{
· Case: 2,
· Token: example102.c:1:2: SHORT "short",
}
Example (Case03) 
fmt.Println(exampleAST(103, "\U00100002 int ("))

Output:

&cc.TypeSpecifier{
· Case: 3,
· Token: example103.c:1:2: INT "int",
}
Example (Case04) 
fmt.Println(exampleAST(104, "\U00100002 long ("))

Output:

&cc.TypeSpecifier{
· Case: 4,
· Token: example104.c:1:2: LONG "long",
}
Example (Case05) 
fmt.Println(exampleAST(105, "\U00100002 float ("))

Output:

&cc.TypeSpecifier{
· Case: 5,
· Token: example105.c:1:2: FLOAT "float",
}
Example (Case06) 
fmt.Println(exampleAST(106, "\U00100002 double ("))

Output:

&cc.TypeSpecifier{
· Case: 6,
· Token: example106.c:1:2: DOUBLE "double",
}
Example (Case07) 
fmt.Println(exampleAST(107, "\U00100002 signed ("))

Output:

&cc.TypeSpecifier{
· Case: 7,
· Token: example107.c:1:2: SIGNED "signed",
}
Example (Case08) 
fmt.Println(exampleAST(108, "\U00100002 unsigned ("))

Output:

&cc.TypeSpecifier{
· Case: 8,
· Token: example108.c:1:2: UNSIGNED "unsigned",
}
Example (Case09) 
fmt.Println(exampleAST(109, "\U00100002 _Bool ("))

Output:

&cc.TypeSpecifier{
· Case: 9,
· Token: example109.c:1:2: BOOL "_Bool",
}
Example (Case10) 
fmt.Println(exampleAST(110, "\U00100002 _Complex ("))

Output:

&cc.TypeSpecifier{
· Case: 10,
· Token: example110.c:1:2: COMPLEX "_Complex",
}
Example (Case11) 
fmt.Println(exampleAST(111, "\U00100002 struct a ("))

Output:

&cc.TypeSpecifier{
· Case: 11,
· StructOrUnionSpecifier: &cc.StructOrUnionSpecifier{
· · Case: 1,
· · StructOrUnion: &cc.StructOrUnion{
· · · Token: example111.c:1:2: STRUCT "struct",
· · },
· · Token: example111.c:1:9: IDENTIFIER "a",
· },
}
Example (Case12) 
fmt.Println(exampleAST(112, "\U00100002 enum a ("))

Output:

&cc.TypeSpecifier{
· Case: 12,
· EnumSpecifier: &cc.EnumSpecifier{
· · Case: 1,
· · Token: example112.c:1:2: ENUM "enum",
· · Token2: example112.c:1:7: IDENTIFIER "a",
· },
}
Example (Case13) 
fmt.Println(exampleAST(113, "\U00100002 typedef int i; i j;"))

Output:

&cc.TypeSpecifier{
· Case: 13,
· Token: example113.c:1:17: TYPEDEFNAME "i",
}
Example (Case14) 
fmt.Println(exampleAST(114, "\U00100002 typeof ( 'a' ) ("))

Output:

&cc.TypeSpecifier{
· Type: int,
· Case: 14,
· Expression: &cc.Expression{
· · Type: int,
· · Value: 97,
· · Case: 1,
· · Token: example114.c:1:11: CHARCONST "'a'",
· },
· Token: example114.c:1:2: TYPEOF "typeof",
· Token2: example114.c:1:9: '(',
· Token3: example114.c:1:15: ')',
}
Example (Case15) 
fmt.Println(exampleAST(115, "\U00100002 typeof ( _Bool ) ("))

Output:

&cc.TypeSpecifier{
· Type: bool,
· Case: 15,
· Token: example115.c:1:2: TYPEOF "typeof",
· Token2: example115.c:1:9: '(',
· Token3: example115.c:1:17: ')',
· TypeName: &cc.TypeName{
· · Type: bool,
· · SpecifierQualifierList: &cc.SpecifierQualifierList{
· · · TypeSpecifier: &cc.TypeSpecifier{
· · · · Case: 9,
· · · · Token: example115.c:1:11: 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.

type VolatileOpt 

type VolatileOpt struct {
	Token xc.Token
}

VolatileOpt represents data reduced by productions: 

VolatileOpt:
        /* empty */
|       "volatile"   // Case 1
Example 
fmt.Println(exampleAST(268, "\U00100002 asm (") == (*VolatileOpt)(nil))

Output:

true
Example (Case1) 
fmt.Println(exampleAST(269, "\U00100002 asm volatile ("))

Output:

&cc.VolatileOpt{
· Token: example269.c:1:6: VOLATILE "volatile",
}

func (*VolatileOpt) Pos 

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

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

func (*VolatileOpt) String 

func (n *VolatileOpt) String() string

String implements fmt.Stringer.

Source Files

View all Source files

Directories

Path Synopsis
Package cc is a C99 compiler front end.
 Package cc is a C99 compiler front end.

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.