ast.go

package main

// WACC Group 34
//
// ast.go: the structures for the AST the functions that parse the syntax tree
//
// Types, statements, expressions in the WACC language
// Functions to parse the WACC syntax tree into the AST

import (
	"bytes"
	"errors"
	"fmt"
	"reflect"
	"strconv"
	"sync"
)

// Type is an interface for WACC type
type Type interface {
	aststring(indent string) string
	Match(Type) bool
	String() string
	MangleSymbol() string
}

// InvalidType is a WACC type for invalid constructs
type InvalidType struct{}

// Prints invalid Types. Format:
//   "<invalid>"
func (m InvalidType) String() string {
	return "<invalid>"
}

// MangleSymbol returns the type in a form that is ready to be included in
// the mangled function symbol
func (m InvalidType) MangleSymbol() string {
	panic(fmt.Errorf("Trying to mangle void type"))
}

// VoidType is a WACC type for cases where the type is not known
type VoidType struct{}

// MangleSymbol returns the type in a form that is ready to be included in
// the mangled function symbol
func (m VoidType) MangleSymbol() string {
	return "unknown"
}

// Prints void Types. Format:
//   "<void>"
func (m VoidType) String() string {
	return "<void>"
}

// IntType is the WACC type for integers
type IntType struct{}

// Prints integer Types. Format:
//   "int"
func (i IntType) String() string {
	return "int"
}

// MangleSymbol returns the type in a form that is ready to be included in
// the mangled function symbol
func (m IntType) MangleSymbol() string {
	return m.String()
}

// EnumType is the WACC type for booleans
type EnumType struct {
	TokenBase
	ident  string
	values map[string]int
}

// Prints enum Types. Format:
//   "enum + *name*"
func (e EnumType) String() string {
	return fmt.Sprintf("enum %v", e.ident)
}

// MangleSymbol returns the type in a form that is ready to be included in
// the mangled function symbol
func (e EnumType) MangleSymbol() string {
	return fmt.Sprintf("enum_%v", e.ident)
}

// BoolType is the WACC type for booleans
type BoolType struct{}

// Prints boolean Types. Format:
//   "bool"
func (b BoolType) String() string {
	return "bool"
}

// MangleSymbol returns the type in a form that is ready to be included in
// the mangled function symbol
func (m BoolType) MangleSymbol() string {
	return m.String()
}

// CharType is the WACC type for characters
type CharType struct{}

// Prints char Types. Format:
//   "char"
func (c CharType) String() string {
	return "char"
}

// MangleSymbol returns the type in a form that is ready to be included in
// the mangled function symbol
func (m CharType) MangleSymbol() string {
	return m.String()
}

// PairType is the WACC type for pairs
type PairType struct {
	first  Type
	second Type
}

// Prints pair Types. Format:
//   "pair([fst], [snd])"
// Recurses on fst and snd.
func (p PairType) String() string {
	var first = fmt.Sprintf("%v", p.first)
	var second = fmt.Sprintf("%v", p.second)

	if p.first == nil {
		first = "pair"
	}
	if p.second == nil {
		second = "pair"
	}
	return fmt.Sprintf("pair(%v, %v)", first, second)
}

// MangleSymbol returns the type in a form that is ready to be included in
// the mangled function symbol
func (m PairType) MangleSymbol() string {
	return fmt.Sprintf(
		"p_f_%s_s_%s_e",
		m.first.MangleSymbol(),
		m.second.MangleSymbol(),
	)
}

// ArrayType is the WACC type for arrays
type ArrayType struct {
	base Type
}

// Prints array Types. Format:
//   "[arr][]"
// Recurses on arr.
func (a ArrayType) String() string {
	return fmt.Sprintf("%v[]", a.base)
}

// MangleSymbol returns the type in a form that is ready to be included in
// the mangled function symbol
func (m ArrayType) MangleSymbol() string {
	return fmt.Sprintf(
		"a_%s_e",
		m.base.MangleSymbol(),
	)
}

// ClassMember holds class member data
type ClassMember struct {
	TokenBase
	ident string
	wtype Type
	get   bool
	set   bool
}

// ClassType represents a class in WACC
type ClassType struct {
	TokenBase
	name    string
	members []*ClassMember
	methods []*FunctionDef
}

// Prints class Types. Format:
//   [classname]
func (m *ClassType) String() string {
	return m.name
}

// MangleSymbol returns the type in a form that is ready to be included in
// the mangled function symbol
func (m *ClassType) MangleSymbol() string {
	return fmt.Sprintf("class_%v", m.name)
}

// Expression is the interface for WACC expressions
type Expression interface {
	aststring(indent string) string
	TypeCheck(*Scope, chan<- error)
	Type() Type
	Token() *token32
	SetToken(*token32)
	CodeGen(*FunctionContext, Reg, chan<- Instr)
	Weight() int
	Optimise(*OptimisationContext) Expression
}

// Statement is the interface for WACC statements
type Statement interface {
	GetNext() Statement
	SetNext(Statement)
	istring(level int) string
	aststring(indent string) string
	TypeCheck(*Scope, chan<- error)
	Token() *token32
	SetToken(*token32)
	CodeGen(*FunctionContext, chan<- Instr)
	Optimise(*OptimisationContext) Statement
}

// TokenBase is the base structure that contains the token reference
type TokenBase struct {
	token *token32
}

// Token returns the token in TokenBase
func (m *TokenBase) Token() *token32 {
	return m.token
}

// SetToken sets the current token in TokenBase
func (m *TokenBase) SetToken(token *token32) {
	m.token = token
}

// BaseStatement contains the pointer to the next statement
type BaseStatement struct {
	TokenBase
	next Statement
}

// GetNext returns the next statment in BaseStatment
func (m *BaseStatement) GetNext() Statement {
	return m.next
}

// SetNext sets the next statment in BaseStatment
func (m *BaseStatement) SetNext(next Statement) {
	m.next = next
}

// SkipStatement is the struct for WACC skip statement
type SkipStatement struct {
	BaseStatement
}

// Continue Statement is the struct for WACC continue statement
type ContinueStatement struct {
	BaseStatement
}

// BreakStatement is the struct for WACC break statement
type BreakStatement struct {
	BaseStatement
}

// BlockStatement is the struct for creating new block scope
type BlockStatement struct {
	BaseStatement
	body Statement
}

// DeclareAssignStatement declares a new variable and assigns the right hand
// side expression to it
type DeclareAssignStatement struct {
	BaseStatement
	wtype Type
	ident string
	rhs   RHS
}

// LHS is the interface for the left hand side of an assignment
type LHS interface {
	aststring(indent string) string
	TypeCheck(*Scope, chan<- error)
	Type() Type
	Token() *token32
	SetToken(*token32)
	CodeGen(*FunctionContext, Reg, chan<- Instr)
	Optimise(*OptimisationContext) LHS
}

// PairElemLHS is the struct for a pair on the lhs of an assignment
type PairElemLHS struct {
	TokenBase
	wtype Type
	snd   bool
	expr  Expression
}

// Type returns the Type of the LHS
func (m *PairElemLHS) Type() Type {
	return m.wtype
}

// ArrayLHS is the struct for an array on the lhs of an assignment
type ArrayLHS struct {
	TokenBase
	wtype Type
	ident string
	index []Expression
}

