options {
  JDK_VERSION = "1.6";
  STATIC = false;
  IGNORE_CASE = true;
}

PARSER_BEGIN(ExpressParser)
package org.simantics.express.parser; 
import org.simantics.express.ast.types.*;
import org.simantics.express.ast.expressions.*;
import java.util.List;
import java.util.ArrayList;

public class ExpressParser {
}
PARSER_END(ExpressParser)

/* Lexer */

SKIP:
{ <WHITESPACE: " " | "\n" | "\r" | "\t" > 
| <COMMENT1: "(*" (~["*"] | "*" ~[")"])* "*)" >  
| <COMMENT2: "--" (~["\n"])* >
}

TOKEN:
{ ";" | "(" | ")" | "\\" | "?" | "[" | "]"
| "{" | "}" | "|" | "&" | ":" | ":=" | ":=:"
| ":<>:" | "," | "." | "=" | "<" | ">"
| "<=" | ">=" | "/" | "+" | "-" | "*" | "@"
| "<*" | "<>" | "**" | "||" 
| <ENTITY:"ENTITY"> 
| <END_ENTITY:"END_ENTITY">
| <SCHEMA:"SCHEMA"> 
| <END_SCHEMA:"END_SCHEMA">
| <CONSTANT:"CONSTANT"> 
| <END_CONSTANT:"END_CONSTANT">
| <FUNCTION:"FUNCTION"> 
| <END_FUNCTION:"END_FUNCTION">
| <PROCEDURE:"PROCEDURE"> 
| <END_PROCEDURE:"END_PROCEDURE">
| <RULE:"RULE"> 
| <END_RULE:"END_RULE">
| <TYPE:"TYPE"> 
| <END_TYPE:"END_TYPE">
| <SUBTYPE_CONSTRAINT:"SUBTYPE_CONSTRAINT"> 
| <END_SUBTYPE_CONSTRAINT:"END_SUBTYPE_CONSTRAINT">
| <LOCAL:"LOCAL"> 
| <END_LOCAL:"END_LOCAL">

| <ABSTRACT:"ABSTRACT"> 
| <EXTENSIBLE:"EXTENSIBLE">
| <GENERIC_ENTITY:"GENERIC_ENTITY">
| <BASED_ON:"BASED_ON">
| <WITH:"WITH">
| <SUBTYPE:"SUBTYPE"> 
| <SUPERTYPE:"SUPERTYPE"> 
| <OF:"OF">
| <ONEOF:"ONEOF">
| <ANDOR:"ANDOR"> 
| <AND:"AND"> 
| <SELF:"SELF">
| <USE:"USE">
| <REFERENCE:"REFERENCE">
| <FROM:"FROM">
| <FOR:"FOR">
| <DERIVE:"DERIVE">
| <INVERSE:"INVERSE">
| <OPTIONAL:"OPTIONAL">
| <FIXED:"FIXED">
| <UNIQUE:"UNIQUE">
| <WHERE:"WHERE">
| <LIKE:"LIKE">
| <IN:"IN">
| <OR:"OR">
| <XOR:"XOR">
| <MOD:"MOD">
| <DIV:"DIV">
| <QUERY:"QUERY">
| <NOT:"NOT">
| <AS:"AS">
| <TRUE:"TRUE">
| <FALSE:"FALSE">
| <RENAMED:"RENAMED">

| <STRING_:"STRING">
| <INTEGER:"INTEGER">
| <REAL:"REAL">
| <NUMBER:"NUMBER">
| <BOOLEAN:"BOOLEAN">
| <LOGICAL:"LOGICAL">
| <BINARY:"BINARY">
| <BAG:"BAG">
| <ARRAY:"ARRAY">
| <LIST:"LIST">
| <SET:"SET">
| <SELECT:"SELECT">
| <ENUMERATION:"ENUMERATION">
| <GENERIC:"GENERIC">
| <AGGREGATE:"AGGREGATE">

| <ALIAS: "ALIAS">
| <RETURN: "RETURN">
| <IF: "IF">
| <END_IF: "END_IF">
| <THEN: "THEN">
| <ELSE: "ELSE">
| <REPEAT: "REPEAT">
| <END_REPEAT: "END_REPEAT">
| <TO: "TO">
| <BY: "BY">
| <WHILE: "WHILE">
| <UNTIL: "UNTIL">
| <CASE: "CASE">
| <END_CASE: "END_CASE">
| <BEGIN: "BEGIN">
| <END: "END">
| <ESCAPE: "ESCAPE">
| <SKIP_: "SKIP">
| <VAR: "VAR">

| <STRING: "'" (~["'"])* "'">
| <IDENT: ["a"-"z","A"-"Z"] (["a"-"z","A"-"Z","_","0"-"9"])* >
| <INT: (["0"-"9"])+ >
| <FLOAT: <INT> "." (<INT>)? (("e"|"E") ("+"|"-")?  <INT>)? >
}

