TOKEN :
{ < FORFAMEL: "Forfamel" >
| < KOALISH: "Koalish" >
| < KUMBANG: "Kumbang" >
| < MODEL: "model" >
| < ROOT: "root" >
| < ROOTSYMBOL: "$" >
| < TYPE: "type" >
| < ABSTRACT: "abstract" >
| < FEATURE: "feature" >
| < ATTRIBUTE: "attribute" >
| < INTERFACE: "interface" >
| < COMPONENT: "component" >
| < SUBFEATURES: "subfeatures" >
| < ATTRIBUTES: "attributes" >
| < PROVIDES: "provides" >
| < REQUIRES: "requires" >
| < CONTAINS: "contains" >
| < CONNECTS: "connects" >
| < OPTIONAL: "optional" >
| < GROUNDED: "grounded" >
| < CONSTRAINTS: "constraints" >
| < IMPLEMENTATION: "implementation" >
| < PRESENT: "present" >
| < CARDINALITY: "cardinality" >
| < INSTANCEOF: "instance_of" >
| < HASINSTANCES: "has_instances" >
| < HASPART_OFTYPE: "has_part_of_type" >
| < CONNECTED: "connected" >
| < CONNECTED_TO: "connected_to" >
| < EXTENDS: "extends" >
| < VALUE: "value" >
| < HIDDEN: "hidden" >
| < NONE: "none" >
| < SAME: "same" >
| < DIFFERENT: "different" >
| < LBRACE: "{" >
| < LPAREN: "(" >
| < LBRACKET: "[" >
| < RBRACKET: "]" >
| < RPAREN: ")" >
| < RBRACE: "}" >
| < SEMICOLON: ";" >
| < COMMA: "," >
| < EQUIVALENT: "<=>" >
| < IMPLIES: "=>" >
| < EQUALS: "=" >
| < AND: "and" >
| < OR: "or" >
| < NE: "!=" >
| < LT: "<" >
| < GT: ">" >
| < LTE: "<=" >
| < GTE: ">=" >
| < MINUS: "-" >
| < PLUS: "+" >
| < DIV: "/" >
| < MOD: "mod" >
| < DOT: "." >
| < ASTERISK: "*" >
| < QUESTION_MARK: "?" >
| < INTEGER_LITERAL: ["0"-"9"](["0"-"9"])* >
| < NOT: "not" >
| < FORALL: "for_all" >
| < EXISTS: "exists" >
| < COLON: ":" >
| < ATTR: "@" >
| < ARROW: "->" >
| < STRING_LITERAL: "\"" (~["\"", "\n", "\r"])* ("\"" | "\n" | "\r") >
| < IDENTIFIER: (["a"-"z"]|["A"-"Z"]|["0"-"9"]|["_"])+ >
}

void SyntaxModel():
{}
{ SyntaxModelKind() <MODEL> <IDENTIFIER> (<ROOT> (<FEATURE>|<COMPONENT>) <IDENTIFIER>)+ (SyntaxTypeDefinition())* }

void SyntaxModelKind():
{}
{ <FORFAMEL> | <KOALISH> | <KUMBANG> }

void SyntaxTypeDefinition():
{}
{
  SyntaxAttributeTypeDefinition() 
| SyntaxInterfaceTypeDefinition() 
| SyntaxComposableTypeDefinition()
}

void SyntaxComposableTypeDefinition():
{}
{ [<ABSTRACT>] (<FEATURE>|<COMPONENT>) <TYPE> SyntaxDisplayIdentifier() [<EXTENDS> SyntaxIdentifierList()] 
 <LBRACE> (SyntaxSection())* <RBRACE>
}

void SyntaxAttributeTypeDefinition():
{}
{ <ATTRIBUTE> <TYPE> SyntaxDisplayIdentifier() <EQUALS> <LBRACE> SyntaxValueEnumeration() <RBRACE> }

void SyntaxInterfaceTypeDefinition():
{}
{ <INTERFACE> <TYPE> SyntaxDisplayIdentifier() <LBRACE> (<IDENTIFIER> <SEMICOLON> )* <RBRACE> }

void SyntaxSection():
{}
{ SyntaxSubfeatureSection() 
| SyntaxAttributeSection() 
| SyntaxProvideSection() 
| SyntaxRequireSection() 
| SyntaxConstraintSection() 
| SyntaxContainSection()
| SyntaxConnectSection()
| SyntaxImplementationSection()
}