// Type returns the Type of the LHS
func (m *ArrayLHS) Type() Type {
	return m.wtype
}

// VarLHS is the struct for a variable on the lhs of an assignment
type VarLHS struct {
	TokenBase
	wtype Type
	ident string
}

// Type returns the Type of the LHS
func (m *VarLHS) Type() Type {
	return m.wtype
}

// RHS is the interface for the right hand side of an assignment
type RHS interface {
	aststring(indent string) string
	TypeCheck(*Scope, chan<- error)
	Type() Type
	Token() *token32
	SetToken(*token32)
	CodeGen(*FunctionContext, Reg, chan<- Instr)
	Optimise(*OptimisationContext) RHS
}

// PairLiterRHS is the struct for pair literals on the rhs of an assignment
type PairLiterRHS struct {
	TokenBase
	PairLiteral
}

// Type returns the deduced type of the right hand side assignment source.
func (m *PairLiterRHS) Type() Type {
	fstT := m.fst.Type()
	sndT := m.snd.Type()

	return PairType{first: fstT, second: sndT}
}

// ArrayLiterRHS is the struct for array literals on the rhs of an assignment
type ArrayLiterRHS struct {
	TokenBase
	elements []Expression
}

// Type returns the deduced type of the right hand side assignment source.
func (m *ArrayLiterRHS) Type() Type {
	if len(m.elements) == 0 {
		return ArrayType{base: VoidType{}}
	}

	t := m.elements[0].Type()

	return ArrayType{t}
}

// PairElemRHS is the struct for pair elements on the rhs of an assignment
type PairElemRHS struct {
	TokenBase
	snd  bool
	expr Expression
}

// Type returns the deduced type of the right hand side assignment source.
func (m *PairElemRHS) Type() Type {
	switch t := m.expr.Type().(type) {
	case PairType:
		if !m.snd {
			return t.first
		}
		return t.second
	default:
		return InvalidType{}
	}
}

// FunctionCall is the base struct for function calls
type FunctionCall struct {
	obj          string
	ident        string
	mangledIdent string
	args         []Expression
	wtype        Type
}

// FunctionCall is the struct for function calls not being assigned to a var
type FunctionCallStat struct {
	BaseStatement
	FunctionCall
}

// FunctionCallRHS is the struct for function calls on the rhs of an assignment
type FunctionCallRHS struct {
	TokenBase
	FunctionCall
}

// Type returns the deduced type of the right hand side assignment source.
func (m *FunctionCallRHS) Type() Type {
	return m.wtype
}

// ExpressionRHS is the struct for expressions on the rhs of an assignment
type ExpressionRHS struct {
	TokenBase
	expr Expression
}

// Type returns the deduced type of the right hand side assignment source.
func (m *ExpressionRHS) Type() Type {
	return m.expr.Type()
}

// NewInstanceRHS is the for new class instance on the rhs of an assignment
type NewInstanceRHS struct {
	TokenBase
	constr string
	wtype  Type
	args   []Expression
}

// Type returns the deduced type of the right hand side assignment source.
func (m *NewInstanceRHS) Type() Type {
	return m.wtype
}

// AssignStatement is the struct for an assignment statement
type AssignStatement struct {
	BaseStatement
	target LHS
	rhs    RHS
}

// ReadStatement is the struct for a read statement
type ReadStatement struct {
	BaseStatement
	target LHS
}

// FreeStatement is the struct for a free statement
type FreeStatement struct {
	BaseStatement
	expr Expression
}

// ReturnStatement is the struct for a return statement
type ReturnStatement struct {
	BaseStatement
	expr Expression
}

// ExitStatement is the struct for an exit statement
type ExitStatement struct {
	BaseStatement
	expr Expression
}

// PrintLnStatement is the struct for a println statement
type PrintLnStatement struct {
	BaseStatement
	expr Expression
}

// PrintStatement is the struct for a print statement
type PrintStatement struct {
	BaseStatement
	expr Expression
}

// IfStatement is the struct for a if-else statement
type IfStatement struct {
	BaseStatement
	cond      Expression
	trueStat  Statement
	falseStat Statement
}

// WhileStatement is the struct for a while statement
type WhileStatement struct {
	BaseStatement
	cond Expression
	body Statement
}

// SwitchStatement is the struct for a while statement
type SwitchStatement struct {
	BaseStatement
	cond        Expression
	cases       []Expression
	fts         []bool
	bodies      []Statement
	defaultCase Statement
}

// DoWhileStatement is the struct for a doWhile statement
type DoWhileStatement struct {
	BaseStatement
	cond Expression
	body Statement
}

//ForStatement is the struct for a for statement
type ForStatement struct {
	BaseStatement
	init  Statement
	cond  Expression
	after Statement
	body  Statement
}

// FunctionParam is the struct for a function parameter
type FunctionParam struct {
	TokenBase
	name  string
	wtype Type
}

// FunctionDef is the struct for a function definition
type FunctionDef struct {
	TokenBase
	ident      string
	class      *ClassType
	returnType Type
	params     []*FunctionParam
	body       Statement
}

// Symbol returns the mangled symbol of the function to distinguish overloaded
// variants
func (m *FunctionDef) Symbol() string {
	var buffer bytes.Buffer

	buffer.WriteString(m.ident)

	if m.class != nil {
		buffer.WriteString(fmt.Sprintf("__class_%s_", m.class.name))
	}

	if len(m.params) > 0 {
		buffer.WriteString("__ol_")
	}

	for _, param := range m.params {
		buffer.WriteString(
			fmt.Sprintf("_%s", param.wtype.MangleSymbol()),
		)
	}

	return buffer.String()
}

// AST is the main struct that represents the abstract syntax tree
type AST struct {
	main      Statement
	functions []*FunctionDef
	includes  []string
	classes   []*ClassType
	enums     []*EnumType
}

// nodeRange given a node returns a channel from which all nodes at the same
// level can be read
func nodeRange(node *node32) <-chan *node32 {
	out := make(chan *node32)
	go func() {
		for ; node != nil; node = node.next {
			out <- node
		}
		close(out)
	}()
	return out
}

// nextNode given a node and a peg rule returns the first node in the chain
// that was created from that peg rule
func nextNode(node *node32, rule pegRule) *node32 {
	for cnode := range nodeRange(node) {
		if cnode.pegRule == rule {
			return cnode
		}
	}

	return nil
}

// parse array element access inside an expression
func parseArrayElem(node *node32) (Expression, error) {
	arrElem := &ArrayElem{}

	arrElem.ident = node.match

	// read and add all the indexer expressions
	for enode := nextNode(node, ruleEXPR); enode != nil; enode = nextNode(enode.next, ruleEXPR) {
		var exp Expression
		var err error
		if exp, err = parseExpr(enode.up); err != nil {
			return nil, err
		}
		arrElem.indexes = append(arrElem.indexes, exp)
	}

	return arrElem, nil
}

// Ident is the struct to represent an identifier
type Ident struct {
	TokenBase
	wtype Type
	ident string
}

// Type returns the Type of the expression
func (m *Ident) Type() Type {
	return m.wtype
}