/* Parser */

void document() : {}
{ (schema())* <EOF>
}

void schema() : {}
{ <SCHEMA> <IDENT> ";" 
	(interface_())*
	(constDecl())?
	(decl())*
  <END_SCHEMA> ";"
}

void interface_() : {}
{ <USE> <FROM> <IDENT> ( "(" references() ")" )? ";"
| <REFERENCE> <FROM> <IDENT> ( "(" references() ")" )? ";"
}

void references() : {}
{ reference() ("," reference())* 
}

void reference() : {}
{ <IDENT> (<AS> <IDENT>)? 
}

void constDecl() : {}
{ <CONSTANT> (<IDENT> ":" typeB() ":=" exp() ";")+ <END_CONSTANT> ";"
}

void decl() : {}
{ ruleDecl()
| decl0()
}

void ruleDecl() : {}
{ <RULE> <IDENT> <FOR> "(" idents() ")" ";" 
	localDecls()
	(statement())*
	where()
  <END_RULE> ";"
}

void decl0() : {}
{ entityDecl()
| functionDecl()
| procedureDecl()
| typeDecl()
| subtypeConstraintDecl()
}

void entityDecl() : {}
{ <ENTITY> <IDENT> (supertype())? (subtype())? ";"
	 (attributes() ":" (<OPTIONAL>)? typeB() ";")*
	 (<DERIVE> (attribute() ":" typeB() ":=" exp() ";")+ )?
	 (<INVERSE> (attribute() ":" typeI() <FOR> attribute() ";")+ )?
	 (<UNIQUE> ( ( LOOKAHEAD(2) <IDENT> ":")? attributes() ";")+ )?
	 (where())?
  <END_ENTITY> ";"
}

void localDecls() : {}
{ (decl0())*
  (constDecl())?
  (<LOCAL> ( idents() ":" typeP() (":=" exp())* ";")+ <END_LOCAL> ";")?
}

void functionDecl() : {}
{ <FUNCTION> <IDENT> ("(" parameter() (";" parameter())* ")")? ":" typeP() ";" 
	localDecls()
	(statement())+
  <END_FUNCTION> ";"
}

void procedureDecl() : {}
{ <PROCEDURE> <IDENT> ("(" parameterP() (";" parameterP())* ")")? ";" 
    localDecls()
    (statement())+
  <END_PROCEDURE> ";"
}

void typeDecl() : {}
{ <TYPE> <IDENT> "=" typeU() ";" (where())? <END_TYPE> ";"
}

void subtypeConstraintDecl() : {}
{ <SUBTYPE_CONSTRAINT> <IDENT> <FOR> <IDENT> ";"
	(<ABSTRACT> <SUPERTYPE> ";")?
	(supertypeExpression() ";")?
  <END_SUBTYPE_CONSTRAINT> ";"
}

void where() : {}
{ <WHERE> ( ( LOOKAHEAD(2) <IDENT> ":")? exp() ";")+
}

void parameter() : {}
{ idents() ":" typeP()
}

void parameterP() : {}
{ parameter()
| <VAR> parameterP()
}

void supertype() : {}
{ <SUPERTYPE> <OF> "(" supertypeExpression() ")"
| <ABSTRACT> <SUPERTYPE> (<OF> "(" supertypeExpression() ")")?
}

void supertypeExpression() : {}
{ supertypeExpression2() (<ANDOR> supertypeExpression2())*
}

void supertypeExpression2() : {}
{ supertypeExpression3() (<AND> supertypeExpression3())*
}