void SyntaxSubfeatureSection():
{}
{ <SUBFEATURES> (SyntaxPartSpecification())* }

void SyntaxAttributeSection():
{}
{ <ATTRIBUTES> (SyntaxAttribute())* }

void SyntaxProvideSection():
{}
{ <PROVIDES> (SyntaxInterface())* }

void SyntaxRequireSection():
{}
{ <REQUIRES> (SyntaxInterface())* }

void SyntaxInterface():
{}
{ SyntaxIdentifierList() SyntaxInterfaceSpecification() (<COMMA> SyntaxInterfaceSpecification())* <SEMICOLON> }

void SyntaxInterfaceSpecification():
{}
{ SyntaxDisplayIdentifier() [<LBRACE> (<OPTIONAL> | <GROUNDED> ) [ <COMMA> (<OPTIONAL> | <GROUNDED> )] <RBRACE>] }

void SyntaxConstraintSection():
{}
{ <CONSTRAINTS> (SyntaxConstraint())* }

void SyntaxContainSection():
{}
{ <CONTAINS> (SyntaxPartSpecification())* }

void SyntaxImplementationSection():
{}
{ <IMPLEMENTATION> (SyntaxConstraint())* }

void SyntaxPartSpecification():
{}
{ SyntaxIdentifierList() SyntaxDisplayIdentifier() [SyntaxCardinality()] [<LBRACE> (<NONE> | <SAME> | <DIFFERENT>) <RBRACE>] <SEMICOLON> }

void SyntaxIdentifierList():
{}
{ <IDENTIFIER> | <LPAREN> <IDENTIFIER> (SyntaxIdentifierListEnd())* <RPAREN> }

void SyntaxIdentifierListEnd():
{}
{ <COMMA> <IDENTIFIER> }

void SyntaxCardinality():
{}
{ <LBRACKET> <INTEGER_LITERAL> [<MINUS> <INTEGER_LITERAL>] <RBRACKET> }

void SyntaxAttribute():
{}
{ <IDENTIFIER> SyntaxDisplayIdentifier() [ <LBRACE> <HIDDEN> <RBRACE> ] <SEMICOLON>}

void SyntaxValueEnumeration():
{}
{ SyntaxValueDefinition() (SyntaxEnumerationRest())* }

void SyntaxValueDefinition():
{}
{ ( [ <MINUS> ] <INTEGER_LITERAL> | <IDENTIFIER> ) [ <STRING_LITERAL> ] }

void SyntaxValue():
{}
{ [<MINUS>] <INTEGER_LITERAL> | <IDENTIFIER> }

void SyntaxEnumerationRest():
{}
{ <COMMA> SyntaxValueDefinition() }

//	Change this to a more complex expression if need should arise.
void SyntaxFunction(): 
{}
{ <IDENTIFIER> }

void SyntaxConnectSection():
{}
{ <CONNECTS> (SyntaxConnection())* }

void SyntaxConnection():
{}
{ <IDENTIFIER> [<DOT> <IDENTIFIER>] <EQUALS> <IDENTIFIER> [<DOT> <IDENTIFIER>] <SEMICOLON> }

void SyntaxConstraint():
{}
{ SyntaxEquivalenceExpression() <SEMICOLON> }

void SyntaxQuantification():
{}
{  [<NOT>] (<FORALL> | <EXISTS>) <LPAREN> SyntaxVariableBinding() (<COMMA> SyntaxVariableBinding())* <RPAREN> }

void SyntaxVariableBinding():
{}
{ <IDENTIFIER> <COLON> SyntaxStructureReference() }

void SyntaxEquivalenceExpression():
{}
{ SyntaxImplicationExpression() [<EQUIVALENT> SyntaxImplicationExpression()] }

void SyntaxImplicationExpression():
{}
{ SyntaxAndOrExpression() [<IMPLIES> SyntaxAndOrExpression()] }

// Syntactically, and's and or's may alternate, but not semantically
void SyntaxAndOrExpression():
{}
{ SyntaxQuantifiedExpression() ((<AND>|<OR>) SyntaxQuantifiedExpression())*}

//	nee SyntaxPrimitiveExpression
void SyntaxQuantifiedExpression(): // Name is not very good.
{}
{ (LOOKAHEAD(2) SyntaxQuantification())* [<NOT>]
(   SyntaxConfigurationPredicateExpression() 
  | SyntaxComparisonExpression()
)
}

