/** The {@link Parser} for a full fledged SQL query. */ public static Parser<Relation> query() { Parser.Reference<Relation> relationRef = Parser.newReference(); Parser<Relation> subQuery = ExpressionParser.paren(relationRef.lazy()); Parser.Reference<Expression> conditionRef = Parser.newReference(); Parser<Expression> expr = ExpressionParser.expression(conditionRef.lazy()); Parser<Expression> cond = ExpressionParser.condition(expr, subQuery); Parser<Relation> relation = query(expr, cond, subQuery.or(TABLE)); conditionRef.set(cond); relationRef.set(relation); return relation; }
static Parser<Rule> rule() { Parser.Reference<Rule> ref = Parser.newReference(); Parser<Rule> atom = Parsers.or(LITERAL, IDENT, unit(ref.lazy())); Parser<Rule> parser = alternative(sequential(atom)); ref.set(parser); return parser; }
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; }
public static Parser<Program> program() { Parser.Reference<Member> memberRef = Parser.newReference(); Parser.Reference<Statement> stmtRef = Parser.newReference(); Parser<Expression> expr = ExpressionParser.expression(body(memberRef.lazy()), stmtRef.lazy()); Parser<Statement> stmt = StatementParser.statement(expr); stmtRef.set(stmt); Parser<Modifier> mod = StatementParser.modifier(expr); Parser.Reference<Declaration> decRef = Parser.newReference(); Parser<Member> member = Parsers.or( fieldDef(expr), methodDef(mod, expr, stmt), constructorDef(mod, stmt), initializerDef(stmt), nestedDef(decRef.lazy())); memberRef.set(member); Parser<Declaration> declaration = Parsers.or( classDef(mod, member), interfaceDef(mod, member), enumDef(expr, member), annotationDef(mod, member)); decRef.set(declaration); return Parsers.sequence(PACKAGE.optional(), IMPORT.many(), declaration.many(), Program::new); }
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<TypeLiteral> elementTypeLiteral() { Parser.Reference<TypeLiteral> ref = Parser.newReference(); Parser<TypeLiteral> lazy = ref.lazy(); Parser<TypeLiteral> arg = wildcard(lazy).or(lazy); Parser<String> nativeTypeName = TerminalParser.oneOf( "byte", "short", "int", "long", "boolean", "char", "float", "double", "void") .map(Object::toString); Parser<String> typeName = nativeTypeName.or(Terminals.Identifier.PARSER); Parser<TypeLiteral> parser = Parsers.sequence( typeName.sepBy1(term(".")), TypeLiteralParser.optionalTypeArgs(arg), SimpleTypeLiteral::new); ref.set(parser.postfix(ARRAY_OF)); return parser; }
static Parser<Relation> join(Parser<Relation> rel, Parser<Expression> cond) { Parser.Reference<Relation> ref = Parser.newReference(); Parser<Relation> lazy = ref.lazy(); Parser<Relation> atom = aliasable(ExpressionParser.paren(lazy).or(rel)); // Cannot use regular infix operator because of the "join ... on ..." syntax. Parser<UnaryOperator<Relation>> crossJoin = TerminalParser.phrase("cross join").next(atom).map(r -> l -> new CrossJoinRelation(l, r)); Parser<Relation> parser = atom.postfix(Parsers.or( joinOn(INNER_JOIN, lazy, cond), joinOn(LEFT_JOIN, lazy, cond), joinOn(RIGHT_JOIN, lazy, cond), joinOn(FULL_JOIN, lazy, cond), crossJoin)); ref.set(parser); return parser; }
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; } }
static Parser<Expression> arithmetic(Parser<Expression> atom) { Parser.Reference<Expression> reference = Parser.newReference(); Parser<Expression> operand = Parsers.or(paren(reference.lazy()), functionCall(reference.lazy()), atom); Parser<Expression> parser = new OperatorTable<Expression>() .infixl(binary("+", Op.PLUS), 10) .infixl(binary("-", Op.MINUS), 10) .infixl(binary("*", Op.MUL), 20) .infixl(binary("/", Op.DIV), 20) .infixl(binary("%", Op.MOD), 20) .prefix(unary("-", Op.NEG), 50) .build(operand); reference.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; } }
static Parser<Expression> expression( Parser<Expression> atom, Parser<DefBody> classBody, Parser<Statement> statement) { Parser.Reference<Expression> ref = Parser.newReference(); Parser<Expression> lazy = ref.lazy(); atom = Parsers.or(castOrExpression(lazy), simpleNewExpression(lazy, classBody),