private boolean peekToken(TokenKind possible1, TokenKind possible2) { Token t = peekToken(); if (t == null) { return false; } return (t.kind == possible1 || t.kind == possible2); }
private boolean peekToken(TokenKind possible1, TokenKind possible2, TokenKind possible3) { Token t = peekToken(); if (t == null) { return false; } return (t.kind == possible1 || t.kind == possible2 || t.kind == possible3); }
private boolean peekSelectToken() { Token t = peekToken(); if (t == null) { return false; } return (t.kind == TokenKind.SELECT || t.kind == TokenKind.SELECT_FIRST || t.kind == TokenKind.SELECT_LAST); }
private boolean peekToken(TokenKind desiredTokenKind) { return peekToken(desiredTokenKind, false); }
private boolean peekIdentifierToken(String identifierString) { Token t = peekToken(); if (t == null) { return false; } return (t.kind == TokenKind.IDENTIFIER && identifierString.equalsIgnoreCase(t.stringValue())); }
private boolean maybeEatIndexer() { Token t = peekToken(); if (!peekToken(TokenKind.LSQUARE, true)) { return false; } Assert.state(t != null, "No token"); SpelNodeImpl expr = eatExpression(); Assert.state(expr != null, "No node"); eatToken(TokenKind.RSQUARE); this.constructedNodes.push(new Indexer(t.startPos, t.endPos, expr)); return true; }
private boolean maybeEatProjection(boolean nullSafeNavigation) { Token t = peekToken(); if (!peekToken(TokenKind.PROJECT, true)) { return false; } Assert.state(t != null, "No token"); SpelNodeImpl expr = eatExpression(); Assert.state(expr != null, "No node"); eatToken(TokenKind.RSQUARE); this.constructedNodes.push(new Projection(nullSafeNavigation, t.startPos, t.endPos, expr)); return true; }
private boolean maybeEatNullReference() { if (peekToken(TokenKind.IDENTIFIER)) { Token nullToken = peekToken(); Assert.state(nullToken != null, "Expected token"); if (!"null".equalsIgnoreCase(nullToken.stringValue())) { return false; } nextToken(); this.constructedNodes.push(new NullLiteral(nullToken.startPos, nullToken.endPos)); return true; } return false; }
@Nullable private SpelNodeImpl[] maybeEatMethodArgs() { if (!peekToken(TokenKind.LPAREN)) { return null; } List<SpelNodeImpl> args = new ArrayList<>(); consumeArguments(args); eatToken(TokenKind.RPAREN); return args.toArray(new SpelNodeImpl[0]); }
@Nullable private SpelNodeImpl eatNonDottedNode() { if (peekToken(TokenKind.LSQUARE)) { if (maybeEatIndexer()) { return pop(); } } return null; }
@Nullable private SpelNodeImpl eatNode() { return (peekToken(TokenKind.DOT, TokenKind.SAFE_NAVI) ? eatDottedNode() : eatNonDottedNode()); }
private void eatConstructorArgs(List<SpelNodeImpl> accumulatedArguments) { if (!peekToken(TokenKind.LPAREN)) { throw new InternalParseException(new SpelParseException(this.expressionString, positionOf(peekToken()), SpelMessage.MISSING_CONSTRUCTOR_ARGS)); } consumeArguments(accumulatedArguments); eatToken(TokenKind.RPAREN); }
private boolean maybeEatParenExpression() { if (peekToken(TokenKind.LPAREN)) { nextToken(); SpelNodeImpl expr = eatExpression(); Assert.state(expr != null, "No node"); eatToken(TokenKind.RPAREN); push(expr); return true; } else { return false; } }
@Nullable private SpelNodeImpl eatLogicalOrExpression() { SpelNodeImpl expr = eatLogicalAndExpression(); while (peekIdentifierToken("or") || peekToken(TokenKind.SYMBOLIC_OR)) { Token t = takeToken(); //consume OR SpelNodeImpl rhExpr = eatLogicalAndExpression(); checkOperands(t, expr, rhExpr); expr = new OpOr(t.startPos, t.endPos, expr, rhExpr); } return expr; }
@Nullable private SpelNodeImpl eatLogicalAndExpression() { SpelNodeImpl expr = eatRelationalExpression(); while (peekIdentifierToken("and") || peekToken(TokenKind.SYMBOLIC_AND)) { Token t = takeToken(); // consume 'AND' SpelNodeImpl rhExpr = eatRelationalExpression(); checkOperands(t, expr, rhExpr); expr = new OpAnd(t.startPos, t.endPos, expr, rhExpr); } return expr; }
@Nullable private SpelNodeImpl eatPowerIncDecExpression() { SpelNodeImpl expr = eatUnaryExpression(); if (peekToken(TokenKind.POWER)) { Token t = takeToken(); //consume POWER SpelNodeImpl rhExpr = eatUnaryExpression(); checkRightOperand(t, rhExpr); return new OperatorPower(t.startPos, t.endPos, expr, rhExpr); } if (expr != null && peekToken(TokenKind.INC, TokenKind.DEC)) { Token t = takeToken(); //consume INC/DEC if (t.getKind() == TokenKind.INC) { return new OpInc(t.startPos, t.endPos, true, expr); } return new OpDec(t.startPos, t.endPos, true, expr); } return expr; }
@Nullable private SpelNodeImpl eatSumExpression() { SpelNodeImpl expr = eatProductExpression(); while (peekToken(TokenKind.PLUS, TokenKind.MINUS, TokenKind.INC)) { Token t = takeToken(); //consume PLUS or MINUS or INC SpelNodeImpl rhExpr = eatProductExpression(); checkRightOperand(t, rhExpr); if (t.kind == TokenKind.PLUS) { expr = new OpPlus(t.startPos, t.endPos, expr, rhExpr); } else if (t.kind == TokenKind.MINUS) { expr = new OpMinus(t.startPos, t.endPos, expr, rhExpr); } } return expr; }
private SpelNodeImpl eatDottedNode() { Token t = takeToken(); // it was a '.' or a '?.' boolean nullSafeNavigation = (t.kind == TokenKind.SAFE_NAVI); if (maybeEatMethodOrProperty(nullSafeNavigation) || maybeEatFunctionOrVar() || maybeEatProjection(nullSafeNavigation) || maybeEatSelection(nullSafeNavigation)) { return pop(); } if (peekToken() == null) { // unexpectedly ran out of data throw internalException(t.startPos, SpelMessage.OOD); } else { throw internalException(t.startPos, SpelMessage.UNEXPECTED_DATA_AFTER_DOT, toString(peekToken())); } }
private boolean maybeEatMethodOrProperty(boolean nullSafeNavigation) { if (peekToken(TokenKind.IDENTIFIER)) { Token methodOrPropertyName = takeToken(); SpelNodeImpl[] args = maybeEatMethodArgs(); if (args == null) { // property push(new PropertyOrFieldReference(nullSafeNavigation, methodOrPropertyName.stringValue(), methodOrPropertyName.startPos, methodOrPropertyName.endPos)); return true; } // method reference push(new MethodReference(nullSafeNavigation, methodOrPropertyName.stringValue(), methodOrPropertyName.startPos, methodOrPropertyName.endPos, args)); // TODO what is the end position for a method reference? the name or the last arg? return true; } return false; }
private boolean maybeEatFunctionOrVar() { if (!peekToken(TokenKind.HASH)) { return false; } Token t = takeToken(); Token functionOrVariableName = eatToken(TokenKind.IDENTIFIER); SpelNodeImpl[] args = maybeEatMethodArgs(); if (args == null) { push(new VariableReference(functionOrVariableName.stringValue(), t.startPos, functionOrVariableName.endPos)); return true; } push(new FunctionReference(functionOrVariableName.stringValue(), t.startPos, functionOrVariableName.endPos, args)); return true; }