Expression:
    BooleanExpression
;

BooleanExpression returns Expression:
    Comparison 
    (({AndOrExpression.left=current} op=LogicOperator ) right=Comparison)*;
    
Comparison returns Expression:
       Addition
       (({Comparison.left=current} op=EquationOperator ) right=Addition)*;

Addition returns Expression:
	Multiplication (({Plus.left=current} '+' | {Minus.left=current} '-') right=Multiplication)*;

Multiplication returns Expression:
	PrimaryExpression (({Multi.left=current} '*' | {Div.left=current} '/') right=PrimaryExpression)*;

PrimaryExpression returns Expression:
	lBrace='(' expression=Expression rBrace=')' | function=Function lBrace='(' expression=Expression rBrace=')' |
	{NumberLiteral} value=NUMBER | SignalIdentifier | ParameterIdentifier | {BooleanLiteral} bool=('true' | 'false')
;
Function:
	'abs' | 'square' | 'cube'
;

LogicOperator:
	name =('and' | 'or') 
;

EquationOperator:
	name=(Equal | LessOrEqual | LessThan | GreaterOrEqual | GreaterThan | NotEqual)
;
	
	Equal:
		'==' | 'is' 'equal' 'to'
	;
	
	LessOrEqual:
		'<=' | 'is' 'less' 'or' 'equal' 'to'
	;
	
	LessThan:
		'<' | 'is' 'less' 'than'
	;
	
	GreaterOrEqual:
		'>=' | 'is' 'greater' 'or' 'equal' 'to'
	;

	GreaterThan:
		'>' | 'is' 'greater' 'than'
	;
	
	NotEqual:
		'~=' | 'is' 'not' 'equal'
	;

NumberLiteral:
	value=NUMBER
;

SignalIdentifier:
	'signal' sigID=[SignalName]
;

ParameterIdentifier:
	'parameter' paramID=[ParameterName]
;

def dispatch CharSequence gen(AndOrExpression exp) {
		'''«exp.left.gen» «exp.op.transform» «exp.right.gen»'''
	}
	
	def dispatch CharSequence transform(LogicOperator exp) {
		if (exp.name == 'and') {
			'&'
		} else if (exp.name == 'or') {
			'|'
		}
	}
	
	def dispatch CharSequence transform(EquationOperator exp) {
                //incomplete, and your grammar kind a sucks regarding whitespace in the sentenses => better to have extra types foreach branch
		if (exp.name == '==') {
			'=='
		} else if (exp.name == 'is equal to') {
			'=='
		} else {
			throw new IllegalArgumentException(exp.toString);
		}
	}
	
	def dispatch CharSequence gen(Comparison exp) {
		'''«exp.left.gen» «exp.op.transform» «exp.right.gen»'''
	}
	def dispatch CharSequence gen(Div exp) {
		'''«exp.left.gen» / «exp.right.gen»'''
	}
	def dispatch CharSequence gen(Multi exp) {
		'''«exp.left.gen» * «exp.right.gen»'''
	}
	
	def dispatch CharSequence gen(Plus exp) {
		'''«exp.left.gen» + «exp.right.gen»'''
	}
	
	def dispatch CharSequence gen(Minus exp) {
		'''«exp.left.gen» + «exp.right.gen»'''
	}
	
	def dispatch CharSequence gen(NumberLiteral exp) {
		'''«exp.value»'''
	}
	def dispatch CharSequence gen(SignalIdentifier exp) {
		'''«exp.sigID»'''
	}
	def dispatch CharSequence gen(ParameterIdentifier exp) {
		'''«exp.paramID»'''
	}
	def dispatch CharSequence gen(BooleanLiteral exp) {
		'''«exp.bool»'''
	}
	
	def dispatch CharSequence gen(Expression exp) {
		if (exp.LBrace != null && exp.RBrace != null && exp.function == null) {
			'''(«exp.expression.gen»)'''
		} else if (exp.LBrace != null && exp.RBrace != null && exp.function != null) {
			'''«exp.function»(«exp.expression.gen»)'''
		} else {
			throw new IllegalArgumentException(exp.toString);
		}
	}