// IntLiteral is the struct to represent an integer literal
type IntLiteral struct {
	TokenBase
	value int
}

// Type returns the Type of the expression
func (m *IntLiteral) Type() Type {
	return IntType{}
}

// EnumLiteral is the struct to represent an integer literal
type EnumLiteral struct {
	TokenBase
	wtype Type
	ident string
	field string
	value int
}

// Type returns the Type of the expression
func (m *EnumLiteral) Type() Type {
	return m.wtype
}

// BoolLiteralTrue is the struct to represent a true boolean literal
type BoolLiteralTrue struct {
	TokenBase
}

// Type returns the Type of the expression
func (m *BoolLiteralTrue) Type() Type {
	return BoolType{}
}

// BoolLiteralFalse is the struct to represent a false boolean literal
type BoolLiteralFalse struct {
	TokenBase
}

// Type returns the Type of the expression
func (m *BoolLiteralFalse) Type() Type {
	return BoolType{}
}

// CharLiteral is the struct to represent a character literal
type CharLiteral struct {
	TokenBase
	char string
}

// Type returns the Type of the expression
func (m *CharLiteral) Type() Type {
	return CharType{}
}

// StringLiteral is the struct to represent a string literal
type StringLiteral struct {
	TokenBase
	str string
}

// Type returns the Type of the expression
func (m *StringLiteral) Type() Type {
	return ArrayType{CharType{}}
}

// PairLiteral is the struct to represent a pair literal
type PairLiteral struct {
	TokenBase
	weightCache int
	fst         Expression
	snd         Expression
}

// Type returns the Type of the expression
func (m *PairLiteral) Type() Type {
	return PairType{first: m.fst.Type(), second: m.snd.Type()}
}

// NullPair is the struct to represent a null pair
type NullPair struct {
	TokenBase
}

// Type returns the Type of the expression
func (m *NullPair) Type() Type {
	return PairType{first: VoidType{}, second: VoidType{}}
}

// ArrayElem is the struct to represent an array element
type ArrayElem struct {
	TokenBase
	weightCache int
	ident       string
	wtype       Type
	indexes     []Expression
}

// Type returns the Type of the expression
func (m *ArrayElem) Type() Type {
	return m.wtype
}

// UnaryOperator is the struct to represent the unary operators
type UnaryOperator interface {
	Expression
	GetExpression() Expression
	SetExpression(Expression)
}

// UnaryOperatorBase is the struct to represent the expression having the unary
// operator
type UnaryOperatorBase struct {
	TokenBase
	weightCache int
	expr        Expression
}

// GetExpression returns the expression associated with UnaryOperator
func (m *UnaryOperatorBase) GetExpression() Expression {
	return m.expr
}

// SetExpression sets the expression associated with UnaryOperator
func (m *UnaryOperatorBase) SetExpression(exp Expression) {
	m.expr = exp
}

// UnaryOperatorNot represents '!'
type UnaryOperatorNot struct {
	UnaryOperatorBase
}

// Type returns the Type of the expression
func (m *UnaryOperatorNot) Type() Type {
	return BoolType{}
}

// UnaryOperatorNegate represents '-'
type UnaryOperatorNegate struct {
	UnaryOperatorBase
}

// Type returns the Type of the expression
func (m *UnaryOperatorNegate) Type() Type {
	return IntType{}
}

// UnaryOperatorLen represents 'len'
type UnaryOperatorLen struct {
	UnaryOperatorBase
}

// Type returns the Type of the expression
func (m *UnaryOperatorLen) Type() Type {
	return IntType{}
}

// UnaryOperatorOrd represents 'ord'
type UnaryOperatorOrd struct {
	UnaryOperatorBase
}

// Type returns the Type of the expression
func (m *UnaryOperatorOrd) Type() Type {
	return IntType{}
}

// UnaryOperatorChr represents 'chr'
type UnaryOperatorChr struct {
	UnaryOperatorBase
}

// Type returns the Type of the expression
func (m *UnaryOperatorChr) Type() Type {
	return CharType{}
}

// BinaryOperator represents a generic binaryOperator which might be an expr.
type BinaryOperator interface {
	Expression
	GetRHS() Expression
	SetRHS(Expression)
	GetLHS() Expression
	SetLHS(Expression)
}

// BinaryOperatorBase represents the base of a binary operator.
type BinaryOperatorBase struct {
	TokenBase
	weightCache int
	lhs         Expression
	rhs         Expression
}

// GetLHS returns the left-hand-side associated with a BinaryOperatorBase.
func (m *BinaryOperatorBase) GetLHS() Expression {
	return m.lhs
}

// SetLHS sets the left-hand-side associated with a BinaryOperatorBase.
func (m *BinaryOperatorBase) SetLHS(exp Expression) {
	m.lhs = exp
}

// GetRHS returns the right-hand-side associated with a BinaryOperatorBase.
func (m *BinaryOperatorBase) GetRHS() Expression {
	return m.rhs
}

// SetRHS sets the right-hand-side associated with a BinaryOperatorBase.
func (m *BinaryOperatorBase) SetRHS(exp Expression) {
	m.rhs = exp
}

// BinaryOperatorMult represents '*'
type BinaryOperatorMult struct {
	BinaryOperatorBase
}

// Type returns the Type of the expression
func (m *BinaryOperatorMult) Type() Type {
	return IntType{}
}

// BinaryOperatorDiv represents '/'
type BinaryOperatorDiv struct {
	BinaryOperatorBase
}

// Type returns the Type of the expression
func (m *BinaryOperatorDiv) Type() Type {
	return IntType{}
}

// BinaryOperatorMod represents '%'
type BinaryOperatorMod struct {
	BinaryOperatorBase
}

// Type returns the Type of the expression
func (m *BinaryOperatorMod) Type() Type {
	return IntType{}
}

// BinaryOperatorAdd represents '+'
type BinaryOperatorAdd struct {
	BinaryOperatorBase
}

// Type returns the Type of the expression
func (m *BinaryOperatorAdd) Type() Type {
	return IntType{}
}

// BinaryOperatorSub represents '-'
type BinaryOperatorSub struct {
	BinaryOperatorBase
}

// Type returns the Type of the expression
func (m *BinaryOperatorSub) Type() Type {
	return IntType{}
}

// BinaryOperatorGreaterThan represents '>'
type BinaryOperatorGreaterThan struct {
	BinaryOperatorBase
}

// Type returns the Type of the expression
func (m *BinaryOperatorGreaterThan) Type() Type {
	return BoolType{}
}

// BinaryOperatorGreaterEqual represents '>='
type BinaryOperatorGreaterEqual struct {
	BinaryOperatorBase
}

// Type returns the Type of the expression
func (m *BinaryOperatorGreaterEqual) Type() Type {
	return BoolType{}
}

// BinaryOperatorLessThan represents '<'
type BinaryOperatorLessThan struct {
	BinaryOperatorBase
}

// Type returns the Type of the expression
func (m *BinaryOperatorLessThan) Type() Type {
	return BoolType{}
}

// BinaryOperatorLessEqual represents '<='
type BinaryOperatorLessEqual struct {
	BinaryOperatorBase
}

// Type returns the Type of the expression
func (m *BinaryOperatorLessEqual) Type() Type {
	return BoolType{}
}

