silverchain.jj

options {
  JDK_VERSION = "1.8";
  STATIC = false;
  LOOKAHEAD = 2;
}

PARSER_BEGIN(Parser)
package silverchain.parser;

import java.util.ArrayList;
import java.util.List;

public final class Parser {

  private static Range range(ASTNode left, ASTNode right) {
    right = right == null ? left : right;
    return new Range(left.range().begin(), right.range().end());
  }

  private static Range range(ASTNode left, Token token, ASTNode right) {
    if (right == null) {
      return new Range(left.range().begin(), range(token).end());
    }
    return range(left, right);
  }

  private static Range range(ASTNode node, Token token) {
    if (node == null) {
      return range(token);
    }
    if (token == null) {
      return node.range();
    }
    return new Range(node.range().begin(), range(token).end());
  }

  private static Range range(Token token, ASTNode node) {
    if (node == null) {
      return range(token);
    }
    return new Range(range(token).begin(), node.range().end());
  }

  private static Range range(Token token1, Token token2) {
    return new Range(range(token1).begin(), range(token2).end());
  }

  private static Range range(Token token) {
    return new Range(
        new Location(token.beginLine, token.beginColumn),
        new Location(token.endLine, token.endColumn));
  }
}

PARSER_END(Parser)

SKIP : {
  " " |
  "\t" |
  "\r" |
  "\n" |
  "\f" |
  <"//" (~["\r", "\n"])*> |
  <"/*" (~["*"] | ("*" ~["/"]))* "*/">
}

TOKEN: {
  < SUPER: "super" > |
  < EXTENDS: "extends" > |
  < VOID: "void" > |
  < THROWS: "throws" > |
  < NAME: ["a"-"z","A"-"Z","_"](["a"-"z","A"-"Z","0"-"9","_"])* > |
  < NUMBER: "0" | ["1"-"9"](["0"-"9"])* >
}

List<Grammar> start(): {
  Grammar g;
  List<Grammar> gs = new ArrayList<>();
} {
  (g = grammar() { gs.add(g); })+ <EOF> {
    return gs;
  }
}

Grammar grammar(): {
  Type t;
  Token c;
  Rules rs = null;
} {
  t = type() "{" (rs = rules())? "}" {
    return new Grammar(range(t, token), t, rs);
  }
}

Type type(): {
  QualifiedName n;
  TypeParameters ps = null;
  Token b = null;
} {
  n = qualifiedName() ("<" ps = typeParameters() ">" { b = token; })? {
    return new Type(range(n, b), n, ps);
  }
}

Rules rules(): {
  Rule r;
  Rules rs = null;
} {
  r = rule() (rs = rules())? {
    return new Rules(range(r, rs), r, rs);
  }
}

Rule rule(): {
  RuleExpression e;
  TypeReference r = null;
  Token t = null;
} {
  (r = typeReference() | <VOID> { t = token; }) e = ruleExpression() ";" {
    return new Rule(r == null ? range(t, token) : range(r, token), e, r);
  }
}

RuleExpression ruleExpression(): {
  RuleTerm t;
  RuleExpression e = null;
} {
  t = ruleTerm() ("|" e = ruleExpression())? {
    return new RuleExpression(range(t, e), t, e);
  }
}

RuleTerm ruleTerm(): {
  RuleFactor f;
  RuleTerm t = null;
} {
  f = ruleFactor() (LOOKAHEAD(ruleTerm()) t = ruleTerm())? {
    return new RuleTerm(range(f, t), f, t);
  }
}

RuleFactor ruleFactor(): {
  RuleElement e;
  RepeatOperator o = null;
} {
  e = ruleElement() (o = repeatOperator())? {
    return new RuleFactor(range(e, o), e, o);
  }
}

RuleElement ruleElement(): {
  Method m;
  RuleExpression e;
  Token p;
} {
  m = method() {
    return new RuleElement(m.range(), m, null);
  } |
  "(" { p = token; } e = ruleExpression() ")" {
    return new RuleElement(range(p, token), null, e);
  }
}

