ast.go

// CAUTION: Generated by yy - DO NOT EDIT.

// Copyright 2015 The PL0 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 pl0

import (
	"go/token"

	"github.com/cznic/xc"
)

// Block represents data reduced by production:
//
//	Block:
//	        ConstsOpt VarsOpt ProcListOpt Statement
type Block struct {
	addr        int
	ConstsOpt   *ConstsOpt
	ProcListOpt *ProcListOpt
	Statement   *Statement
	VarsOpt     *VarsOpt
}

func (n *Block) fragment() interface{} { return n }

// String implements fmt.Stringer.
func (n *Block) String() string {
	return PrettyString(n)
}

// Pos reports the position of the first component of n or zero if it's empty.
func (n *Block) Pos() token.Pos {
	if p := n.ConstsOpt.Pos(); p != 0 {
		return p
	}

	if p := n.VarsOpt.Pos(); p != 0 {
		return p
	}

	if p := n.ProcListOpt.Pos(); p != 0 {
		return p
	}

	return n.Statement.Pos()
}

// Condition represents data reduced by productions:
//
//	Condition:
//	        "ODD" Expression
//	|       Expression '=' Expression   // Case 1
//	|       Expression '#' Expression   // Case 2
//	|       Expression '<' Expression   // Case 3
//	|       Expression "<=" Expression  // Case 4
//	|       Expression '>' Expression   // Case 5
//	|       Expression ">=" Expression  // Case 6
type Condition struct {
	Case        int
	Expression  *Expression
	Expression2 *Expression
	Token       xc.Token
}

func (n *Condition) fragment() interface{} { return n }

// String implements fmt.Stringer.
func (n *Condition) String() string {
	return PrettyString(n)
}

// Pos reports the position of the first component of n or zero if it's empty.
func (n *Condition) Pos() token.Pos {
	switch n.Case {
	case 1, 2, 3, 4, 5, 6:
		return n.Expression.Pos()
	case 0:
		return n.Token.Pos()
	default:
		panic("internal error")
	}
}

// ConstSpec represents data reduced by production:
//
//	ConstSpec:
//	        IDENT '=' Number
type ConstSpec struct {
	Number *Number
	Token  xc.Token
	Token2 xc.Token
}

func (n *ConstSpec) fragment() interface{} { return n }

// String implements fmt.Stringer.
func (n *ConstSpec) String() string {
	return PrettyString(n)
}

// Pos reports the position of the first component of n or zero if it's empty.
func (n *ConstSpec) Pos() token.Pos {
	return n.Token.Pos()
}

// ConstSpecList represents data reduced by productions:
//
//	ConstSpecList:
//	        ConstSpec
//	|       ConstSpecList ',' ConstSpec  // Case 1
type ConstSpecList struct {
	Case          int
	ConstSpec     *ConstSpec
	ConstSpecList *ConstSpecList
	Token         xc.Token
}

func (n *ConstSpecList) reverse() *ConstSpecList {
	if n == nil {
		return nil
	}

	na := n
	nb := na.ConstSpecList
	for nb != nil {
		nc := nb.ConstSpecList
		nb.ConstSpecList = na
		na = nb
		nb = nc
	}
	n.ConstSpecList = nil
	return na
}

func (n *ConstSpecList) fragment() interface{} { return n.reverse() }

// String implements fmt.Stringer.
func (n *ConstSpecList) String() string {
	return PrettyString(n)
}

// Pos reports the position of the first component of n or zero if it's empty.
func (n *ConstSpecList) Pos() token.Pos {
	switch n.Case {
	case 0:
		return n.ConstSpec.Pos()
	case 1:
		return n.ConstSpecList.Pos()
	default:
		panic("internal error")
	}
}

// Consts represents data reduced by production:
//
//	Consts:
//	        "CONST" ConstSpecList ';'
type Consts struct {
	ConstSpecList *ConstSpecList
	Token         xc.Token
	Token2        xc.Token
}

func (n *Consts) fragment() interface{} { return n }

// String implements fmt.Stringer.
func (n *Consts) String() string {
	return PrettyString(n)
}

// Pos reports the position of the first component of n or zero if it's empty.
func (n *Consts) Pos() token.Pos {
	return n.Token.Pos()
}

// ConstsOpt represents data reduced by productions:
//
//	ConstsOpt:
//	        /* empty */
//	|       Consts       // Case 1
type ConstsOpt struct {
	Consts *Consts
}

func (n *ConstsOpt) fragment() interface{} { return n }

// String implements fmt.Stringer.
func (n *ConstsOpt) String() string {
	return PrettyString(n)
}

// Pos reports the position of the first component of n or zero if it's empty.
func (n *ConstsOpt) Pos() token.Pos {
	if n == nil {
		return 0
	}

	return n.Consts.Pos()
}

// Expression represents data reduced by productions:
//
//	Expression:
//	        '+' Term
//	|       '-' Term             // Case 1
//	|       Term                 // Case 2
//	|       Expression '+' Term  // Case 3
//	|       Expression '-' Term  // Case 4
type Expression struct {
	Case       int
	Expression *Expression
	Term       *Term
	Token      xc.Token
}