// BinaryOperatorEqual represents '=='
type BinaryOperatorEqual struct {
	BinaryOperatorBase
}

// Type returns the Type of the expression
func (m *BinaryOperatorEqual) Type() Type {
	return BoolType{}
}

// BinaryOperatorNotEqual represents '!='
type BinaryOperatorNotEqual struct {
	BinaryOperatorBase
}

// Type returns the Type of the expression
func (m *BinaryOperatorNotEqual) Type() Type {
	return BoolType{}
}

// BinaryOperatorAnd represents '&&'
type BinaryOperatorAnd struct {
	BinaryOperatorBase
}

// Type returns the Type of the expression
func (m *BinaryOperatorAnd) Type() Type {
	return BoolType{}
}

// BinaryOperatorOr represents '||'
type BinaryOperatorOr struct {
	BinaryOperatorBase
}

// Type returns the Type of the expression
func (m *BinaryOperatorOr) Type() Type {
	return BoolType{}
}

// BinaryOperatorBitAnd represents '&'
type BinaryOperatorBitAnd struct {
	BinaryOperatorBase
}

// Type returns the Type of the expression
func (m *BinaryOperatorBitAnd) Type() Type {
	return IntType{}
}

// BinaryOperatorBitOr represents '|'
type BinaryOperatorBitOr struct {
	BinaryOperatorBase
}

// Type returns the Type of the expression
func (m *BinaryOperatorBitOr) Type() Type {
	return IntType{}
}

// ExprParen represents '()'
type ExprParen struct {
	TokenBase
}

// Type returns the Type of the expression
func (m *ExprParen) Type() Type {
	return InvalidType{}
}

// VoidExpr represents an expression without anything in it
type VoidExpr struct {
	TokenBase
}

// Type returns the Type of the expression
func (m *VoidExpr) Type() Type {
	return VoidType{}
}

// exprStream given an expression node sends the all the nodes after it to
// channel skipping over spaces and flattening out the structure
func exprStream(node *node32) <-chan *node32 {
	out := make(chan *node32)
	go func() {
		for ; node != nil; node = node.next {
			switch node.pegRule {
			case ruleSPACE:
			case ruleBOOLLITER:
				out <- node.up
			case ruleEXPR:
				for inode := range exprStream(node.up) {
					out <- inode
				}
			default:
				out <- node
			}
		}
		close(out)
	}()
	return out
}

// PriorityMap is a map from interface to integers. It holds all
// the priority value of all the Unary/Binary Operators
var PriorityMap = map[interface{}]int{
	UnaryOperatorNot{}:           2,
	UnaryOperatorNegate{}:        2,
	UnaryOperatorLen{}:           2,
	UnaryOperatorOrd{}:           2,
	UnaryOperatorChr{}:           2,
	BinaryOperatorMult{}:         3,
	BinaryOperatorDiv{}:          3,
	BinaryOperatorMod{}:          3,
	BinaryOperatorAdd{}:          4,
	BinaryOperatorSub{}:          4,
	BinaryOperatorGreaterThan{}:  6,
	BinaryOperatorGreaterEqual{}: 6,
	BinaryOperatorLessThan{}:     6,
	BinaryOperatorLessEqual{}:    6,
	BinaryOperatorEqual{}:        7,
	BinaryOperatorNotEqual{}:     7,
	BinaryOperatorAnd{}:          11,
	BinaryOperatorBitAnd{}:       11,
	BinaryOperatorOr{}:           12,
	BinaryOperatorBitOr{}:        12,
	ExprParen{}:                  13,
}

// parseExpr parses an expression and builds an expression tree that respects
// the operator precedence
// the function uses the shunting yard algorithm to achieve this
func parseExpr(node *node32) (Expression, error) {
	var stack []Expression
	var opstack []Expression

	// push an expression to the stack
	push := func(e Expression) {
		stack = append(stack, e)
	}

	// peek at the top of the expression stack
	peek := func() Expression {
		if len(stack) == 0 {
			return nil
		}
		return stack[len(stack)-1]
	}

	// pop and return the expression at the top the expression stack
	pop := func() (ret Expression) {
		ret, stack = stack[len(stack)-1], stack[:len(stack)-1]
		return
	}

	// push an operator to the operator stack
	pushop := func(e Expression) {
		opstack = append(opstack, e)
	}

	// peek at the top the operator stack
	peekop := func() Expression {
		if len(opstack) == 0 {
			return nil
		}
		return opstack[len(opstack)-1]
	}

	// pop and return the operator at the top of the operator stack
	popop := func() {
		var exp Expression

		exp, opstack = opstack[len(opstack)-1], opstack[:len(opstack)-1]

		switch t := exp.(type) {
		case UnaryOperator:
			t.SetExpression(pop())
		case BinaryOperator:
			t.SetRHS(pop())
			t.SetLHS(pop())
		case *ExprParen:
			exp = nil
		}

		if exp != nil {
			push(exp)
		}
	}

	// prio returns the priority of a given operator
	// the lesser the value the more tightly the operator binds
	// values taken from the operator precedence of C
	// special case parenthesis,  otherwise a high value
	prio := func(exp Expression) int {
		typ := reflect.TypeOf(exp).Elem()
		expr := reflect.New(typ).Elem().Interface()

		value, exists := PriorityMap[expr]
		if !exists {
			return 42
		}

		return value
	}

	// returns whether the operator is right associative
	rightAssoc := func(exp Expression) bool {
		switch exp.(type) {
		case *UnaryOperatorNot,
			*UnaryOperatorNegate,
			*UnaryOperatorLen,
			*UnaryOperatorOrd,
			*UnaryOperatorChr:
			return true
		default:
			return false
		}
	}

	// given a peg rule return the operator with the expressions set
	ruleToOp := func(outer, inner pegRule) Expression {

		var PEGOperatorMap = map[pegRule]map[pegRule]Expression{
			ruleUNARYOPER: {
				ruleBANG:  &UnaryOperatorNot{},
				ruleMINUS: &UnaryOperatorNegate{},
				ruleLEN:   &UnaryOperatorLen{},
				ruleORD:   &UnaryOperatorOrd{},
				ruleCHR:   &UnaryOperatorChr{},
			},
			ruleBINARYOPER: {
				ruleSTAR:    &BinaryOperatorMult{},
				ruleDIV:     &BinaryOperatorDiv{},
				ruleMOD:     &BinaryOperatorMod{},
				rulePLUS:    &BinaryOperatorAdd{},
				ruleMINUS:   &BinaryOperatorSub{},
				ruleGT:      &BinaryOperatorGreaterThan{},
				ruleGE:      &BinaryOperatorGreaterEqual{},
				ruleLT:      &BinaryOperatorLessThan{},
				ruleLE:      &BinaryOperatorLessEqual{},
				ruleEQUEQU:  &BinaryOperatorEqual{},
				ruleBANGEQU: &BinaryOperatorNotEqual{},
				ruleANDAND:  &BinaryOperatorAnd{},
				ruleOROR:    &BinaryOperatorOr{},
				ruleAND:     &BinaryOperatorBitAnd{},
				ruleOR:      &BinaryOperatorBitOr{},
			},
		}

		value, exists := PEGOperatorMap[outer][inner]
		if !exists {
			return nil
		}

		return value
	}

	// process the nodes in order
	for enode := range exprStream(node) {
		switch enode.pegRule {
		case ruleINTLITER:
			num, err := strconv.ParseInt(enode.match, 10, 32)
			if err != nil {
				// number does not fit into WACC integer size
				numerr := err.(*strconv.NumError)
				switch numerr.Err {
				case strconv.ErrRange:
					return nil, CreateBigIntError(
						&enode.token32,
						enode.match,
					)
				}
				return nil, err
			}
			push(&IntLiteral{value: int(num)})
		case ruleFALSE:
			push(&BoolLiteralFalse{})
		case ruleTRUE:
			push(&BoolLiteralTrue{})
		case ruleCHARLITER:
			push(&CharLiteral{char: enode.up.next.match})
		case ruleSTRLITER:
			strLiter := &StringLiteral{}
			strNode := nextNode(enode.up, ruleSTR)
			if strNode != nil {
				// string may be empty, only set contents if not
				strLiter.str = strNode.match
			}
			push(strLiter)
		case rulePAIRLITER:
			push(&NullPair{})
		case ruleIDENT:
			push(&Ident{ident: enode.match})
		case ruleENUMLITER:
			enumLiter := &EnumLiteral{}
			enumLiter.ident = nextNode(enode.up, ruleIDENT).match
			enumLiter.field = nextNode(enode.up.next, ruleIDENT).match

			push(enumLiter)
		case ruleARRAYELEM:
			arrElem, err := parseArrayElem(enode.up)
			if err != nil {
				return nil, err
			}
			push(arrElem)
		case ruleUNARYOPER, ruleBINARYOPER:
			op1 := ruleToOp(enode.pegRule, enode.up.pegRule)
		op2l:
			for op2 := peekop(); op2 != nil; op2 = peekop() {
				if op2 == nil {
					break
				}

				// pop all operators with more tight binding
				switch {
				case !rightAssoc(op1) && prio(op1) >= prio(op2),
					rightAssoc(op1) && prio(op1) > prio(op2):
					popop()
				default:
					break op2l
				}
			}
			pushop(op1)
		case ruleLPAR:
			pushop(&ExprParen{})
		case ruleRPAR:
			// when a parenthesis is closed pop all the operators
			// the were inside
		parloop:
			for {
				switch peekop().(type) {
				case *ExprParen:
					popop()
					break parloop
				default:
					popop()
				}
			}
		}

		// set tokens on newly pushed expressions
		if val := peek(); val != nil && val.Token() == nil {
			peek().SetToken(&node.token32)
		}

		if op := peekop(); op != nil && op.Token() == nil {
			peekop().SetToken(&node.token32)
		}
	}

	// if operators are still left pop them
	for peekop() != nil {
		popop()
	}

	return pop(), nil
}

