#include "ast.h"
#include <string>

COMPILER Xreate

AST root;  // current program unit (procedure or main program)

bool checkParametersList()
{
  scanner.ResetPeek();
  Token x = scanner->Peek();
  return la->kind == _ident && x->kind  == _lparen;
}

bool checkInfix()
{
    scanner.ResetPeek();
  Token x = scanner->Peek();
  return la->kind == _ident && x->kind  == _ident;
}

bool check

CHARACTERS
  letter = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz".
  digit = "0123456789".
  cr  = '\r'.
  lf  = '\n'.
  tab = '\t'.

TOKENS
  ident  = letter {letter | digit}.
  number = digit {digit}.
  string = '"' {letter} '"'.
  lparen = '('. 
  rparen = ')'.

COMMENTS FROM "/*" TO "*/" NESTED
COMMENTS FROM "//" TO lf

IGNORE cr + lf + tab

PRODUCTIONS

Xreate = { ( FDecl | RuleDecl ) }.

Ident<std::wstring& name>
= ident                  (. name = t->val; .).


FDecl<> =  							(. std::wstring fname; Expression fbody; std::wstring varname; TypeAnnotation typIn; TypeAnnotation typOut; .)
Ident<fname> '=' "function" ':'		(. Function f = Function(fname); .)
( Type<typOut>  					(. f.setReturnType(typOut); .)
| '('Ident<varname> ':' Type<typIn>   (. f.addArg(varname, typIn); .)
{',' Ident<varname> ':' Type<typIn>  (. f.addArg(varname, typIn);.)
} ')' "->" Type<typOut>				(. f.setReturnType(typOut); .)
{',' FnTag<f> }
) '{' {VDecl<f> ';' }
Expr<fbody> ';' '}' (. f.setBody(fbody); root.add(f); .)  .

TypeTerm<TypeAtom& typ> = ("string" | "int" | "num" | "float" | "bool") (. typ = Atom<Type_t>(t->val); .) .
Type<TypeAnnotation& typ> =  (. TypeAnnotation typ2; TypeAtom typ3; .)
('[' Type<typ2> ']'  (. typ = TypeAnnotation(TypeOperator::LIST, typ2); .)
| TypeTerm<typ3> (. typ = TypeAnnotation(typ3); .) 
) .

VDecl<Function& f> =  (. std::wstring vname; Expression e; TypeAnnotation typ; .)
Ident<vname> '=' 
(Expr<e> ':' Type<typ> (. f.addDeclaration(vname, typ, e); .)
|ListLiteral<e> ':' Type<typ>  (. f.addListDeclaration(vname, typ, e); .)
).
                              /*============================ METAPROGRAMMING ===============================*/
                              
FnTag<Function& f> = (.std::wstring tag; TagModifier mod = TagModifier::NONE; .)
Ident<tag>
['-' TagMod<mod>] (. f.addTag(tag, mod); .).

TagMod<TagModifier& mod> = 
(  "assert" (. mod = TagModifier::ASSERT; .)
 | "require" (. mod = TagModifier::REQUIRE; .)
).
 
RuleDecl<> =
"rule" ':' 				(. RuleArguments args; RuleGuards guards; RuleBody body; DomainAnnotation typ; .)
'(' Ident<arg> ':' Domain<typ>  	(. args.add(arg, typ); .)
{',' Ident<arg> ':'Domain<typ>  	(. args.add(arg, typ); .)
} ')'
["case" RGuard<guards> {',' RGuard<guards>}]
                                        (.  .)
'{' RBody<args, guards> '}'     	.

Domain<DomainAnnotation& dom> = 
(
  "function"  				(. dom = DomainAnnotation::FUNCTION; .)
  | "variable"    			(. dom = DomainAnnotation::VARIABLE; .)
).

RGuard<RuleGuards& guards>=          (. MetaExpression e; .)
MetaExpr<e>                       (. guards.add(e); .).

MetaExpr<MetaExpression& e>=
MetaExpr2<e>
[MetaOp<op> MetaExpr2<e2>           (. MetaParameters params;
                                      params.add(e);
                                      params.add(e2);
                                      e = MetaExpression(op, params); .)
].

MetaExpr2<MetaExpression& e>=      (. std::wstring i1, i2, infix; MetaParameters params; .)
( IF(checkParametersList()) Ident<i1> '(' [ MetaParams<params> ] ')'
                                        (. e = MetaExpression(Operator::CALL, i1, params); .)
| IF(checkInfix()) Ident<i1> Ident<infix> Ident<i2>                                       
                                        (. params.add(Expression(Atom<Identifier_t>(i1->val)));
                                           params.add(Expression(Atom<Identifier_t>(i2->val)));
                                           e = MetaExpression(Operator::CALL, Atom<Identifier_t>(infix->val), params); .)
| Ident<i1>                             (. e = MetaExpression(Atom<Identifier_t>(i1->val)); .)
| '(' MetaExpr<e> ')'
).

MetaParams<MetaParameters& params> = (. MetaExpr e; .)
MetaExpr<e>                      (. params.add(e); .)
{',' MetaExpr<e>                 (. params.add(e).)
}.

RBody<RuleBody& body> =         (. MetaExpr e; .)
  "warning" MetaExpr<e> ["message" string] .

MetaOp< Operator& op> =
 '-' '>'                          (. op = OPERATOR::IMPL; .)
.




/*============================ Expressions ===============================*/

ListLiteral<Expression& e> =  (. Expression e2; .)
'['  								(. e = Expression(Operator::LIST, Expression()); .)
[ Expr<e2> 							(. e.addArg(e2); .)
{',' Expr<e2> 						(. e.addArg(e2); .)
}] ']'.


Expr< Expression& e>         (. Operator op; Expression e2; .)
= SimExpr< e>		 
  [ RelOp< op>
    SimExpr< e2>      (. e = Expression(op, e); e.addArg(e2); .)
  ].

SimExpr< Expression& e>      (. Operator op; Expression e2; .)
= Term< e>
  { AddOp< op>
    Term< e2>         (. e = Expression(op, e);	e.addArg(e2);.)
	}.

Term< Expression& e>         (. Operator op; Expression e2; .)
= Factor< e>
  { MulOp< op>
    Factor< e2>        (. e = Expression(op, e); e.addArg(e2); .)
  }.

Factor< Expression& e>       (. std::wstring name;.)
=                        
  (IF (checkParametersList()) Ident< name> 
                                    (. e = Expression(Operator::CALL, Atom<Identifier_t>(name)); .)
  '(' [CalleeParams<e>] ')'
  | Ident< name>                    (. e = Expression(Atom<Identifier_t>(name)); .)

  | number                          (. e = Expression(Atom<Number_t>(t->val)); .)
  | '-' Factor< e>                  (. e = Expression(Operator::NEG, e); .)
  | '(' Expr<e> ')'  
  ).

CalleeParams<Expression& e> = (. Expression e2; .)
  Expr<e2>		(. e.addArg(e2); .)
  {',' Expr<e2> 		(. e.addArg(e2); .)
  }.

AddOp< Operator& op>
=                        (. op = Operator::ADD; .)
  ( '+'
  | '-'                  (. op = Operator::SUB; .)
  ).

MulOp< Operator& op>
=                        (. op = Operator::MUL; .)
  ( '*'
  | '/'                  (. op = Operator::DIV; .)
  ).

RelOp< Operator& op>
=                        (. op = Operator::EQU; .)
  ( '=' '='
  | '<'                  (. op = Operator::LSS; .)
  | '>'                  (. op = Operator::GTR; .)
  ).
  
END Xreate.