RepeatOperator repeatOperator(): {
  Token l;
  Token u = null;
  Token b;
  Token c = null;
} {
  "*" {
    return new RepeatOperator(range(token), 0, null);
  } |
  "+" {
    return new RepeatOperator(range(token), 1, null);
  } |
  "?" {
    return new RepeatOperator(range(token), 0, 1);
  } |
  "[" { b = token; } l = <NUMBER> ("," { c = token; } (u = <NUMBER>)?)? "]" {
    int i = Integer.parseInt(l.image);
    if (c == null) {
        return new RepeatOperator(range(b, token), i, i);
    } else {
      if (u == null) {
        return new RepeatOperator(range(b, token), i, null);
      } else {
        Integer j = Integer.parseInt(u.image);
        return new RepeatOperator(range(b, token), i, j);
      }
    }
  }
}

Method method(): {
  Token n;
  MethodParameters p;
  TypeReferences rs = null;
} {
  n = <NAME> p = methodParameters() (<THROWS> rs = typeReferences())? {
    return new Method(range(n, token), n.image, p, rs);
  }
}

MethodParameters methodParameters(): {
  Token s = null;
  Token p;
  TypeParameterList ts = null;
  FormalParameters fs = null;
} {
  ("<" { s = token; } ts = typeParameterList() ">")?
  "(" { p = token; } (fs = formalParameters())? ")" {
    return new MethodParameters(range(s == null ? p : s, token), ts, fs);
  }
}

FormalParameters formalParameters(): {
  FormalParameter p;
  FormalParameters ps = null;
} {
  p = formalParameter() ("," ps = formalParameters())? {
    return new FormalParameters(range(p, ps), p, ps);
  }
}

FormalParameter formalParameter(): {
  TypeReference r;
  Token n;
  Token e = null;
} {
  r = typeReference() (e = "...")? n = <NAME> {
    return new FormalParameter(range(r, n), r, n.image, e != null);
  }
}

TypeReference typeReference(): {
  QualifiedName n;
  TypeArguments r = null;
  Token t = null;
} {
  n = qualifiedName() ("<" r = typeArguments() ">")? (t = "[" "]")? {
    return new TypeReference(range(n, token), n, r, t != null);
  }
}

TypeReferences typeReferences(): {
  TypeReference r;
  TypeReferences rs = null;
} {
  r = typeReference() ("," rs = typeReferences())? {
    return new TypeReferences(range(r, rs), r, rs);
  }
}

TypeArguments typeArguments(): {
  TypeArgument a;
  TypeArguments as = null;
} {
  a = typeArgument() ("," as = typeArguments())? {
    return new TypeArguments(range(a, as), a, as);
  }
}

TypeArgument typeArgument(): {
  TypeReference r;
  Token w;
  TypeParameterBound b = null;
} {
  r = typeReference() { return new TypeArgument(r.range(), r, null); } |
  w = "?" (b = typeParameterBound())? { return new TypeArgument(range(w, b), null, b); }
}

TypeParameters typeParameters(): {
  TypeParameterList ps1;
  TypeParameterList ps2 = null;
  Token s;
} {
  ps1 = typeParameterList() (";" ps2 = typeParameterList())? {
    return new TypeParameters(range(ps1, ps2), ps1, ps2);
  } |
  ";" { s = token; } ps2 = typeParameterList() {
    return new TypeParameters(range(s, ps2), null, ps2);
  }
}

TypeParameterList typeParameterList(): {
  TypeParameter p;
  TypeParameterList ps = null;
} {
  p = typeParameter() ("," ps = typeParameterList())? {
    return new TypeParameterList(range(p, ps), p, ps);
  }
}

TypeParameter typeParameter(): {
  Token n;
  TypeParameterBound b = null;
} {
  n = <NAME> (b = typeParameterBound())?{
    return new TypeParameter(range(n, b), n.image, b);
  }
}

TypeParameterBound typeParameterBound(): {
  Token d = null;
  TypeReference r;
} {
  (<EXTENDS> | <SUPER>) { d = token; } r = typeReference() {
    boolean u = d.image.equals("extends");
    return new TypeParameterBound(range(d, r), u, r);
  }
}

QualifiedName qualifiedName(): {
  Token n;
  List<Token> ns = new ArrayList<>();
} {
  n = <NAME> { ns.add(n); } ("." n = <NAME> { ns.add(n); })* {
    QualifiedName q = null;
    for (Token t : ns) {
      q = new QualifiedName(range(q, t), q, t.image);
    }
    return q;
  }
}