func (n *Expression) fragment() interface{} { return n }

// String implements fmt.Stringer.
func (n *Expression) String() string {
	return PrettyString(n)
}

// Pos reports the position of the first component of n or zero if it's empty.
func (n *Expression) Pos() token.Pos {
	switch n.Case {
	case 3, 4:
		return n.Expression.Pos()
	case 2:
		return n.Term.Pos()
	case 0, 1:
		return n.Token.Pos()
	default:
		panic("internal error")
	}
}

// Factor represents data reduced by productions:
//
//	Factor:
//	        IDENT
//	|       Number              // Case 1
//	|       '(' Expression ')'  // Case 2
type Factor struct {
	Case       int
	Expression *Expression
	Number     *Number
	Token      xc.Token
	Token2     xc.Token
}

func (n *Factor) fragment() interface{} { return n }

// String implements fmt.Stringer.
func (n *Factor) String() string {
	return PrettyString(n)
}

// Pos reports the position of the first component of n or zero if it's empty.
func (n *Factor) Pos() token.Pos {
	switch n.Case {
	case 1:
		return n.Number.Pos()
	case 0, 2:
		return n.Token.Pos()
	default:
		panic("internal error")
	}
}

// Number represents data reduced by production:
//
//	Number:
//	        NUMBER
type Number struct {
	Value int // Numeric value of the token.
	Token xc.Token
}

func (n *Number) fragment() interface{} { return n }

// String implements fmt.Stringer.
func (n *Number) String() string {
	return PrettyString(n)
}

// Pos reports the position of the first component of n or zero if it's empty.
func (n *Number) Pos() token.Pos {
	return n.Token.Pos()
}

// ProcList represents data reduced by productions:
//
//	ProcList:
//	        ProcSpec
//	|       ProcList ProcSpec  // Case 1
type ProcList struct {
	Case     int
	ProcList *ProcList
	ProcSpec *ProcSpec
}

func (n *ProcList) reverse() *ProcList {
	if n == nil {
		return nil
	}

	na := n
	nb := na.ProcList
	for nb != nil {
		nc := nb.ProcList
		nb.ProcList = na
		na = nb
		nb = nc
	}
	n.ProcList = nil
	return na
}

func (n *ProcList) fragment() interface{} { return n.reverse() }

// String implements fmt.Stringer.
func (n *ProcList) String() string {
	return PrettyString(n)
}

// Pos reports the position of the first component of n or zero if it's empty.
func (n *ProcList) Pos() token.Pos {
	switch n.Case {
	case 1:
		return n.ProcList.Pos()
	case 0:
		return n.ProcSpec.Pos()
	default:
		panic("internal error")
	}
}

// ProcListOpt represents data reduced by productions:
//
//	ProcListOpt:
//	        /* empty */
//	|       ProcList     // Case 1
type ProcListOpt struct {
	ProcList *ProcList
}

func (n *ProcListOpt) fragment() interface{} { return n }

// String implements fmt.Stringer.
func (n *ProcListOpt) String() string {
	return PrettyString(n)
}

// Pos reports the position of the first component of n or zero if it's empty.
func (n *ProcListOpt) Pos() token.Pos {
	if n == nil {
		return 0
	}

	return n.ProcList.Pos()
}

// ProcSpec represents data reduced by production:
//
//	ProcSpec:
//	        "PROCEDURE" IDENT ';' Block ';'
type ProcSpec struct {
	addr   int
	enter  *Enter
	jmp    *Jmp
	Block  *Block
	Token  xc.Token
	Token2 xc.Token
	Token3 xc.Token
	Token4 xc.Token
}

func (n *ProcSpec) fragment() interface{} { return n }

// String implements fmt.Stringer.
func (n *ProcSpec) String() string {
	return PrettyString(n)
}

// Pos reports the position of the first component of n or zero if it's empty.
func (n *ProcSpec) Pos() token.Pos {
	return n.Token.Pos()
}

// Program represents data reduced by production:
//
//	Program:
//	        Block '.'
type Program struct {
	Code  []Instruction
	Block *Block
	Token xc.Token
}

func (n *Program) fragment() interface{} { return n }

// String implements fmt.Stringer.
func (n *Program) String() string {
	return PrettyString(n)
}

// Pos reports the position of the first component of n or zero if it's empty.
func (n *Program) Pos() token.Pos {
	if p := n.Block.Pos(); p != 0 {
		return p
	}

	return n.Token.Pos()
}

// Statement represents data reduced by productions:
//
//	Statement:
//	        /* empty */
//	|       IDENT ":=" Expression             // Case 1
//	|       "CALL" IDENT                      // Case 2
//	|       '?' IDENT                         // Case 3
//	|       '!' Expression                    // Case 4
//	|       "BEGIN" StatementList "END"       // Case 5
//	|       "IF" Condition "THEN" Statement   // Case 6
//	|       "WHILE" Condition "DO" Statement  // Case 7
type Statement struct {
	Case          int
	Condition     *Condition
	Expression    *Expression
	Statement     *Statement
	StatementList *StatementList
	Token         xc.Token
	Token2        xc.Token
}

