@Override public Parser<T> label(String overrideName) { return Parser.this.label(overrideName); } @Override boolean apply(ParseContext ctxt) {
@Override public Parser<T> label(String name) { return Parser.this.label(name).peek(); } @Override boolean apply(ParseContext ctxt) {
@Override public Parser<T> label(String name) { return Parser.this.label(name).atomic(); } @Override boolean apply(ParseContext ctxt) {
/** * A {@link Parser} that recognizes a sequence of tokens identified by {@code tokenNames}, as an * atomic step. */ public Parser<?> phrase(String... tokenNames) { Parser<?>[] wordParsers = new Parser<?>[tokenNames.length]; for (int i = 0; i < tokenNames.length; i++) { wordParsers[i] = token(tokenNames[i]); } String phrase = Strings.join(" ", tokenNames); return Parsers.sequence(wordParsers).atomic().retn(phrase).label(phrase); }
static Parser<Expression> expression(Parser<Expression> cond) { Parser.Reference<Expression> reference = Parser.newReference(); Parser<Expression> lazyExpr = reference.lazy(); Parser<Expression> atom = Parsers.or( NUMBER, WILDCARD, QUALIFIED_NAME, simpleCase(lazyExpr), fullCase(cond, lazyExpr)); Parser<Expression> expression = arithmetic(atom).label("expression"); reference.set(expression); return expression; }
static Parser<Relation> union(Parser<Relation> rel) { Parser.Reference<Relation> ref = Parser.newReference(); Parser<Relation> parser = ExpressionParser.paren(ref.lazy()).or(rel).infixl( TerminalParser.term("union").next(TerminalParser.term("all").succeeds()) .label("relation") .map(a -> (l, r) -> new UnionRelation(l, a, r))); ref.set(parser); return parser; }
static Parser<Expression> logical(Parser<Expression> expr) { Parser.Reference<Expression> ref = Parser.newReference(); Parser<Expression> parser = new OperatorTable<Expression>() .prefix(unary("not", Op.NOT), 30) .infixl(binary("and", Op.AND), 20) .infixl(binary("or", Op.OR), 10) .build(paren(ref.lazy()).or(expr)).label("logical expression"); ref.set(parser); return parser; }
static Parser<Statement> statement(Parser<Expression> expr) { Parser.Reference<Statement> ref = Parser.newReference(); Parser<Statement> lazy = ref.lazy(); @SuppressWarnings("unchecked") Parser<Statement> parser = Parsers.or( returnStatement(expr), BREAK, CONTINUE, blockStatement(lazy), foreachStatement(expr, lazy), forStatement(expr, lazy), whileStatement(expr, lazy), doWhileStatement(lazy, expr), ifStatement(expr, lazy), switchStatement(expr, lazy), tryStatement(modifier(expr), lazy), throwStatement(expr), synchronizedBlock(lazy), assertStatement(expr), varStatement(expr), thisCall(expr), superCall(expr), expression(expr), NOP).prefix(LABEL).label("statement"); ref.set(parser); return parser; } }