void subtype() : {}
{ <SUBTYPE> <OF> "(" idents() ")"
}

void supertypeExpression3() : {}
{ <IDENT>
| <ONEOF> "(" supertypeExpression() ("," supertypeExpression())* ")"
| "(" supertypeExpression() ")"
}

void attribute() : {}
{ <IDENT>
| <SELF> "\\" <IDENT> "." <IDENT> (<RENAMED> <IDENT>)?
}

void attributes() : {}
{ attribute() ("," attribute())*
}

ExpType typeBI() : {}
{ <BOOLEAN> { return ExpBoolean.INSTANCE; }
| <REAL> /* */ { return ExpReal.INSTANCE; }
| <NUMBER> { return ExpNumber.INSTANCE; }
| <BINARY> ( "(" exp1() ")")? ( <FIXED> )? { return ExpBinary.INSTANCE; }
| <LOGICAL> { return ExpLogical.INSTANCE; }
| <STRING_> ( "(" exp1() ")")? ( <FIXED> )? { return ExpString.INSTANCE; }
| <INTEGER> { return ExpInteger.INSTANCE; }
}

ExpType typeB() : { ExpType type; }
{ type=typeN() { return type; }
| type=typeBI() { return type; }
| type=typeA() { return type; }
}

ExpType typeA() : { ExpType type; }
{ <BAG> bound() <OF> type=typeB() { return new ExpBag(type); }
| <ARRAY> bound() <OF> (<OPTIONAL>)? (<UNIQUE>)? type=typeB() { return new ExpArray(type); }
| <LIST> bound() <OF> (<UNIQUE>)? type=typeB() { return new ExpList(type); }
| <SET> bound() <OF> type=typeB() { return new ExpSet(type); }
}

ExpType typeI() : { ExpType type; }
{ type=typeN() { return type; }
| <BAG> bound() <OF> type=typeN() { return new ExpBag(type); }
| <SET> bound() <OF> type=typeN() { return new ExpSet(type); }
}

ExpType typeN() : { Token tt; }
{ tt=<IDENT> { return new ExpTypeName(tt.image); }
}

ExpType typeP() : { ExpType type; }
{ type=typeBI() { return type; } 
| type=typeN(){ return type; }
| <BAG> bound() <OF> type=typeP() { return new ExpBag(type); }
| <ARRAY> bound() <OF> (<OPTIONAL>)? (<UNIQUE>)? type=typeP() { return new ExpArray(type); }
| <LIST> bound() <OF> (<UNIQUE>)? type=typeP() { return new ExpList(type); }
| <SET> bound() <OF> type=typeP() { return new ExpSet(type); }
| <GENERIC> (":" <IDENT>)?  { return ExpGeneric.INSTANCE; }
| <GENERIC_ENTITY> { return ExpGenericEntity.INSTANCE; }
| <AGGREGATE> (":" <IDENT>)? <OF> type=typeP() { return new ExpAggregate(type); }
}

ExpType typeU() : {}
{ { ExpType type; } type=typeB() { return type; }
| LOOKAHEAD(3) (<EXTENSIBLE>)? (<GENERIC_ENTITY>)? <SELECT> 
    (<BASED_ON> <IDENT> (<WITH> "(" idents() ")")?
    | "(" idents() ")"
    )? { return new ExpSelect(); }
| LOOKAHEAD(3) (<EXTENSIBLE>)? (<GENERIC_ENTITY>)? <ENUMERATION> 
    (<BASED_ON> <IDENT> (<WITH> "(" idents() ")")?
    | <OF> "(" idents() ")"
    )? { return new ExpEnumeration(); }
}

void bound() : {}
{ ("[" exp1() ":" exp1() "]")?
}

ExpExpression exp() : { ExpExpression exp; }
{ exp=exp1() 
	( {ExpExpression exp2; String op;} op=op0() exp2=exp1() 
	    { exp = new ExpBinaryExpression(exp, op, exp2); } )? 
	{ return exp; }
}

String op0() : {}
{ ">" { return ">"; }
| "<" { return "<"; } 
| ">=" { return ">="; }
| "<=" { return "<="; }
| ":=:" { return ":=:"; } 
| ":<>:" { return ":<>:"; }
| "=" { return "="; }
| "<>" { return "<>"; }
| <LIKE> { return "like"; } 
| <IN> { return "in"; }
}