func (n *Statement) fragment() interface{} { return n }

// String implements fmt.Stringer.
func (n *Statement) String() string {
	return PrettyString(n)
}

// Pos reports the position of the first component of n or zero if it's empty.
func (n *Statement) Pos() token.Pos {
	switch n.Case {
	case 0:
		return 0
	case 1, 2, 3, 4, 5, 6, 7:
		return n.Token.Pos()
	default:
		panic("internal error")
	}
}

// StatementList represents data reduced by productions:
//
//	StatementList:
//	        Statement
//	|       StatementList ';' Statement  // Case 1
type StatementList struct {
	Case          int
	Statement     *Statement
	StatementList *StatementList
	Token         xc.Token
}

func (n *StatementList) reverse() *StatementList {
	if n == nil {
		return nil
	}

	na := n
	nb := na.StatementList
	for nb != nil {
		nc := nb.StatementList
		nb.StatementList = na
		na = nb
		nb = nc
	}
	n.StatementList = nil
	return na
}

func (n *StatementList) fragment() interface{} { return n.reverse() }

// String implements fmt.Stringer.
func (n *StatementList) String() string {
	return PrettyString(n)
}

// Pos reports the position of the first component of n or zero if it's empty.
func (n *StatementList) Pos() token.Pos {
	switch n.Case {
	case 0:
		return n.Statement.Pos()
	case 1:
		if p := n.StatementList.Pos(); p != 0 {
			return p
		}

		return n.Token.Pos()
	default:
		panic("internal error")
	}
}

// Term represents data reduced by productions:
//
//	Term:
//	        Factor
//	|       Term '*' Factor  // Case 1
//	|       Term '/' Factor  // Case 2
type Term struct {
	Case   int
	Factor *Factor
	Term   *Term
	Token  xc.Token
}

func (n *Term) fragment() interface{} { return n }

// String implements fmt.Stringer.
func (n *Term) String() string {
	return PrettyString(n)
}

// Pos reports the position of the first component of n or zero if it's empty.
func (n *Term) Pos() token.Pos {
	switch n.Case {
	case 0:
		return n.Factor.Pos()
	case 1, 2:
		return n.Term.Pos()
	default:
		panic("internal error")
	}
}

// Variable represents data reduced by production:
//
//	Variable:
//	        IDENT
type Variable struct {
	index int
	Token xc.Token
}

func (n *Variable) fragment() interface{} { return n }

// String implements fmt.Stringer.
func (n *Variable) String() string {
	return PrettyString(n)
}

// Pos reports the position of the first component of n or zero if it's empty.
func (n *Variable) Pos() token.Pos {
	return n.Token.Pos()
}

// VariableList represents data reduced by productions:
//
//	VariableList:
//	        Variable
//	|       VariableList ',' Variable  // Case 1
type VariableList struct {
	Case         int
	Token        xc.Token
	Variable     *Variable
	VariableList *VariableList
}

func (n *VariableList) reverse() *VariableList {
	if n == nil {
		return nil
	}

	na := n
	nb := na.VariableList
	for nb != nil {
		nc := nb.VariableList
		nb.VariableList = na
		na = nb
		nb = nc
	}
	n.VariableList = nil
	return na
}

func (n *VariableList) fragment() interface{} { return n.reverse() }

// String implements fmt.Stringer.
func (n *VariableList) String() string {
	return PrettyString(n)
}

// Pos reports the position of the first component of n or zero if it's empty.
func (n *VariableList) Pos() token.Pos {
	switch n.Case {
	case 0:
		return n.Variable.Pos()
	case 1:
		return n.VariableList.Pos()
	default:
		panic("internal error")
	}
}

// Vars represents data reduced by production:
//
//	Vars:
//	        "VAR" VariableList ';'
type Vars struct {
	nvars        int
	Token        xc.Token
	Token2       xc.Token
	VariableList *VariableList
}

func (n *Vars) fragment() interface{} { return n }

// String implements fmt.Stringer.
func (n *Vars) String() string {
	return PrettyString(n)
}

// Pos reports the position of the first component of n or zero if it's empty.
func (n *Vars) Pos() token.Pos {
	return n.Token.Pos()
}

// VarsOpt represents data reduced by productions:
//
//	VarsOpt:
//	        /* empty */
//	|       Vars         // Case 1
type VarsOpt struct {
	Vars *Vars
}

func (n *VarsOpt) fragment() interface{} { return n }

// String implements fmt.Stringer.
func (n *VarsOpt) String() string {
	return PrettyString(n)
}

// Pos reports the position of the first component of n or zero if it's empty.
func (n *VarsOpt) Pos() token.Pos {
	if n == nil {
		return 0
	}

	return n.Vars.Pos()
}