// parseLHS parses all left hand side constructs that can be assigned to
func parseLHS(node *node32) (LHS, error) {
	switch node.pegRule {
	case rulePAIRELEM:
		target := new(PairElemLHS)

		target.SetToken(&node.token32)

		fstNode := nextNode(node.up, ruleFST)
		target.snd = fstNode == nil

		exprNode := nextNode(node.up, ruleEXPR)
		var err error
		if target.expr, err = parseExpr(exprNode.up); err != nil {
			return nil, err
		}

		return target, nil
	case ruleARRAYELEM:
		target := new(ArrayLHS)

		target.SetToken(&node.token32)

		identNode := nextNode(node.up, ruleIDENT)
		target.ident = identNode.match

		for exprNode := nextNode(node.up, ruleEXPR); exprNode != nil; exprNode = nextNode(exprNode.next, ruleEXPR) {
			var expr Expression
			var err error
			if expr, err = parseExpr(exprNode.up); err != nil {
				return nil, err
			}
			target.index = append(target.index, expr)
		}

		return target, nil
	case ruleIDENT:
		target := &VarLHS{ident: node.match}
		target.SetToken(&node.token32)
		return target, nil
	default:
		return nil, fmt.Errorf("Unexpected %s %s", node.String(), node.match)
	}
}

// parseRHS parses all right hand side constructs that provide assignable values
func parseRHS(node *node32) (RHS, error) {
	switch node.pegRule {
	case ruleNEWPAIR:
		var err error
		pair := new(PairLiterRHS)

		pair.SetToken(&node.token32)

		fstNode := nextNode(node, ruleEXPR)
		if pair.fst, err = parseExpr(fstNode.up); err != nil {
			return nil, err
		}

		sndNode := nextNode(fstNode.next, ruleEXPR)
		if pair.snd, err = parseExpr(sndNode.up); err != nil {
			return nil, err
		}

		return pair, nil
	case ruleARRAYLITER:
		node = node.up

		arr := new(ArrayLiterRHS)

		arr.SetToken(&node.token32)

		for node = nextNode(node, ruleEXPR); node != nil; node = nextNode(node.next, ruleEXPR) {
			var err error
			var expr Expression

			if expr, err = parseExpr(node.up); err != nil {
				return nil, err
			}
			arr.elements = append(arr.elements, expr)
		}

		return arr, nil
	case rulePAIRELEM:
		target := new(PairElemRHS)

		target.SetToken(&node.token32)

		fstNode := nextNode(node.up, ruleFST)
		target.snd = fstNode == nil

		exprNode := nextNode(node.up, ruleEXPR)
		var err error
		if target.expr, err = parseExpr(exprNode.up); err != nil {
			return nil, err
		}

		return target, nil
	case ruleFCALL:
		node = node.up
		call := new(FunctionCallRHS)

		call.SetToken(&node.token32)

		objNode := nextNode(node, ruleCLASSOBJ)
		if objNode != nil {
			call.obj = objNode.match
		}

		identNode := nextNode(node, ruleIDENT)
		call.ident = identNode.match

		arglistNode := nextNode(node, ruleARGLIST)
		if arglistNode == nil {
			return call, nil
		}

		for argNode := nextNode(arglistNode.up, ruleEXPR); argNode != nil; argNode = nextNode(argNode.next, ruleEXPR) {
			var err error
			var expr Expression

			if expr, err = parseExpr(argNode.up); err != nil {
				return nil, err
			}

			call.args = append(call.args, expr)
		}

		return call, nil
	case ruleEXPR:
		exprRHS := new(ExpressionRHS)

		exprRHS.SetToken(&node.token32)

		var err error
		var expr Expression
		if expr, err = parseExpr(node.up); err != nil {
			return nil, err
		}

		exprRHS.expr = expr

		return exprRHS, nil
	case ruleNEW:
		newInst := new(NewInstanceRHS)

		newInst.SetToken(&node.token32)

		identNode := nextNode(node, ruleIDENT)

		newInst.wtype = &ClassType{name: identNode.match}

		arglistNode := nextNode(node, ruleARGLIST)
		if arglistNode != nil {
			for argNode := nextNode(arglistNode.up, ruleEXPR); argNode != nil; argNode = nextNode(argNode.next, ruleEXPR) {
				var err error
				var expr Expression

				if expr, err = parseExpr(argNode.up); err != nil {
					return nil, err
				}

				newInst.args = append(newInst.args, expr)
			}
		}

		return newInst, nil
	default:
		return nil, fmt.Errorf("Unexpected rule %s %s", node.String(), node.match)
	}
}

