gunit Arith;
@header{ 
package de.hshn.se.akse.ss09.parser;
}
////////////////////////////////////////-----------Lexer Tests --------------------

//natural numbers
INT:
"0" OK
"1" OK
"123" OK
"1000" OK
"01" FAIL
"00" FAIL

//floating point numbers
FLOAT:
"1.0" OK
"0.234" OK
".0" FAIL
"1.0.1" FAIL

//negative numbers are not yet part of the language

//variable identifiers start with a letter, possibly followed by a sequence of
//letters, numbers or the special symbol '_'
ID:
"x" OK
"X" OK
"x1" OK
"X1" OK
"d_x1" OK
"account_balance" OK
"cAsEiNsEnSiTiVe" OK
"a_0_1" OK
"x!" FAIL
"1x" FAIL
"_1" FAIL

//operators
PLUS:
"+" OK
MINUS:
"-" OK
MULT:
"*" OK
DIV:
"/" OK

//left parenthesis
LPAREN:
"(" OK

//right parenthesis
RPAREN:
")" OK

//keywords
WRITE:
"write" OK
"WRITE" OK
"wRiTe" OK

READ:
"read" OK
"READ" OK
"rEaD" OK

TRUE:
"true" OK
"TRUE" OK
"tRuE" OK

FALSE:
"false" OK
"FALSE" OK
"fAlSe" OK

////////////////////////////////////////////---------Parser Tests -------------

program	:
"int var := 3  float foo := 3.0" -> (PROG (IASSIGN var 3) (FASSIGN foo 3.0))
" " -> "PROG"
"int a:=3 float b:=3.0+a write b" -> (PROG (IASSIGN a 3) (FASSIGN b (FPLUS 3.0 (CAST_I2F a))) (FWRITE b))
//testInput1.aplus OK
//testInput2.aplus OK

statement:
"int var := 3" -> (IASSIGN var 3)
"write 3+3" -> (IWRITE (IPLUS 3 3))
"read int var"  -> (IREAD var)
"3 + 3"  FAIL

assignment:
"int var := 3" -> (IASSIGN var 3)
"int var := 2 + 3" -> (IASSIGN var (IPLUS 2 3))
"int var := 3.0" FAIL

"float var := 3.0" -> (FASSIGN var 3.0)
"float var := 2.0 + 3.0" -> (FASSIGN var (FPLUS 2.0 3.0))
"float var := 30" -> (FASSIGN var 30.0)

"bool t := true" -> (BASSIGN t true)
"bool f := false" -> (BASSIGN f false)
"bool a := (3<4)" -> (BASSIGN a (< 3 4))
"bool somethin := 3" FAIL
"bool somethin := 3.0" FAIL



input :
"read int alpha"  -> (IREAD alpha)
"read float alpha" -> (FREAD alpha)

output  : 
"write 3+3*3" -> (IWRITE (IPLUS 3 (IMULT 3 3)))
"write 3.4+3.0*3.0" -> (FWRITE (FPLUS 3.4 (FMULT 3.0 3.0)))

int_expr:
"3 * 3 + 3"  -> (IPLUS (IMULT 3 3) 3)
"3 + 3 * 3"  -> (IPLUS 3 (IMULT 3 3))
"0 + 3 * 3"  -> (IPLUS 0 (IMULT 3 3))

int_term	:
"(3*3) * (3+3)" -> (IMULT (IMULT 3 3) (IPLUS 3 3))

unary_int_expr:
"- 3"     ->  (IUMINUS 3)
"-(3 + 3 * 1)" -> (IUMINUS (IPLUS 3 (IMULT 3 1)))

int_factor:
"3" -> "3"

float_expr:
"3.0 * 3.0 + 3.0"  -> (FPLUS (FMULT 3.0 3.0) 3.0)
"3.0 + 3.0 * 3.0"  -> (FPLUS 3.0 (FMULT 3.0 3.0))
"0.0 + 3.0 * 3.0"  -> (FPLUS 0.0 (FMULT 3.0 3.0))

//also allow mixed expressions when assigning to float
"3.0 * 3 + 3.0"  -> (FPLUS (FMULT 3.0 3.0) 3.0)
"3 + 3.0 * 3.0"  -> (FPLUS 3.0 (FMULT 3.0 3.0))
"0 + 3.0 * 3.0"  -> (FPLUS 0.0 (FMULT 3.0 3.0))

float_term  :
"(3.0*3.0) * (3.0+3.0)" -> (FMULT (FMULT 3.0 3.0) (FPLUS 3.0 3.0))

unary_float_expr:
"- 3.0"     ->  (FUMINUS 3.0)
"-(3.0 + 3.0 * 1.0)" -> (FUMINUS (FPLUS 3.0 (FMULT 3.0 1.0)))

float_factor:
"3.0" -> "3.0"


or_expression:
"!(!true || !true)" -> (! (|| (! true) (! true)))

and_expression:
"!true && !true" -> (&& (! true) (! true))

unary_bool_expr:
"!true"   -> (! true)
"!false"  -> (! false)

bool_atom:
"true" OK
"false" OK
"(true||false)" -> (|| true false)

euqality_expression:
"3 == 3"  -> (== 3 3)
"3 != 3"  -> (!= 3 3)

relational_expression:
"3 < 3"   -> (< 3 3)
"3 <= 3"  -> (<= 3 3)
"3 > 3"   -> (> 3 3)
"3 >= 3"  -> (>= 3 3)