@detectDelim

@external prop implicitCompletion from './props'

@top Problem { statement* }

statement {
  ProblemDeclaration {
    ckw<"problem"> QualifiedName "."
  } |
  ClassDefinition {
    ckw<"abstract">? ckw<"class"> RelationName
    (ckw<"extends"> sep<",", RelationName>)?
    (ClassBody {  "{" ReferenceDeclaration* "}" } | ".")
  } |
  EnumDefinition {
    ckw<"enum"> RelationName
    (EnumBody { "{" sep<",", IndividualNodeName> "}" } | ".")
  } |
  PredicateDefinition {
    (
      (ckw<"error"> | ckw<"contained"> | ckw<"containment">) ckw<"pred">? |
      ckw<"pred">
    )
    RelationName ParameterList<Parameter>?
    PredicateBody { ("<->" sep<OrOp, Conjunction>)?  "." }
  } |
  //RuleDefinition {
  //  ckw<"rule">
  //  RuleName ParameterList<Parameter>?
  //  RuleBody { ":" sep<OrOp, Conjunction> "==>" sep<OrOp, Consequent> "." }
  //} |
  Assertion {
    ckw<"default">? (NotOp | UnknownOp)? RelationName
    ParameterList<AssertionArgument> (":" LogicValue)? "."
  } |
  NodeValueAssertion {
    QualifiedName ":" Constant "."
  } |
  IndividualDeclaration {
    ckw<"indiv"> sep<",", IndividualNodeName> "."
  } |
  ScopeDeclaration {
    ckw<"scope"> sep<",", ScopeElement> "."
  }
}

ReferenceDeclaration {
  (
    ExplicitContainmentReference[@dynamicPrecedence=1] {
      (ckw<"refers"> | ckw<"contains"> | ckw<"container">) RelationName ~containment
    } |
    ImplicitContainmentReference {
      RelationName ~containment
    }
  )
  ("[" Multiplicity? "]")?
  RelationName
  (kw<"opposite"> RelationName)?
  ";"?
}

Parameter { Modality? RelationName? VariableName }

Conjunction { ("," | Literal)+ }

OrOp { ";" }

Literal {
  Modality? (NotOp | ckw<"count">)? Modality? Atom
  ((":=" | "<:") LogicValue | ComparisonOp int)?
}

Atom { RelationName "+"? ParameterList<Argument> }

//Consequent { ("," | Action)+ }

//Action {
//   ckw<"new"> VariableName ("<:" VariableName)? |
//   ckw<"delete"> VariableName |
//   Literal
//}

Argument { VariableName | Constant }

AssertionArgument { NodeName | StarArgument | Constant }

Constant { Real | String }

LogicValue {
  ckw<"true"> | ckw<"false"> | ckw<"unknown"> | ckw<"error">
}

Modality {
  ckw<"must"> | ckw<"may"> | ckw<"current">
}

ScopeElement { RelationName ("=" | "+=") Multiplicity }

Multiplicity { (IntMult "..")? (IntMult | StarMult)}

RelationName { QualifiedName }

//RuleName { QualifiedName }

IndividualNodeName { QualifiedName }

VariableName { QualifiedName }

NodeName { QualifiedName }

QualifiedName[implicitCompletion=true] { identifier ("::" identifier)* }

kw<term> { @specialize[@name={term},implicitCompletion=true]<identifier, term> }

ckw<term> { @extend[@name={term},implicitCompletion=true]<identifier, term> }

ParameterList<content> { "(" sep<",", content> ")" }

sep<separator, content> { sep1<separator, content>? }

sep1<separator, content> { content (separator content)* }

@skip { LineComment | BlockComment | whitespace }

@tokens {
  whitespace { std.whitespace+ }

  LineComment { ("//" | "%") ![\n]* }

  BlockComment { "/*" blockCommentRest }

  blockCommentRest { ![*] blockCommentRest | "*" blockCommentAfterStar }

  blockCommentAfterStar { "/" | "*" blockCommentAfterStar | ![/*] blockCommentRest }

  @precedence { BlockComment, LineComment }

  identifier { $[A-Za-z_] $[a-zA-Z0-9_]* }

  int { $[0-9]+ }

  IntMult { int }

  StarMult { "*" }

  Real { "-"? (exponential | int ("." (int | exponential))?) }

  exponential { int ("e" | "E") ("+" | "-")? int }

  String {
    "'" (![\\'\n] | "\\" ![\n] | "\\\n")+ "'" |
    "\"" (![\\"\n] | "\\" (![\n] | "\n"))* "\""
  }

  ComparisonOp { ">" | ">=" | "<" | "<=" | "==" }

  NotOp { "!" }

  UnknownOp { "?" }

  StarArgument { "*" }

  "{" "}" "(" ")" "[" "]" "." ".." "," ":" "<->" "~>"
}