expr_def.go

// Code generated by cmd. DO NOT EDIT.

package expr

import "reflect"

type Expr interface {
	AcceptStr(visitor ExprVisitorStr) string
	AcceptObj(visitor ExprVisitorObj) (interface{}, error)
} 

type ExprVisitorStr interface{
	VisitExprBinaryStr(binary *ExprBinary) string
	VisitExprCallStr(call *ExprCall) string
	VisitExprGroupingStr(grouping *ExprGrouping) string
	VisitExprLiteralStr(literal *ExprLiteral) string
	VisitExprLogicalStr(logical *ExprLogical) string
	VisitExprUnaryStr(unary *ExprUnary) string
	VisitExprArrayStr(array *ExprArray) string
	VisitExprVariableStr(variable *ExprVariable) string
}

type ExprVisitorObj interface{
	VisitExprBinaryObj(binary *ExprBinary) (interface{}, error)
	VisitExprCallObj(call *ExprCall) (interface{}, error)
	VisitExprGroupingObj(grouping *ExprGrouping) (interface{}, error)
	VisitExprLiteralObj(literal *ExprLiteral) (interface{}, error)
	VisitExprLogicalObj(logical *ExprLogical) (interface{}, error)
	VisitExprUnaryObj(unary *ExprUnary) (interface{}, error)
	VisitExprArrayObj(array *ExprArray) (interface{}, error)
	VisitExprVariableObj(variable *ExprVariable) (interface{}, error)
}

type ExprBinary struct {
	left Expr
	operator *Token
	right Expr
}

func NewExprBinary(left Expr, operator *Token, right Expr) Expr {
	t := &ExprBinary{}
	t.left = left
	t.operator = operator
	t.right = right
	return t
}

func (e *ExprBinary) AcceptStr(visitor ExprVisitorStr) string {
	return visitor.VisitExprBinaryStr(e)
}

func (e *ExprBinary) AcceptObj(visitor ExprVisitorObj) (interface{}, error) {
	return visitor.VisitExprBinaryObj(e)
}

type ExprCall struct {
	callee Expr
	paren *Token
	arguments []Expr
}

func NewExprCall(callee Expr, paren *Token, arguments []Expr) Expr {
	t := &ExprCall{}
	t.callee = callee
	t.paren = paren
	t.arguments = arguments
	return t
}

func (e *ExprCall) AcceptStr(visitor ExprVisitorStr) string {
	return visitor.VisitExprCallStr(e)
}

func (e *ExprCall) AcceptObj(visitor ExprVisitorObj) (interface{}, error) {
	return visitor.VisitExprCallObj(e)
}

type ExprGrouping struct {
	expression Expr
}

func NewExprGrouping(expression Expr) Expr {
	t := &ExprGrouping{}
	t.expression = expression
	return t
}

func (e *ExprGrouping) AcceptStr(visitor ExprVisitorStr) string {
	return visitor.VisitExprGroupingStr(e)
}

func (e *ExprGrouping) AcceptObj(visitor ExprVisitorObj) (interface{}, error) {
	return visitor.VisitExprGroupingObj(e)
}

type ExprLiteral struct {
	value interface{}
	rtype reflect.Kind
}

func NewExprLiteral(value interface{}, rtype reflect.Kind) Expr {
	t := &ExprLiteral{}
	t.value = value
	t.rtype = rtype
	return t
}

func (e *ExprLiteral) AcceptStr(visitor ExprVisitorStr) string {
	return visitor.VisitExprLiteralStr(e)
}

func (e *ExprLiteral) AcceptObj(visitor ExprVisitorObj) (interface{}, error) {
	return visitor.VisitExprLiteralObj(e)
}

type ExprLogical struct {
	left Expr
	operator *Token
	right Expr
}

func NewExprLogical(left Expr, operator *Token, right Expr) Expr {
	t := &ExprLogical{}
	t.left = left
	t.operator = operator
	t.right = right
	return t
}

func (e *ExprLogical) AcceptStr(visitor ExprVisitorStr) string {
	return visitor.VisitExprLogicalStr(e)
}

func (e *ExprLogical) AcceptObj(visitor ExprVisitorObj) (interface{}, error) {
	return visitor.VisitExprLogicalObj(e)
}

type ExprUnary struct {
	operator *Token
	right Expr
}

func NewExprUnary(operator *Token, right Expr) Expr {
	t := &ExprUnary{}
	t.operator = operator
	t.right = right
	return t
}

func (e *ExprUnary) AcceptStr(visitor ExprVisitorStr) string {
	return visitor.VisitExprUnaryStr(e)
}

func (e *ExprUnary) AcceptObj(visitor ExprVisitorObj) (interface{}, error) {
	return visitor.VisitExprUnaryObj(e)
}

type ExprArray struct {
	bracket *Token
	items []Expr
}

func NewExprArray(bracket *Token, items []Expr) Expr {
	t := &ExprArray{}
	t.bracket = bracket
	t.items = items
	return t
}

func (e *ExprArray) AcceptStr(visitor ExprVisitorStr) string {
	return visitor.VisitExprArrayStr(e)
}

func (e *ExprArray) AcceptObj(visitor ExprVisitorObj) (interface{}, error) {
	return visitor.VisitExprArrayObj(e)
}

type ExprVariable struct {
	name *Token
}

func NewExprVariable(name *Token) Expr {
	t := &ExprVariable{}
	t.name = name
	return t
}

func (e *ExprVariable) AcceptStr(visitor ExprVisitorStr) string {
	return visitor.VisitExprVariableStr(e)
}

func (e *ExprVariable) AcceptObj(visitor ExprVisitorObj) (interface{}, error) {
	return visitor.VisitExprVariableObj(e)
}