ExpExpression exp1() : { ExpExpression exp; }
{ exp=exp2() 
	( {ExpExpression exp2; String op;} op=op1() exp2=exp2()
	   { exp = new ExpBinaryExpression(exp, op, exp2); }
	)* 
	{ return exp; }
}

String op1() : {}
{ <OR> { return "or"; }
| <XOR> { return "xor"; }
| "+" { return "+"; }
| "-" { return "-"; }
}

ExpExpression exp2() : { ExpExpression exp; }
{ exp=exp3() 
    ( {ExpExpression exp2; String op;} op=op2() exp2=exp3()
       { exp = new ExpBinaryExpression(exp, op, exp2); }
    )* 
    { return exp; }
}

String op2() : {}
{ <AND> { return "and"; }
| <MOD> { return "mod"; }
| <DIV> { return "div"; }
| "*" { return "*"; }
| "/" { return "/"; }
| "||" { return "||"; }
}

ExpExpression exp3() : { ExpExpression exp; }
{ exp=exp4() 
    ( {ExpExpression exp2;} "**" exp2=exp4()
       { exp = new ExpBinaryExpression(exp, "**", exp2); }
    )* 
    { return exp; }
}

ExpExpression exp4() : { ExpExpression exp; }
{ "[" (exp() (":" exp())? ("," exp() (":" exp())?)* )? "]"   { return null; }
| <QUERY> "(" <IDENT> "<*" exp1() "|" exp() ")" { return null; }
| "{" exp1() ("<" | "<=") exp1() ("<" | "<=") exp1() "}" { return null; }
| "+" exp=exp5() { return new ExpUnaryExpression(exp, "+"); }
| "-" exp=exp5() { return new ExpUnaryExpression(exp, "-"); }
| <NOT> exp=exp5() { return new ExpUnaryExpression(exp, "not"); }
| exp=exp5() { return exp; }
}

ExpExpression exp5() : { Token tt; ExpExpression exp; }
{ tt=<INT> { return new ExpIntegerLiteral(tt.image); }  
| "(" exp=exp() ")" { return exp; }
| "?" { return ExpQuestionMark.INSTANCE; }
| <SELF> exp=quals(ExpQuestionMark.INSTANCE) { return exp; }
| <IDENT> ("(" (exp() ("," exp())*)? ")")? quals(null) { return null; }
| tt=<STRING> { return new ExpStringLiteral(tt.image.substring(1, tt.image.length()-1)); }  
| tt=<FLOAT> { return new ExpFloatLiteral(tt.image); }  
| <TRUE> { return ExpBooleanLiteral.TRUE; }  
| <FALSE> { return ExpBooleanLiteral.FALSE; } 
/* ... */
}

ExpExpression quals(ExpExpression base) : {}
{ ( "." <IDENT>
  | "\\" <IDENT>
  | "[" exp() (":" exp1())? "]" 
  )* { return base; }
}

void statement() : {}
{ <RETURN> (exp1())? ";"
| <IF> exp() <THEN> (statement())+ (<ELSE> (statement())+)? <END_IF> ";"
| LOOKAHEAD(2) <IDENT> quals(null) ":=" exp() ";"
| <REPEAT> 
   (<IDENT> ":=" exp1() <TO> exp1() (<BY> exp2())?)?
   (<WHILE> exp())?
   (<UNTIL> exp())? ";" 
   (statement())+ <END_REPEAT> ";"
| <CASE> exp() <OF> ( exp() ("," exp())* ":" statement() )* <END_CASE> ";"
| <BEGIN> (statement())+ <END> ";"
| <ESCAPE> ";"
| <SKIP_> ";"
| LOOKAHEAD(2) <IDENT> "(" (exp() ("," exp())*)? ")" ";"
| ";"
/* | ... */
}

String[] idents() : { List<String> idents = new ArrayList<String>(2); Token tt; } 
{ tt=<IDENT> { idents.add(tt.image); } ("," tt=<IDENT> { idents.add(tt.image); })* 
	{ return idents.toArray(new String[idents.size()]); }
}