// parseBaseType parse basic type definition
func parseBaseType(node *node32) (Type, error) {
	switch node.pegRule {
	case ruleINT:
		return IntType{}, nil
	case ruleBOOL:
		return BoolType{}, nil
	case ruleCHAR:
		return CharType{}, nil
	case ruleSTRING:
		return ArrayType{base: CharType{}}, nil
	case ruleVOID:
		return VoidType{}, nil
	case ruleCLASSTYPE:
		return &ClassType{name: node.up.match}, nil
	case ruleENUMTYPE:
		return &EnumType{ident: node.up.next.match}, nil
	default:
		return nil, fmt.Errorf("Unknown type: %s", node.up.match)
	}
}

// parsePairType parse a pair type
// when entering this method the pair always has type specification
func parsePairType(node *node32) (Type, error) {
	var err error

	pairType := PairType{first: VoidType{}, second: VoidType{}}

	first := nextNode(node, rulePAIRELEMTYPE)

	second := nextNode(first.next, rulePAIRELEMTYPE)

	if pairType.first, err = parseType(first.up); err != nil {
		return nil, err
	}
	if pairType.second, err = parseType(second.up); err != nil {
		return nil, err
	}

	return pairType, nil

}

// parseType parse a type definition
func parseType(node *node32) (Type, error) {
	var err error
	var wtype Type

	switch node.pegRule {
	case ruleBASETYPE:
		if wtype, err = parseBaseType(node.up); err != nil {
			return nil, err
		}
	case rulePAIRTYPE:
		if wtype, err = parsePairType(node.up); err != nil {
			return nil, err
		}
	case rulePAIR: // pair inside a pair, that misses type information
		return PairType{VoidType{}, VoidType{}}, nil
	}

	for node = nextNode(node.next, ruleARRAYTYPE); node != nil; node = nextNode(node.next, ruleARRAYTYPE) {
		wtype = ArrayType{base: wtype}
	}

	return wtype, nil
}

// parseOpOpStat parses the ++, --, ** side effects.
func parseOpOpStat(node *node32) (RHS, error) {
	rhs := new(ExpressionRHS)
	rhs.SetToken(&node.token32)

	lhs, err := parseExpr(nextNode(node, ruleASSIGNLHS).up)
	if err != nil {
		return nil, err
	}

	switch nextNode(node, ruleOPOP).up.pegRule {
	case rulePLUSPLUS:
		one := &IntLiteral{value: 1}
		binOp := &BinaryOperatorAdd{BinaryOperatorBase{rhs: one, lhs: lhs}}
		binOp.SetToken(&node.token32)
		rhs.expr = binOp

	case ruleMINUSMINUS:
		one := &IntLiteral{value: 1}
		binOp := &BinaryOperatorSub{BinaryOperatorBase{rhs: one, lhs: lhs}}
		binOp.SetToken(&node.token32)
		rhs.expr = binOp
	}

	return rhs, nil
}

// parseOpEquStat parses the +=, -=, *=, /=, %= side effects.
func parseOpEquStat(node *node32) (RHS, error) {
	rhs := new(ExpressionRHS)
	rhs.SetToken(&node.token32)

	lhs, err := parseExpr(nextNode(node, ruleASSIGNLHS).up)
	if err != nil {
		return nil, err
	}

	exprNode := nextNode(node, ruleEXPR)
	expr, err := parseExpr(exprNode.up)
	if err != nil {
		return nil, err
	}

	switch nextNode(node, ruleOPEQU).up.pegRule {
	case rulePLUSEQU:
		binOp := &BinaryOperatorAdd{BinaryOperatorBase{rhs: expr, lhs: lhs}}
		binOp.SetToken(&node.token32)
		rhs.expr = binOp

	case ruleMINUSEQU:
		binOp := &BinaryOperatorSub{BinaryOperatorBase{rhs: expr, lhs: lhs}}
		binOp.SetToken(&node.token32)
		rhs.expr = binOp

	case ruleSTAREQU:
		binOp := &BinaryOperatorMult{BinaryOperatorBase{rhs: expr, lhs: lhs}}
		binOp.SetToken(&node.token32)
		rhs.expr = binOp

	case ruleDIVEQU:
		binOp := &BinaryOperatorDiv{BinaryOperatorBase{rhs: expr, lhs: lhs}}
		binOp.SetToken(&node.token32)
		rhs.expr = binOp

	case ruleMODEQU:
		binOp := &BinaryOperatorMod{BinaryOperatorBase{rhs: expr, lhs: lhs}}
		binOp.SetToken(&node.token32)
		rhs.expr = binOp
	}

	return rhs, nil
}

