本文整理汇总了Java中org.codehaus.jparsec.Parser.newReference方法的典型用法代码示例。如果您正苦于以下问题:Java Parser.newReference方法的具体用法?Java Parser.newReference怎么用?Java Parser.newReference使用的例子?那么恭喜您, 这里精选的方法代码示例或许可以为您提供帮助。您也可以进一步了解该方法所在类org.codehaus.jparsec.Parser
的用法示例。
在下文中一共展示了Parser.newReference方法的14个代码示例,这些例子默认根据受欢迎程度排序。您可以为喜欢或者感觉有用的代码点赞,您的评价将有助于系统推荐出更棒的Java代码示例。
示例1: arithmetic
import org.codehaus.jparsec.Parser; //导入方法依赖的package包/类
static Parser<Expression> arithmetic(Parser<Expression> atom) {
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.AGG_DIV), 5)
.infixl(binary("<", Op.LESS), 7)
.infixl(binary("<=", Op.LESS_EQ), 7)
.infixl(binary("=", Op.EQ), 7)
.infixl(binary("!=", Op.NOT_EQ), 7)
.infixl(binary(">", Op.GREATER), 7)
.infixl(binary(">=", Op.GREATER_EQ), 7)
.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), 30)
.build(operand);
reference.set(parser);
return parser;
}
示例2: statementParser
import org.codehaus.jparsec.Parser; //导入方法依赖的package包/类
private static Parser<ExpressionNode> statementParser(
Parser<ExpressionNode> expParser) {
Parser.Reference<ExpressionNode> reference = Parser.newReference();
Parser<ExpressionNode> lazyExpr = reference.lazy();
Parser<ExpressionNode> nestedParser = statementSequenceParser(lazyExpr,
expParser);
Parser<ExpressionNode> parser = Parsers.sequence(token("begin"),
statementSequenceParser(lazyExpr, expParser), token("end"),
new Map3<Token, ExpressionNode, Token, ExpressionNode>() {
public ExpressionNode map(Token begin, ExpressionNode body,
Token end) {
return new StatementNode(tokenLocation(begin).join(
tokenLocation(end)), (SequenceNode) body);
}
});
reference.set(nestedParser);
return parser;
}
示例3: fieldOrFunctionParser
import org.codehaus.jparsec.Parser; //导入方法依赖的package包/类
protected Parser<QlField> fieldOrFunctionParser() {
Parser.Reference<QlField> fieldOrFuncParserRef = Parser.newReference();
Parser<Tuple3<String, QlField, Boolean>> simpleParser = simpleFieldParser();
Parser<Tuple3<String, QlField, Boolean>> fieldParser = fieldParser(fieldOrFuncParserRef);
Parser<QlField> fieldOrFuncParser =
Parsers.or(functionParser(fieldOrFuncParserRef), fieldParser,
simpleParser).map(
new Map<Tuple3<String, QlField, Boolean>, QlField>() {
@Override
public QlField map(Tuple3<String, QlField, Boolean> fieldInfo) {
return QlField.create(null, fieldInfo.a, fieldInfo.b,
fieldInfo.c);
}
});
fieldOrFuncParserRef.lazySet(fieldOrFuncParser);
return fieldOrFuncParser;
}
示例4: fieldOrFunctionParserOB
import org.codehaus.jparsec.Parser; //导入方法依赖的package包/类
protected Parser<Pair<QlField, QlSortOrderType>> fieldOrFunctionParserOB() {
Parser.Reference<Pair<QlField, QlSortOrderType>> fieldOrFuncParserRef = Parser.newReference();
Parser<Tuple3<String, Pair<QlField, QlSortOrderType>, Boolean>> simpleParser = simpleFieldParserOB();
Parser<Tuple3<String, Pair<QlField, QlSortOrderType>, Boolean>> fieldParser = fieldParserOB(fieldOrFuncParserRef);
Parser<Pair<QlField, QlSortOrderType>> fieldOrFuncParser =
Parsers.or(functionParserOB(fieldOrFuncParserRef), fieldParser,
simpleParser).map(
new Map<Tuple3<String, Pair<QlField, QlSortOrderType>, Boolean>, Pair<QlField, QlSortOrderType>>() {
@Override
public Pair<QlField, QlSortOrderType> map(Tuple3<String, Pair<QlField, QlSortOrderType>, Boolean> fieldInfo) {
return new Pair<QlField, QlSortOrderType>(QlField.create(null, fieldInfo.a, fieldInfo.b.a,
fieldInfo.c), QlSortOrderType.DEFAULT);
}
});
fieldOrFuncParserRef.lazySet(fieldOrFuncParser);
return fieldOrFuncParser;
}
示例5: qualifiedFieldOrFunctionParser
import org.codehaus.jparsec.Parser; //导入方法依赖的package包/类
protected Parser<QlField> qualifiedFieldOrFunctionParser() {
Parser.Reference<QlField> fieldOrFuncParserRef = Parser.newReference();
Parser<Tuple3<String, QlField, Boolean>> simpleParser = simpleFieldParser();
Parser<Tuple3<String, QlField, Boolean>> fieldParser = fieldParser(fieldOrFuncParserRef);
Parser<String> qualifierParser = regex("[a-zA-Z]+\\s+", false)
.followedBy(regex("from", false).not().peek()).atomic().optional(null);
Parser<QlField> fieldOrFuncParser = Parsers.pair(qualifierParser,
Parsers.or(functionParser(fieldOrFuncParserRef), fieldParser,
simpleParser)).map(
new Map<Pair<String, Tuple3<String, QlField, Boolean>>, QlField>() {
@Override
public QlField map(
Pair<String, Tuple3<String, QlField, Boolean>> fieldInfo) {
String qualifier = fieldInfo.a == null ? null : fieldInfo.a.trim();
return QlField.create(qualifier, fieldInfo.b.a, fieldInfo.b.b,
fieldInfo.b.c);
}
});
fieldOrFuncParserRef.lazySet(fieldOrFuncParser);
return fieldOrFuncParser;
}
示例6: parse
import org.codehaus.jparsec.Parser; //导入方法依赖的package包/类
/** Parses {@code string} to a {@link TypeToken}. */
public TypeToken<?> parse(String string) throws ParserException {
Parser.Reference<Type> ref = Parser.newReference();
Parser<Type> type = Parsers.or(
wildcardType(ref.lazy()), parameterizedType(ref.lazy()), arrayClass(), rawType());
ref.set(type.postfix(TERMS.phrase("[", "]").retn(Types::newArrayType)));
return TypeToken.of(
ref.get().from(TERMS.tokenizer(), Scanners.WHITESPACES.optional()).parse(string));
}
示例7: shapeParser
import org.codehaus.jparsec.Parser; //导入方法依赖的package包/类
private Parser<MatrixShape> shapeParser() {
Parser.Reference<MatrixShape> reference = Parser.newReference();
Parser<MatrixShape> lazyExpr = reference.lazy();
Parser<MatrixShape> parser = Parsers.or(shapeBinOpParser(lazyExpr),
powerShapeParser(lazyExpr),
shapeUnOpParser(lazyExpr), bangShapeParser(),
scalarShapeParser());
reference.set(parser);
return parser;
}
示例8: expressionParser
import org.codehaus.jparsec.Parser; //导入方法依赖的package包/类
private Parser<Expression> expressionParser() {
Parser.Reference<Expression> reference = Parser.newReference();
Parser<Expression> lazyExpr = reference.lazy();
Parser<Expression> parser = Parsers.or(applicationParser(lazyExpr),
applicationDebugParser(lazyExpr), ifParser(lazyExpr),
lambdaParser(lazyExpr), constParser(), stringParser(), literalMatrix(),
matrixConstructorParser(), keyParser(), VARIABLE);
reference.set(parser);
return parser;
}
示例9: unitParser
import org.codehaus.jparsec.Parser; //导入方法依赖的package包/类
private Parser<Unit> unitParser() {
Parser.Reference<Unit> reference = Parser.newReference();
Parser<Unit> lazyExpr = reference.lazy();
Parser<Unit> parser = Parsers.or(unitPower(lazyExpr),
unitMult(lazyExpr), unitDiv(lazyExpr), unitScaled(),
unitNamed());
reference.set(parser);
return parser;
}
示例10: typeParserRec
import org.codehaus.jparsec.Parser; //导入方法依赖的package包/类
private static Parser<TypeNode> typeParserRec() {
Parser.Reference<TypeNode> reference = Parser.newReference();
Parser<TypeNode> termParser = termParser();
Parser<TypeNode> lazyExpr = reference.lazy();
Parser<TypeNode> parser = Parsers.or(typeSchemeParser(lazyExpr),
functionTypeParser(lazyExpr),
simpleFunctionTypeParser(lazyExpr),
parametricTypeParser(lazyExpr), matrixTypeParser(Parsers.or(
parametricTypeParser(lazyExpr), termParser)),
matrixTermIdentifier());
reference.set(parser);
return parser;
}
示例11: ifRestParser
import org.codehaus.jparsec.Parser; //导入方法依赖的package包/类
private static Parser<List<Pair<ExpressionNode, ExpressionNode>>> ifRestParser(
Parser<ExpressionNode> statementParser,
Parser<ExpressionNode> expParser) {
Parser.Reference<List<Pair<ExpressionNode, ExpressionNode>>> reference = Parser
.newReference();
Parser<List<Pair<ExpressionNode, ExpressionNode>>> parser = Parsers.or(
ifRestEndParser(statementParser, expParser),
ifRestRestParser(statementParser, expParser, reference.lazy()));
reference.set(parser);
return parser;
}
示例12: expressionParser
import org.codehaus.jparsec.Parser; //导入方法依赖的package包/类
private static Parser<ExpressionNode> expressionParser() {
Parser.Reference<ExpressionNode> reference = Parser.newReference();
Parser<ExpressionNode> lazyExpr = reference.lazy();
Parser<ExpressionNode> parser = Parsers.or(
arithmeticParser(nonArithmeticParser(lazyExpr)),
nonArithmeticParser(lazyExpr));
reference.set(parser);
return parser;
}
示例13: one
import org.codehaus.jparsec.Parser; //导入方法依赖的package包/类
public static Parser<ExprNode> one ()
{
Parser.Reference<ExprNode> ref = Parser.newReference();
Parser<ExprNode> lazy = ref.lazy();
Parser<ExprNode> parser;
parser = Parsers.or(BOOLEAN_PARSER, NULL_PARSER, DECIMAL_PARSER, INTEGER_PARSER, NAME_PARSER, STRING_PARSER);
parser = Parsers.or(paren(lazy), list(lazy), dict(lazy), set(lazy), parser);
parser = new OperatorTable<ExprNode>()
.postfix(qualified(), 120)
.postfix(invocationWithParens(lazy), 120)
.infixl(binary("|", term("|")), 110)
.infixr(binary("**", term("**")), 100)
.infixl(binary("*", term("*")), 90)
.infixl(binary("/", term("/")), 90)
.infixl(binary("//", term("//")), 90)
.infixl(binary("%", term("%")), 90)
.infixl(binary("+", term("+")), 80)
.infixl(binary("-", term("-")), 80)
.infixl(binary("~", term("~")), 70)
.infixl(binary("not in", TagParsers.name("not", "in")), 60)
.infixl(binary("in", TagParsers.name("in")), 60)
.infixl(binary("is not", TagParsers.name("is", "not")), 60)
.infixl(binary("is", TagParsers.name("is")), 60)
.infixl(binary("<", term("<")), 60)
.infixl(binary("<=", term("<=")), 60)
.infixl(binary(">", term(">")), 60)
.infixl(binary(">=", term(">=")), 60)
.infixl(binary("==", term("==")), 60)
.infixl(binary("!=", term("!=")), 60)
.prefix(unary("not", TagParsers.name("not")), 50)
.infixl(binary("and", TagParsers.name("and")), 40)
.infixl(binary("or", TagParsers.name("or")), 30)
.infixl(ifElse(lazy), 20)
.build(parser);
ref.set(parser);
return Marker.mark(parser);
}
示例14: reInitialize
import org.codehaus.jparsec.Parser; //导入方法依赖的package包/类
final void reInitialize() {
regexRef = Parser.newReference();
}