void SyntaxComparisonExpression():
{}
{ SyntaxAdditiveExpression() [SyntaxComparisonOperator() SyntaxAdditiveExpression()] }

void SyntaxAdditiveExpression():
{}
{ SyntaxMultiplicativeExpression() ( (<PLUS > |<MINUS>) SyntaxMultiplicativeExpression())* }

void SyntaxMultiplicativeExpression():
{}
{ SyntaxPrimitiveArithmetic() ( (<ASTERISK> | <DIV> | <MOD>) SyntaxPrimitiveArithmetic())* }

void SyntaxPrimitiveArithmetic():
{}
{
(
  LOOKAHEAD(2) 
  [<MINUS>]
  (  SyntaxCardinalityExpression() 
     | SyntaxAttributeValue() 
     | <LPAREN> SyntaxEquivalenceExpression() <RPAREN>
  )
  |
  SyntaxValue()
)
}

void SyntaxCardinalityExpression():
{}
{ <CARDINALITY> <LPAREN> SyntaxStructureReference() <RPAREN> }

void SyntaxConfigurationPredicateExpression():
{}
{ SyntaxPresentExpression()
| SyntaxInstanceOfExpression()
| SyntaxHasInstancesExpression()
| SyntaxHasPartOfTypeExpression()
| SyntaxConnectedExpression()
| SyntaxConnectedToExpression()
}

void SyntaxPresentExpression():
{}
{ <PRESENT> <LPAREN> SyntaxStructureReference() <RPAREN> }

void SyntaxInstanceOfExpression():
{}
{ <INSTANCEOF> <LPAREN> SyntaxStructureReference() <COMMA> <IDENTIFIER> <RPAREN> }

void SyntaxHasInstancesExpression():
{}
{ <HASINSTANCES> <LPAREN> <IDENTIFIER> <RPAREN> }

void SyntaxHasPartOfTypeExpression():
{}
{ <HASPART_OFTYPE> <LPAREN> [ LOOKAHEAD(2) SyntaxStructureReference() <COMMA>] <IDENTIFIER> <RPAREN> }

void SyntaxConnectedExpression():
{}
{ <CONNECTED> <LPAREN> SyntaxStructureReference() <RPAREN> }

void SyntaxConnectedToExpression():
{}
{ <CONNECTED_TO> <LPAREN> SyntaxStructureReference() <COMMA> SyntaxStructureReference() <RPAREN> }

void SyntaxAttributeValue(): 
{}
{ <VALUE> <LPAREN> [ LOOKAHEAD(2) SyntaxStructureReference() <COMMA>] <IDENTIFIER> <RPAREN> }

void SyntaxDisplayIdentifier():
{}
{ <IDENTIFIER> [<STRING_LITERAL>] }

void SyntaxStructureReference():
{}
{ 
[SyntaxRootSymbol() | SyntaxStructureReferenceItem()] 
(<DOT> SyntaxStructureReferenceItem()) * 
[<ARROW> SyntaxStructureReferenceItem() ] 
}

void SyntaxStructureReferenceItem():
{}
{ (<ASTERISK> | <QUESTION_MARK> | <IDENTIFIER>) [ <COLON> <IDENTIFIER> ] }

void SyntaxRootSymbol():
{}
{ (<FEATURE> | <COMPONENT>) <MINUS> <ROOT> }

void SyntaxComparisonOperator():
{}
{
 <EQUALS> | <NE> | <LT> | <LTE> | <GT> | <GTE> 
}

void SyntaxConfigurationReference():
{}
{ SyntaxConfigurationComposableReference() 
[ <ARROW> <IDENTIFIER> [<COLON> <IDENTIFIER>] 
   [ <EQUALS> SyntaxConfigurationComposableReference() <ARROW> <IDENTIFIER> [<COLON> <IDENTIFIER>]]
| <ATTR> <IDENTIFIER> [ <EQUALS> <IDENTIFIER>]
]
}

void SyntaxConfigurationComposableReference():
{}
{
  (<FEATURE> | <COMPONENT>) <MINUS> <ROOT> 
  (SyntaxConfigurationReferenceItem())* 
}

void SyntaxConfigurationReferenceItem():
{}
{ <DOT> <IDENTIFIER> [<LBRACKET> <INTEGER_LITERAL> <RBRACKET>] [<COLON> <IDENTIFIER>] }