// parseStatement parses a statement by checking which rule they start with
// that defines them uniquely
func parseStatement(node *node32) (Statement, error) {
	var stm Statement
	var err error

	switch node.pegRule {
	case ruleSKIP:
		stm = &SkipStatement{}
	case ruleCONTINUE:
		stm = &ContinueStatement{}
	case ruleBREAK:
		stm = &BreakStatement{}
	case ruleBEGIN:
		block := new(BlockStatement)

		bodyNode := nextNode(node, ruleSTAT)
		if block.body, err = parseStatement(bodyNode.up); err != nil {
			return nil, err
		}

		stm = block
	case ruleVAR:
		fallthrough
	case ruleTYPE:
		decl := new(DeclareAssignStatement)

		typeNode := nextNode(node, ruleTYPE)
		if typeNode != nil {
			if decl.wtype, err = parseType(typeNode.up); err != nil {
				return nil, err
			}
		}

		identNode := nextNode(node, ruleIDENT)
		decl.ident = identNode.match

		rhsNode := nextNode(node, ruleASSIGNRHS)
		if decl.rhs, err = parseRHS(rhsNode.up); err != nil {
			return nil, err
		}

		stm = decl
	case ruleASSIGNLHS:
		assign := new(AssignStatement)

		lhsNode := nextNode(node, ruleASSIGNLHS)
		if assign.target, err = parseLHS(lhsNode.up); err != nil {
			return nil, err
		}

		if nextNode(node, ruleEQU) != nil {
			rhsNode := nextNode(node, ruleASSIGNRHS)
			if assign.rhs, err = parseRHS(rhsNode.up); err != nil {
				return nil, err
			}

		} else {
			switch assign.target.(type) {
			case *VarLHS:
			case *ArrayLHS:
			default:
				return nil, fmt.Errorf("syntax error: Side Effecting pairs not allowed")
			}

			var rhs RHS

			if opOpNode := nextNode(node, ruleOPOP); opOpNode != nil {
				rhs, err = parseOpOpStat(node)
				if err != nil {
					return nil, err
				}

			} else {
				rhs, err = parseOpEquStat(node)
				if err != nil {
					return nil, err
				}
			}
			assign.rhs = rhs
		}

		stm = assign
	case ruleREAD:
		read := new(ReadStatement)

		lhsNode := nextNode(node, ruleASSIGNLHS)
		if read.target, err = parseLHS(lhsNode.up); err != nil {
			return nil, err
		}

		stm = read
	case ruleFREE:
		free := new(FreeStatement)

		exprNode := nextNode(node, ruleEXPR)
		if free.expr, err = parseExpr(exprNode.up); err != nil {
			return nil, err
		}

		stm = free
	case ruleRETURN:
		retur := new(ReturnStatement)

		exprNode := nextNode(node, ruleEXPR)
		if exprNode != nil {
			if retur.expr, err = parseExpr(exprNode.up); err != nil {
				return nil, err
			}
		} else {
			retur.expr = &VoidExpr{}
		}

		stm = retur
	case ruleEXIT:
		exit := new(ExitStatement)

		exprNode := nextNode(node, ruleEXPR)
		if exit.expr, err = parseExpr(exprNode.up); err != nil {
			return nil, err
		}

		stm = exit
	case rulePRINTLN:
		println := new(PrintLnStatement)

		exprNode := nextNode(node, ruleEXPR)
		if println.expr, err = parseExpr(exprNode.up); err != nil {
			return nil, err
		}

		stm = println
	case rulePRINT:
		print := new(PrintStatement)

		exprNode := nextNode(node, ruleEXPR)
		if print.expr, err = parseExpr(exprNode.up); err != nil {
			return nil, err
		}

		stm = print
	case ruleFCALL:
		fnode := node.up
		call := new(FunctionCallStat)

		call.SetToken(&node.token32)

		objNode := nextNode(fnode, ruleCLASSOBJ)
		if objNode != nil {
			call.obj = objNode.match
		}

		identNode := nextNode(fnode, ruleIDENT)
		call.ident = identNode.match

		arglistNode := nextNode(fnode, ruleARGLIST)
		if arglistNode != nil {
			for argNode := nextNode(arglistNode.up, ruleEXPR); argNode != nil; argNode = nextNode(argNode.next, ruleEXPR) {
				var err error
				var expr Expression

				if expr, err = parseExpr(argNode.up); err != nil {
					return nil, err
				}

				call.args = append(call.args, expr)
			}
		}

		stm = call
	case ruleIF:
		ifs := new(IfStatement)

		exprNode := nextNode(node, ruleEXPR)
		if ifs.cond, err = parseExpr(exprNode.up); err != nil {
			return nil, err
		}

		bodyNode := nextNode(node, ruleSTAT)
		if ifs.trueStat, err = parseStatement(bodyNode.up); err != nil {
			return nil, err
		}

		elseNode := nextNode(bodyNode.next, ruleSTAT)
		if elseNode != nil {
			if ifs.falseStat, err = parseStatement(elseNode.up); err != nil {
				return nil, err
			}
		}

		stm = ifs
	case ruleWHILE:
		whiles := new(WhileStatement)

		exprNode := nextNode(node, ruleEXPR)
		if whiles.cond, err = parseExpr(exprNode.up); err != nil {
			return nil, err
		}

		bodyNode := nextNode(node, ruleSTAT)
		if whiles.body, err = parseStatement(bodyNode.up); err != nil {
			return nil, err
		}
		stm = whiles
	case ruleDO:
		whiles := new(DoWhileStatement)

		bodyNode := nextNode(node, ruleSTAT)
		if whiles.body, err = parseStatement(bodyNode.up); err != nil {
			return nil, err
		}

		exprNode := nextNode(node, ruleEXPR)
		if whiles.cond, err = parseExpr(exprNode.up); err != nil {
			return nil, err
		}

		stm = whiles

	case ruleSWITCH:
		switchs := new(SwitchStatement)

		condNode := nextNode(node, ruleEXPR)
		onNode := nextNode(node, ruleON)

		if onNode.begin > condNode.begin {
			if switchs.cond, err = parseExpr(condNode.up); err != nil {
				return nil, err
			}
		} else {
			switchs.cond = &BoolLiteralTrue{}
			switchs.cond.SetToken(&condNode.token32)
		}

		for caseNode := nextNode(onNode, ruleCASE); caseNode != nil; caseNode = nextNode(caseNode.next, ruleCASE) {
			exprNode := nextNode(caseNode, ruleEXPR)

			if expr, err := parseExpr(exprNode.up); err == nil {
				switchs.cases = append(switchs.cases, expr)
			} else {
				return nil, err
			}

			stmNode := nextNode(caseNode, ruleSTAT)

			if stat, err := parseStatement(stmNode.up); err == nil {
				switchs.bodies = append(switchs.bodies, stat)
			} else {
				return nil, err
			}

			ftNode := stmNode.next

			ft := false
			if ftNode != nil && ftNode.pegRule == ruleFALLTHROUGH {
				ft = true
			}
			switchs.fts = append(switchs.fts, ft)
		}

		defaultHolder := nextNode(node, ruleDEFAULT)
		defaultNode := nextNode(defaultHolder, ruleSTAT)

		if defaultNode != nil {
			if switchs.defaultCase, err = parseStatement(defaultNode.up); err != nil {
				return nil, err
			}
		}

		node = nextNode(node, ruleEND)

		stm = switchs
	case ruleFOR:
		fors := new(ForStatement)

		initNode := nextNode(node, ruleSTAT)
		if fors.init, err = parseStatement(initNode.up); err != nil {
			return nil, err
		}

		exprNode := nextNode(node, ruleEXPR)
		if fors.cond, err = parseExpr(exprNode.up); err != nil {
			return nil, err
		}

		afterNode := nextNode(initNode.next, ruleSTAT)
		if fors.after, err = parseStatement(afterNode.up); err != nil {
			return nil, err
		}

		bodyNode := nextNode(afterNode.next, ruleSTAT)
		if fors.body, err = parseStatement(bodyNode.up); err != nil {
			return nil, err
		}

		node = bodyNode

		stm = fors
	default:
		return nil, fmt.Errorf(
			"unexpected %s %s",
			node.String(),
			node.match,
		)
	}

	// check if there is semicolon and parse the next statement
	if semi := nextNode(node, ruleSEMI); semi != nil {
		var next Statement
		if nextStat := semi.next; nextStat != nil {
			if next, err = parseStatement(nextStat.up); err == nil {
				stm.SetNext(next)
			} else {
				return nil, err
			}
		}
	}

	stm.SetToken(&node.token32)

	return stm, nil
}

// parse the parameters of a function definition
func parseParam(node *node32) (*FunctionParam, error) {
	var err error

	param := &FunctionParam{}

	param.SetToken(&node.token32)

	param.wtype, err = parseType(nextNode(node, ruleTYPE).up)
	if err != nil {
		return nil, err
	}

	param.name = nextNode(node, ruleIDENT).match

	return param, nil
}

// parse a function defintion
func parseFunction(node *node32) (*FunctionDef, error) {
	var err error
	function := &FunctionDef{}

	function.SetToken(&node.token32)

	function.returnType, err = parseType(nextNode(node, ruleTYPE).up)
	if err != nil {
		return nil, err
	}

	function.ident = nextNode(node, ruleIDENT).match

	paramListNode := nextNode(node, rulePARAMLIST)
	// argument list may be missing with zero arguments
	if paramListNode != nil {
		for pnode := range nodeRange(paramListNode.up) {
			if pnode.pegRule == rulePARAM {
				var param *FunctionParam
				param, err = parseParam(pnode.up)
				if err != nil {
					return nil, err
				}
				function.params = append(function.params, param)
			}
		}
	}

	function.body, err = parseStatement(nextNode(node, ruleSTAT).up)
	if err != nil {
		return nil, err
	}

	return function, nil
}

