private static <T> Parser<List<T>> list(Parser<T> p) { return p.sepBy1(TerminalParser.term(",")); } }
/** * A {@link Parser} that runs {@code this} 0 or more times separated by {@code delim}. * * <p>The return values are collected in a {@link List}. */ public final Parser<List<T>> sepBy(Parser<?> delim) { return Parsers.or(sepBy1(delim), EmptyListParser.<T>instance()); }
static Parser<Rule> alternative(Parser<Rule> rule) { return rule.sepBy1(TerminalParser.term("|")).map(list -> list.size() == 1 ? list.get(0) : new AltRule(list)); } }
static Parser<List<Relation>> fromClause(Parser<Relation> rel) { return TerminalParser.term("from").next(aliasable(rel).sepBy1(TerminalParser.term(","))); }
static Parser<Statement> expressionList(Parser<Expression> expr) { return expr.sepBy1(term(",")).followedBy(term(";")).map(ExpressionListStatement::new); }
static Parser<List<TypeLiteral>> optionalTypeArgs(Parser<TypeLiteral> parser) { return between(term("<"), parser.sepBy1(term(",")), term(">")) .optional(TypeLiteralParser.EMPTY_TYPE_ARGUMENT_LIST); }
static Parser<Declaration> interfaceDef(Parser<Modifier> mod, Parser<Member> member) { return Parsers.sequence( mod.many(), term("interface").next(Terminals.Identifier.PARSER), TYPE_PARAMETERS.optional(), term("extends").next(TypeLiteralParser.ELEMENT_TYPE_LITERAL.sepBy1(term(","))).optional(), body(member), InterfaceDef::new); }
static Parser<Statement> varStatement(Parser<Expression> expr) { Parser<Expression> initializer = term("=").next(ExpressionParser.arrayInitializerOrRegularExpression(expr)); Parser<VarStatement.Var> var = Parsers.sequence( Terminals.Identifier.PARSER, initializer.optional(), VarStatement.Var::new); return Parsers.sequence( modifier(expr).many(), TypeLiteralParser.TYPE_LITERAL, var.sepBy1(term(",")).followedBy(term(";")), VarStatement::new); }
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<Declaration> classDef(Parser<Modifier> mod, Parser<Member> member) { return Parsers.sequence( mod.many(), term("class").next(Terminals.Identifier.PARSER), TYPE_PARAMETERS.optional(), term("extends").next(TypeLiteralParser.ELEMENT_TYPE_LITERAL).optional(), term("implements").next(TypeLiteralParser.ELEMENT_TYPE_LITERAL.sepBy1(term(","))).optional(), body(member), ClassDef::new); }
static Parser<Member> constructorDef(Parser<Modifier> mod, Parser<Statement> stmt) { return Parsers.sequence( mod.many(), Terminals.Identifier.PARSER, term("(").next(StatementParser.parameter(mod).sepBy(term(","))).followedBy(term(")")), term("throws").next(TypeLiteralParser.ELEMENT_TYPE_LITERAL.sepBy1(term(","))).optional(), StatementParser.blockStatement(stmt), ConstructorDef::new); }
static Parser<Member> methodDef( Parser<Modifier> mod, Parser<Expression> defaultValue, Parser<Statement> stmt) { return Parsers.sequence( mod.many(), TYPE_PARAMETERS.optional(), TypeLiteralParser.TYPE_LITERAL, Terminals.Identifier.PARSER, term("(").next(StatementParser.parameter(mod).sepBy(term(","))).followedBy(term(")")), term("throws").next(TypeLiteralParser.ELEMENT_TYPE_LITERAL.sepBy1(term(","))).optional(), term("default").next(ExpressionParser.arrayInitializerOrRegularExpression(defaultValue)) .optional(), Parsers.or( StatementParser.blockStatement(stmt), term(";").retn((BlockStatement) null)), MethodDef::new); }
static Parser<Declaration> enumDef(Parser<Expression> expr, Parser<Member> member) { Parser<EnumDef.Value> enumValue = Parsers.sequence( Terminals.Identifier.PARSER, between(term("("), expr.sepBy(term(",")), term(")")) .optional(), between(term("{"), member.many(), term("}")).optional(), EnumDef.Value::new); return Parsers.sequence( StatementParser.modifier(expr).many(), term("enum").next(Terminals.Identifier.PARSER), term("implements").next(TypeLiteralParser.ELEMENT_TYPE_LITERAL.sepBy1(term(","))).optional(), term("{").next(enumValue.sepBy(term(","))), term(";").next(member.many()).optional().followedBy(term("}")), EnumDef::new); }