/** * Equivalent to {@link Parser#between(Parser, Parser)}. Use this to list the parsers in the * natural order. */ public static <T> Parser<T> between(Parser<?> before, Parser<T> parser, Parser<?> after) { return parser.between(before, after); }
private static Parser<Void> quotedBy(Parser<Void> parser, Parser<?> quote) { return parser.between(quote, quote); }
static <T> Parser<T> paren(Parser<T> parser) { return parser.between(term("("), term(")")); } static Parser<Expression> arithmetic(Parser<Expression> atom) {
static <T> Parser<T> paren(Parser<T> parser) { return parser.between(term("("), term(")")); }
static Parser<BinaryOperator<Expression>> conditional(Parser<Expression> consequence) { // "? consequence :" can be think of as a right associative infix operator. // consequence can be the lazy expression, which is everything return consequence.between(term("?"), term(":")) .map(cons -> (cond, alt) -> new ConditionalExpression(cond, cons, alt)); }
static Parser<UnaryOperator<Expression>> subscript(Parser<Expression> expr) { return expr.between(term("["), term("]")).map(i -> a -> new ArraySubscriptExpression(a, i)); }
public static Parser<Expression> arrayInitializer(Parser<Expression> expr) { return expr.sepEndBy(term(",")).between(term("{"), term("}")).map(ArrayInitializer::new); }
static Parser<Expression> newArrayWithExplicitLength(Parser<Expression> expr) { return Parsers.sequence(term("new").next(TypeLiteralParser.TYPE_LITERAL), expr.between(term("["), term("]")), Parsers.between(term("{"), expr.sepBy(term(",")), term("}")).optional(), NewArrayExpression::new); }
static Parser<Integer> parser() { Parser.Reference<Integer> ref = Parser.newReference(); Parser<Integer> term = ref.lazy().between(isChar('('), isChar(')')).or(NUMBER); Parser<Integer> parser = new OperatorTable<Integer>() .prefix(op('-', NEG), 100) .infixl(op('+', PLUS), 10) .infixl(op('-', MINUS), 10) .infixl(op('*', MUL), 20) .infixl(op('/', DIV), 20) .infixl(op('%', MOD), 20) .build(term); ref.set(parser); return parser; } }