// parseInclude parses all the WACC files included in the current AST
func parseInclude(node *node32) string {
	strNode := nextNode(node, ruleSTRLITER)
	file := nextNode(strNode.up, ruleSTR).match

	return file
}

// autoGenerateGetSet generates getter and setter methods for the class members
func autoGenerateGetSet(class *ClassType) (*ClassType, error) {
	for _, member := range class.members {
		if member.get {
			autoGet := &FunctionDef{}
			autoGet.returnType = member.wtype
			autoGet.ident = member.ident

			autoGet.body = &ReturnStatement{
				expr: &Ident{ident: fmt.Sprintf("@%v", member.ident)},
			}

			class.methods = append(class.methods, autoGet)
		}

		if member.set {
			autoSet := &FunctionDef{}
			autoSet.returnType = VoidType{}
			autoSet.ident = member.ident

			param := &FunctionParam{
				name:  "value",
				wtype: member.wtype,
			}

			autoSet.params = append(autoSet.params, param)

			autoSet.body = &AssignStatement{
				target: &VarLHS{
					ident: fmt.Sprintf("@%v", member.ident),
				},
				rhs: &ExpressionRHS{
					expr: &Ident{ident: "value"},
				},
			}

			class.methods = append(class.methods, autoSet)
		}
	}

	return class, nil
}

// parseClass parses all the members declared in a class
func parseClassMembers(node *node32) (*ClassMember, error) {
	var err error

	member := &ClassMember{}
	member.get = false
	member.set = false

	member.SetToken(&node.token32)
	member.ident = nextNode(node, ruleIDENT).match

	member.wtype, err = parseType(nextNode(node, ruleTYPE).up)
	if err != nil {
		return nil, err
	}

	if node := nextNode(node, ruleGETSET); node != nil {
		getset := node.up
		if getset = nextNode(getset, ruleGET); getset != nil {
			member.get = true
		}

		if getset = nextNode(getset, ruleSET); getset != nil {
			member.set = true
		}

		if getset != nil {
			if nextNode(getset.next, ruleGET) != nil ||
				nextNode(getset.next, ruleSET) != nil {
				return nil, fmt.Errorf(
					"syntax error: GET/SET used multiple times",
				)
			}
		}
	}

	return member, nil
}

// parseClass parses all the Classes declared in the current ASR
func parseClass(node *node32) (*ClassType, error) {
	class := &ClassType{}

	class.SetToken(&node.token32)

	for node := range nodeRange(node) {
		switch node.pegRule {
		case ruleCLASS:
		case ruleIS:
		case ruleSPACE:
		case ruleEND:
		case ruleIDENT:
			class.name = node.match
		case ruleMEMBERDEF:
			m, err := parseClassMembers(node.up)
			class.members = append(class.members, m)
			if err != nil {
				return nil, err
			}
		case ruleFUNC:
			f, err := parseFunction(node.up)
			class.methods = append(class.methods, f)
			if err != nil {
				return nil, err
			}
		default:
			return nil, fmt.Errorf(
				"Unexpected %s %s",
				node.String(),
				node.match,
			)
		}
	}

	class, err := autoGenerateGetSet(class)
	if err != nil {
		return nil, err
	}

	return class, nil
}

func parseEnum(node *node32) (*EnumType, error) {
	enum := &EnumType{}

	enum.SetToken(&node.token32)

	enum.ident = nextNode(node, ruleIDENT).match

	enum.values = make(map[string]int)

	var i int
	for enumNode := nextNode(node, ruleENUMASSIGN); enumNode != nil; enumNode = nextNode(enumNode.next, ruleENUMASSIGN) {
		enumIdent := nextNode(enumNode.up, ruleIDENT).match

		if value := nextNode(enumNode.up, ruleINTLITER); value != nil {
			num, err := strconv.ParseInt(value.match, 10, 32)
			if err != nil {
				// number does not fit into WACC integer size
				numerr := err.(*strconv.NumError)
				switch numerr.Err {
				case strconv.ErrRange:
					return nil, CreateBigIntError(
						&value.token32,
						value.match,
					)
				}
				return nil, err
			}

			i = int(num)
		}

		enum.values[enumIdent] = i
		i++
	}

	return enum, nil
}

// parse the main WACC block that contains all function definitions and the main
// body
func parseWACC(node *node32, ifm *IncludeFiles) (*AST, error) {
	ast := &AST{}

	for node := range nodeRange(node) {
		switch node.pegRule {
		case ruleBEGIN:
		case ruleEND:
		case ruleSPACE:
		case ruleENUMDEF:
			e, err := parseEnum(node.up)
			if err != nil {
				return nil, err
			}

			ast.enums = append(ast.enums, e)
		case ruleCLASSDEF:
			c, err := parseClass(node.up)
			if err != nil {
				return nil, err
			}

			ast.classes = append(ast.classes, c)
		case ruleINCL:
			i := parseInclude(node.up)
			ast.includes = append(ast.includes, i)
		case ruleFUNC:
			f, err := parseFunction(node.up)
			if err != nil {
				return nil, err
			}

			ast.functions = append(ast.functions, f)
		case ruleSTAT:
			var err error
			ast.main, err = parseStatement(node.up)
			if err != nil {
				return nil, err
			}
		default:
			return nil, fmt.Errorf(
				"Unexpected %s %s",
				node.String(),
				node.match,
			)
		}
	}

	appendIncludedFiles(ast, ifm)

	return ast, nil
}

// IncludeFiles holds the included files
type IncludeFiles struct {
	sync.RWMutex
	files map[string]bool
	dir   string
}

// Include will add the files to the map
func (m *IncludeFiles) Include(file string) {
	m.Lock()
	defer m.Unlock()

	if m.files == nil {
		m.files = make(map[string]bool)
	}

	m.files[file] = true
}

// appendIncludedFiles appends all the functions in the included files to base
// wacc file. It discards the main function of the included file.
func appendIncludedFiles(ast *AST, ifm *IncludeFiles) {
	for _, include := range ast.includes {
		absoluteFile := fmt.Sprintf("%v/%v", ifm.dir,
			include)

		_, included := ifm.files[absoluteFile]
		if included {
			continue
		}

		ifm.Include(absoluteFile)

		waccIncl := parseInput(absoluteFile)
		astIncl := generateASTFromWACC(waccIncl, ifm)

		ast.enums = append(ast.enums,
			astIncl.enums...)

		ast.classes = append(ast.classes,
			astIncl.classes...)

		ast.functions = append(ast.functions,
			astIncl.functions...)
	}
}

// ParseAST given a syntax tree generated by the Peg library returns the
// internal representation of the WACC AST. On this AST further syntax and
// semantic analysis can be performed.
func ParseAST(wacc *WACC, ifm *IncludeFiles) (ast *AST, err error) {
	ast, err = nil, errors.New("expected ruleWACC")
	node := wacc.AST()

	if node.pegRule == ruleWACC {
		ast, err = parseWACC(node.up, ifm)
	}

	return
}