mirror of
https://github.com/cwinfo/matterbridge.git
synced 2024-12-28 03:15:39 +00:00
5233 lines
135 KiB
Go
5233 lines
135 KiB
Go
// Code generated by yy. DO NOT EDIT.
|
|
|
|
// Copyright 2019 The CC Authors. All rights reserved.
|
|
// Use of this source code is governed by a BSD-style
|
|
// license that can be found in the LICENSE file.
|
|
|
|
package cc
|
|
|
|
import (
|
|
"fmt"
|
|
|
|
"modernc.org/token"
|
|
)
|
|
|
|
// AbstractDeclaratorCase represents case numbers of production AbstractDeclarator
|
|
type AbstractDeclaratorCase int
|
|
|
|
// Values of type AbstractDeclaratorCase
|
|
const (
|
|
AbstractDeclaratorPtr AbstractDeclaratorCase = iota
|
|
AbstractDeclaratorDecl
|
|
)
|
|
|
|
// String implements fmt.Stringer
|
|
func (n AbstractDeclaratorCase) String() string {
|
|
switch n {
|
|
case AbstractDeclaratorPtr:
|
|
return "AbstractDeclaratorPtr"
|
|
case AbstractDeclaratorDecl:
|
|
return "AbstractDeclaratorDecl"
|
|
default:
|
|
return fmt.Sprintf("AbstractDeclaratorCase(%v)", int(n))
|
|
}
|
|
}
|
|
|
|
// AbstractDeclarator represents data reduced by productions:
|
|
//
|
|
// AbstractDeclarator:
|
|
// Pointer // Case AbstractDeclaratorPtr
|
|
// | Pointer DirectAbstractDeclarator // Case AbstractDeclaratorDecl
|
|
type AbstractDeclarator struct {
|
|
typ Type
|
|
Case AbstractDeclaratorCase `PrettyPrint:"stringer,zero"`
|
|
DirectAbstractDeclarator *DirectAbstractDeclarator
|
|
Pointer *Pointer
|
|
}
|
|
|
|
// String implements fmt.Stringer.
|
|
func (n *AbstractDeclarator) String() string { return PrettyString(n) }
|
|
|
|
// Position reports the position of the first component of n, if available.
|
|
func (n *AbstractDeclarator) Position() (r token.Position) {
|
|
if n == nil {
|
|
return r
|
|
}
|
|
|
|
switch n.Case {
|
|
case 0:
|
|
return n.Pointer.Position()
|
|
case 1:
|
|
if p := n.Pointer.Position(); p.IsValid() {
|
|
return p
|
|
}
|
|
|
|
return n.DirectAbstractDeclarator.Position()
|
|
default:
|
|
panic("internal error")
|
|
}
|
|
}
|
|
|
|
// AdditiveExpressionCase represents case numbers of production AdditiveExpression
|
|
type AdditiveExpressionCase int
|
|
|
|
// Values of type AdditiveExpressionCase
|
|
const (
|
|
AdditiveExpressionMul AdditiveExpressionCase = iota
|
|
AdditiveExpressionAdd
|
|
AdditiveExpressionSub
|
|
)
|
|
|
|
// String implements fmt.Stringer
|
|
func (n AdditiveExpressionCase) String() string {
|
|
switch n {
|
|
case AdditiveExpressionMul:
|
|
return "AdditiveExpressionMul"
|
|
case AdditiveExpressionAdd:
|
|
return "AdditiveExpressionAdd"
|
|
case AdditiveExpressionSub:
|
|
return "AdditiveExpressionSub"
|
|
default:
|
|
return fmt.Sprintf("AdditiveExpressionCase(%v)", int(n))
|
|
}
|
|
}
|
|
|
|
// AdditiveExpression represents data reduced by productions:
|
|
//
|
|
// AdditiveExpression:
|
|
// MultiplicativeExpression // Case AdditiveExpressionMul
|
|
// | AdditiveExpression '+' MultiplicativeExpression // Case AdditiveExpressionAdd
|
|
// | AdditiveExpression '-' MultiplicativeExpression // Case AdditiveExpressionSub
|
|
type AdditiveExpression struct {
|
|
lexicalScope Scope
|
|
Operand Operand
|
|
promote Type
|
|
IsSideEffectsFree bool
|
|
AdditiveExpression *AdditiveExpression
|
|
Case AdditiveExpressionCase `PrettyPrint:"stringer,zero"`
|
|
MultiplicativeExpression *MultiplicativeExpression
|
|
Token Token
|
|
}
|
|
|
|
// String implements fmt.Stringer.
|
|
func (n *AdditiveExpression) String() string { return PrettyString(n) }
|
|
|
|
// Position reports the position of the first component of n, if available.
|
|
func (n *AdditiveExpression) Position() (r token.Position) {
|
|
if n == nil {
|
|
return r
|
|
}
|
|
|
|
switch n.Case {
|
|
case 1, 2:
|
|
if p := n.AdditiveExpression.Position(); p.IsValid() {
|
|
return p
|
|
}
|
|
|
|
if p := n.Token.Position(); p.IsValid() {
|
|
return p
|
|
}
|
|
|
|
return n.MultiplicativeExpression.Position()
|
|
case 0:
|
|
return n.MultiplicativeExpression.Position()
|
|
default:
|
|
panic("internal error")
|
|
}
|
|
}
|
|
|
|
// AlignmentSpecifierCase represents case numbers of production AlignmentSpecifier
|
|
type AlignmentSpecifierCase int
|
|
|
|
// Values of type AlignmentSpecifierCase
|
|
const (
|
|
AlignmentSpecifierAlignasType AlignmentSpecifierCase = iota
|
|
AlignmentSpecifierAlignasExpr
|
|
)
|
|
|
|
// String implements fmt.Stringer
|
|
func (n AlignmentSpecifierCase) String() string {
|
|
switch n {
|
|
case AlignmentSpecifierAlignasType:
|
|
return "AlignmentSpecifierAlignasType"
|
|
case AlignmentSpecifierAlignasExpr:
|
|
return "AlignmentSpecifierAlignasExpr"
|
|
default:
|
|
return fmt.Sprintf("AlignmentSpecifierCase(%v)", int(n))
|
|
}
|
|
}
|
|
|
|
// AlignmentSpecifier represents data reduced by productions:
|
|
//
|
|
// AlignmentSpecifier:
|
|
// "_Alignas" '(' TypeName ')' // Case AlignmentSpecifierAlignasType
|
|
// | "_Alignas" '(' ConstantExpression ')' // Case AlignmentSpecifierAlignasExpr
|
|
type AlignmentSpecifier struct {
|
|
Case AlignmentSpecifierCase `PrettyPrint:"stringer,zero"`
|
|
ConstantExpression *ConstantExpression
|
|
Token Token
|
|
Token2 Token
|
|
Token3 Token
|
|
TypeName *TypeName
|
|
}
|
|
|
|
// String implements fmt.Stringer.
|
|
func (n *AlignmentSpecifier) String() string { return PrettyString(n) }
|
|
|
|
// Position reports the position of the first component of n, if available.
|
|
func (n *AlignmentSpecifier) Position() (r token.Position) {
|
|
if n == nil {
|
|
return r
|
|
}
|
|
|
|
switch n.Case {
|
|
case 1:
|
|
if p := n.Token.Position(); p.IsValid() {
|
|
return p
|
|
}
|
|
|
|
if p := n.Token2.Position(); p.IsValid() {
|
|
return p
|
|
}
|
|
|
|
if p := n.ConstantExpression.Position(); p.IsValid() {
|
|
return p
|
|
}
|
|
|
|
return n.Token3.Position()
|
|
case 0:
|
|
if p := n.Token.Position(); p.IsValid() {
|
|
return p
|
|
}
|
|
|
|
if p := n.Token2.Position(); p.IsValid() {
|
|
return p
|
|
}
|
|
|
|
if p := n.TypeName.Position(); p.IsValid() {
|
|
return p
|
|
}
|
|
|
|
return n.Token3.Position()
|
|
default:
|
|
panic("internal error")
|
|
}
|
|
}
|
|
|
|
// AndExpressionCase represents case numbers of production AndExpression
|
|
type AndExpressionCase int
|
|
|
|
// Values of type AndExpressionCase
|
|
const (
|
|
AndExpressionEq AndExpressionCase = iota
|
|
AndExpressionAnd
|
|
)
|
|
|
|
// String implements fmt.Stringer
|
|
func (n AndExpressionCase) String() string {
|
|
switch n {
|
|
case AndExpressionEq:
|
|
return "AndExpressionEq"
|
|
case AndExpressionAnd:
|
|
return "AndExpressionAnd"
|
|
default:
|
|
return fmt.Sprintf("AndExpressionCase(%v)", int(n))
|
|
}
|
|
}
|
|
|
|
// AndExpression represents data reduced by productions:
|
|
//
|
|
// AndExpression:
|
|
// EqualityExpression // Case AndExpressionEq
|
|
// | AndExpression '&' EqualityExpression // Case AndExpressionAnd
|
|
type AndExpression struct {
|
|
Operand Operand
|
|
promote Type
|
|
IsSideEffectsFree bool
|
|
AndExpression *AndExpression
|
|
Case AndExpressionCase `PrettyPrint:"stringer,zero"`
|
|
EqualityExpression *EqualityExpression
|
|
Token Token
|
|
}
|
|
|
|
// String implements fmt.Stringer.
|
|
func (n *AndExpression) String() string { return PrettyString(n) }
|
|
|
|
// Position reports the position of the first component of n, if available.
|
|
func (n *AndExpression) Position() (r token.Position) {
|
|
if n == nil {
|
|
return r
|
|
}
|
|
|
|
switch n.Case {
|
|
case 1:
|
|
if p := n.AndExpression.Position(); p.IsValid() {
|
|
return p
|
|
}
|
|
|
|
if p := n.Token.Position(); p.IsValid() {
|
|
return p
|
|
}
|
|
|
|
return n.EqualityExpression.Position()
|
|
case 0:
|
|
return n.EqualityExpression.Position()
|
|
default:
|
|
panic("internal error")
|
|
}
|
|
}
|
|
|
|
// ArgumentExpressionList represents data reduced by productions:
|
|
//
|
|
// ArgumentExpressionList:
|
|
// AssignmentExpression
|
|
// | ArgumentExpressionList ',' AssignmentExpression
|
|
type ArgumentExpressionList struct {
|
|
ArgumentExpressionList *ArgumentExpressionList
|
|
AssignmentExpression *AssignmentExpression
|
|
Token Token
|
|
}
|
|
|
|
// String implements fmt.Stringer.
|
|
func (n *ArgumentExpressionList) String() string { return PrettyString(n) }
|
|
|
|
// Position reports the position of the first component of n, if available.
|
|
func (n *ArgumentExpressionList) Position() (r token.Position) {
|
|
if n == nil {
|
|
return r
|
|
}
|
|
|
|
return n.AssignmentExpression.Position()
|
|
}
|
|
|
|
// Asm represents data reduced by production:
|
|
//
|
|
// Asm:
|
|
// "__asm__" AsmQualifierList '(' STRINGLITERAL AsmArgList ')'
|
|
type Asm struct {
|
|
AsmArgList *AsmArgList
|
|
AsmQualifierList *AsmQualifierList
|
|
Token Token
|
|
Token2 Token
|
|
Token3 Token
|
|
Token4 Token
|
|
}
|
|
|
|
// String implements fmt.Stringer.
|
|
func (n *Asm) String() string { return PrettyString(n) }
|
|
|
|
// Position reports the position of the first component of n, if available.
|
|
func (n *Asm) Position() (r token.Position) {
|
|
if n == nil {
|
|
return r
|
|
}
|
|
|
|
if p := n.Token.Position(); p.IsValid() {
|
|
return p
|
|
}
|
|
|
|
if p := n.AsmQualifierList.Position(); p.IsValid() {
|
|
return p
|
|
}
|
|
|
|
if p := n.Token2.Position(); p.IsValid() {
|
|
return p
|
|
}
|
|
|
|
if p := n.Token3.Position(); p.IsValid() {
|
|
return p
|
|
}
|
|
|
|
if p := n.AsmArgList.Position(); p.IsValid() {
|
|
return p
|
|
}
|
|
|
|
return n.Token4.Position()
|
|
}
|
|
|
|
// AsmArgList represents data reduced by productions:
|
|
//
|
|
// AsmArgList:
|
|
// ':' AsmExpressionList
|
|
// | AsmArgList ':' AsmExpressionList
|
|
type AsmArgList struct {
|
|
AsmArgList *AsmArgList
|
|
AsmExpressionList *AsmExpressionList
|
|
Token Token
|
|
}
|
|
|
|
// String implements fmt.Stringer.
|
|
func (n *AsmArgList) String() string { return PrettyString(n) }
|
|
|
|
// Position reports the position of the first component of n, if available.
|
|
func (n *AsmArgList) Position() (r token.Position) {
|
|
if n == nil {
|
|
return r
|
|
}
|
|
|
|
if p := n.Token.Position(); p.IsValid() {
|
|
return p
|
|
}
|
|
|
|
return n.AsmExpressionList.Position()
|
|
}
|
|
|
|
// AsmExpressionList represents data reduced by productions:
|
|
//
|
|
// AsmExpressionList:
|
|
// AsmIndex AssignmentExpression
|
|
// | AsmExpressionList ',' AsmIndex AssignmentExpression
|
|
type AsmExpressionList struct {
|
|
AsmExpressionList *AsmExpressionList
|
|
AsmIndex *AsmIndex
|
|
AssignmentExpression *AssignmentExpression
|
|
Token Token
|
|
}
|
|
|
|
// String implements fmt.Stringer.
|
|
func (n *AsmExpressionList) String() string { return PrettyString(n) }
|
|
|
|
// Position reports the position of the first component of n, if available.
|
|
func (n *AsmExpressionList) Position() (r token.Position) {
|
|
if n == nil {
|
|
return r
|
|
}
|
|
|
|
if p := n.AsmIndex.Position(); p.IsValid() {
|
|
return p
|
|
}
|
|
|
|
return n.AssignmentExpression.Position()
|
|
}
|
|
|
|
// AsmFunctionDefinition represents data reduced by production:
|
|
//
|
|
// AsmFunctionDefinition:
|
|
// DeclarationSpecifiers Declarator AsmStatement
|
|
type AsmFunctionDefinition struct {
|
|
AsmStatement *AsmStatement
|
|
DeclarationSpecifiers *DeclarationSpecifiers
|
|
Declarator *Declarator
|
|
}
|
|
|
|
// String implements fmt.Stringer.
|
|
func (n *AsmFunctionDefinition) String() string { return PrettyString(n) }
|
|
|
|
// Position reports the position of the first component of n, if available.
|
|
func (n *AsmFunctionDefinition) Position() (r token.Position) {
|
|
if n == nil {
|
|
return r
|
|
}
|
|
|
|
if p := n.DeclarationSpecifiers.Position(); p.IsValid() {
|
|
return p
|
|
}
|
|
|
|
if p := n.Declarator.Position(); p.IsValid() {
|
|
return p
|
|
}
|
|
|
|
return n.AsmStatement.Position()
|
|
}
|
|
|
|
// AsmIndex represents data reduced by production:
|
|
//
|
|
// AsmIndex:
|
|
// '[' Expression ']'
|
|
type AsmIndex struct {
|
|
Expression *Expression
|
|
Token Token
|
|
Token2 Token
|
|
}
|
|
|
|
// String implements fmt.Stringer.
|
|
func (n *AsmIndex) String() string { return PrettyString(n) }
|
|
|
|
// Position reports the position of the first component of n, if available.
|
|
func (n *AsmIndex) Position() (r token.Position) {
|
|
if n == nil {
|
|
return r
|
|
}
|
|
|
|
if p := n.Token.Position(); p.IsValid() {
|
|
return p
|
|
}
|
|
|
|
if p := n.Expression.Position(); p.IsValid() {
|
|
return p
|
|
}
|
|
|
|
return n.Token2.Position()
|
|
}
|
|
|
|
// AsmQualifierCase represents case numbers of production AsmQualifier
|
|
type AsmQualifierCase int
|
|
|
|
// Values of type AsmQualifierCase
|
|
const (
|
|
AsmQualifierVolatile AsmQualifierCase = iota
|
|
AsmQualifierInline
|
|
AsmQualifierGoto
|
|
)
|
|
|
|
// String implements fmt.Stringer
|
|
func (n AsmQualifierCase) String() string {
|
|
switch n {
|
|
case AsmQualifierVolatile:
|
|
return "AsmQualifierVolatile"
|
|
case AsmQualifierInline:
|
|
return "AsmQualifierInline"
|
|
case AsmQualifierGoto:
|
|
return "AsmQualifierGoto"
|
|
default:
|
|
return fmt.Sprintf("AsmQualifierCase(%v)", int(n))
|
|
}
|
|
}
|
|
|
|
// AsmQualifier represents data reduced by productions:
|
|
//
|
|
// AsmQualifier:
|
|
// "volatile" // Case AsmQualifierVolatile
|
|
// | "inline" // Case AsmQualifierInline
|
|
// | "goto" // Case AsmQualifierGoto
|
|
type AsmQualifier struct {
|
|
Case AsmQualifierCase `PrettyPrint:"stringer,zero"`
|
|
Token Token
|
|
}
|
|
|
|
// String implements fmt.Stringer.
|
|
func (n *AsmQualifier) String() string { return PrettyString(n) }
|
|
|
|
// Position reports the position of the first component of n, if available.
|
|
func (n *AsmQualifier) Position() (r token.Position) {
|
|
if n == nil {
|
|
return r
|
|
}
|
|
|
|
return n.Token.Position()
|
|
}
|
|
|
|
// AsmQualifierList represents data reduced by productions:
|
|
//
|
|
// AsmQualifierList:
|
|
// AsmQualifier
|
|
// | AsmQualifierList AsmQualifier
|
|
type AsmQualifierList struct {
|
|
AsmQualifier *AsmQualifier
|
|
AsmQualifierList *AsmQualifierList
|
|
}
|
|
|
|
// String implements fmt.Stringer.
|
|
func (n *AsmQualifierList) String() string { return PrettyString(n) }
|
|
|
|
// Position reports the position of the first component of n, if available.
|
|
func (n *AsmQualifierList) Position() (r token.Position) {
|
|
if n == nil {
|
|
return r
|
|
}
|
|
|
|
return n.AsmQualifier.Position()
|
|
}
|
|
|
|
// AsmStatement represents data reduced by production:
|
|
//
|
|
// AsmStatement:
|
|
// Asm AttributeSpecifierList ';'
|
|
type AsmStatement struct {
|
|
Asm *Asm
|
|
AttributeSpecifierList *AttributeSpecifierList
|
|
Token Token
|
|
}
|
|
|
|
// String implements fmt.Stringer.
|
|
func (n *AsmStatement) String() string { return PrettyString(n) }
|
|
|
|
// Position reports the position of the first component of n, if available.
|
|
func (n *AsmStatement) Position() (r token.Position) {
|
|
if n == nil {
|
|
return r
|
|
}
|
|
|
|
if p := n.Asm.Position(); p.IsValid() {
|
|
return p
|
|
}
|
|
|
|
if p := n.AttributeSpecifierList.Position(); p.IsValid() {
|
|
return p
|
|
}
|
|
|
|
return n.Token.Position()
|
|
}
|
|
|
|
// AssignmentExpressionCase represents case numbers of production AssignmentExpression
|
|
type AssignmentExpressionCase int
|
|
|
|
// Values of type AssignmentExpressionCase
|
|
const (
|
|
AssignmentExpressionCond AssignmentExpressionCase = iota
|
|
AssignmentExpressionAssign
|
|
AssignmentExpressionMul
|
|
AssignmentExpressionDiv
|
|
AssignmentExpressionMod
|
|
AssignmentExpressionAdd
|
|
AssignmentExpressionSub
|
|
AssignmentExpressionLsh
|
|
AssignmentExpressionRsh
|
|
AssignmentExpressionAnd
|
|
AssignmentExpressionXor
|
|
AssignmentExpressionOr
|
|
)
|
|
|
|
// String implements fmt.Stringer
|
|
func (n AssignmentExpressionCase) String() string {
|
|
switch n {
|
|
case AssignmentExpressionCond:
|
|
return "AssignmentExpressionCond"
|
|
case AssignmentExpressionAssign:
|
|
return "AssignmentExpressionAssign"
|
|
case AssignmentExpressionMul:
|
|
return "AssignmentExpressionMul"
|
|
case AssignmentExpressionDiv:
|
|
return "AssignmentExpressionDiv"
|
|
case AssignmentExpressionMod:
|
|
return "AssignmentExpressionMod"
|
|
case AssignmentExpressionAdd:
|
|
return "AssignmentExpressionAdd"
|
|
case AssignmentExpressionSub:
|
|
return "AssignmentExpressionSub"
|
|
case AssignmentExpressionLsh:
|
|
return "AssignmentExpressionLsh"
|
|
case AssignmentExpressionRsh:
|
|
return "AssignmentExpressionRsh"
|
|
case AssignmentExpressionAnd:
|
|
return "AssignmentExpressionAnd"
|
|
case AssignmentExpressionXor:
|
|
return "AssignmentExpressionXor"
|
|
case AssignmentExpressionOr:
|
|
return "AssignmentExpressionOr"
|
|
default:
|
|
return fmt.Sprintf("AssignmentExpressionCase(%v)", int(n))
|
|
}
|
|
}
|
|
|
|
// AssignmentExpression represents data reduced by productions:
|
|
//
|
|
// AssignmentExpression:
|
|
// ConditionalExpression // Case AssignmentExpressionCond
|
|
// | UnaryExpression '=' AssignmentExpression // Case AssignmentExpressionAssign
|
|
// | UnaryExpression "*=" AssignmentExpression // Case AssignmentExpressionMul
|
|
// | UnaryExpression "/=" AssignmentExpression // Case AssignmentExpressionDiv
|
|
// | UnaryExpression "%=" AssignmentExpression // Case AssignmentExpressionMod
|
|
// | UnaryExpression "+=" AssignmentExpression // Case AssignmentExpressionAdd
|
|
// | UnaryExpression "-=" AssignmentExpression // Case AssignmentExpressionSub
|
|
// | UnaryExpression "<<=" AssignmentExpression // Case AssignmentExpressionLsh
|
|
// | UnaryExpression ">>=" AssignmentExpression // Case AssignmentExpressionRsh
|
|
// | UnaryExpression "&=" AssignmentExpression // Case AssignmentExpressionAnd
|
|
// | UnaryExpression "^=" AssignmentExpression // Case AssignmentExpressionXor
|
|
// | UnaryExpression "|=" AssignmentExpression // Case AssignmentExpressionOr
|
|
type AssignmentExpression struct {
|
|
Operand Operand
|
|
InitializerOperand Operand // When the expression is used in an initializer
|
|
lexicalScope Scope
|
|
promote Type
|
|
IsSideEffectsFree bool
|
|
AssignmentExpression *AssignmentExpression
|
|
Case AssignmentExpressionCase `PrettyPrint:"stringer,zero"`
|
|
ConditionalExpression *ConditionalExpression
|
|
Token Token
|
|
UnaryExpression *UnaryExpression
|
|
}
|
|
|
|
// String implements fmt.Stringer.
|
|
func (n *AssignmentExpression) String() string { return PrettyString(n) }
|
|
|
|
// Position reports the position of the first component of n, if available.
|
|
func (n *AssignmentExpression) Position() (r token.Position) {
|
|
if n == nil {
|
|
return r
|
|
}
|
|
|
|
switch n.Case {
|
|
case 0:
|
|
return n.ConditionalExpression.Position()
|
|
case 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11:
|
|
if p := n.UnaryExpression.Position(); p.IsValid() {
|
|
return p
|
|
}
|
|
|
|
if p := n.Token.Position(); p.IsValid() {
|
|
return p
|
|
}
|
|
|
|
return n.AssignmentExpression.Position()
|
|
default:
|
|
panic("internal error")
|
|
}
|
|
}
|
|
|
|
// AtomicTypeSpecifier represents data reduced by production:
|
|
//
|
|
// AtomicTypeSpecifier:
|
|
// "_Atomic" '(' TypeName ')'
|
|
type AtomicTypeSpecifier struct {
|
|
list []*TypeSpecifier
|
|
Token Token
|
|
Token2 Token
|
|
Token3 Token
|
|
TypeName *TypeName
|
|
}
|
|
|
|
// String implements fmt.Stringer.
|
|
func (n *AtomicTypeSpecifier) String() string { return PrettyString(n) }
|
|
|
|
// Position reports the position of the first component of n, if available.
|
|
func (n *AtomicTypeSpecifier) Position() (r token.Position) {
|
|
if n == nil {
|
|
return r
|
|
}
|
|
|
|
if p := n.Token.Position(); p.IsValid() {
|
|
return p
|
|
}
|
|
|
|
if p := n.Token2.Position(); p.IsValid() {
|
|
return p
|
|
}
|
|
|
|
if p := n.TypeName.Position(); p.IsValid() {
|
|
return p
|
|
}
|
|
|
|
return n.Token3.Position()
|
|
}
|
|
|
|
// AttributeSpecifier represents data reduced by production:
|
|
//
|
|
// AttributeSpecifier:
|
|
// "__attribute__" '(' '(' AttributeValueList ')' ')'
|
|
type AttributeSpecifier struct {
|
|
AttributeValueList *AttributeValueList
|
|
Token Token
|
|
Token2 Token
|
|
Token3 Token
|
|
Token4 Token
|
|
Token5 Token
|
|
}
|
|
|
|
// String implements fmt.Stringer.
|
|
func (n *AttributeSpecifier) String() string { return PrettyString(n) }
|
|
|
|
// Position reports the position of the first component of n, if available.
|
|
func (n *AttributeSpecifier) Position() (r token.Position) {
|
|
if n == nil {
|
|
return r
|
|
}
|
|
|
|
if p := n.Token.Position(); p.IsValid() {
|
|
return p
|
|
}
|
|
|
|
if p := n.Token2.Position(); p.IsValid() {
|
|
return p
|
|
}
|
|
|
|
if p := n.Token3.Position(); p.IsValid() {
|
|
return p
|
|
}
|
|
|
|
if p := n.AttributeValueList.Position(); p.IsValid() {
|
|
return p
|
|
}
|
|
|
|
if p := n.Token4.Position(); p.IsValid() {
|
|
return p
|
|
}
|
|
|
|
return n.Token5.Position()
|
|
}
|
|
|
|
// AttributeSpecifierList represents data reduced by productions:
|
|
//
|
|
// AttributeSpecifierList:
|
|
// AttributeSpecifier
|
|
// | AttributeSpecifierList AttributeSpecifier
|
|
type AttributeSpecifierList struct {
|
|
AttributeSpecifier *AttributeSpecifier
|
|
AttributeSpecifierList *AttributeSpecifierList
|
|
}
|
|
|
|
// String implements fmt.Stringer.
|
|
func (n *AttributeSpecifierList) String() string { return PrettyString(n) }
|
|
|
|
// Position reports the position of the first component of n, if available.
|
|
func (n *AttributeSpecifierList) Position() (r token.Position) {
|
|
if n == nil {
|
|
return r
|
|
}
|
|
|
|
return n.AttributeSpecifier.Position()
|
|
}
|
|
|
|
// AttributeValueCase represents case numbers of production AttributeValue
|
|
type AttributeValueCase int
|
|
|
|
// Values of type AttributeValueCase
|
|
const (
|
|
AttributeValueIdent AttributeValueCase = iota
|
|
AttributeValueExpr
|
|
)
|
|
|
|
// String implements fmt.Stringer
|
|
func (n AttributeValueCase) String() string {
|
|
switch n {
|
|
case AttributeValueIdent:
|
|
return "AttributeValueIdent"
|
|
case AttributeValueExpr:
|
|
return "AttributeValueExpr"
|
|
default:
|
|
return fmt.Sprintf("AttributeValueCase(%v)", int(n))
|
|
}
|
|
}
|
|
|
|
// AttributeValue represents data reduced by productions:
|
|
//
|
|
// AttributeValue:
|
|
// IDENTIFIER // Case AttributeValueIdent
|
|
// | IDENTIFIER '(' ExpressionList ')' // Case AttributeValueExpr
|
|
type AttributeValue struct {
|
|
lexicalScope Scope
|
|
Case AttributeValueCase `PrettyPrint:"stringer,zero"`
|
|
ExpressionList *ExpressionList
|
|
Token Token
|
|
Token2 Token
|
|
Token3 Token
|
|
}
|
|
|
|
// String implements fmt.Stringer.
|
|
func (n *AttributeValue) String() string { return PrettyString(n) }
|
|
|
|
// Position reports the position of the first component of n, if available.
|
|
func (n *AttributeValue) Position() (r token.Position) {
|
|
if n == nil {
|
|
return r
|
|
}
|
|
|
|
switch n.Case {
|
|
case 0:
|
|
return n.Token.Position()
|
|
case 1:
|
|
if p := n.Token.Position(); p.IsValid() {
|
|
return p
|
|
}
|
|
|
|
if p := n.Token2.Position(); p.IsValid() {
|
|
return p
|
|
}
|
|
|
|
if p := n.ExpressionList.Position(); p.IsValid() {
|
|
return p
|
|
}
|
|
|
|
return n.Token3.Position()
|
|
default:
|
|
panic("internal error")
|
|
}
|
|
}
|
|
|
|
// AttributeValueList represents data reduced by productions:
|
|
//
|
|
// AttributeValueList:
|
|
// AttributeValue
|
|
// | AttributeValueList ',' AttributeValue
|
|
type AttributeValueList struct {
|
|
AttributeValue *AttributeValue
|
|
AttributeValueList *AttributeValueList
|
|
Token Token
|
|
}
|
|
|
|
// String implements fmt.Stringer.
|
|
func (n *AttributeValueList) String() string { return PrettyString(n) }
|
|
|
|
// Position reports the position of the first component of n, if available.
|
|
func (n *AttributeValueList) Position() (r token.Position) {
|
|
if n == nil {
|
|
return r
|
|
}
|
|
|
|
return n.AttributeValue.Position()
|
|
}
|
|
|
|
// BlockItemCase represents case numbers of production BlockItem
|
|
type BlockItemCase int
|
|
|
|
// Values of type BlockItemCase
|
|
const (
|
|
BlockItemDecl BlockItemCase = iota
|
|
BlockItemStmt
|
|
BlockItemLabel
|
|
BlockItemFuncDef
|
|
BlockItemPragma
|
|
)
|
|
|
|
// String implements fmt.Stringer
|
|
func (n BlockItemCase) String() string {
|
|
switch n {
|
|
case BlockItemDecl:
|
|
return "BlockItemDecl"
|
|
case BlockItemStmt:
|
|
return "BlockItemStmt"
|
|
case BlockItemLabel:
|
|
return "BlockItemLabel"
|
|
case BlockItemFuncDef:
|
|
return "BlockItemFuncDef"
|
|
case BlockItemPragma:
|
|
return "BlockItemPragma"
|
|
default:
|
|
return fmt.Sprintf("BlockItemCase(%v)", int(n))
|
|
}
|
|
}
|
|
|
|
// BlockItem represents data reduced by productions:
|
|
//
|
|
// BlockItem:
|
|
// Declaration // Case BlockItemDecl
|
|
// | Statement // Case BlockItemStmt
|
|
// | LabelDeclaration // Case BlockItemLabel
|
|
// | DeclarationSpecifiers Declarator CompoundStatement // Case BlockItemFuncDef
|
|
// | PragmaSTDC // Case BlockItemPragma
|
|
type BlockItem struct {
|
|
fn *FunctionDefinition // Case FuncDef
|
|
closure map[StringID]struct{} // Case FuncDef
|
|
Last bool
|
|
Case BlockItemCase `PrettyPrint:"stringer,zero"`
|
|
CompoundStatement *CompoundStatement
|
|
Declaration *Declaration
|
|
DeclarationSpecifiers *DeclarationSpecifiers
|
|
Declarator *Declarator
|
|
LabelDeclaration *LabelDeclaration
|
|
PragmaSTDC *PragmaSTDC
|
|
Statement *Statement
|
|
}
|
|
|
|
// String implements fmt.Stringer.
|
|
func (n *BlockItem) String() string { return PrettyString(n) }
|
|
|
|
// Position reports the position of the first component of n, if available.
|
|
func (n *BlockItem) Position() (r token.Position) {
|
|
if n == nil {
|
|
return r
|
|
}
|
|
|
|
switch n.Case {
|
|
case 0:
|
|
return n.Declaration.Position()
|
|
case 3:
|
|
if p := n.DeclarationSpecifiers.Position(); p.IsValid() {
|
|
return p
|
|
}
|
|
|
|
if p := n.Declarator.Position(); p.IsValid() {
|
|
return p
|
|
}
|
|
|
|
return n.CompoundStatement.Position()
|
|
case 2:
|
|
return n.LabelDeclaration.Position()
|
|
case 4:
|
|
return n.PragmaSTDC.Position()
|
|
case 1:
|
|
return n.Statement.Position()
|
|
default:
|
|
panic("internal error")
|
|
}
|
|
}
|
|
|
|
// BlockItemList represents data reduced by productions:
|
|
//
|
|
// BlockItemList:
|
|
// BlockItem
|
|
// | BlockItemList BlockItem
|
|
type BlockItemList struct {
|
|
BlockItem *BlockItem
|
|
BlockItemList *BlockItemList
|
|
}
|
|
|
|
// String implements fmt.Stringer.
|
|
func (n *BlockItemList) String() string { return PrettyString(n) }
|
|
|
|
// Position reports the position of the first component of n, if available.
|
|
func (n *BlockItemList) Position() (r token.Position) {
|
|
if n == nil {
|
|
return r
|
|
}
|
|
|
|
return n.BlockItem.Position()
|
|
}
|
|
|
|
// CastExpressionCase represents case numbers of production CastExpression
|
|
type CastExpressionCase int
|
|
|
|
// Values of type CastExpressionCase
|
|
const (
|
|
CastExpressionUnary CastExpressionCase = iota
|
|
CastExpressionCast
|
|
)
|
|
|
|
// String implements fmt.Stringer
|
|
func (n CastExpressionCase) String() string {
|
|
switch n {
|
|
case CastExpressionUnary:
|
|
return "CastExpressionUnary"
|
|
case CastExpressionCast:
|
|
return "CastExpressionCast"
|
|
default:
|
|
return fmt.Sprintf("CastExpressionCase(%v)", int(n))
|
|
}
|
|
}
|
|
|
|
// CastExpression represents data reduced by productions:
|
|
//
|
|
// CastExpression:
|
|
// UnaryExpression // Case CastExpressionUnary
|
|
// | '(' TypeName ')' CastExpression // Case CastExpressionCast
|
|
type CastExpression struct {
|
|
Operand Operand
|
|
IsSideEffectsFree bool
|
|
Case CastExpressionCase `PrettyPrint:"stringer,zero"`
|
|
CastExpression *CastExpression
|
|
Token Token
|
|
Token2 Token
|
|
TypeName *TypeName
|
|
UnaryExpression *UnaryExpression
|
|
}
|
|
|
|
// String implements fmt.Stringer.
|
|
func (n *CastExpression) String() string { return PrettyString(n) }
|
|
|
|
// Position reports the position of the first component of n, if available.
|
|
func (n *CastExpression) Position() (r token.Position) {
|
|
if n == nil {
|
|
return r
|
|
}
|
|
|
|
switch n.Case {
|
|
case 1:
|
|
if p := n.Token.Position(); p.IsValid() {
|
|
return p
|
|
}
|
|
|
|
if p := n.TypeName.Position(); p.IsValid() {
|
|
return p
|
|
}
|
|
|
|
if p := n.Token2.Position(); p.IsValid() {
|
|
return p
|
|
}
|
|
|
|
return n.CastExpression.Position()
|
|
case 0:
|
|
return n.UnaryExpression.Position()
|
|
default:
|
|
panic("internal error")
|
|
}
|
|
}
|
|
|
|
// CompoundStatement represents data reduced by production:
|
|
//
|
|
// CompoundStatement:
|
|
// '{' BlockItemList '}'
|
|
type CompoundStatement struct {
|
|
Operand Operand
|
|
children []*CompoundStatement
|
|
declarations []*Declaration
|
|
isJumpTarget bool
|
|
labeledStmts []*LabeledStatement
|
|
parent *CompoundStatement
|
|
scope Scope
|
|
BlockItemList *BlockItemList
|
|
Token Token
|
|
Token2 Token
|
|
}
|
|
|
|
// String implements fmt.Stringer.
|
|
func (n *CompoundStatement) String() string { return PrettyString(n) }
|
|
|
|
// Position reports the position of the first component of n, if available.
|
|
func (n *CompoundStatement) Position() (r token.Position) {
|
|
if n == nil {
|
|
return r
|
|
}
|
|
|
|
if p := n.Token.Position(); p.IsValid() {
|
|
return p
|
|
}
|
|
|
|
if p := n.BlockItemList.Position(); p.IsValid() {
|
|
return p
|
|
}
|
|
|
|
return n.Token2.Position()
|
|
}
|
|
|
|
// ConditionalExpressionCase represents case numbers of production ConditionalExpression
|
|
type ConditionalExpressionCase int
|
|
|
|
// Values of type ConditionalExpressionCase
|
|
const (
|
|
ConditionalExpressionLOr ConditionalExpressionCase = iota
|
|
ConditionalExpressionCond
|
|
)
|
|
|
|
// String implements fmt.Stringer
|
|
func (n ConditionalExpressionCase) String() string {
|
|
switch n {
|
|
case ConditionalExpressionLOr:
|
|
return "ConditionalExpressionLOr"
|
|
case ConditionalExpressionCond:
|
|
return "ConditionalExpressionCond"
|
|
default:
|
|
return fmt.Sprintf("ConditionalExpressionCase(%v)", int(n))
|
|
}
|
|
}
|
|
|
|
// ConditionalExpression represents data reduced by productions:
|
|
//
|
|
// ConditionalExpression:
|
|
// LogicalOrExpression // Case ConditionalExpressionLOr
|
|
// | LogicalOrExpression '?' Expression ':' ConditionalExpression // Case ConditionalExpressionCond
|
|
type ConditionalExpression struct {
|
|
Operand Operand
|
|
IsSideEffectsFree bool
|
|
Case ConditionalExpressionCase `PrettyPrint:"stringer,zero"`
|
|
ConditionalExpression *ConditionalExpression
|
|
Expression *Expression
|
|
LogicalOrExpression *LogicalOrExpression
|
|
Token Token
|
|
Token2 Token
|
|
}
|
|
|
|
// String implements fmt.Stringer.
|
|
func (n *ConditionalExpression) String() string { return PrettyString(n) }
|
|
|
|
// Position reports the position of the first component of n, if available.
|
|
func (n *ConditionalExpression) Position() (r token.Position) {
|
|
if n == nil {
|
|
return r
|
|
}
|
|
|
|
switch n.Case {
|
|
case 0:
|
|
return n.LogicalOrExpression.Position()
|
|
case 1:
|
|
if p := n.LogicalOrExpression.Position(); p.IsValid() {
|
|
return p
|
|
}
|
|
|
|
if p := n.Token.Position(); p.IsValid() {
|
|
return p
|
|
}
|
|
|
|
if p := n.Expression.Position(); p.IsValid() {
|
|
return p
|
|
}
|
|
|
|
if p := n.Token2.Position(); p.IsValid() {
|
|
return p
|
|
}
|
|
|
|
return n.ConditionalExpression.Position()
|
|
default:
|
|
panic("internal error")
|
|
}
|
|
}
|
|
|
|
// ConstantExpression represents data reduced by production:
|
|
//
|
|
// ConstantExpression:
|
|
// ConditionalExpression
|
|
type ConstantExpression struct {
|
|
Operand Operand
|
|
ConditionalExpression *ConditionalExpression
|
|
}
|
|
|
|
// String implements fmt.Stringer.
|
|
func (n *ConstantExpression) String() string { return PrettyString(n) }
|
|
|
|
// Position reports the position of the first component of n, if available.
|
|
func (n *ConstantExpression) Position() (r token.Position) {
|
|
if n == nil {
|
|
return r
|
|
}
|
|
|
|
return n.ConditionalExpression.Position()
|
|
}
|
|
|
|
// Declaration represents data reduced by production:
|
|
//
|
|
// Declaration:
|
|
// DeclarationSpecifiers InitDeclaratorList ';'
|
|
type Declaration struct {
|
|
DeclarationSpecifiers *DeclarationSpecifiers
|
|
InitDeclaratorList *InitDeclaratorList
|
|
Token Token
|
|
}
|
|
|
|
// String implements fmt.Stringer.
|
|
func (n *Declaration) String() string { return PrettyString(n) }
|
|
|
|
// Position reports the position of the first component of n, if available.
|
|
func (n *Declaration) Position() (r token.Position) {
|
|
if n == nil {
|
|
return r
|
|
}
|
|
|
|
if p := n.DeclarationSpecifiers.Position(); p.IsValid() {
|
|
return p
|
|
}
|
|
|
|
if p := n.InitDeclaratorList.Position(); p.IsValid() {
|
|
return p
|
|
}
|
|
|
|
return n.Token.Position()
|
|
}
|
|
|
|
// DeclarationList represents data reduced by productions:
|
|
//
|
|
// DeclarationList:
|
|
// Declaration
|
|
// | DeclarationList Declaration
|
|
type DeclarationList struct {
|
|
Declaration *Declaration
|
|
DeclarationList *DeclarationList
|
|
}
|
|
|
|
// String implements fmt.Stringer.
|
|
func (n *DeclarationList) String() string { return PrettyString(n) }
|
|
|
|
// Position reports the position of the first component of n, if available.
|
|
func (n *DeclarationList) Position() (r token.Position) {
|
|
if n == nil {
|
|
return r
|
|
}
|
|
|
|
return n.Declaration.Position()
|
|
}
|
|
|
|
// DeclarationSpecifiersCase represents case numbers of production DeclarationSpecifiers
|
|
type DeclarationSpecifiersCase int
|
|
|
|
// Values of type DeclarationSpecifiersCase
|
|
const (
|
|
DeclarationSpecifiersStorage DeclarationSpecifiersCase = iota
|
|
DeclarationSpecifiersTypeSpec
|
|
DeclarationSpecifiersTypeQual
|
|
DeclarationSpecifiersFunc
|
|
DeclarationSpecifiersAlignSpec
|
|
DeclarationSpecifiersAttribute
|
|
)
|
|
|
|
// String implements fmt.Stringer
|
|
func (n DeclarationSpecifiersCase) String() string {
|
|
switch n {
|
|
case DeclarationSpecifiersStorage:
|
|
return "DeclarationSpecifiersStorage"
|
|
case DeclarationSpecifiersTypeSpec:
|
|
return "DeclarationSpecifiersTypeSpec"
|
|
case DeclarationSpecifiersTypeQual:
|
|
return "DeclarationSpecifiersTypeQual"
|
|
case DeclarationSpecifiersFunc:
|
|
return "DeclarationSpecifiersFunc"
|
|
case DeclarationSpecifiersAlignSpec:
|
|
return "DeclarationSpecifiersAlignSpec"
|
|
case DeclarationSpecifiersAttribute:
|
|
return "DeclarationSpecifiersAttribute"
|
|
default:
|
|
return fmt.Sprintf("DeclarationSpecifiersCase(%v)", int(n))
|
|
}
|
|
}
|
|
|
|
// DeclarationSpecifiers represents data reduced by productions:
|
|
//
|
|
// DeclarationSpecifiers:
|
|
// StorageClassSpecifier DeclarationSpecifiers // Case DeclarationSpecifiersStorage
|
|
// | TypeSpecifier DeclarationSpecifiers // Case DeclarationSpecifiersTypeSpec
|
|
// | TypeQualifier DeclarationSpecifiers // Case DeclarationSpecifiersTypeQual
|
|
// | FunctionSpecifier DeclarationSpecifiers // Case DeclarationSpecifiersFunc
|
|
// | AlignmentSpecifier DeclarationSpecifiers // Case DeclarationSpecifiersAlignSpec
|
|
// | AttributeSpecifier DeclarationSpecifiers // Case DeclarationSpecifiersAttribute
|
|
type DeclarationSpecifiers struct {
|
|
class storageClass
|
|
AlignmentSpecifier *AlignmentSpecifier
|
|
AttributeSpecifier *AttributeSpecifier
|
|
Case DeclarationSpecifiersCase `PrettyPrint:"stringer,zero"`
|
|
DeclarationSpecifiers *DeclarationSpecifiers
|
|
FunctionSpecifier *FunctionSpecifier
|
|
StorageClassSpecifier *StorageClassSpecifier
|
|
TypeQualifier *TypeQualifier
|
|
TypeSpecifier *TypeSpecifier
|
|
}
|
|
|
|
// String implements fmt.Stringer.
|
|
func (n *DeclarationSpecifiers) String() string { return PrettyString(n) }
|
|
|
|
// Position reports the position of the first component of n, if available.
|
|
func (n *DeclarationSpecifiers) Position() (r token.Position) {
|
|
if n == nil {
|
|
return r
|
|
}
|
|
|
|
switch n.Case {
|
|
case 4:
|
|
if p := n.AlignmentSpecifier.Position(); p.IsValid() {
|
|
return p
|
|
}
|
|
|
|
return n.DeclarationSpecifiers.Position()
|
|
case 5:
|
|
if p := n.AttributeSpecifier.Position(); p.IsValid() {
|
|
return p
|
|
}
|
|
|
|
return n.DeclarationSpecifiers.Position()
|
|
case 3:
|
|
if p := n.FunctionSpecifier.Position(); p.IsValid() {
|
|
return p
|
|
}
|
|
|
|
return n.DeclarationSpecifiers.Position()
|
|
case 0:
|
|
if p := n.StorageClassSpecifier.Position(); p.IsValid() {
|
|
return p
|
|
}
|
|
|
|
return n.DeclarationSpecifiers.Position()
|
|
case 2:
|
|
if p := n.TypeQualifier.Position(); p.IsValid() {
|
|
return p
|
|
}
|
|
|
|
return n.DeclarationSpecifiers.Position()
|
|
case 1:
|
|
if p := n.TypeSpecifier.Position(); p.IsValid() {
|
|
return p
|
|
}
|
|
|
|
return n.DeclarationSpecifiers.Position()
|
|
default:
|
|
panic("internal error")
|
|
}
|
|
}
|
|
|
|
// Declarator represents data reduced by production:
|
|
//
|
|
// Declarator:
|
|
// Pointer DirectDeclarator AttributeSpecifierList
|
|
type Declarator struct {
|
|
Linkage Linkage
|
|
Read int
|
|
StorageClass StorageClass
|
|
Write int
|
|
funcDefinition *FunctionDefinition
|
|
lhs map[*Declarator]struct{}
|
|
td typeDescriptor
|
|
typ Type
|
|
AddressTaken bool
|
|
IsParameter bool
|
|
IsTypedefName bool
|
|
SubjectOfAsgnOp bool
|
|
SubjectOfIncDec bool
|
|
called bool
|
|
fnDef bool
|
|
hasInitializer bool
|
|
implicit bool
|
|
AttributeSpecifierList *AttributeSpecifierList
|
|
DirectDeclarator *DirectDeclarator
|
|
Pointer *Pointer
|
|
}
|
|
|
|
// String implements fmt.Stringer.
|
|
func (n *Declarator) String() string { return PrettyString(n) }
|
|
|
|
// Position reports the position of the first component of n, if available.
|
|
func (n *Declarator) Position() (r token.Position) {
|
|
if n == nil {
|
|
return r
|
|
}
|
|
|
|
if p := n.Pointer.Position(); p.IsValid() {
|
|
return p
|
|
}
|
|
|
|
if p := n.DirectDeclarator.Position(); p.IsValid() {
|
|
return p
|
|
}
|
|
|
|
return n.AttributeSpecifierList.Position()
|
|
}
|
|
|
|
// Designation represents data reduced by production:
|
|
//
|
|
// Designation:
|
|
// DesignatorList '='
|
|
type Designation struct {
|
|
DesignatorList *DesignatorList
|
|
Token Token
|
|
}
|
|
|
|
// String implements fmt.Stringer.
|
|
func (n *Designation) String() string { return PrettyString(n) }
|
|
|
|
// Position reports the position of the first component of n, if available.
|
|
func (n *Designation) Position() (r token.Position) {
|
|
if n == nil {
|
|
return r
|
|
}
|
|
|
|
if p := n.DesignatorList.Position(); p.IsValid() {
|
|
return p
|
|
}
|
|
|
|
return n.Token.Position()
|
|
}
|
|
|
|
// DesignatorCase represents case numbers of production Designator
|
|
type DesignatorCase int
|
|
|
|
// Values of type DesignatorCase
|
|
const (
|
|
DesignatorIndex DesignatorCase = iota
|
|
DesignatorField
|
|
DesignatorField2
|
|
)
|
|
|
|
// String implements fmt.Stringer
|
|
func (n DesignatorCase) String() string {
|
|
switch n {
|
|
case DesignatorIndex:
|
|
return "DesignatorIndex"
|
|
case DesignatorField:
|
|
return "DesignatorField"
|
|
case DesignatorField2:
|
|
return "DesignatorField2"
|
|
default:
|
|
return fmt.Sprintf("DesignatorCase(%v)", int(n))
|
|
}
|
|
}
|
|
|
|
// Designator represents data reduced by productions:
|
|
//
|
|
// Designator:
|
|
// '[' ConstantExpression ']' // Case DesignatorIndex
|
|
// | '.' IDENTIFIER // Case DesignatorField
|
|
// | IDENTIFIER ':' // Case DesignatorField2
|
|
type Designator struct {
|
|
lexicalScope Scope
|
|
Case DesignatorCase `PrettyPrint:"stringer,zero"`
|
|
ConstantExpression *ConstantExpression
|
|
Token Token
|
|
Token2 Token
|
|
}
|
|
|
|
// String implements fmt.Stringer.
|
|
func (n *Designator) String() string { return PrettyString(n) }
|
|
|
|
// Position reports the position of the first component of n, if available.
|
|
func (n *Designator) Position() (r token.Position) {
|
|
if n == nil {
|
|
return r
|
|
}
|
|
|
|
switch n.Case {
|
|
case 0:
|
|
if p := n.Token.Position(); p.IsValid() {
|
|
return p
|
|
}
|
|
|
|
if p := n.ConstantExpression.Position(); p.IsValid() {
|
|
return p
|
|
}
|
|
|
|
return n.Token2.Position()
|
|
case 1, 2:
|
|
if p := n.Token.Position(); p.IsValid() {
|
|
return p
|
|
}
|
|
|
|
return n.Token2.Position()
|
|
default:
|
|
panic("internal error")
|
|
}
|
|
}
|
|
|
|
// DesignatorList represents data reduced by productions:
|
|
//
|
|
// DesignatorList:
|
|
// Designator
|
|
// | DesignatorList Designator
|
|
type DesignatorList struct {
|
|
Designator *Designator
|
|
DesignatorList *DesignatorList
|
|
}
|
|
|
|
// String implements fmt.Stringer.
|
|
func (n *DesignatorList) String() string { return PrettyString(n) }
|
|
|
|
// Position reports the position of the first component of n, if available.
|
|
func (n *DesignatorList) Position() (r token.Position) {
|
|
if n == nil {
|
|
return r
|
|
}
|
|
|
|
return n.Designator.Position()
|
|
}
|
|
|
|
// DirectAbstractDeclaratorCase represents case numbers of production DirectAbstractDeclarator
|
|
type DirectAbstractDeclaratorCase int
|
|
|
|
// Values of type DirectAbstractDeclaratorCase
|
|
const (
|
|
DirectAbstractDeclaratorDecl DirectAbstractDeclaratorCase = iota
|
|
DirectAbstractDeclaratorArr
|
|
DirectAbstractDeclaratorStaticArr
|
|
DirectAbstractDeclaratorArrStatic
|
|
DirectAbstractDeclaratorArrStar
|
|
DirectAbstractDeclaratorFunc
|
|
)
|
|
|
|
// String implements fmt.Stringer
|
|
func (n DirectAbstractDeclaratorCase) String() string {
|
|
switch n {
|
|
case DirectAbstractDeclaratorDecl:
|
|
return "DirectAbstractDeclaratorDecl"
|
|
case DirectAbstractDeclaratorArr:
|
|
return "DirectAbstractDeclaratorArr"
|
|
case DirectAbstractDeclaratorStaticArr:
|
|
return "DirectAbstractDeclaratorStaticArr"
|
|
case DirectAbstractDeclaratorArrStatic:
|
|
return "DirectAbstractDeclaratorArrStatic"
|
|
case DirectAbstractDeclaratorArrStar:
|
|
return "DirectAbstractDeclaratorArrStar"
|
|
case DirectAbstractDeclaratorFunc:
|
|
return "DirectAbstractDeclaratorFunc"
|
|
default:
|
|
return fmt.Sprintf("DirectAbstractDeclaratorCase(%v)", int(n))
|
|
}
|
|
}
|
|
|
|
// DirectAbstractDeclarator represents data reduced by productions:
|
|
//
|
|
// DirectAbstractDeclarator:
|
|
// '(' AbstractDeclarator ')' // Case DirectAbstractDeclaratorDecl
|
|
// | DirectAbstractDeclarator '[' TypeQualifiers AssignmentExpression ']' // Case DirectAbstractDeclaratorArr
|
|
// | DirectAbstractDeclarator '[' "static" TypeQualifiers AssignmentExpression ']' // Case DirectAbstractDeclaratorStaticArr
|
|
// | DirectAbstractDeclarator '[' TypeQualifiers "static" AssignmentExpression ']' // Case DirectAbstractDeclaratorArrStatic
|
|
// | DirectAbstractDeclarator '[' '*' ']' // Case DirectAbstractDeclaratorArrStar
|
|
// | DirectAbstractDeclarator '(' ParameterTypeList ')' // Case DirectAbstractDeclaratorFunc
|
|
type DirectAbstractDeclarator struct {
|
|
paramScope Scope
|
|
typeQualifiers *typeBase
|
|
AbstractDeclarator *AbstractDeclarator
|
|
AssignmentExpression *AssignmentExpression
|
|
Case DirectAbstractDeclaratorCase `PrettyPrint:"stringer,zero"`
|
|
DirectAbstractDeclarator *DirectAbstractDeclarator
|
|
ParameterTypeList *ParameterTypeList
|
|
Token Token
|
|
Token2 Token
|
|
Token3 Token
|
|
TypeQualifiers *TypeQualifiers
|
|
}
|
|
|
|
// String implements fmt.Stringer.
|
|
func (n *DirectAbstractDeclarator) String() string { return PrettyString(n) }
|
|
|
|
// Position reports the position of the first component of n, if available.
|
|
func (n *DirectAbstractDeclarator) Position() (r token.Position) {
|
|
if n == nil {
|
|
return r
|
|
}
|
|
|
|
switch n.Case {
|
|
case 5:
|
|
if p := n.DirectAbstractDeclarator.Position(); p.IsValid() {
|
|
return p
|
|
}
|
|
|
|
if p := n.Token.Position(); p.IsValid() {
|
|
return p
|
|
}
|
|
|
|
if p := n.ParameterTypeList.Position(); p.IsValid() {
|
|
return p
|
|
}
|
|
|
|
return n.Token2.Position()
|
|
case 4:
|
|
if p := n.DirectAbstractDeclarator.Position(); p.IsValid() {
|
|
return p
|
|
}
|
|
|
|
if p := n.Token.Position(); p.IsValid() {
|
|
return p
|
|
}
|
|
|
|
if p := n.Token2.Position(); p.IsValid() {
|
|
return p
|
|
}
|
|
|
|
return n.Token3.Position()
|
|
case 2:
|
|
if p := n.DirectAbstractDeclarator.Position(); p.IsValid() {
|
|
return p
|
|
}
|
|
|
|
if p := n.Token.Position(); p.IsValid() {
|
|
return p
|
|
}
|
|
|
|
if p := n.Token2.Position(); p.IsValid() {
|
|
return p
|
|
}
|
|
|
|
if p := n.TypeQualifiers.Position(); p.IsValid() {
|
|
return p
|
|
}
|
|
|
|
if p := n.AssignmentExpression.Position(); p.IsValid() {
|
|
return p
|
|
}
|
|
|
|
return n.Token3.Position()
|
|
case 1:
|
|
if p := n.DirectAbstractDeclarator.Position(); p.IsValid() {
|
|
return p
|
|
}
|
|
|
|
if p := n.Token.Position(); p.IsValid() {
|
|
return p
|
|
}
|
|
|
|
if p := n.TypeQualifiers.Position(); p.IsValid() {
|
|
return p
|
|
}
|
|
|
|
if p := n.AssignmentExpression.Position(); p.IsValid() {
|
|
return p
|
|
}
|
|
|
|
return n.Token2.Position()
|
|
case 3:
|
|
if p := n.DirectAbstractDeclarator.Position(); p.IsValid() {
|
|
return p
|
|
}
|
|
|
|
if p := n.Token.Position(); p.IsValid() {
|
|
return p
|
|
}
|
|
|
|
if p := n.TypeQualifiers.Position(); p.IsValid() {
|
|
return p
|
|
}
|
|
|
|
if p := n.Token2.Position(); p.IsValid() {
|
|
return p
|
|
}
|
|
|
|
if p := n.AssignmentExpression.Position(); p.IsValid() {
|
|
return p
|
|
}
|
|
|
|
return n.Token3.Position()
|
|
case 0:
|
|
if p := n.Token.Position(); p.IsValid() {
|
|
return p
|
|
}
|
|
|
|
if p := n.AbstractDeclarator.Position(); p.IsValid() {
|
|
return p
|
|
}
|
|
|
|
return n.Token2.Position()
|
|
default:
|
|
panic("internal error")
|
|
}
|
|
}
|
|
|
|
// DirectDeclaratorCase represents case numbers of production DirectDeclarator
|
|
type DirectDeclaratorCase int
|
|
|
|
// Values of type DirectDeclaratorCase
|
|
const (
|
|
DirectDeclaratorIdent DirectDeclaratorCase = iota
|
|
DirectDeclaratorDecl
|
|
DirectDeclaratorArr
|
|
DirectDeclaratorStaticArr
|
|
DirectDeclaratorArrStatic
|
|
DirectDeclaratorStar
|
|
DirectDeclaratorFuncParam
|
|
DirectDeclaratorFuncIdent
|
|
)
|
|
|
|
// String implements fmt.Stringer
|
|
func (n DirectDeclaratorCase) String() string {
|
|
switch n {
|
|
case DirectDeclaratorIdent:
|
|
return "DirectDeclaratorIdent"
|
|
case DirectDeclaratorDecl:
|
|
return "DirectDeclaratorDecl"
|
|
case DirectDeclaratorArr:
|
|
return "DirectDeclaratorArr"
|
|
case DirectDeclaratorStaticArr:
|
|
return "DirectDeclaratorStaticArr"
|
|
case DirectDeclaratorArrStatic:
|
|
return "DirectDeclaratorArrStatic"
|
|
case DirectDeclaratorStar:
|
|
return "DirectDeclaratorStar"
|
|
case DirectDeclaratorFuncParam:
|
|
return "DirectDeclaratorFuncParam"
|
|
case DirectDeclaratorFuncIdent:
|
|
return "DirectDeclaratorFuncIdent"
|
|
default:
|
|
return fmt.Sprintf("DirectDeclaratorCase(%v)", int(n))
|
|
}
|
|
}
|
|
|
|
// DirectDeclarator represents data reduced by productions:
|
|
//
|
|
// DirectDeclarator:
|
|
// IDENTIFIER Asm // Case DirectDeclaratorIdent
|
|
// | '(' AttributeSpecifierList Declarator ')' // Case DirectDeclaratorDecl
|
|
// | DirectDeclarator '[' TypeQualifiers AssignmentExpression ']' // Case DirectDeclaratorArr
|
|
// | DirectDeclarator '[' "static" TypeQualifiers AssignmentExpression ']' // Case DirectDeclaratorStaticArr
|
|
// | DirectDeclarator '[' TypeQualifiers "static" AssignmentExpression ']' // Case DirectDeclaratorArrStatic
|
|
// | DirectDeclarator '[' TypeQualifiers '*' ']' // Case DirectDeclaratorStar
|
|
// | DirectDeclarator '(' ParameterTypeList ')' // Case DirectDeclaratorFuncParam
|
|
// | DirectDeclarator '(' IdentifierList ')' // Case DirectDeclaratorFuncIdent
|
|
type DirectDeclarator struct {
|
|
lexicalScope Scope
|
|
paramScope Scope
|
|
typeQualifiers *typeBase
|
|
idListNoDeclList bool
|
|
Asm *Asm
|
|
AssignmentExpression *AssignmentExpression
|
|
AttributeSpecifierList *AttributeSpecifierList
|
|
Case DirectDeclaratorCase `PrettyPrint:"stringer,zero"`
|
|
Declarator *Declarator
|
|
DirectDeclarator *DirectDeclarator
|
|
IdentifierList *IdentifierList
|
|
ParameterTypeList *ParameterTypeList
|
|
Token Token
|
|
Token2 Token
|
|
Token3 Token
|
|
TypeQualifiers *TypeQualifiers
|
|
}
|
|
|
|
// String implements fmt.Stringer.
|
|
func (n *DirectDeclarator) String() string { return PrettyString(n) }
|
|
|
|
// Position reports the position of the first component of n, if available.
|
|
func (n *DirectDeclarator) Position() (r token.Position) {
|
|
if n == nil {
|
|
return r
|
|
}
|
|
|
|
switch n.Case {
|
|
case 7:
|
|
if p := n.DirectDeclarator.Position(); p.IsValid() {
|
|
return p
|
|
}
|
|
|
|
if p := n.Token.Position(); p.IsValid() {
|
|
return p
|
|
}
|
|
|
|
if p := n.IdentifierList.Position(); p.IsValid() {
|
|
return p
|
|
}
|
|
|
|
return n.Token2.Position()
|
|
case 6:
|
|
if p := n.DirectDeclarator.Position(); p.IsValid() {
|
|
return p
|
|
}
|
|
|
|
if p := n.Token.Position(); p.IsValid() {
|
|
return p
|
|
}
|
|
|
|
if p := n.ParameterTypeList.Position(); p.IsValid() {
|
|
return p
|
|
}
|
|
|
|
return n.Token2.Position()
|
|
case 3:
|
|
if p := n.DirectDeclarator.Position(); p.IsValid() {
|
|
return p
|
|
}
|
|
|
|
if p := n.Token.Position(); p.IsValid() {
|
|
return p
|
|
}
|
|
|
|
if p := n.Token2.Position(); p.IsValid() {
|
|
return p
|
|
}
|
|
|
|
if p := n.TypeQualifiers.Position(); p.IsValid() {
|
|
return p
|
|
}
|
|
|
|
if p := n.AssignmentExpression.Position(); p.IsValid() {
|
|
return p
|
|
}
|
|
|
|
return n.Token3.Position()
|
|
case 2:
|
|
if p := n.DirectDeclarator.Position(); p.IsValid() {
|
|
return p
|
|
}
|
|
|
|
if p := n.Token.Position(); p.IsValid() {
|
|
return p
|
|
}
|
|
|
|
if p := n.TypeQualifiers.Position(); p.IsValid() {
|
|
return p
|
|
}
|
|
|
|
if p := n.AssignmentExpression.Position(); p.IsValid() {
|
|
return p
|
|
}
|
|
|
|
return n.Token2.Position()
|
|
case 4:
|
|
if p := n.DirectDeclarator.Position(); p.IsValid() {
|
|
return p
|
|
}
|
|
|
|
if p := n.Token.Position(); p.IsValid() {
|
|
return p
|
|
}
|
|
|
|
if p := n.TypeQualifiers.Position(); p.IsValid() {
|
|
return p
|
|
}
|
|
|
|
if p := n.Token2.Position(); p.IsValid() {
|
|
return p
|
|
}
|
|
|
|
if p := n.AssignmentExpression.Position(); p.IsValid() {
|
|
return p
|
|
}
|
|
|
|
return n.Token3.Position()
|
|
case 5:
|
|
if p := n.DirectDeclarator.Position(); p.IsValid() {
|
|
return p
|
|
}
|
|
|
|
if p := n.Token.Position(); p.IsValid() {
|
|
return p
|
|
}
|
|
|
|
if p := n.TypeQualifiers.Position(); p.IsValid() {
|
|
return p
|
|
}
|
|
|
|
if p := n.Token2.Position(); p.IsValid() {
|
|
return p
|
|
}
|
|
|
|
return n.Token3.Position()
|
|
case 0:
|
|
if p := n.Token.Position(); p.IsValid() {
|
|
return p
|
|
}
|
|
|
|
return n.Asm.Position()
|
|
case 1:
|
|
if p := n.Token.Position(); p.IsValid() {
|
|
return p
|
|
}
|
|
|
|
if p := n.AttributeSpecifierList.Position(); p.IsValid() {
|
|
return p
|
|
}
|
|
|
|
if p := n.Declarator.Position(); p.IsValid() {
|
|
return p
|
|
}
|
|
|
|
return n.Token2.Position()
|
|
default:
|
|
panic("internal error")
|
|
}
|
|
}
|
|
|
|
// EnumSpecifierCase represents case numbers of production EnumSpecifier
|
|
type EnumSpecifierCase int
|
|
|
|
// Values of type EnumSpecifierCase
|
|
const (
|
|
EnumSpecifierDef EnumSpecifierCase = iota
|
|
EnumSpecifierTag
|
|
)
|
|
|
|
// String implements fmt.Stringer
|
|
func (n EnumSpecifierCase) String() string {
|
|
switch n {
|
|
case EnumSpecifierDef:
|
|
return "EnumSpecifierDef"
|
|
case EnumSpecifierTag:
|
|
return "EnumSpecifierTag"
|
|
default:
|
|
return fmt.Sprintf("EnumSpecifierCase(%v)", int(n))
|
|
}
|
|
}
|
|
|
|
// EnumSpecifier represents data reduced by productions:
|
|
//
|
|
// EnumSpecifier:
|
|
// "enum" AttributeSpecifierList IDENTIFIER '{' EnumeratorList ',' '}' // Case EnumSpecifierDef
|
|
// | "enum" AttributeSpecifierList IDENTIFIER // Case EnumSpecifierTag
|
|
type EnumSpecifier struct {
|
|
lexicalScope Scope
|
|
typ Type
|
|
min Value
|
|
max Value
|
|
AttributeSpecifierList *AttributeSpecifierList
|
|
Case EnumSpecifierCase `PrettyPrint:"stringer,zero"`
|
|
EnumeratorList *EnumeratorList
|
|
Token Token
|
|
Token2 Token
|
|
Token3 Token
|
|
Token4 Token
|
|
Token5 Token
|
|
}
|
|
|
|
// String implements fmt.Stringer.
|
|
func (n *EnumSpecifier) String() string { return PrettyString(n) }
|
|
|
|
// Position reports the position of the first component of n, if available.
|
|
func (n *EnumSpecifier) Position() (r token.Position) {
|
|
if n == nil {
|
|
return r
|
|
}
|
|
|
|
switch n.Case {
|
|
case 1:
|
|
if p := n.Token.Position(); p.IsValid() {
|
|
return p
|
|
}
|
|
|
|
if p := n.AttributeSpecifierList.Position(); p.IsValid() {
|
|
return p
|
|
}
|
|
|
|
return n.Token2.Position()
|
|
case 0:
|
|
if p := n.Token.Position(); p.IsValid() {
|
|
return p
|
|
}
|
|
|
|
if p := n.AttributeSpecifierList.Position(); p.IsValid() {
|
|
return p
|
|
}
|
|
|
|
if p := n.Token2.Position(); p.IsValid() {
|
|
return p
|
|
}
|
|
|
|
if p := n.Token3.Position(); p.IsValid() {
|
|
return p
|
|
}
|
|
|
|
if p := n.EnumeratorList.Position(); p.IsValid() {
|
|
return p
|
|
}
|
|
|
|
if p := n.Token4.Position(); p.IsValid() {
|
|
return p
|
|
}
|
|
|
|
return n.Token5.Position()
|
|
default:
|
|
panic("internal error")
|
|
}
|
|
}
|
|
|
|
// EnumeratorCase represents case numbers of production Enumerator
|
|
type EnumeratorCase int
|
|
|
|
// Values of type EnumeratorCase
|
|
const (
|
|
EnumeratorIdent EnumeratorCase = iota
|
|
EnumeratorExpr
|
|
)
|
|
|
|
// String implements fmt.Stringer
|
|
func (n EnumeratorCase) String() string {
|
|
switch n {
|
|
case EnumeratorIdent:
|
|
return "EnumeratorIdent"
|
|
case EnumeratorExpr:
|
|
return "EnumeratorExpr"
|
|
default:
|
|
return fmt.Sprintf("EnumeratorCase(%v)", int(n))
|
|
}
|
|
}
|
|
|
|
// Enumerator represents data reduced by productions:
|
|
//
|
|
// Enumerator:
|
|
// IDENTIFIER AttributeSpecifierList // Case EnumeratorIdent
|
|
// | IDENTIFIER AttributeSpecifierList '=' ConstantExpression // Case EnumeratorExpr
|
|
type Enumerator struct {
|
|
lexicalScope Scope
|
|
Operand Operand
|
|
AttributeSpecifierList *AttributeSpecifierList
|
|
Case EnumeratorCase `PrettyPrint:"stringer,zero"`
|
|
ConstantExpression *ConstantExpression
|
|
Token Token
|
|
Token2 Token
|
|
}
|
|
|
|
// String implements fmt.Stringer.
|
|
func (n *Enumerator) String() string { return PrettyString(n) }
|
|
|
|
// Position reports the position of the first component of n, if available.
|
|
func (n *Enumerator) Position() (r token.Position) {
|
|
if n == nil {
|
|
return r
|
|
}
|
|
|
|
switch n.Case {
|
|
case 0:
|
|
if p := n.Token.Position(); p.IsValid() {
|
|
return p
|
|
}
|
|
|
|
return n.AttributeSpecifierList.Position()
|
|
case 1:
|
|
if p := n.Token.Position(); p.IsValid() {
|
|
return p
|
|
}
|
|
|
|
if p := n.AttributeSpecifierList.Position(); p.IsValid() {
|
|
return p
|
|
}
|
|
|
|
if p := n.Token2.Position(); p.IsValid() {
|
|
return p
|
|
}
|
|
|
|
return n.ConstantExpression.Position()
|
|
default:
|
|
panic("internal error")
|
|
}
|
|
}
|
|
|
|
// EnumeratorList represents data reduced by productions:
|
|
//
|
|
// EnumeratorList:
|
|
// Enumerator
|
|
// | EnumeratorList ',' Enumerator
|
|
type EnumeratorList struct {
|
|
Enumerator *Enumerator
|
|
EnumeratorList *EnumeratorList
|
|
Token Token
|
|
}
|
|
|
|
// String implements fmt.Stringer.
|
|
func (n *EnumeratorList) String() string { return PrettyString(n) }
|
|
|
|
// Position reports the position of the first component of n, if available.
|
|
func (n *EnumeratorList) Position() (r token.Position) {
|
|
if n == nil {
|
|
return r
|
|
}
|
|
|
|
return n.Enumerator.Position()
|
|
}
|
|
|
|
// EqualityExpressionCase represents case numbers of production EqualityExpression
|
|
type EqualityExpressionCase int
|
|
|
|
// Values of type EqualityExpressionCase
|
|
const (
|
|
EqualityExpressionRel EqualityExpressionCase = iota
|
|
EqualityExpressionEq
|
|
EqualityExpressionNeq
|
|
)
|
|
|
|
// String implements fmt.Stringer
|
|
func (n EqualityExpressionCase) String() string {
|
|
switch n {
|
|
case EqualityExpressionRel:
|
|
return "EqualityExpressionRel"
|
|
case EqualityExpressionEq:
|
|
return "EqualityExpressionEq"
|
|
case EqualityExpressionNeq:
|
|
return "EqualityExpressionNeq"
|
|
default:
|
|
return fmt.Sprintf("EqualityExpressionCase(%v)", int(n))
|
|
}
|
|
}
|
|
|
|
// EqualityExpression represents data reduced by productions:
|
|
//
|
|
// EqualityExpression:
|
|
// RelationalExpression // Case EqualityExpressionRel
|
|
// | EqualityExpression "==" RelationalExpression // Case EqualityExpressionEq
|
|
// | EqualityExpression "!=" RelationalExpression // Case EqualityExpressionNeq
|
|
type EqualityExpression struct {
|
|
Operand Operand
|
|
promote Type
|
|
IsSideEffectsFree bool
|
|
Case EqualityExpressionCase `PrettyPrint:"stringer,zero"`
|
|
EqualityExpression *EqualityExpression
|
|
RelationalExpression *RelationalExpression
|
|
Token Token
|
|
}
|
|
|
|
// String implements fmt.Stringer.
|
|
func (n *EqualityExpression) String() string { return PrettyString(n) }
|
|
|
|
// Position reports the position of the first component of n, if available.
|
|
func (n *EqualityExpression) Position() (r token.Position) {
|
|
if n == nil {
|
|
return r
|
|
}
|
|
|
|
switch n.Case {
|
|
case 1, 2:
|
|
if p := n.EqualityExpression.Position(); p.IsValid() {
|
|
return p
|
|
}
|
|
|
|
if p := n.Token.Position(); p.IsValid() {
|
|
return p
|
|
}
|
|
|
|
return n.RelationalExpression.Position()
|
|
case 0:
|
|
return n.RelationalExpression.Position()
|
|
default:
|
|
panic("internal error")
|
|
}
|
|
}
|
|
|
|
// ExclusiveOrExpressionCase represents case numbers of production ExclusiveOrExpression
|
|
type ExclusiveOrExpressionCase int
|
|
|
|
// Values of type ExclusiveOrExpressionCase
|
|
const (
|
|
ExclusiveOrExpressionAnd ExclusiveOrExpressionCase = iota
|
|
ExclusiveOrExpressionXor
|
|
)
|
|
|
|
// String implements fmt.Stringer
|
|
func (n ExclusiveOrExpressionCase) String() string {
|
|
switch n {
|
|
case ExclusiveOrExpressionAnd:
|
|
return "ExclusiveOrExpressionAnd"
|
|
case ExclusiveOrExpressionXor:
|
|
return "ExclusiveOrExpressionXor"
|
|
default:
|
|
return fmt.Sprintf("ExclusiveOrExpressionCase(%v)", int(n))
|
|
}
|
|
}
|
|
|
|
// ExclusiveOrExpression represents data reduced by productions:
|
|
//
|
|
// ExclusiveOrExpression:
|
|
// AndExpression // Case ExclusiveOrExpressionAnd
|
|
// | ExclusiveOrExpression '^' AndExpression // Case ExclusiveOrExpressionXor
|
|
type ExclusiveOrExpression struct {
|
|
Operand Operand
|
|
promote Type
|
|
IsSideEffectsFree bool
|
|
AndExpression *AndExpression
|
|
Case ExclusiveOrExpressionCase `PrettyPrint:"stringer,zero"`
|
|
ExclusiveOrExpression *ExclusiveOrExpression
|
|
Token Token
|
|
}
|
|
|
|
// String implements fmt.Stringer.
|
|
func (n *ExclusiveOrExpression) String() string { return PrettyString(n) }
|
|
|
|
// Position reports the position of the first component of n, if available.
|
|
func (n *ExclusiveOrExpression) Position() (r token.Position) {
|
|
if n == nil {
|
|
return r
|
|
}
|
|
|
|
switch n.Case {
|
|
case 0:
|
|
return n.AndExpression.Position()
|
|
case 1:
|
|
if p := n.ExclusiveOrExpression.Position(); p.IsValid() {
|
|
return p
|
|
}
|
|
|
|
if p := n.Token.Position(); p.IsValid() {
|
|
return p
|
|
}
|
|
|
|
return n.AndExpression.Position()
|
|
default:
|
|
panic("internal error")
|
|
}
|
|
}
|
|
|
|
// ExpressionCase represents case numbers of production Expression
|
|
type ExpressionCase int
|
|
|
|
// Values of type ExpressionCase
|
|
const (
|
|
ExpressionAssign ExpressionCase = iota
|
|
ExpressionComma
|
|
)
|
|
|
|
// String implements fmt.Stringer
|
|
func (n ExpressionCase) String() string {
|
|
switch n {
|
|
case ExpressionAssign:
|
|
return "ExpressionAssign"
|
|
case ExpressionComma:
|
|
return "ExpressionComma"
|
|
default:
|
|
return fmt.Sprintf("ExpressionCase(%v)", int(n))
|
|
}
|
|
}
|
|
|
|
// Expression represents data reduced by productions:
|
|
//
|
|
// Expression:
|
|
// AssignmentExpression // Case ExpressionAssign
|
|
// | Expression ',' AssignmentExpression // Case ExpressionComma
|
|
type Expression struct {
|
|
Operand Operand
|
|
IsSideEffectsFree bool
|
|
AssignmentExpression *AssignmentExpression
|
|
Case ExpressionCase `PrettyPrint:"stringer,zero"`
|
|
Expression *Expression
|
|
Token Token
|
|
}
|
|
|
|
// String implements fmt.Stringer.
|
|
func (n *Expression) String() string { return PrettyString(n) }
|
|
|
|
// Position reports the position of the first component of n, if available.
|
|
func (n *Expression) Position() (r token.Position) {
|
|
if n == nil {
|
|
return r
|
|
}
|
|
|
|
switch n.Case {
|
|
case 0:
|
|
return n.AssignmentExpression.Position()
|
|
case 1:
|
|
if p := n.Expression.Position(); p.IsValid() {
|
|
return p
|
|
}
|
|
|
|
if p := n.Token.Position(); p.IsValid() {
|
|
return p
|
|
}
|
|
|
|
return n.AssignmentExpression.Position()
|
|
default:
|
|
panic("internal error")
|
|
}
|
|
}
|
|
|
|
// ExpressionList represents data reduced by productions:
|
|
//
|
|
// ExpressionList:
|
|
// AssignmentExpression
|
|
// | ExpressionList ',' AssignmentExpression
|
|
type ExpressionList struct {
|
|
AssignmentExpression *AssignmentExpression
|
|
ExpressionList *ExpressionList
|
|
Token Token
|
|
}
|
|
|
|
// String implements fmt.Stringer.
|
|
func (n *ExpressionList) String() string { return PrettyString(n) }
|
|
|
|
// Position reports the position of the first component of n, if available.
|
|
func (n *ExpressionList) Position() (r token.Position) {
|
|
if n == nil {
|
|
return r
|
|
}
|
|
|
|
return n.AssignmentExpression.Position()
|
|
}
|
|
|
|
// ExpressionStatement represents data reduced by production:
|
|
//
|
|
// ExpressionStatement:
|
|
// Expression AttributeSpecifierList ';'
|
|
type ExpressionStatement struct {
|
|
AttributeSpecifierList *AttributeSpecifierList
|
|
Expression *Expression
|
|
Token Token
|
|
}
|
|
|
|
// String implements fmt.Stringer.
|
|
func (n *ExpressionStatement) String() string { return PrettyString(n) }
|
|
|
|
// Position reports the position of the first component of n, if available.
|
|
func (n *ExpressionStatement) Position() (r token.Position) {
|
|
if n == nil {
|
|
return r
|
|
}
|
|
|
|
if p := n.Expression.Position(); p.IsValid() {
|
|
return p
|
|
}
|
|
|
|
if p := n.AttributeSpecifierList.Position(); p.IsValid() {
|
|
return p
|
|
}
|
|
|
|
return n.Token.Position()
|
|
}
|
|
|
|
// ExternalDeclarationCase represents case numbers of production ExternalDeclaration
|
|
type ExternalDeclarationCase int
|
|
|
|
// Values of type ExternalDeclarationCase
|
|
const (
|
|
ExternalDeclarationFuncDef ExternalDeclarationCase = iota
|
|
ExternalDeclarationDecl
|
|
ExternalDeclarationAsm
|
|
ExternalDeclarationAsmStmt
|
|
ExternalDeclarationEmpty
|
|
ExternalDeclarationPragma
|
|
)
|
|
|
|
// String implements fmt.Stringer
|
|
func (n ExternalDeclarationCase) String() string {
|
|
switch n {
|
|
case ExternalDeclarationFuncDef:
|
|
return "ExternalDeclarationFuncDef"
|
|
case ExternalDeclarationDecl:
|
|
return "ExternalDeclarationDecl"
|
|
case ExternalDeclarationAsm:
|
|
return "ExternalDeclarationAsm"
|
|
case ExternalDeclarationAsmStmt:
|
|
return "ExternalDeclarationAsmStmt"
|
|
case ExternalDeclarationEmpty:
|
|
return "ExternalDeclarationEmpty"
|
|
case ExternalDeclarationPragma:
|
|
return "ExternalDeclarationPragma"
|
|
default:
|
|
return fmt.Sprintf("ExternalDeclarationCase(%v)", int(n))
|
|
}
|
|
}
|
|
|
|
// ExternalDeclaration represents data reduced by productions:
|
|
//
|
|
// ExternalDeclaration:
|
|
// FunctionDefinition // Case ExternalDeclarationFuncDef
|
|
// | Declaration // Case ExternalDeclarationDecl
|
|
// | AsmFunctionDefinition // Case ExternalDeclarationAsm
|
|
// | AsmStatement // Case ExternalDeclarationAsmStmt
|
|
// | ';' // Case ExternalDeclarationEmpty
|
|
// | PragmaSTDC // Case ExternalDeclarationPragma
|
|
type ExternalDeclaration struct {
|
|
AsmFunctionDefinition *AsmFunctionDefinition
|
|
AsmStatement *AsmStatement
|
|
Case ExternalDeclarationCase `PrettyPrint:"stringer,zero"`
|
|
Declaration *Declaration
|
|
FunctionDefinition *FunctionDefinition
|
|
PragmaSTDC *PragmaSTDC
|
|
Token Token
|
|
}
|
|
|
|
// String implements fmt.Stringer.
|
|
func (n *ExternalDeclaration) String() string { return PrettyString(n) }
|
|
|
|
// Position reports the position of the first component of n, if available.
|
|
func (n *ExternalDeclaration) Position() (r token.Position) {
|
|
if n == nil {
|
|
return r
|
|
}
|
|
|
|
switch n.Case {
|
|
case 2:
|
|
return n.AsmFunctionDefinition.Position()
|
|
case 3:
|
|
return n.AsmStatement.Position()
|
|
case 1:
|
|
return n.Declaration.Position()
|
|
case 0:
|
|
return n.FunctionDefinition.Position()
|
|
case 5:
|
|
return n.PragmaSTDC.Position()
|
|
case 4:
|
|
return n.Token.Position()
|
|
default:
|
|
panic("internal error")
|
|
}
|
|
}
|
|
|
|
// FunctionDefinition represents data reduced by production:
|
|
//
|
|
// FunctionDefinition:
|
|
// DeclarationSpecifiers Declarator DeclarationList CompoundStatement
|
|
type FunctionDefinition struct {
|
|
CallSiteComplexExpr []*AssignmentExpression
|
|
CompositeLiterals []*PostfixExpression
|
|
ComputedGotos map[StringID]*UnaryExpression
|
|
Gotos map[StringID]*JumpStatement
|
|
InitDeclarators []*InitDeclarator
|
|
Labels map[StringID]*LabeledStatement
|
|
ReturnComplexExpr []*Expression
|
|
VLAs []*Declarator
|
|
compoundStatements []*CompoundStatement
|
|
checked bool
|
|
CompoundStatement *CompoundStatement
|
|
DeclarationList *DeclarationList
|
|
DeclarationSpecifiers *DeclarationSpecifiers
|
|
Declarator *Declarator
|
|
}
|
|
|
|
// String implements fmt.Stringer.
|
|
func (n *FunctionDefinition) String() string { return PrettyString(n) }
|
|
|
|
// Position reports the position of the first component of n, if available.
|
|
func (n *FunctionDefinition) Position() (r token.Position) {
|
|
if n == nil {
|
|
return r
|
|
}
|
|
|
|
if p := n.DeclarationSpecifiers.Position(); p.IsValid() {
|
|
return p
|
|
}
|
|
|
|
if p := n.Declarator.Position(); p.IsValid() {
|
|
return p
|
|
}
|
|
|
|
if p := n.DeclarationList.Position(); p.IsValid() {
|
|
return p
|
|
}
|
|
|
|
return n.CompoundStatement.Position()
|
|
}
|
|
|
|
// FunctionSpecifierCase represents case numbers of production FunctionSpecifier
|
|
type FunctionSpecifierCase int
|
|
|
|
// Values of type FunctionSpecifierCase
|
|
const (
|
|
FunctionSpecifierInline FunctionSpecifierCase = iota
|
|
FunctionSpecifierNoreturn
|
|
)
|
|
|
|
// String implements fmt.Stringer
|
|
func (n FunctionSpecifierCase) String() string {
|
|
switch n {
|
|
case FunctionSpecifierInline:
|
|
return "FunctionSpecifierInline"
|
|
case FunctionSpecifierNoreturn:
|
|
return "FunctionSpecifierNoreturn"
|
|
default:
|
|
return fmt.Sprintf("FunctionSpecifierCase(%v)", int(n))
|
|
}
|
|
}
|
|
|
|
// FunctionSpecifier represents data reduced by productions:
|
|
//
|
|
// FunctionSpecifier:
|
|
// "inline" // Case FunctionSpecifierInline
|
|
// | "_Noreturn" // Case FunctionSpecifierNoreturn
|
|
type FunctionSpecifier struct {
|
|
Case FunctionSpecifierCase `PrettyPrint:"stringer,zero"`
|
|
Token Token
|
|
}
|
|
|
|
// String implements fmt.Stringer.
|
|
func (n *FunctionSpecifier) String() string { return PrettyString(n) }
|
|
|
|
// Position reports the position of the first component of n, if available.
|
|
func (n *FunctionSpecifier) Position() (r token.Position) {
|
|
if n == nil {
|
|
return r
|
|
}
|
|
|
|
return n.Token.Position()
|
|
}
|
|
|
|
// IdentifierList represents data reduced by productions:
|
|
//
|
|
// IdentifierList:
|
|
// IDENTIFIER
|
|
// | IdentifierList ',' IDENTIFIER
|
|
type IdentifierList struct {
|
|
lexicalScope Scope
|
|
IdentifierList *IdentifierList
|
|
Token Token
|
|
Token2 Token
|
|
}
|
|
|
|
// String implements fmt.Stringer.
|
|
func (n *IdentifierList) String() string { return PrettyString(n) }
|
|
|
|
// Position reports the position of the first component of n, if available.
|
|
func (n *IdentifierList) Position() (r token.Position) {
|
|
if n == nil {
|
|
return r
|
|
}
|
|
|
|
return n.Token.Position()
|
|
}
|
|
|
|
// InclusiveOrExpressionCase represents case numbers of production InclusiveOrExpression
|
|
type InclusiveOrExpressionCase int
|
|
|
|
// Values of type InclusiveOrExpressionCase
|
|
const (
|
|
InclusiveOrExpressionXor InclusiveOrExpressionCase = iota
|
|
InclusiveOrExpressionOr
|
|
)
|
|
|
|
// String implements fmt.Stringer
|
|
func (n InclusiveOrExpressionCase) String() string {
|
|
switch n {
|
|
case InclusiveOrExpressionXor:
|
|
return "InclusiveOrExpressionXor"
|
|
case InclusiveOrExpressionOr:
|
|
return "InclusiveOrExpressionOr"
|
|
default:
|
|
return fmt.Sprintf("InclusiveOrExpressionCase(%v)", int(n))
|
|
}
|
|
}
|
|
|
|
// InclusiveOrExpression represents data reduced by productions:
|
|
//
|
|
// InclusiveOrExpression:
|
|
// ExclusiveOrExpression // Case InclusiveOrExpressionXor
|
|
// | InclusiveOrExpression '|' ExclusiveOrExpression // Case InclusiveOrExpressionOr
|
|
type InclusiveOrExpression struct {
|
|
Operand Operand
|
|
promote Type
|
|
IsSideEffectsFree bool
|
|
Case InclusiveOrExpressionCase `PrettyPrint:"stringer,zero"`
|
|
ExclusiveOrExpression *ExclusiveOrExpression
|
|
InclusiveOrExpression *InclusiveOrExpression
|
|
Token Token
|
|
}
|
|
|
|
// String implements fmt.Stringer.
|
|
func (n *InclusiveOrExpression) String() string { return PrettyString(n) }
|
|
|
|
// Position reports the position of the first component of n, if available.
|
|
func (n *InclusiveOrExpression) Position() (r token.Position) {
|
|
if n == nil {
|
|
return r
|
|
}
|
|
|
|
switch n.Case {
|
|
case 0:
|
|
return n.ExclusiveOrExpression.Position()
|
|
case 1:
|
|
if p := n.InclusiveOrExpression.Position(); p.IsValid() {
|
|
return p
|
|
}
|
|
|
|
if p := n.Token.Position(); p.IsValid() {
|
|
return p
|
|
}
|
|
|
|
return n.ExclusiveOrExpression.Position()
|
|
default:
|
|
panic("internal error")
|
|
}
|
|
}
|
|
|
|
// InitDeclaratorCase represents case numbers of production InitDeclarator
|
|
type InitDeclaratorCase int
|
|
|
|
// Values of type InitDeclaratorCase
|
|
const (
|
|
InitDeclaratorDecl InitDeclaratorCase = iota
|
|
InitDeclaratorInit
|
|
)
|
|
|
|
// String implements fmt.Stringer
|
|
func (n InitDeclaratorCase) String() string {
|
|
switch n {
|
|
case InitDeclaratorDecl:
|
|
return "InitDeclaratorDecl"
|
|
case InitDeclaratorInit:
|
|
return "InitDeclaratorInit"
|
|
default:
|
|
return fmt.Sprintf("InitDeclaratorCase(%v)", int(n))
|
|
}
|
|
}
|
|
|
|
// InitDeclarator represents data reduced by productions:
|
|
//
|
|
// InitDeclarator:
|
|
// Declarator AttributeSpecifierList // Case InitDeclaratorDecl
|
|
// | Declarator AttributeSpecifierList '=' Initializer // Case InitDeclaratorInit
|
|
type InitDeclarator struct {
|
|
initializer *InitializerValue
|
|
AttributeSpecifierList *AttributeSpecifierList
|
|
Case InitDeclaratorCase `PrettyPrint:"stringer,zero"`
|
|
Declarator *Declarator
|
|
Initializer *Initializer
|
|
Token Token
|
|
}
|
|
|
|
// String implements fmt.Stringer.
|
|
func (n *InitDeclarator) String() string { return PrettyString(n) }
|
|
|
|
// Position reports the position of the first component of n, if available.
|
|
func (n *InitDeclarator) Position() (r token.Position) {
|
|
if n == nil {
|
|
return r
|
|
}
|
|
|
|
switch n.Case {
|
|
case 0:
|
|
if p := n.Declarator.Position(); p.IsValid() {
|
|
return p
|
|
}
|
|
|
|
return n.AttributeSpecifierList.Position()
|
|
case 1:
|
|
if p := n.Declarator.Position(); p.IsValid() {
|
|
return p
|
|
}
|
|
|
|
if p := n.AttributeSpecifierList.Position(); p.IsValid() {
|
|
return p
|
|
}
|
|
|
|
if p := n.Token.Position(); p.IsValid() {
|
|
return p
|
|
}
|
|
|
|
return n.Initializer.Position()
|
|
default:
|
|
panic("internal error")
|
|
}
|
|
}
|
|
|
|
// InitDeclaratorList represents data reduced by productions:
|
|
//
|
|
// InitDeclaratorList:
|
|
// InitDeclarator
|
|
// | InitDeclaratorList ',' AttributeSpecifierList InitDeclarator
|
|
type InitDeclaratorList struct {
|
|
AttributeSpecifierList *AttributeSpecifierList
|
|
InitDeclarator *InitDeclarator
|
|
InitDeclaratorList *InitDeclaratorList
|
|
Token Token
|
|
}
|
|
|
|
// String implements fmt.Stringer.
|
|
func (n *InitDeclaratorList) String() string { return PrettyString(n) }
|
|
|
|
// Position reports the position of the first component of n, if available.
|
|
func (n *InitDeclaratorList) Position() (r token.Position) {
|
|
if n == nil {
|
|
return r
|
|
}
|
|
|
|
return n.InitDeclarator.Position()
|
|
}
|
|
|
|
// InitializerCase represents case numbers of production Initializer
|
|
type InitializerCase int
|
|
|
|
// Values of type InitializerCase
|
|
const (
|
|
InitializerExpr InitializerCase = iota
|
|
InitializerInitList
|
|
)
|
|
|
|
// String implements fmt.Stringer
|
|
func (n InitializerCase) String() string {
|
|
switch n {
|
|
case InitializerExpr:
|
|
return "InitializerExpr"
|
|
case InitializerInitList:
|
|
return "InitializerInitList"
|
|
default:
|
|
return fmt.Sprintf("InitializerCase(%v)", int(n))
|
|
}
|
|
}
|
|
|
|
// Initializer represents data reduced by productions:
|
|
//
|
|
// Initializer:
|
|
// AssignmentExpression // Case InitializerExpr
|
|
// | '{' InitializerList ',' '}' // Case InitializerInitList
|
|
type Initializer struct {
|
|
Field Field // Where aplicable
|
|
Offset uintptr // Case Expr
|
|
field0 Field
|
|
list []*Initializer
|
|
parent *Initializer
|
|
trailingComma *Token
|
|
typ Type
|
|
isConst bool
|
|
isZero bool
|
|
AssignmentExpression *AssignmentExpression
|
|
Case InitializerCase `PrettyPrint:"stringer,zero"`
|
|
InitializerList *InitializerList
|
|
Token Token
|
|
Token2 Token
|
|
Token3 Token
|
|
}
|
|
|
|
// String implements fmt.Stringer.
|
|
func (n *Initializer) String() string { return PrettyString(n) }
|
|
|
|
// Position reports the position of the first component of n, if available.
|
|
func (n *Initializer) Position() (r token.Position) {
|
|
if n == nil {
|
|
return r
|
|
}
|
|
|
|
switch n.Case {
|
|
case 0:
|
|
return n.AssignmentExpression.Position()
|
|
case 1:
|
|
if p := n.Token.Position(); p.IsValid() {
|
|
return p
|
|
}
|
|
|
|
if p := n.InitializerList.Position(); p.IsValid() {
|
|
return p
|
|
}
|
|
|
|
if p := n.Token2.Position(); p.IsValid() {
|
|
return p
|
|
}
|
|
|
|
return n.Token3.Position()
|
|
default:
|
|
panic("internal error")
|
|
}
|
|
}
|
|
|
|
// InitializerList represents data reduced by productions:
|
|
//
|
|
// InitializerList:
|
|
// Designation Initializer
|
|
// | InitializerList ',' Designation Initializer
|
|
type InitializerList struct {
|
|
list []*Initializer
|
|
isConst bool
|
|
isZero bool
|
|
Designation *Designation
|
|
Initializer *Initializer
|
|
InitializerList *InitializerList
|
|
Token Token
|
|
}
|
|
|
|
// String implements fmt.Stringer.
|
|
func (n *InitializerList) String() string { return PrettyString(n) }
|
|
|
|
// Position reports the position of the first component of n, if available.
|
|
func (n *InitializerList) Position() (r token.Position) {
|
|
if n == nil {
|
|
return r
|
|
}
|
|
|
|
if p := n.Designation.Position(); p.IsValid() {
|
|
return p
|
|
}
|
|
|
|
return n.Initializer.Position()
|
|
}
|
|
|
|
// IterationStatementCase represents case numbers of production IterationStatement
|
|
type IterationStatementCase int
|
|
|
|
// Values of type IterationStatementCase
|
|
const (
|
|
IterationStatementWhile IterationStatementCase = iota
|
|
IterationStatementDo
|
|
IterationStatementFor
|
|
IterationStatementForDecl
|
|
)
|
|
|
|
// String implements fmt.Stringer
|
|
func (n IterationStatementCase) String() string {
|
|
switch n {
|
|
case IterationStatementWhile:
|
|
return "IterationStatementWhile"
|
|
case IterationStatementDo:
|
|
return "IterationStatementDo"
|
|
case IterationStatementFor:
|
|
return "IterationStatementFor"
|
|
case IterationStatementForDecl:
|
|
return "IterationStatementForDecl"
|
|
default:
|
|
return fmt.Sprintf("IterationStatementCase(%v)", int(n))
|
|
}
|
|
}
|
|
|
|
// IterationStatement represents data reduced by productions:
|
|
//
|
|
// IterationStatement:
|
|
// "while" '(' Expression ')' Statement // Case IterationStatementWhile
|
|
// | "do" Statement "while" '(' Expression ')' ';' // Case IterationStatementDo
|
|
// | "for" '(' Expression ';' Expression ';' Expression ')' Statement // Case IterationStatementFor
|
|
// | "for" '(' Declaration Expression ';' Expression ')' Statement // Case IterationStatementForDecl
|
|
type IterationStatement struct {
|
|
Case IterationStatementCase `PrettyPrint:"stringer,zero"`
|
|
Declaration *Declaration
|
|
Expression *Expression
|
|
Expression2 *Expression
|
|
Expression3 *Expression
|
|
Statement *Statement
|
|
Token Token
|
|
Token2 Token
|
|
Token3 Token
|
|
Token4 Token
|
|
Token5 Token
|
|
}
|
|
|
|
// String implements fmt.Stringer.
|
|
func (n *IterationStatement) String() string { return PrettyString(n) }
|
|
|
|
// Position reports the position of the first component of n, if available.
|
|
func (n *IterationStatement) Position() (r token.Position) {
|
|
if n == nil {
|
|
return r
|
|
}
|
|
|
|
switch n.Case {
|
|
case 1:
|
|
if p := n.Token.Position(); p.IsValid() {
|
|
return p
|
|
}
|
|
|
|
if p := n.Statement.Position(); p.IsValid() {
|
|
return p
|
|
}
|
|
|
|
if p := n.Token2.Position(); p.IsValid() {
|
|
return p
|
|
}
|
|
|
|
if p := n.Token3.Position(); p.IsValid() {
|
|
return p
|
|
}
|
|
|
|
if p := n.Expression.Position(); p.IsValid() {
|
|
return p
|
|
}
|
|
|
|
if p := n.Token4.Position(); p.IsValid() {
|
|
return p
|
|
}
|
|
|
|
return n.Token5.Position()
|
|
case 3:
|
|
if p := n.Token.Position(); p.IsValid() {
|
|
return p
|
|
}
|
|
|
|
if p := n.Token2.Position(); p.IsValid() {
|
|
return p
|
|
}
|
|
|
|
if p := n.Declaration.Position(); p.IsValid() {
|
|
return p
|
|
}
|
|
|
|
if p := n.Expression.Position(); p.IsValid() {
|
|
return p
|
|
}
|
|
|
|
if p := n.Token3.Position(); p.IsValid() {
|
|
return p
|
|
}
|
|
|
|
if p := n.Expression2.Position(); p.IsValid() {
|
|
return p
|
|
}
|
|
|
|
if p := n.Token4.Position(); p.IsValid() {
|
|
return p
|
|
}
|
|
|
|
return n.Statement.Position()
|
|
case 2:
|
|
if p := n.Token.Position(); p.IsValid() {
|
|
return p
|
|
}
|
|
|
|
if p := n.Token2.Position(); p.IsValid() {
|
|
return p
|
|
}
|
|
|
|
if p := n.Expression.Position(); p.IsValid() {
|
|
return p
|
|
}
|
|
|
|
if p := n.Token3.Position(); p.IsValid() {
|
|
return p
|
|
}
|
|
|
|
if p := n.Expression2.Position(); p.IsValid() {
|
|
return p
|
|
}
|
|
|
|
if p := n.Token4.Position(); p.IsValid() {
|
|
return p
|
|
}
|
|
|
|
if p := n.Expression3.Position(); p.IsValid() {
|
|
return p
|
|
}
|
|
|
|
if p := n.Token5.Position(); p.IsValid() {
|
|
return p
|
|
}
|
|
|
|
return n.Statement.Position()
|
|
case 0:
|
|
if p := n.Token.Position(); p.IsValid() {
|
|
return p
|
|
}
|
|
|
|
if p := n.Token2.Position(); p.IsValid() {
|
|
return p
|
|
}
|
|
|
|
if p := n.Expression.Position(); p.IsValid() {
|
|
return p
|
|
}
|
|
|
|
if p := n.Token3.Position(); p.IsValid() {
|
|
return p
|
|
}
|
|
|
|
return n.Statement.Position()
|
|
default:
|
|
panic("internal error")
|
|
}
|
|
}
|
|
|
|
// JumpStatementCase represents case numbers of production JumpStatement
|
|
type JumpStatementCase int
|
|
|
|
// Values of type JumpStatementCase
|
|
const (
|
|
JumpStatementGoto JumpStatementCase = iota
|
|
JumpStatementGotoExpr
|
|
JumpStatementContinue
|
|
JumpStatementBreak
|
|
JumpStatementReturn
|
|
)
|
|
|
|
// String implements fmt.Stringer
|
|
func (n JumpStatementCase) String() string {
|
|
switch n {
|
|
case JumpStatementGoto:
|
|
return "JumpStatementGoto"
|
|
case JumpStatementGotoExpr:
|
|
return "JumpStatementGotoExpr"
|
|
case JumpStatementContinue:
|
|
return "JumpStatementContinue"
|
|
case JumpStatementBreak:
|
|
return "JumpStatementBreak"
|
|
case JumpStatementReturn:
|
|
return "JumpStatementReturn"
|
|
default:
|
|
return fmt.Sprintf("JumpStatementCase(%v)", int(n))
|
|
}
|
|
}
|
|
|
|
// JumpStatement represents data reduced by productions:
|
|
//
|
|
// JumpStatement:
|
|
// "goto" IDENTIFIER ';' // Case JumpStatementGoto
|
|
// | "goto" '*' Expression ';' // Case JumpStatementGotoExpr
|
|
// | "continue" ';' // Case JumpStatementContinue
|
|
// | "break" ';' // Case JumpStatementBreak
|
|
// | "return" Expression ';' // Case JumpStatementReturn
|
|
type JumpStatement struct {
|
|
context Node
|
|
lexicalScope Scope
|
|
Case JumpStatementCase `PrettyPrint:"stringer,zero"`
|
|
Expression *Expression
|
|
Token Token
|
|
Token2 Token
|
|
Token3 Token
|
|
}
|
|
|
|
// String implements fmt.Stringer.
|
|
func (n *JumpStatement) String() string { return PrettyString(n) }
|
|
|
|
// Position reports the position of the first component of n, if available.
|
|
func (n *JumpStatement) Position() (r token.Position) {
|
|
if n == nil {
|
|
return r
|
|
}
|
|
|
|
switch n.Case {
|
|
case 4:
|
|
if p := n.Token.Position(); p.IsValid() {
|
|
return p
|
|
}
|
|
|
|
if p := n.Expression.Position(); p.IsValid() {
|
|
return p
|
|
}
|
|
|
|
return n.Token2.Position()
|
|
case 2, 3:
|
|
if p := n.Token.Position(); p.IsValid() {
|
|
return p
|
|
}
|
|
|
|
return n.Token2.Position()
|
|
case 1:
|
|
if p := n.Token.Position(); p.IsValid() {
|
|
return p
|
|
}
|
|
|
|
if p := n.Token2.Position(); p.IsValid() {
|
|
return p
|
|
}
|
|
|
|
if p := n.Expression.Position(); p.IsValid() {
|
|
return p
|
|
}
|
|
|
|
return n.Token3.Position()
|
|
case 0:
|
|
if p := n.Token.Position(); p.IsValid() {
|
|
return p
|
|
}
|
|
|
|
if p := n.Token2.Position(); p.IsValid() {
|
|
return p
|
|
}
|
|
|
|
return n.Token3.Position()
|
|
default:
|
|
panic("internal error")
|
|
}
|
|
}
|
|
|
|
// LabelDeclaration represents data reduced by production:
|
|
//
|
|
// LabelDeclaration:
|
|
// "__label__" IdentifierList ';'
|
|
type LabelDeclaration struct {
|
|
IdentifierList *IdentifierList
|
|
Token Token
|
|
Token2 Token
|
|
}
|
|
|
|
// String implements fmt.Stringer.
|
|
func (n *LabelDeclaration) String() string { return PrettyString(n) }
|
|
|
|
// Position reports the position of the first component of n, if available.
|
|
func (n *LabelDeclaration) Position() (r token.Position) {
|
|
if n == nil {
|
|
return r
|
|
}
|
|
|
|
if p := n.Token.Position(); p.IsValid() {
|
|
return p
|
|
}
|
|
|
|
if p := n.IdentifierList.Position(); p.IsValid() {
|
|
return p
|
|
}
|
|
|
|
return n.Token2.Position()
|
|
}
|
|
|
|
// LabeledStatementCase represents case numbers of production LabeledStatement
|
|
type LabeledStatementCase int
|
|
|
|
// Values of type LabeledStatementCase
|
|
const (
|
|
LabeledStatementLabel LabeledStatementCase = iota
|
|
LabeledStatementCaseLabel
|
|
LabeledStatementRange
|
|
LabeledStatementDefault
|
|
)
|
|
|
|
// String implements fmt.Stringer
|
|
func (n LabeledStatementCase) String() string {
|
|
switch n {
|
|
case LabeledStatementLabel:
|
|
return "LabeledStatementLabel"
|
|
case LabeledStatementCaseLabel:
|
|
return "LabeledStatementCaseLabel"
|
|
case LabeledStatementRange:
|
|
return "LabeledStatementRange"
|
|
case LabeledStatementDefault:
|
|
return "LabeledStatementDefault"
|
|
default:
|
|
return fmt.Sprintf("LabeledStatementCase(%v)", int(n))
|
|
}
|
|
}
|
|
|
|
// LabeledStatement represents data reduced by productions:
|
|
//
|
|
// LabeledStatement:
|
|
// IDENTIFIER ':' AttributeSpecifierList Statement // Case LabeledStatementLabel
|
|
// | "case" ConstantExpression ':' Statement // Case LabeledStatementCaseLabel
|
|
// | "case" ConstantExpression "..." ConstantExpression ':' Statement // Case LabeledStatementRange
|
|
// | "default" ':' Statement // Case LabeledStatementDefault
|
|
type LabeledStatement struct {
|
|
block *CompoundStatement
|
|
lexicalScope Scope
|
|
AttributeSpecifierList *AttributeSpecifierList
|
|
Case LabeledStatementCase `PrettyPrint:"stringer,zero"`
|
|
ConstantExpression *ConstantExpression
|
|
ConstantExpression2 *ConstantExpression
|
|
Statement *Statement
|
|
Token Token
|
|
Token2 Token
|
|
Token3 Token
|
|
}
|
|
|
|
// String implements fmt.Stringer.
|
|
func (n *LabeledStatement) String() string { return PrettyString(n) }
|
|
|
|
// Position reports the position of the first component of n, if available.
|
|
func (n *LabeledStatement) Position() (r token.Position) {
|
|
if n == nil {
|
|
return r
|
|
}
|
|
|
|
switch n.Case {
|
|
case 2:
|
|
if p := n.Token.Position(); p.IsValid() {
|
|
return p
|
|
}
|
|
|
|
if p := n.ConstantExpression.Position(); p.IsValid() {
|
|
return p
|
|
}
|
|
|
|
if p := n.Token2.Position(); p.IsValid() {
|
|
return p
|
|
}
|
|
|
|
if p := n.ConstantExpression2.Position(); p.IsValid() {
|
|
return p
|
|
}
|
|
|
|
if p := n.Token3.Position(); p.IsValid() {
|
|
return p
|
|
}
|
|
|
|
return n.Statement.Position()
|
|
case 1:
|
|
if p := n.Token.Position(); p.IsValid() {
|
|
return p
|
|
}
|
|
|
|
if p := n.ConstantExpression.Position(); p.IsValid() {
|
|
return p
|
|
}
|
|
|
|
if p := n.Token2.Position(); p.IsValid() {
|
|
return p
|
|
}
|
|
|
|
return n.Statement.Position()
|
|
case 0:
|
|
if p := n.Token.Position(); p.IsValid() {
|
|
return p
|
|
}
|
|
|
|
if p := n.Token2.Position(); p.IsValid() {
|
|
return p
|
|
}
|
|
|
|
if p := n.AttributeSpecifierList.Position(); p.IsValid() {
|
|
return p
|
|
}
|
|
|
|
return n.Statement.Position()
|
|
case 3:
|
|
if p := n.Token.Position(); p.IsValid() {
|
|
return p
|
|
}
|
|
|
|
if p := n.Token2.Position(); p.IsValid() {
|
|
return p
|
|
}
|
|
|
|
return n.Statement.Position()
|
|
default:
|
|
panic("internal error")
|
|
}
|
|
}
|
|
|
|
// LogicalAndExpressionCase represents case numbers of production LogicalAndExpression
|
|
type LogicalAndExpressionCase int
|
|
|
|
// Values of type LogicalAndExpressionCase
|
|
const (
|
|
LogicalAndExpressionOr LogicalAndExpressionCase = iota
|
|
LogicalAndExpressionLAnd
|
|
)
|
|
|
|
// String implements fmt.Stringer
|
|
func (n LogicalAndExpressionCase) String() string {
|
|
switch n {
|
|
case LogicalAndExpressionOr:
|
|
return "LogicalAndExpressionOr"
|
|
case LogicalAndExpressionLAnd:
|
|
return "LogicalAndExpressionLAnd"
|
|
default:
|
|
return fmt.Sprintf("LogicalAndExpressionCase(%v)", int(n))
|
|
}
|
|
}
|
|
|
|
// LogicalAndExpression represents data reduced by productions:
|
|
//
|
|
// LogicalAndExpression:
|
|
// InclusiveOrExpression // Case LogicalAndExpressionOr
|
|
// | LogicalAndExpression "&&" InclusiveOrExpression // Case LogicalAndExpressionLAnd
|
|
type LogicalAndExpression struct {
|
|
Operand Operand
|
|
IsSideEffectsFree bool
|
|
Case LogicalAndExpressionCase `PrettyPrint:"stringer,zero"`
|
|
InclusiveOrExpression *InclusiveOrExpression
|
|
LogicalAndExpression *LogicalAndExpression
|
|
Token Token
|
|
}
|
|
|
|
// String implements fmt.Stringer.
|
|
func (n *LogicalAndExpression) String() string { return PrettyString(n) }
|
|
|
|
// Position reports the position of the first component of n, if available.
|
|
func (n *LogicalAndExpression) Position() (r token.Position) {
|
|
if n == nil {
|
|
return r
|
|
}
|
|
|
|
switch n.Case {
|
|
case 0:
|
|
return n.InclusiveOrExpression.Position()
|
|
case 1:
|
|
if p := n.LogicalAndExpression.Position(); p.IsValid() {
|
|
return p
|
|
}
|
|
|
|
if p := n.Token.Position(); p.IsValid() {
|
|
return p
|
|
}
|
|
|
|
return n.InclusiveOrExpression.Position()
|
|
default:
|
|
panic("internal error")
|
|
}
|
|
}
|
|
|
|
// LogicalOrExpressionCase represents case numbers of production LogicalOrExpression
|
|
type LogicalOrExpressionCase int
|
|
|
|
// Values of type LogicalOrExpressionCase
|
|
const (
|
|
LogicalOrExpressionLAnd LogicalOrExpressionCase = iota
|
|
LogicalOrExpressionLOr
|
|
)
|
|
|
|
// String implements fmt.Stringer
|
|
func (n LogicalOrExpressionCase) String() string {
|
|
switch n {
|
|
case LogicalOrExpressionLAnd:
|
|
return "LogicalOrExpressionLAnd"
|
|
case LogicalOrExpressionLOr:
|
|
return "LogicalOrExpressionLOr"
|
|
default:
|
|
return fmt.Sprintf("LogicalOrExpressionCase(%v)", int(n))
|
|
}
|
|
}
|
|
|
|
// LogicalOrExpression represents data reduced by productions:
|
|
//
|
|
// LogicalOrExpression:
|
|
// LogicalAndExpression // Case LogicalOrExpressionLAnd
|
|
// | LogicalOrExpression "||" LogicalAndExpression // Case LogicalOrExpressionLOr
|
|
type LogicalOrExpression struct {
|
|
Operand Operand
|
|
IsSideEffectsFree bool
|
|
Case LogicalOrExpressionCase `PrettyPrint:"stringer,zero"`
|
|
LogicalAndExpression *LogicalAndExpression
|
|
LogicalOrExpression *LogicalOrExpression
|
|
Token Token
|
|
}
|
|
|
|
// String implements fmt.Stringer.
|
|
func (n *LogicalOrExpression) String() string { return PrettyString(n) }
|
|
|
|
// Position reports the position of the first component of n, if available.
|
|
func (n *LogicalOrExpression) Position() (r token.Position) {
|
|
if n == nil {
|
|
return r
|
|
}
|
|
|
|
switch n.Case {
|
|
case 0:
|
|
return n.LogicalAndExpression.Position()
|
|
case 1:
|
|
if p := n.LogicalOrExpression.Position(); p.IsValid() {
|
|
return p
|
|
}
|
|
|
|
if p := n.Token.Position(); p.IsValid() {
|
|
return p
|
|
}
|
|
|
|
return n.LogicalAndExpression.Position()
|
|
default:
|
|
panic("internal error")
|
|
}
|
|
}
|
|
|
|
// MultiplicativeExpressionCase represents case numbers of production MultiplicativeExpression
|
|
type MultiplicativeExpressionCase int
|
|
|
|
// Values of type MultiplicativeExpressionCase
|
|
const (
|
|
MultiplicativeExpressionCast MultiplicativeExpressionCase = iota
|
|
MultiplicativeExpressionMul
|
|
MultiplicativeExpressionDiv
|
|
MultiplicativeExpressionMod
|
|
)
|
|
|
|
// String implements fmt.Stringer
|
|
func (n MultiplicativeExpressionCase) String() string {
|
|
switch n {
|
|
case MultiplicativeExpressionCast:
|
|
return "MultiplicativeExpressionCast"
|
|
case MultiplicativeExpressionMul:
|
|
return "MultiplicativeExpressionMul"
|
|
case MultiplicativeExpressionDiv:
|
|
return "MultiplicativeExpressionDiv"
|
|
case MultiplicativeExpressionMod:
|
|
return "MultiplicativeExpressionMod"
|
|
default:
|
|
return fmt.Sprintf("MultiplicativeExpressionCase(%v)", int(n))
|
|
}
|
|
}
|
|
|
|
// MultiplicativeExpression represents data reduced by productions:
|
|
//
|
|
// MultiplicativeExpression:
|
|
// CastExpression // Case MultiplicativeExpressionCast
|
|
// | MultiplicativeExpression '*' CastExpression // Case MultiplicativeExpressionMul
|
|
// | MultiplicativeExpression '/' CastExpression // Case MultiplicativeExpressionDiv
|
|
// | MultiplicativeExpression '%' CastExpression // Case MultiplicativeExpressionMod
|
|
type MultiplicativeExpression struct {
|
|
Operand Operand
|
|
promote Type
|
|
IsSideEffectsFree bool
|
|
Case MultiplicativeExpressionCase `PrettyPrint:"stringer,zero"`
|
|
CastExpression *CastExpression
|
|
MultiplicativeExpression *MultiplicativeExpression
|
|
Token Token
|
|
}
|
|
|
|
// String implements fmt.Stringer.
|
|
func (n *MultiplicativeExpression) String() string { return PrettyString(n) }
|
|
|
|
// Position reports the position of the first component of n, if available.
|
|
func (n *MultiplicativeExpression) Position() (r token.Position) {
|
|
if n == nil {
|
|
return r
|
|
}
|
|
|
|
switch n.Case {
|
|
case 0:
|
|
return n.CastExpression.Position()
|
|
case 1, 2, 3:
|
|
if p := n.MultiplicativeExpression.Position(); p.IsValid() {
|
|
return p
|
|
}
|
|
|
|
if p := n.Token.Position(); p.IsValid() {
|
|
return p
|
|
}
|
|
|
|
return n.CastExpression.Position()
|
|
default:
|
|
panic("internal error")
|
|
}
|
|
}
|
|
|
|
// ParameterDeclarationCase represents case numbers of production ParameterDeclaration
|
|
type ParameterDeclarationCase int
|
|
|
|
// Values of type ParameterDeclarationCase
|
|
const (
|
|
ParameterDeclarationDecl ParameterDeclarationCase = iota
|
|
ParameterDeclarationAbstract
|
|
)
|
|
|
|
// String implements fmt.Stringer
|
|
func (n ParameterDeclarationCase) String() string {
|
|
switch n {
|
|
case ParameterDeclarationDecl:
|
|
return "ParameterDeclarationDecl"
|
|
case ParameterDeclarationAbstract:
|
|
return "ParameterDeclarationAbstract"
|
|
default:
|
|
return fmt.Sprintf("ParameterDeclarationCase(%v)", int(n))
|
|
}
|
|
}
|
|
|
|
// ParameterDeclaration represents data reduced by productions:
|
|
//
|
|
// ParameterDeclaration:
|
|
// DeclarationSpecifiers Declarator AttributeSpecifierList // Case ParameterDeclarationDecl
|
|
// | DeclarationSpecifiers AbstractDeclarator // Case ParameterDeclarationAbstract
|
|
type ParameterDeclaration struct {
|
|
typ Type
|
|
AbstractDeclarator *AbstractDeclarator
|
|
AttributeSpecifierList *AttributeSpecifierList
|
|
Case ParameterDeclarationCase `PrettyPrint:"stringer,zero"`
|
|
DeclarationSpecifiers *DeclarationSpecifiers
|
|
Declarator *Declarator
|
|
}
|
|
|
|
// String implements fmt.Stringer.
|
|
func (n *ParameterDeclaration) String() string { return PrettyString(n) }
|
|
|
|
// Position reports the position of the first component of n, if available.
|
|
func (n *ParameterDeclaration) Position() (r token.Position) {
|
|
if n == nil {
|
|
return r
|
|
}
|
|
|
|
switch n.Case {
|
|
case 1:
|
|
if p := n.DeclarationSpecifiers.Position(); p.IsValid() {
|
|
return p
|
|
}
|
|
|
|
return n.AbstractDeclarator.Position()
|
|
case 0:
|
|
if p := n.DeclarationSpecifiers.Position(); p.IsValid() {
|
|
return p
|
|
}
|
|
|
|
if p := n.Declarator.Position(); p.IsValid() {
|
|
return p
|
|
}
|
|
|
|
return n.AttributeSpecifierList.Position()
|
|
default:
|
|
panic("internal error")
|
|
}
|
|
}
|
|
|
|
// ParameterList represents data reduced by productions:
|
|
//
|
|
// ParameterList:
|
|
// ParameterDeclaration
|
|
// | ParameterList ',' ParameterDeclaration
|
|
type ParameterList struct {
|
|
ParameterDeclaration *ParameterDeclaration
|
|
ParameterList *ParameterList
|
|
Token Token
|
|
}
|
|
|
|
// String implements fmt.Stringer.
|
|
func (n *ParameterList) String() string { return PrettyString(n) }
|
|
|
|
// Position reports the position of the first component of n, if available.
|
|
func (n *ParameterList) Position() (r token.Position) {
|
|
if n == nil {
|
|
return r
|
|
}
|
|
|
|
return n.ParameterDeclaration.Position()
|
|
}
|
|
|
|
// ParameterTypeListCase represents case numbers of production ParameterTypeList
|
|
type ParameterTypeListCase int
|
|
|
|
// Values of type ParameterTypeListCase
|
|
const (
|
|
ParameterTypeListList ParameterTypeListCase = iota
|
|
ParameterTypeListVar
|
|
)
|
|
|
|
// String implements fmt.Stringer
|
|
func (n ParameterTypeListCase) String() string {
|
|
switch n {
|
|
case ParameterTypeListList:
|
|
return "ParameterTypeListList"
|
|
case ParameterTypeListVar:
|
|
return "ParameterTypeListVar"
|
|
default:
|
|
return fmt.Sprintf("ParameterTypeListCase(%v)", int(n))
|
|
}
|
|
}
|
|
|
|
// ParameterTypeList represents data reduced by productions:
|
|
//
|
|
// ParameterTypeList:
|
|
// ParameterList // Case ParameterTypeListList
|
|
// | ParameterList ',' "..." // Case ParameterTypeListVar
|
|
type ParameterTypeList struct {
|
|
Case ParameterTypeListCase `PrettyPrint:"stringer,zero"`
|
|
ParameterList *ParameterList
|
|
Token Token
|
|
Token2 Token
|
|
}
|
|
|
|
// String implements fmt.Stringer.
|
|
func (n *ParameterTypeList) String() string { return PrettyString(n) }
|
|
|
|
// Position reports the position of the first component of n, if available.
|
|
func (n *ParameterTypeList) Position() (r token.Position) {
|
|
if n == nil {
|
|
return r
|
|
}
|
|
|
|
switch n.Case {
|
|
case 0:
|
|
return n.ParameterList.Position()
|
|
case 1:
|
|
if p := n.ParameterList.Position(); p.IsValid() {
|
|
return p
|
|
}
|
|
|
|
if p := n.Token.Position(); p.IsValid() {
|
|
return p
|
|
}
|
|
|
|
return n.Token2.Position()
|
|
default:
|
|
panic("internal error")
|
|
}
|
|
}
|
|
|
|
// PointerCase represents case numbers of production Pointer
|
|
type PointerCase int
|
|
|
|
// Values of type PointerCase
|
|
const (
|
|
PointerTypeQual PointerCase = iota
|
|
PointerPtr
|
|
PointerBlock
|
|
)
|
|
|
|
// String implements fmt.Stringer
|
|
func (n PointerCase) String() string {
|
|
switch n {
|
|
case PointerTypeQual:
|
|
return "PointerTypeQual"
|
|
case PointerPtr:
|
|
return "PointerPtr"
|
|
case PointerBlock:
|
|
return "PointerBlock"
|
|
default:
|
|
return fmt.Sprintf("PointerCase(%v)", int(n))
|
|
}
|
|
}
|
|
|
|
// Pointer represents data reduced by productions:
|
|
//
|
|
// Pointer:
|
|
// '*' TypeQualifiers // Case PointerTypeQual
|
|
// | '*' TypeQualifiers Pointer // Case PointerPtr
|
|
// | '^' TypeQualifiers // Case PointerBlock
|
|
type Pointer struct {
|
|
typeQualifiers *typeBase
|
|
Case PointerCase `PrettyPrint:"stringer,zero"`
|
|
Pointer *Pointer
|
|
Token Token
|
|
TypeQualifiers *TypeQualifiers
|
|
}
|
|
|
|
// String implements fmt.Stringer.
|
|
func (n *Pointer) String() string { return PrettyString(n) }
|
|
|
|
// Position reports the position of the first component of n, if available.
|
|
func (n *Pointer) Position() (r token.Position) {
|
|
if n == nil {
|
|
return r
|
|
}
|
|
|
|
switch n.Case {
|
|
case 0, 2:
|
|
if p := n.Token.Position(); p.IsValid() {
|
|
return p
|
|
}
|
|
|
|
return n.TypeQualifiers.Position()
|
|
case 1:
|
|
if p := n.Token.Position(); p.IsValid() {
|
|
return p
|
|
}
|
|
|
|
if p := n.TypeQualifiers.Position(); p.IsValid() {
|
|
return p
|
|
}
|
|
|
|
return n.Pointer.Position()
|
|
default:
|
|
panic("internal error")
|
|
}
|
|
}
|
|
|
|
// PostfixExpressionCase represents case numbers of production PostfixExpression
|
|
type PostfixExpressionCase int
|
|
|
|
// Values of type PostfixExpressionCase
|
|
const (
|
|
PostfixExpressionPrimary PostfixExpressionCase = iota
|
|
PostfixExpressionIndex
|
|
PostfixExpressionCall
|
|
PostfixExpressionSelect
|
|
PostfixExpressionPSelect
|
|
PostfixExpressionInc
|
|
PostfixExpressionDec
|
|
PostfixExpressionComplit
|
|
PostfixExpressionTypeCmp
|
|
PostfixExpressionChooseExpr
|
|
)
|
|
|
|
// String implements fmt.Stringer
|
|
func (n PostfixExpressionCase) String() string {
|
|
switch n {
|
|
case PostfixExpressionPrimary:
|
|
return "PostfixExpressionPrimary"
|
|
case PostfixExpressionIndex:
|
|
return "PostfixExpressionIndex"
|
|
case PostfixExpressionCall:
|
|
return "PostfixExpressionCall"
|
|
case PostfixExpressionSelect:
|
|
return "PostfixExpressionSelect"
|
|
case PostfixExpressionPSelect:
|
|
return "PostfixExpressionPSelect"
|
|
case PostfixExpressionInc:
|
|
return "PostfixExpressionInc"
|
|
case PostfixExpressionDec:
|
|
return "PostfixExpressionDec"
|
|
case PostfixExpressionComplit:
|
|
return "PostfixExpressionComplit"
|
|
case PostfixExpressionTypeCmp:
|
|
return "PostfixExpressionTypeCmp"
|
|
case PostfixExpressionChooseExpr:
|
|
return "PostfixExpressionChooseExpr"
|
|
default:
|
|
return fmt.Sprintf("PostfixExpressionCase(%v)", int(n))
|
|
}
|
|
}
|
|
|
|
// PostfixExpression represents data reduced by productions:
|
|
//
|
|
// PostfixExpression:
|
|
// PrimaryExpression // Case PostfixExpressionPrimary
|
|
// | PostfixExpression '[' Expression ']' // Case PostfixExpressionIndex
|
|
// | PostfixExpression '(' ArgumentExpressionList ')' // Case PostfixExpressionCall
|
|
// | PostfixExpression '.' IDENTIFIER // Case PostfixExpressionSelect
|
|
// | PostfixExpression "->" IDENTIFIER // Case PostfixExpressionPSelect
|
|
// | PostfixExpression "++" // Case PostfixExpressionInc
|
|
// | PostfixExpression "--" // Case PostfixExpressionDec
|
|
// | '(' TypeName ')' '{' InitializerList ',' '}' // Case PostfixExpressionComplit
|
|
// | "__builtin_types_compatible_p" '(' TypeName ',' TypeName ')' // Case PostfixExpressionTypeCmp
|
|
// | "__builtin_choose_expr" '(' AssignmentExpression ',' AssignmentExpression ',' AssignmentExpression ')' // Case PostfixExpressionChooseExpr
|
|
type PostfixExpression struct {
|
|
Operand Operand
|
|
Field Field // Case Select, PSelect
|
|
IsSideEffectsFree bool
|
|
ArgumentExpressionList *ArgumentExpressionList
|
|
AssignmentExpression *AssignmentExpression
|
|
AssignmentExpression2 *AssignmentExpression
|
|
AssignmentExpression3 *AssignmentExpression
|
|
Case PostfixExpressionCase `PrettyPrint:"stringer,zero"`
|
|
Expression *Expression
|
|
InitializerList *InitializerList
|
|
PostfixExpression *PostfixExpression
|
|
PrimaryExpression *PrimaryExpression
|
|
Token Token
|
|
Token2 Token
|
|
Token3 Token
|
|
Token4 Token
|
|
Token5 Token
|
|
TypeName *TypeName
|
|
TypeName2 *TypeName
|
|
}
|
|
|
|
// String implements fmt.Stringer.
|
|
func (n *PostfixExpression) String() string { return PrettyString(n) }
|
|
|
|
// Position reports the position of the first component of n, if available.
|
|
func (n *PostfixExpression) Position() (r token.Position) {
|
|
if n == nil {
|
|
return r
|
|
}
|
|
|
|
switch n.Case {
|
|
case 5, 6:
|
|
if p := n.PostfixExpression.Position(); p.IsValid() {
|
|
return p
|
|
}
|
|
|
|
return n.Token.Position()
|
|
case 2:
|
|
if p := n.PostfixExpression.Position(); p.IsValid() {
|
|
return p
|
|
}
|
|
|
|
if p := n.Token.Position(); p.IsValid() {
|
|
return p
|
|
}
|
|
|
|
if p := n.ArgumentExpressionList.Position(); p.IsValid() {
|
|
return p
|
|
}
|
|
|
|
return n.Token2.Position()
|
|
case 1:
|
|
if p := n.PostfixExpression.Position(); p.IsValid() {
|
|
return p
|
|
}
|
|
|
|
if p := n.Token.Position(); p.IsValid() {
|
|
return p
|
|
}
|
|
|
|
if p := n.Expression.Position(); p.IsValid() {
|
|
return p
|
|
}
|
|
|
|
return n.Token2.Position()
|
|
case 3, 4:
|
|
if p := n.PostfixExpression.Position(); p.IsValid() {
|
|
return p
|
|
}
|
|
|
|
if p := n.Token.Position(); p.IsValid() {
|
|
return p
|
|
}
|
|
|
|
return n.Token2.Position()
|
|
case 0:
|
|
return n.PrimaryExpression.Position()
|
|
case 9:
|
|
if p := n.Token.Position(); p.IsValid() {
|
|
return p
|
|
}
|
|
|
|
if p := n.Token2.Position(); p.IsValid() {
|
|
return p
|
|
}
|
|
|
|
if p := n.AssignmentExpression.Position(); p.IsValid() {
|
|
return p
|
|
}
|
|
|
|
if p := n.Token3.Position(); p.IsValid() {
|
|
return p
|
|
}
|
|
|
|
if p := n.AssignmentExpression2.Position(); p.IsValid() {
|
|
return p
|
|
}
|
|
|
|
if p := n.Token4.Position(); p.IsValid() {
|
|
return p
|
|
}
|
|
|
|
if p := n.AssignmentExpression3.Position(); p.IsValid() {
|
|
return p
|
|
}
|
|
|
|
return n.Token5.Position()
|
|
case 8:
|
|
if p := n.Token.Position(); p.IsValid() {
|
|
return p
|
|
}
|
|
|
|
if p := n.Token2.Position(); p.IsValid() {
|
|
return p
|
|
}
|
|
|
|
if p := n.TypeName.Position(); p.IsValid() {
|
|
return p
|
|
}
|
|
|
|
if p := n.Token3.Position(); p.IsValid() {
|
|
return p
|
|
}
|
|
|
|
if p := n.TypeName2.Position(); p.IsValid() {
|
|
return p
|
|
}
|
|
|
|
return n.Token4.Position()
|
|
case 7:
|
|
if p := n.Token.Position(); p.IsValid() {
|
|
return p
|
|
}
|
|
|
|
if p := n.TypeName.Position(); p.IsValid() {
|
|
return p
|
|
}
|
|
|
|
if p := n.Token2.Position(); p.IsValid() {
|
|
return p
|
|
}
|
|
|
|
if p := n.Token3.Position(); p.IsValid() {
|
|
return p
|
|
}
|
|
|
|
if p := n.InitializerList.Position(); p.IsValid() {
|
|
return p
|
|
}
|
|
|
|
if p := n.Token4.Position(); p.IsValid() {
|
|
return p
|
|
}
|
|
|
|
return n.Token5.Position()
|
|
default:
|
|
panic("internal error")
|
|
}
|
|
}
|
|
|
|
// PragmaSTDC represents data reduced by production:
|
|
//
|
|
// PragmaSTDC:
|
|
// "__pragma_stdc" IDENTIFIER IDENTIFIER IDENTIFIER
|
|
type PragmaSTDC struct {
|
|
Token Token
|
|
Token2 Token
|
|
Token3 Token
|
|
Token4 Token
|
|
}
|
|
|
|
// String implements fmt.Stringer.
|
|
func (n *PragmaSTDC) String() string { return PrettyString(n) }
|
|
|
|
// Position reports the position of the first component of n, if available.
|
|
func (n *PragmaSTDC) Position() (r token.Position) {
|
|
if n == nil {
|
|
return r
|
|
}
|
|
|
|
if p := n.Token.Position(); p.IsValid() {
|
|
return p
|
|
}
|
|
|
|
if p := n.Token2.Position(); p.IsValid() {
|
|
return p
|
|
}
|
|
|
|
if p := n.Token3.Position(); p.IsValid() {
|
|
return p
|
|
}
|
|
|
|
return n.Token4.Position()
|
|
}
|
|
|
|
// PrimaryExpressionCase represents case numbers of production PrimaryExpression
|
|
type PrimaryExpressionCase int
|
|
|
|
// Values of type PrimaryExpressionCase
|
|
const (
|
|
PrimaryExpressionIdent PrimaryExpressionCase = iota
|
|
PrimaryExpressionInt
|
|
PrimaryExpressionFloat
|
|
PrimaryExpressionEnum
|
|
PrimaryExpressionChar
|
|
PrimaryExpressionLChar
|
|
PrimaryExpressionString
|
|
PrimaryExpressionLString
|
|
PrimaryExpressionExpr
|
|
PrimaryExpressionStmt
|
|
)
|
|
|
|
// String implements fmt.Stringer
|
|
func (n PrimaryExpressionCase) String() string {
|
|
switch n {
|
|
case PrimaryExpressionIdent:
|
|
return "PrimaryExpressionIdent"
|
|
case PrimaryExpressionInt:
|
|
return "PrimaryExpressionInt"
|
|
case PrimaryExpressionFloat:
|
|
return "PrimaryExpressionFloat"
|
|
case PrimaryExpressionEnum:
|
|
return "PrimaryExpressionEnum"
|
|
case PrimaryExpressionChar:
|
|
return "PrimaryExpressionChar"
|
|
case PrimaryExpressionLChar:
|
|
return "PrimaryExpressionLChar"
|
|
case PrimaryExpressionString:
|
|
return "PrimaryExpressionString"
|
|
case PrimaryExpressionLString:
|
|
return "PrimaryExpressionLString"
|
|
case PrimaryExpressionExpr:
|
|
return "PrimaryExpressionExpr"
|
|
case PrimaryExpressionStmt:
|
|
return "PrimaryExpressionStmt"
|
|
default:
|
|
return fmt.Sprintf("PrimaryExpressionCase(%v)", int(n))
|
|
}
|
|
}
|
|
|
|
// PrimaryExpression represents data reduced by productions:
|
|
//
|
|
// PrimaryExpression:
|
|
// IDENTIFIER // Case PrimaryExpressionIdent
|
|
// | INTCONST // Case PrimaryExpressionInt
|
|
// | FLOATCONST // Case PrimaryExpressionFloat
|
|
// | ENUMCONST // Case PrimaryExpressionEnum
|
|
// | CHARCONST // Case PrimaryExpressionChar
|
|
// | LONGCHARCONST // Case PrimaryExpressionLChar
|
|
// | STRINGLITERAL // Case PrimaryExpressionString
|
|
// | LONGSTRINGLITERAL // Case PrimaryExpressionLString
|
|
// | '(' Expression ')' // Case PrimaryExpressionExpr
|
|
// | '(' CompoundStatement ')' // Case PrimaryExpressionStmt
|
|
type PrimaryExpression struct {
|
|
Operand Operand
|
|
lexicalScope Scope
|
|
resolvedIn Scope
|
|
resolvedTo Node
|
|
IsSideEffectsFree bool
|
|
Case PrimaryExpressionCase `PrettyPrint:"stringer,zero"`
|
|
CompoundStatement *CompoundStatement
|
|
Expression *Expression
|
|
Token Token
|
|
Token2 Token
|
|
}
|
|
|
|
// String implements fmt.Stringer.
|
|
func (n *PrimaryExpression) String() string { return PrettyString(n) }
|
|
|
|
// Position reports the position of the first component of n, if available.
|
|
func (n *PrimaryExpression) Position() (r token.Position) {
|
|
if n == nil {
|
|
return r
|
|
}
|
|
|
|
switch n.Case {
|
|
case 0, 1, 2, 3, 4, 5, 6, 7:
|
|
return n.Token.Position()
|
|
case 9:
|
|
if p := n.Token.Position(); p.IsValid() {
|
|
return p
|
|
}
|
|
|
|
if p := n.CompoundStatement.Position(); p.IsValid() {
|
|
return p
|
|
}
|
|
|
|
return n.Token2.Position()
|
|
case 8:
|
|
if p := n.Token.Position(); p.IsValid() {
|
|
return p
|
|
}
|
|
|
|
if p := n.Expression.Position(); p.IsValid() {
|
|
return p
|
|
}
|
|
|
|
return n.Token2.Position()
|
|
default:
|
|
panic("internal error")
|
|
}
|
|
}
|
|
|
|
// RelationalExpressionCase represents case numbers of production RelationalExpression
|
|
type RelationalExpressionCase int
|
|
|
|
// Values of type RelationalExpressionCase
|
|
const (
|
|
RelationalExpressionShift RelationalExpressionCase = iota
|
|
RelationalExpressionLt
|
|
RelationalExpressionGt
|
|
RelationalExpressionLeq
|
|
RelationalExpressionGeq
|
|
)
|
|
|
|
// String implements fmt.Stringer
|
|
func (n RelationalExpressionCase) String() string {
|
|
switch n {
|
|
case RelationalExpressionShift:
|
|
return "RelationalExpressionShift"
|
|
case RelationalExpressionLt:
|
|
return "RelationalExpressionLt"
|
|
case RelationalExpressionGt:
|
|
return "RelationalExpressionGt"
|
|
case RelationalExpressionLeq:
|
|
return "RelationalExpressionLeq"
|
|
case RelationalExpressionGeq:
|
|
return "RelationalExpressionGeq"
|
|
default:
|
|
return fmt.Sprintf("RelationalExpressionCase(%v)", int(n))
|
|
}
|
|
}
|
|
|
|
// RelationalExpression represents data reduced by productions:
|
|
//
|
|
// RelationalExpression:
|
|
// ShiftExpression // Case RelationalExpressionShift
|
|
// | RelationalExpression '<' ShiftExpression // Case RelationalExpressionLt
|
|
// | RelationalExpression '>' ShiftExpression // Case RelationalExpressionGt
|
|
// | RelationalExpression "<=" ShiftExpression // Case RelationalExpressionLeq
|
|
// | RelationalExpression ">=" ShiftExpression // Case RelationalExpressionGeq
|
|
type RelationalExpression struct {
|
|
Operand Operand
|
|
promote Type
|
|
IsSideEffectsFree bool
|
|
Case RelationalExpressionCase `PrettyPrint:"stringer,zero"`
|
|
RelationalExpression *RelationalExpression
|
|
ShiftExpression *ShiftExpression
|
|
Token Token
|
|
}
|
|
|
|
// String implements fmt.Stringer.
|
|
func (n *RelationalExpression) String() string { return PrettyString(n) }
|
|
|
|
// Position reports the position of the first component of n, if available.
|
|
func (n *RelationalExpression) Position() (r token.Position) {
|
|
if n == nil {
|
|
return r
|
|
}
|
|
|
|
switch n.Case {
|
|
case 1, 2, 3, 4:
|
|
if p := n.RelationalExpression.Position(); p.IsValid() {
|
|
return p
|
|
}
|
|
|
|
if p := n.Token.Position(); p.IsValid() {
|
|
return p
|
|
}
|
|
|
|
return n.ShiftExpression.Position()
|
|
case 0:
|
|
return n.ShiftExpression.Position()
|
|
default:
|
|
panic("internal error")
|
|
}
|
|
}
|
|
|
|
// SelectionStatementCase represents case numbers of production SelectionStatement
|
|
type SelectionStatementCase int
|
|
|
|
// Values of type SelectionStatementCase
|
|
const (
|
|
SelectionStatementIf SelectionStatementCase = iota
|
|
SelectionStatementIfElse
|
|
SelectionStatementSwitch
|
|
)
|
|
|
|
// String implements fmt.Stringer
|
|
func (n SelectionStatementCase) String() string {
|
|
switch n {
|
|
case SelectionStatementIf:
|
|
return "SelectionStatementIf"
|
|
case SelectionStatementIfElse:
|
|
return "SelectionStatementIfElse"
|
|
case SelectionStatementSwitch:
|
|
return "SelectionStatementSwitch"
|
|
default:
|
|
return fmt.Sprintf("SelectionStatementCase(%v)", int(n))
|
|
}
|
|
}
|
|
|
|
// SelectionStatement represents data reduced by productions:
|
|
//
|
|
// SelectionStatement:
|
|
// "if" '(' Expression ')' Statement // Case SelectionStatementIf
|
|
// | "if" '(' Expression ')' Statement "else" Statement // Case SelectionStatementIfElse
|
|
// | "switch" '(' Expression ')' Statement // Case SelectionStatementSwitch
|
|
type SelectionStatement struct {
|
|
promote Type // switch expression promoted type
|
|
cases []*LabeledStatement
|
|
Case SelectionStatementCase `PrettyPrint:"stringer,zero"`
|
|
Expression *Expression
|
|
Statement *Statement
|
|
Statement2 *Statement
|
|
Token Token
|
|
Token2 Token
|
|
Token3 Token
|
|
Token4 Token
|
|
}
|
|
|
|
// String implements fmt.Stringer.
|
|
func (n *SelectionStatement) String() string { return PrettyString(n) }
|
|
|
|
// Position reports the position of the first component of n, if available.
|
|
func (n *SelectionStatement) Position() (r token.Position) {
|
|
if n == nil {
|
|
return r
|
|
}
|
|
|
|
switch n.Case {
|
|
case 0, 2:
|
|
if p := n.Token.Position(); p.IsValid() {
|
|
return p
|
|
}
|
|
|
|
if p := n.Token2.Position(); p.IsValid() {
|
|
return p
|
|
}
|
|
|
|
if p := n.Expression.Position(); p.IsValid() {
|
|
return p
|
|
}
|
|
|
|
if p := n.Token3.Position(); p.IsValid() {
|
|
return p
|
|
}
|
|
|
|
return n.Statement.Position()
|
|
case 1:
|
|
if p := n.Token.Position(); p.IsValid() {
|
|
return p
|
|
}
|
|
|
|
if p := n.Token2.Position(); p.IsValid() {
|
|
return p
|
|
}
|
|
|
|
if p := n.Expression.Position(); p.IsValid() {
|
|
return p
|
|
}
|
|
|
|
if p := n.Token3.Position(); p.IsValid() {
|
|
return p
|
|
}
|
|
|
|
if p := n.Statement.Position(); p.IsValid() {
|
|
return p
|
|
}
|
|
|
|
if p := n.Token4.Position(); p.IsValid() {
|
|
return p
|
|
}
|
|
|
|
return n.Statement2.Position()
|
|
default:
|
|
panic("internal error")
|
|
}
|
|
}
|
|
|
|
// ShiftExpressionCase represents case numbers of production ShiftExpression
|
|
type ShiftExpressionCase int
|
|
|
|
// Values of type ShiftExpressionCase
|
|
const (
|
|
ShiftExpressionAdd ShiftExpressionCase = iota
|
|
ShiftExpressionLsh
|
|
ShiftExpressionRsh
|
|
)
|
|
|
|
// String implements fmt.Stringer
|
|
func (n ShiftExpressionCase) String() string {
|
|
switch n {
|
|
case ShiftExpressionAdd:
|
|
return "ShiftExpressionAdd"
|
|
case ShiftExpressionLsh:
|
|
return "ShiftExpressionLsh"
|
|
case ShiftExpressionRsh:
|
|
return "ShiftExpressionRsh"
|
|
default:
|
|
return fmt.Sprintf("ShiftExpressionCase(%v)", int(n))
|
|
}
|
|
}
|
|
|
|
// ShiftExpression represents data reduced by productions:
|
|
//
|
|
// ShiftExpression:
|
|
// AdditiveExpression // Case ShiftExpressionAdd
|
|
// | ShiftExpression "<<" AdditiveExpression // Case ShiftExpressionLsh
|
|
// | ShiftExpression ">>" AdditiveExpression // Case ShiftExpressionRsh
|
|
type ShiftExpression struct {
|
|
Operand Operand
|
|
promote Type // shift count promoted type
|
|
IsSideEffectsFree bool
|
|
AdditiveExpression *AdditiveExpression
|
|
Case ShiftExpressionCase `PrettyPrint:"stringer,zero"`
|
|
ShiftExpression *ShiftExpression
|
|
Token Token
|
|
}
|
|
|
|
// String implements fmt.Stringer.
|
|
func (n *ShiftExpression) String() string { return PrettyString(n) }
|
|
|
|
// Position reports the position of the first component of n, if available.
|
|
func (n *ShiftExpression) Position() (r token.Position) {
|
|
if n == nil {
|
|
return r
|
|
}
|
|
|
|
switch n.Case {
|
|
case 0:
|
|
return n.AdditiveExpression.Position()
|
|
case 1, 2:
|
|
if p := n.ShiftExpression.Position(); p.IsValid() {
|
|
return p
|
|
}
|
|
|
|
if p := n.Token.Position(); p.IsValid() {
|
|
return p
|
|
}
|
|
|
|
return n.AdditiveExpression.Position()
|
|
default:
|
|
panic("internal error")
|
|
}
|
|
}
|
|
|
|
// SpecifierQualifierListCase represents case numbers of production SpecifierQualifierList
|
|
type SpecifierQualifierListCase int
|
|
|
|
// Values of type SpecifierQualifierListCase
|
|
const (
|
|
SpecifierQualifierListTypeSpec SpecifierQualifierListCase = iota
|
|
SpecifierQualifierListTypeQual
|
|
SpecifierQualifierListAlignSpec
|
|
SpecifierQualifierListAttribute
|
|
)
|
|
|
|
// String implements fmt.Stringer
|
|
func (n SpecifierQualifierListCase) String() string {
|
|
switch n {
|
|
case SpecifierQualifierListTypeSpec:
|
|
return "SpecifierQualifierListTypeSpec"
|
|
case SpecifierQualifierListTypeQual:
|
|
return "SpecifierQualifierListTypeQual"
|
|
case SpecifierQualifierListAlignSpec:
|
|
return "SpecifierQualifierListAlignSpec"
|
|
case SpecifierQualifierListAttribute:
|
|
return "SpecifierQualifierListAttribute"
|
|
default:
|
|
return fmt.Sprintf("SpecifierQualifierListCase(%v)", int(n))
|
|
}
|
|
}
|
|
|
|
// SpecifierQualifierList represents data reduced by productions:
|
|
//
|
|
// SpecifierQualifierList:
|
|
// TypeSpecifier SpecifierQualifierList // Case SpecifierQualifierListTypeSpec
|
|
// | TypeQualifier SpecifierQualifierList // Case SpecifierQualifierListTypeQual
|
|
// | AlignmentSpecifier SpecifierQualifierList // Case SpecifierQualifierListAlignSpec
|
|
// | AttributeSpecifier SpecifierQualifierList // Case SpecifierQualifierListAttribute
|
|
type SpecifierQualifierList struct {
|
|
noStorageClass
|
|
AlignmentSpecifier *AlignmentSpecifier
|
|
AttributeSpecifier *AttributeSpecifier
|
|
Case SpecifierQualifierListCase `PrettyPrint:"stringer,zero"`
|
|
SpecifierQualifierList *SpecifierQualifierList
|
|
TypeQualifier *TypeQualifier
|
|
TypeSpecifier *TypeSpecifier
|
|
}
|
|
|
|
// String implements fmt.Stringer.
|
|
func (n *SpecifierQualifierList) String() string { return PrettyString(n) }
|
|
|
|
// Position reports the position of the first component of n, if available.
|
|
func (n *SpecifierQualifierList) Position() (r token.Position) {
|
|
if n == nil {
|
|
return r
|
|
}
|
|
|
|
switch n.Case {
|
|
case 2:
|
|
if p := n.AlignmentSpecifier.Position(); p.IsValid() {
|
|
return p
|
|
}
|
|
|
|
return n.SpecifierQualifierList.Position()
|
|
case 3:
|
|
if p := n.AttributeSpecifier.Position(); p.IsValid() {
|
|
return p
|
|
}
|
|
|
|
return n.SpecifierQualifierList.Position()
|
|
case 1:
|
|
if p := n.TypeQualifier.Position(); p.IsValid() {
|
|
return p
|
|
}
|
|
|
|
return n.SpecifierQualifierList.Position()
|
|
case 0:
|
|
if p := n.TypeSpecifier.Position(); p.IsValid() {
|
|
return p
|
|
}
|
|
|
|
return n.SpecifierQualifierList.Position()
|
|
default:
|
|
panic("internal error")
|
|
}
|
|
}
|
|
|
|
// StatementCase represents case numbers of production Statement
|
|
type StatementCase int
|
|
|
|
// Values of type StatementCase
|
|
const (
|
|
StatementLabeled StatementCase = iota
|
|
StatementCompound
|
|
StatementExpr
|
|
StatementSelection
|
|
StatementIteration
|
|
StatementJump
|
|
StatementAsm
|
|
)
|
|
|
|
// String implements fmt.Stringer
|
|
func (n StatementCase) String() string {
|
|
switch n {
|
|
case StatementLabeled:
|
|
return "StatementLabeled"
|
|
case StatementCompound:
|
|
return "StatementCompound"
|
|
case StatementExpr:
|
|
return "StatementExpr"
|
|
case StatementSelection:
|
|
return "StatementSelection"
|
|
case StatementIteration:
|
|
return "StatementIteration"
|
|
case StatementJump:
|
|
return "StatementJump"
|
|
case StatementAsm:
|
|
return "StatementAsm"
|
|
default:
|
|
return fmt.Sprintf("StatementCase(%v)", int(n))
|
|
}
|
|
}
|
|
|
|
// Statement represents data reduced by productions:
|
|
//
|
|
// Statement:
|
|
// LabeledStatement // Case StatementLabeled
|
|
// | CompoundStatement // Case StatementCompound
|
|
// | ExpressionStatement // Case StatementExpr
|
|
// | SelectionStatement // Case StatementSelection
|
|
// | IterationStatement // Case StatementIteration
|
|
// | JumpStatement // Case StatementJump
|
|
// | AsmStatement // Case StatementAsm
|
|
type Statement struct {
|
|
Operand Operand // Case CompoundStatement, ExpressionStatement
|
|
AsmStatement *AsmStatement
|
|
Case StatementCase `PrettyPrint:"stringer,zero"`
|
|
CompoundStatement *CompoundStatement
|
|
ExpressionStatement *ExpressionStatement
|
|
IterationStatement *IterationStatement
|
|
JumpStatement *JumpStatement
|
|
LabeledStatement *LabeledStatement
|
|
SelectionStatement *SelectionStatement
|
|
}
|
|
|
|
// String implements fmt.Stringer.
|
|
func (n *Statement) String() string { return PrettyString(n) }
|
|
|
|
// Position reports the position of the first component of n, if available.
|
|
func (n *Statement) Position() (r token.Position) {
|
|
if n == nil {
|
|
return r
|
|
}
|
|
|
|
switch n.Case {
|
|
case 6:
|
|
return n.AsmStatement.Position()
|
|
case 1:
|
|
return n.CompoundStatement.Position()
|
|
case 2:
|
|
return n.ExpressionStatement.Position()
|
|
case 4:
|
|
return n.IterationStatement.Position()
|
|
case 5:
|
|
return n.JumpStatement.Position()
|
|
case 0:
|
|
return n.LabeledStatement.Position()
|
|
case 3:
|
|
return n.SelectionStatement.Position()
|
|
default:
|
|
panic("internal error")
|
|
}
|
|
}
|
|
|
|
// StorageClassSpecifierCase represents case numbers of production StorageClassSpecifier
|
|
type StorageClassSpecifierCase int
|
|
|
|
// Values of type StorageClassSpecifierCase
|
|
const (
|
|
StorageClassSpecifierTypedef StorageClassSpecifierCase = iota
|
|
StorageClassSpecifierExtern
|
|
StorageClassSpecifierStatic
|
|
StorageClassSpecifierAuto
|
|
StorageClassSpecifierRegister
|
|
StorageClassSpecifierThreadLocal
|
|
)
|
|
|
|
// String implements fmt.Stringer
|
|
func (n StorageClassSpecifierCase) String() string {
|
|
switch n {
|
|
case StorageClassSpecifierTypedef:
|
|
return "StorageClassSpecifierTypedef"
|
|
case StorageClassSpecifierExtern:
|
|
return "StorageClassSpecifierExtern"
|
|
case StorageClassSpecifierStatic:
|
|
return "StorageClassSpecifierStatic"
|
|
case StorageClassSpecifierAuto:
|
|
return "StorageClassSpecifierAuto"
|
|
case StorageClassSpecifierRegister:
|
|
return "StorageClassSpecifierRegister"
|
|
case StorageClassSpecifierThreadLocal:
|
|
return "StorageClassSpecifierThreadLocal"
|
|
default:
|
|
return fmt.Sprintf("StorageClassSpecifierCase(%v)", int(n))
|
|
}
|
|
}
|
|
|
|
// StorageClassSpecifier represents data reduced by productions:
|
|
//
|
|
// StorageClassSpecifier:
|
|
// "typedef" // Case StorageClassSpecifierTypedef
|
|
// | "extern" // Case StorageClassSpecifierExtern
|
|
// | "static" // Case StorageClassSpecifierStatic
|
|
// | "auto" // Case StorageClassSpecifierAuto
|
|
// | "register" // Case StorageClassSpecifierRegister
|
|
// | "_Thread_local" // Case StorageClassSpecifierThreadLocal
|
|
type StorageClassSpecifier struct {
|
|
Case StorageClassSpecifierCase `PrettyPrint:"stringer,zero"`
|
|
Token Token
|
|
}
|
|
|
|
// String implements fmt.Stringer.
|
|
func (n *StorageClassSpecifier) String() string { return PrettyString(n) }
|
|
|
|
// Position reports the position of the first component of n, if available.
|
|
func (n *StorageClassSpecifier) Position() (r token.Position) {
|
|
if n == nil {
|
|
return r
|
|
}
|
|
|
|
return n.Token.Position()
|
|
}
|
|
|
|
// StructDeclaration represents data reduced by production:
|
|
//
|
|
// StructDeclaration:
|
|
// SpecifierQualifierList StructDeclaratorList ';'
|
|
type StructDeclaration struct {
|
|
Empty bool // TCC extension
|
|
SpecifierQualifierList *SpecifierQualifierList
|
|
StructDeclaratorList *StructDeclaratorList
|
|
Token Token
|
|
}
|
|
|
|
// String implements fmt.Stringer.
|
|
func (n *StructDeclaration) String() string { return PrettyString(n) }
|
|
|
|
// Position reports the position of the first component of n, if available.
|
|
func (n *StructDeclaration) Position() (r token.Position) {
|
|
if n == nil {
|
|
return r
|
|
}
|
|
|
|
if p := n.SpecifierQualifierList.Position(); p.IsValid() {
|
|
return p
|
|
}
|
|
|
|
if p := n.StructDeclaratorList.Position(); p.IsValid() {
|
|
return p
|
|
}
|
|
|
|
return n.Token.Position()
|
|
}
|
|
|
|
// StructDeclarationList represents data reduced by productions:
|
|
//
|
|
// StructDeclarationList:
|
|
// StructDeclaration
|
|
// | StructDeclarationList StructDeclaration
|
|
type StructDeclarationList struct {
|
|
StructDeclaration *StructDeclaration
|
|
StructDeclarationList *StructDeclarationList
|
|
}
|
|
|
|
// String implements fmt.Stringer.
|
|
func (n *StructDeclarationList) String() string { return PrettyString(n) }
|
|
|
|
// Position reports the position of the first component of n, if available.
|
|
func (n *StructDeclarationList) Position() (r token.Position) {
|
|
if n == nil {
|
|
return r
|
|
}
|
|
|
|
return n.StructDeclaration.Position()
|
|
}
|
|
|
|
// StructDeclaratorCase represents case numbers of production StructDeclarator
|
|
type StructDeclaratorCase int
|
|
|
|
// Values of type StructDeclaratorCase
|
|
const (
|
|
StructDeclaratorDecl StructDeclaratorCase = iota
|
|
StructDeclaratorBitField
|
|
)
|
|
|
|
// String implements fmt.Stringer
|
|
func (n StructDeclaratorCase) String() string {
|
|
switch n {
|
|
case StructDeclaratorDecl:
|
|
return "StructDeclaratorDecl"
|
|
case StructDeclaratorBitField:
|
|
return "StructDeclaratorBitField"
|
|
default:
|
|
return fmt.Sprintf("StructDeclaratorCase(%v)", int(n))
|
|
}
|
|
}
|
|
|
|
// StructDeclarator represents data reduced by productions:
|
|
//
|
|
// StructDeclarator:
|
|
// Declarator // Case StructDeclaratorDecl
|
|
// | Declarator ':' ConstantExpression AttributeSpecifierList // Case StructDeclaratorBitField
|
|
type StructDeclarator struct {
|
|
decl *StructDeclaration
|
|
AttributeSpecifierList *AttributeSpecifierList
|
|
Case StructDeclaratorCase `PrettyPrint:"stringer,zero"`
|
|
ConstantExpression *ConstantExpression
|
|
Declarator *Declarator
|
|
Token Token
|
|
}
|
|
|
|
// String implements fmt.Stringer.
|
|
func (n *StructDeclarator) String() string { return PrettyString(n) }
|
|
|
|
// Position reports the position of the first component of n, if available.
|
|
func (n *StructDeclarator) Position() (r token.Position) {
|
|
if n == nil {
|
|
return r
|
|
}
|
|
|
|
switch n.Case {
|
|
case 0:
|
|
return n.Declarator.Position()
|
|
case 1:
|
|
if p := n.Declarator.Position(); p.IsValid() {
|
|
return p
|
|
}
|
|
|
|
if p := n.Token.Position(); p.IsValid() {
|
|
return p
|
|
}
|
|
|
|
if p := n.ConstantExpression.Position(); p.IsValid() {
|
|
return p
|
|
}
|
|
|
|
return n.AttributeSpecifierList.Position()
|
|
default:
|
|
panic("internal error")
|
|
}
|
|
}
|
|
|
|
// StructDeclaratorList represents data reduced by productions:
|
|
//
|
|
// StructDeclaratorList:
|
|
// StructDeclarator
|
|
// | StructDeclaratorList ',' StructDeclarator
|
|
type StructDeclaratorList struct {
|
|
StructDeclarator *StructDeclarator
|
|
StructDeclaratorList *StructDeclaratorList
|
|
Token Token
|
|
}
|
|
|
|
// String implements fmt.Stringer.
|
|
func (n *StructDeclaratorList) String() string { return PrettyString(n) }
|
|
|
|
// Position reports the position of the first component of n, if available.
|
|
func (n *StructDeclaratorList) Position() (r token.Position) {
|
|
if n == nil {
|
|
return r
|
|
}
|
|
|
|
return n.StructDeclarator.Position()
|
|
}
|
|
|
|
// StructOrUnionCase represents case numbers of production StructOrUnion
|
|
type StructOrUnionCase int
|
|
|
|
// Values of type StructOrUnionCase
|
|
const (
|
|
StructOrUnionStruct StructOrUnionCase = iota
|
|
StructOrUnionUnion
|
|
)
|
|
|
|
// String implements fmt.Stringer
|
|
func (n StructOrUnionCase) String() string {
|
|
switch n {
|
|
case StructOrUnionStruct:
|
|
return "StructOrUnionStruct"
|
|
case StructOrUnionUnion:
|
|
return "StructOrUnionUnion"
|
|
default:
|
|
return fmt.Sprintf("StructOrUnionCase(%v)", int(n))
|
|
}
|
|
}
|
|
|
|
// StructOrUnion represents data reduced by productions:
|
|
//
|
|
// StructOrUnion:
|
|
// "struct" // Case StructOrUnionStruct
|
|
// | "union" // Case StructOrUnionUnion
|
|
type StructOrUnion struct {
|
|
Case StructOrUnionCase `PrettyPrint:"stringer,zero"`
|
|
Token Token
|
|
}
|
|
|
|
// String implements fmt.Stringer.
|
|
func (n *StructOrUnion) String() string { return PrettyString(n) }
|
|
|
|
// Position reports the position of the first component of n, if available.
|
|
func (n *StructOrUnion) Position() (r token.Position) {
|
|
if n == nil {
|
|
return r
|
|
}
|
|
|
|
return n.Token.Position()
|
|
}
|
|
|
|
// StructOrUnionSpecifierCase represents case numbers of production StructOrUnionSpecifier
|
|
type StructOrUnionSpecifierCase int
|
|
|
|
// Values of type StructOrUnionSpecifierCase
|
|
const (
|
|
StructOrUnionSpecifierDef StructOrUnionSpecifierCase = iota
|
|
StructOrUnionSpecifierTag
|
|
)
|
|
|
|
// String implements fmt.Stringer
|
|
func (n StructOrUnionSpecifierCase) String() string {
|
|
switch n {
|
|
case StructOrUnionSpecifierDef:
|
|
return "StructOrUnionSpecifierDef"
|
|
case StructOrUnionSpecifierTag:
|
|
return "StructOrUnionSpecifierTag"
|
|
default:
|
|
return fmt.Sprintf("StructOrUnionSpecifierCase(%v)", int(n))
|
|
}
|
|
}
|
|
|
|
// StructOrUnionSpecifier represents data reduced by productions:
|
|
//
|
|
// StructOrUnionSpecifier:
|
|
// StructOrUnion AttributeSpecifierList IDENTIFIER '{' StructDeclarationList '}' // Case StructOrUnionSpecifierDef
|
|
// | StructOrUnion AttributeSpecifierList IDENTIFIER // Case StructOrUnionSpecifierTag
|
|
type StructOrUnionSpecifier struct {
|
|
lexicalScope Scope
|
|
maxAlign int
|
|
typ Type
|
|
AttributeSpecifierList *AttributeSpecifierList
|
|
Case StructOrUnionSpecifierCase `PrettyPrint:"stringer,zero"`
|
|
StructDeclarationList *StructDeclarationList
|
|
StructOrUnion *StructOrUnion
|
|
Token Token
|
|
Token2 Token
|
|
Token3 Token
|
|
}
|
|
|
|
// String implements fmt.Stringer.
|
|
func (n *StructOrUnionSpecifier) String() string { return PrettyString(n) }
|
|
|
|
// Position reports the position of the first component of n, if available.
|
|
func (n *StructOrUnionSpecifier) Position() (r token.Position) {
|
|
if n == nil {
|
|
return r
|
|
}
|
|
|
|
switch n.Case {
|
|
case 1:
|
|
if p := n.StructOrUnion.Position(); p.IsValid() {
|
|
return p
|
|
}
|
|
|
|
if p := n.AttributeSpecifierList.Position(); p.IsValid() {
|
|
return p
|
|
}
|
|
|
|
return n.Token.Position()
|
|
case 0:
|
|
if p := n.StructOrUnion.Position(); p.IsValid() {
|
|
return p
|
|
}
|
|
|
|
if p := n.AttributeSpecifierList.Position(); p.IsValid() {
|
|
return p
|
|
}
|
|
|
|
if p := n.Token.Position(); p.IsValid() {
|
|
return p
|
|
}
|
|
|
|
if p := n.Token2.Position(); p.IsValid() {
|
|
return p
|
|
}
|
|
|
|
if p := n.StructDeclarationList.Position(); p.IsValid() {
|
|
return p
|
|
}
|
|
|
|
return n.Token3.Position()
|
|
default:
|
|
panic("internal error")
|
|
}
|
|
}
|
|
|
|
// TranslationUnit represents data reduced by productions:
|
|
//
|
|
// TranslationUnit:
|
|
// ExternalDeclaration
|
|
// | TranslationUnit ExternalDeclaration
|
|
type TranslationUnit struct {
|
|
ExternalDeclaration *ExternalDeclaration
|
|
TranslationUnit *TranslationUnit
|
|
}
|
|
|
|
// String implements fmt.Stringer.
|
|
func (n *TranslationUnit) String() string { return PrettyString(n) }
|
|
|
|
// Position reports the position of the first component of n, if available.
|
|
func (n *TranslationUnit) Position() (r token.Position) {
|
|
if n == nil {
|
|
return r
|
|
}
|
|
|
|
return n.ExternalDeclaration.Position()
|
|
}
|
|
|
|
// TypeName represents data reduced by production:
|
|
//
|
|
// TypeName:
|
|
// SpecifierQualifierList AbstractDeclarator
|
|
type TypeName struct {
|
|
typ Type
|
|
AbstractDeclarator *AbstractDeclarator
|
|
SpecifierQualifierList *SpecifierQualifierList
|
|
}
|
|
|
|
// String implements fmt.Stringer.
|
|
func (n *TypeName) String() string { return PrettyString(n) }
|
|
|
|
// Position reports the position of the first component of n, if available.
|
|
func (n *TypeName) Position() (r token.Position) {
|
|
if n == nil {
|
|
return r
|
|
}
|
|
|
|
if p := n.SpecifierQualifierList.Position(); p.IsValid() {
|
|
return p
|
|
}
|
|
|
|
return n.AbstractDeclarator.Position()
|
|
}
|
|
|
|
// TypeQualifierCase represents case numbers of production TypeQualifier
|
|
type TypeQualifierCase int
|
|
|
|
// Values of type TypeQualifierCase
|
|
const (
|
|
TypeQualifierConst TypeQualifierCase = iota
|
|
TypeQualifierRestrict
|
|
TypeQualifierVolatile
|
|
TypeQualifierAtomic
|
|
)
|
|
|
|
// String implements fmt.Stringer
|
|
func (n TypeQualifierCase) String() string {
|
|
switch n {
|
|
case TypeQualifierConst:
|
|
return "TypeQualifierConst"
|
|
case TypeQualifierRestrict:
|
|
return "TypeQualifierRestrict"
|
|
case TypeQualifierVolatile:
|
|
return "TypeQualifierVolatile"
|
|
case TypeQualifierAtomic:
|
|
return "TypeQualifierAtomic"
|
|
default:
|
|
return fmt.Sprintf("TypeQualifierCase(%v)", int(n))
|
|
}
|
|
}
|
|
|
|
// TypeQualifier represents data reduced by productions:
|
|
//
|
|
// TypeQualifier:
|
|
// "const" // Case TypeQualifierConst
|
|
// | "restrict" // Case TypeQualifierRestrict
|
|
// | "volatile" // Case TypeQualifierVolatile
|
|
// | "_Atomic" // Case TypeQualifierAtomic
|
|
type TypeQualifier struct {
|
|
Case TypeQualifierCase `PrettyPrint:"stringer,zero"`
|
|
Token Token
|
|
}
|
|
|
|
// String implements fmt.Stringer.
|
|
func (n *TypeQualifier) String() string { return PrettyString(n) }
|
|
|
|
// Position reports the position of the first component of n, if available.
|
|
func (n *TypeQualifier) Position() (r token.Position) {
|
|
if n == nil {
|
|
return r
|
|
}
|
|
|
|
return n.Token.Position()
|
|
}
|
|
|
|
// TypeQualifiersCase represents case numbers of production TypeQualifiers
|
|
type TypeQualifiersCase int
|
|
|
|
// Values of type TypeQualifiersCase
|
|
const (
|
|
TypeQualifiersTypeQual TypeQualifiersCase = iota
|
|
TypeQualifiersAttribute
|
|
_
|
|
_
|
|
)
|
|
|
|
// String implements fmt.Stringer
|
|
func (n TypeQualifiersCase) String() string {
|
|
switch n {
|
|
case TypeQualifiersTypeQual:
|
|
return "TypeQualifiersTypeQual"
|
|
case TypeQualifiersAttribute:
|
|
return "TypeQualifiersAttribute"
|
|
default:
|
|
return fmt.Sprintf("TypeQualifiersCase(%v)", int(n))
|
|
}
|
|
}
|
|
|
|
// TypeQualifiers represents data reduced by productions:
|
|
//
|
|
// TypeQualifiers:
|
|
// TypeQualifier // Case TypeQualifiersTypeQual
|
|
// | AttributeSpecifier // Case TypeQualifiersAttribute
|
|
// | TypeQualifiers TypeQualifier // Case 2
|
|
// | TypeQualifiers AttributeSpecifier // Case 3
|
|
type TypeQualifiers struct {
|
|
noStorageClass
|
|
AttributeSpecifier *AttributeSpecifier
|
|
Case TypeQualifiersCase `PrettyPrint:"stringer,zero"`
|
|
TypeQualifier *TypeQualifier
|
|
TypeQualifiers *TypeQualifiers
|
|
}
|
|
|
|
// String implements fmt.Stringer.
|
|
func (n *TypeQualifiers) String() string { return PrettyString(n) }
|
|
|
|
// Position reports the position of the first component of n, if available.
|
|
func (n *TypeQualifiers) Position() (r token.Position) {
|
|
if n == nil {
|
|
return r
|
|
}
|
|
|
|
switch n.Case {
|
|
case 1:
|
|
return n.AttributeSpecifier.Position()
|
|
case 0:
|
|
return n.TypeQualifier.Position()
|
|
case 3:
|
|
if p := n.TypeQualifiers.Position(); p.IsValid() {
|
|
return p
|
|
}
|
|
|
|
return n.AttributeSpecifier.Position()
|
|
case 2:
|
|
if p := n.TypeQualifiers.Position(); p.IsValid() {
|
|
return p
|
|
}
|
|
|
|
return n.TypeQualifier.Position()
|
|
default:
|
|
panic("internal error")
|
|
}
|
|
}
|
|
|
|
// TypeSpecifierCase represents case numbers of production TypeSpecifier
|
|
type TypeSpecifierCase int
|
|
|
|
// Values of type TypeSpecifierCase
|
|
const (
|
|
TypeSpecifierVoid TypeSpecifierCase = iota
|
|
TypeSpecifierChar
|
|
TypeSpecifierShort
|
|
TypeSpecifierInt
|
|
TypeSpecifierInt8
|
|
TypeSpecifierInt16
|
|
TypeSpecifierInt32
|
|
TypeSpecifierInt64
|
|
TypeSpecifierInt128
|
|
TypeSpecifierLong
|
|
TypeSpecifierFloat
|
|
TypeSpecifierFloat16
|
|
TypeSpecifierDecimal32
|
|
TypeSpecifierDecimal64
|
|
TypeSpecifierDecimal128
|
|
TypeSpecifierFloat128
|
|
TypeSpecifierFloat80
|
|
TypeSpecifierDouble
|
|
TypeSpecifierSigned
|
|
TypeSpecifierUnsigned
|
|
TypeSpecifierBool
|
|
TypeSpecifierComplex
|
|
TypeSpecifierStructOrUnion
|
|
TypeSpecifierEnum
|
|
TypeSpecifierTypedefName
|
|
TypeSpecifierTypeofExpr
|
|
TypeSpecifierTypeofType
|
|
TypeSpecifierAtomic
|
|
TypeSpecifierFract
|
|
TypeSpecifierSat
|
|
TypeSpecifierAccum
|
|
TypeSpecifierFloat32
|
|
TypeSpecifierFloat64
|
|
TypeSpecifierFloat32x
|
|
TypeSpecifierFloat64x
|
|
)
|
|
|
|
// String implements fmt.Stringer
|
|
func (n TypeSpecifierCase) String() string {
|
|
switch n {
|
|
case TypeSpecifierVoid:
|
|
return "TypeSpecifierVoid"
|
|
case TypeSpecifierChar:
|
|
return "TypeSpecifierChar"
|
|
case TypeSpecifierShort:
|
|
return "TypeSpecifierShort"
|
|
case TypeSpecifierInt:
|
|
return "TypeSpecifierInt"
|
|
case TypeSpecifierInt8:
|
|
return "TypeSpecifierInt8"
|
|
case TypeSpecifierInt16:
|
|
return "TypeSpecifierInt16"
|
|
case TypeSpecifierInt32:
|
|
return "TypeSpecifierInt32"
|
|
case TypeSpecifierInt64:
|
|
return "TypeSpecifierInt64"
|
|
case TypeSpecifierInt128:
|
|
return "TypeSpecifierInt128"
|
|
case TypeSpecifierLong:
|
|
return "TypeSpecifierLong"
|
|
case TypeSpecifierFloat:
|
|
return "TypeSpecifierFloat"
|
|
case TypeSpecifierFloat16:
|
|
return "TypeSpecifierFloat16"
|
|
case TypeSpecifierDecimal32:
|
|
return "TypeSpecifierDecimal32"
|
|
case TypeSpecifierDecimal64:
|
|
return "TypeSpecifierDecimal64"
|
|
case TypeSpecifierDecimal128:
|
|
return "TypeSpecifierDecimal128"
|
|
case TypeSpecifierFloat128:
|
|
return "TypeSpecifierFloat128"
|
|
case TypeSpecifierFloat80:
|
|
return "TypeSpecifierFloat80"
|
|
case TypeSpecifierDouble:
|
|
return "TypeSpecifierDouble"
|
|
case TypeSpecifierSigned:
|
|
return "TypeSpecifierSigned"
|
|
case TypeSpecifierUnsigned:
|
|
return "TypeSpecifierUnsigned"
|
|
case TypeSpecifierBool:
|
|
return "TypeSpecifierBool"
|
|
case TypeSpecifierComplex:
|
|
return "TypeSpecifierComplex"
|
|
case TypeSpecifierStructOrUnion:
|
|
return "TypeSpecifierStructOrUnion"
|
|
case TypeSpecifierEnum:
|
|
return "TypeSpecifierEnum"
|
|
case TypeSpecifierTypedefName:
|
|
return "TypeSpecifierTypedefName"
|
|
case TypeSpecifierTypeofExpr:
|
|
return "TypeSpecifierTypeofExpr"
|
|
case TypeSpecifierTypeofType:
|
|
return "TypeSpecifierTypeofType"
|
|
case TypeSpecifierAtomic:
|
|
return "TypeSpecifierAtomic"
|
|
case TypeSpecifierFract:
|
|
return "TypeSpecifierFract"
|
|
case TypeSpecifierSat:
|
|
return "TypeSpecifierSat"
|
|
case TypeSpecifierAccum:
|
|
return "TypeSpecifierAccum"
|
|
case TypeSpecifierFloat32:
|
|
return "TypeSpecifierFloat32"
|
|
case TypeSpecifierFloat64:
|
|
return "TypeSpecifierFloat64"
|
|
case TypeSpecifierFloat32x:
|
|
return "TypeSpecifierFloat32x"
|
|
case TypeSpecifierFloat64x:
|
|
return "TypeSpecifierFloat64x"
|
|
default:
|
|
return fmt.Sprintf("TypeSpecifierCase(%v)", int(n))
|
|
}
|
|
}
|
|
|
|
// TypeSpecifier represents data reduced by productions:
|
|
//
|
|
// TypeSpecifier:
|
|
// "void" // Case TypeSpecifierVoid
|
|
// | "char" // Case TypeSpecifierChar
|
|
// | "short" // Case TypeSpecifierShort
|
|
// | "int" // Case TypeSpecifierInt
|
|
// | "__int8" // Case TypeSpecifierInt8
|
|
// | "__int16" // Case TypeSpecifierInt16
|
|
// | "__int32" // Case TypeSpecifierInt32
|
|
// | "__int64" // Case TypeSpecifierInt64
|
|
// | "__int128" // Case TypeSpecifierInt128
|
|
// | "long" // Case TypeSpecifierLong
|
|
// | "float" // Case TypeSpecifierFloat
|
|
// | "__fp16" // Case TypeSpecifierFloat16
|
|
// | "_Decimal32" // Case TypeSpecifierDecimal32
|
|
// | "_Decimal64" // Case TypeSpecifierDecimal64
|
|
// | "_Decimal128" // Case TypeSpecifierDecimal128
|
|
// | "_Float128" // Case TypeSpecifierFloat128
|
|
// | "__float80" // Case TypeSpecifierFloat80
|
|
// | "double" // Case TypeSpecifierDouble
|
|
// | "signed" // Case TypeSpecifierSigned
|
|
// | "unsigned" // Case TypeSpecifierUnsigned
|
|
// | "_Bool" // Case TypeSpecifierBool
|
|
// | "_Complex" // Case TypeSpecifierComplex
|
|
// | StructOrUnionSpecifier // Case TypeSpecifierStructOrUnion
|
|
// | EnumSpecifier // Case TypeSpecifierEnum
|
|
// | TYPEDEFNAME // Case TypeSpecifierTypedefName
|
|
// | "typeof" '(' Expression ')' // Case TypeSpecifierTypeofExpr
|
|
// | "typeof" '(' TypeName ')' // Case TypeSpecifierTypeofType
|
|
// | AtomicTypeSpecifier // Case TypeSpecifierAtomic
|
|
// | "_Fract" // Case TypeSpecifierFract
|
|
// | "_Sat" // Case TypeSpecifierSat
|
|
// | "_Accum" // Case TypeSpecifierAccum
|
|
// | "_Float32" // Case TypeSpecifierFloat32
|
|
// | "_Float64" // Case TypeSpecifierFloat64
|
|
// | "_Float32x" // Case TypeSpecifierFloat32x
|
|
// | "_Float64x" // Case TypeSpecifierFloat64x
|
|
type TypeSpecifier struct {
|
|
resolvedIn Scope // Case TypedefName
|
|
typ Type
|
|
AtomicTypeSpecifier *AtomicTypeSpecifier
|
|
Case TypeSpecifierCase `PrettyPrint:"stringer,zero"`
|
|
EnumSpecifier *EnumSpecifier
|
|
Expression *Expression
|
|
StructOrUnionSpecifier *StructOrUnionSpecifier
|
|
Token Token
|
|
Token2 Token
|
|
Token3 Token
|
|
TypeName *TypeName
|
|
}
|
|
|
|
// String implements fmt.Stringer.
|
|
func (n *TypeSpecifier) String() string { return PrettyString(n) }
|
|
|
|
// Position reports the position of the first component of n, if available.
|
|
func (n *TypeSpecifier) Position() (r token.Position) {
|
|
if n == nil {
|
|
return r
|
|
}
|
|
|
|
switch n.Case {
|
|
case 27:
|
|
return n.AtomicTypeSpecifier.Position()
|
|
case 23:
|
|
return n.EnumSpecifier.Position()
|
|
case 22:
|
|
return n.StructOrUnionSpecifier.Position()
|
|
case 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 24, 28, 29, 30, 31, 32, 33, 34:
|
|
return n.Token.Position()
|
|
case 25:
|
|
if p := n.Token.Position(); p.IsValid() {
|
|
return p
|
|
}
|
|
|
|
if p := n.Token2.Position(); p.IsValid() {
|
|
return p
|
|
}
|
|
|
|
if p := n.Expression.Position(); p.IsValid() {
|
|
return p
|
|
}
|
|
|
|
return n.Token3.Position()
|
|
case 26:
|
|
if p := n.Token.Position(); p.IsValid() {
|
|
return p
|
|
}
|
|
|
|
if p := n.Token2.Position(); p.IsValid() {
|
|
return p
|
|
}
|
|
|
|
if p := n.TypeName.Position(); p.IsValid() {
|
|
return p
|
|
}
|
|
|
|
return n.Token3.Position()
|
|
default:
|
|
panic("internal error")
|
|
}
|
|
}
|
|
|
|
// UnaryExpressionCase represents case numbers of production UnaryExpression
|
|
type UnaryExpressionCase int
|
|
|
|
// Values of type UnaryExpressionCase
|
|
const (
|
|
UnaryExpressionPostfix UnaryExpressionCase = iota
|
|
UnaryExpressionInc
|
|
UnaryExpressionDec
|
|
UnaryExpressionAddrof
|
|
UnaryExpressionDeref
|
|
UnaryExpressionPlus
|
|
UnaryExpressionMinus
|
|
UnaryExpressionCpl
|
|
UnaryExpressionNot
|
|
UnaryExpressionSizeofExpr
|
|
UnaryExpressionSizeofType
|
|
UnaryExpressionLabelAddr
|
|
UnaryExpressionAlignofExpr
|
|
UnaryExpressionAlignofType
|
|
UnaryExpressionImag
|
|
UnaryExpressionReal
|
|
)
|
|
|
|
// String implements fmt.Stringer
|
|
func (n UnaryExpressionCase) String() string {
|
|
switch n {
|
|
case UnaryExpressionPostfix:
|
|
return "UnaryExpressionPostfix"
|
|
case UnaryExpressionInc:
|
|
return "UnaryExpressionInc"
|
|
case UnaryExpressionDec:
|
|
return "UnaryExpressionDec"
|
|
case UnaryExpressionAddrof:
|
|
return "UnaryExpressionAddrof"
|
|
case UnaryExpressionDeref:
|
|
return "UnaryExpressionDeref"
|
|
case UnaryExpressionPlus:
|
|
return "UnaryExpressionPlus"
|
|
case UnaryExpressionMinus:
|
|
return "UnaryExpressionMinus"
|
|
case UnaryExpressionCpl:
|
|
return "UnaryExpressionCpl"
|
|
case UnaryExpressionNot:
|
|
return "UnaryExpressionNot"
|
|
case UnaryExpressionSizeofExpr:
|
|
return "UnaryExpressionSizeofExpr"
|
|
case UnaryExpressionSizeofType:
|
|
return "UnaryExpressionSizeofType"
|
|
case UnaryExpressionLabelAddr:
|
|
return "UnaryExpressionLabelAddr"
|
|
case UnaryExpressionAlignofExpr:
|
|
return "UnaryExpressionAlignofExpr"
|
|
case UnaryExpressionAlignofType:
|
|
return "UnaryExpressionAlignofType"
|
|
case UnaryExpressionImag:
|
|
return "UnaryExpressionImag"
|
|
case UnaryExpressionReal:
|
|
return "UnaryExpressionReal"
|
|
default:
|
|
return fmt.Sprintf("UnaryExpressionCase(%v)", int(n))
|
|
}
|
|
}
|
|
|
|
// UnaryExpression represents data reduced by productions:
|
|
//
|
|
// UnaryExpression:
|
|
// PostfixExpression // Case UnaryExpressionPostfix
|
|
// | "++" UnaryExpression // Case UnaryExpressionInc
|
|
// | "--" UnaryExpression // Case UnaryExpressionDec
|
|
// | '&' CastExpression // Case UnaryExpressionAddrof
|
|
// | '*' CastExpression // Case UnaryExpressionDeref
|
|
// | '+' CastExpression // Case UnaryExpressionPlus
|
|
// | '-' CastExpression // Case UnaryExpressionMinus
|
|
// | '~' CastExpression // Case UnaryExpressionCpl
|
|
// | '!' CastExpression // Case UnaryExpressionNot
|
|
// | "sizeof" UnaryExpression // Case UnaryExpressionSizeofExpr
|
|
// | "sizeof" '(' TypeName ')' // Case UnaryExpressionSizeofType
|
|
// | "&&" IDENTIFIER // Case UnaryExpressionLabelAddr
|
|
// | "_Alignof" UnaryExpression // Case UnaryExpressionAlignofExpr
|
|
// | "_Alignof" '(' TypeName ')' // Case UnaryExpressionAlignofType
|
|
// | "__imag__" UnaryExpression // Case UnaryExpressionImag
|
|
// | "__real__" UnaryExpression // Case UnaryExpressionReal
|
|
type UnaryExpression struct {
|
|
Operand Operand
|
|
lexicalScope Scope
|
|
IsSideEffectsFree bool
|
|
Case UnaryExpressionCase `PrettyPrint:"stringer,zero"`
|
|
CastExpression *CastExpression
|
|
PostfixExpression *PostfixExpression
|
|
Token Token
|
|
Token2 Token
|
|
Token3 Token
|
|
TypeName *TypeName
|
|
UnaryExpression *UnaryExpression
|
|
}
|
|
|
|
// String implements fmt.Stringer.
|
|
func (n *UnaryExpression) String() string { return PrettyString(n) }
|
|
|
|
// Position reports the position of the first component of n, if available.
|
|
func (n *UnaryExpression) Position() (r token.Position) {
|
|
if n == nil {
|
|
return r
|
|
}
|
|
|
|
switch n.Case {
|
|
case 0:
|
|
return n.PostfixExpression.Position()
|
|
case 3, 4, 5, 6, 7, 8:
|
|
if p := n.Token.Position(); p.IsValid() {
|
|
return p
|
|
}
|
|
|
|
return n.CastExpression.Position()
|
|
case 11:
|
|
if p := n.Token.Position(); p.IsValid() {
|
|
return p
|
|
}
|
|
|
|
return n.Token2.Position()
|
|
case 10, 13:
|
|
if p := n.Token.Position(); p.IsValid() {
|
|
return p
|
|
}
|
|
|
|
if p := n.Token2.Position(); p.IsValid() {
|
|
return p
|
|
}
|
|
|
|
if p := n.TypeName.Position(); p.IsValid() {
|
|
return p
|
|
}
|
|
|
|
return n.Token3.Position()
|
|
case 1, 2, 9, 12, 14, 15:
|
|
if p := n.Token.Position(); p.IsValid() {
|
|
return p
|
|
}
|
|
|
|
return n.UnaryExpression.Position()
|
|
default:
|
|
panic("internal error")
|
|
}
|
|
}
|