Esempio n. 1
0
 private void CheckRightOperand(Token token, SpelNode operandExpression)
 {
     if (operandExpression == null)
     {
         throw InternalException(token.StartPos, SpelMessage.RIGHT_OPERAND_PROBLEM);
     }
 }
Esempio n. 2
0
 public SpelExpression(string expression, SpelNode ast, SpelParserOptions configuration)
 {
     _expression    = expression;
     _ast           = ast;
     _configuration = configuration;
 }
 private void Push(SpelNode newNode)
 {
     ConstructedNodes.Push(newNode);
 }
        private bool MaybeEatInlineListOrMap()
        {
            var t = PeekToken();

            if (!PeekToken(TokenKind.LCURLY, true))
            {
                return(false);
            }

            if (t == null)
            {
                throw new InvalidOperationException("No token");
            }

            SpelNode expr         = null;
            var      closingCurly = PeekToken();

            if (PeekToken(TokenKind.RCURLY, true))
            {
                // empty list '{}'
                if (closingCurly == null)
                {
                    throw new InvalidOperationException("No token");
                }

                expr = new InlineList(t.StartPos, closingCurly.EndPos);
            }
            else if (PeekToken(TokenKind.COLON, true))
            {
                closingCurly = EatToken(TokenKind.RCURLY);

                // empty map '{:}'
                expr = new InlineMap(t.StartPos, closingCurly.EndPos);
            }
            else
            {
                var firstExpression = EatExpression();

                // Next is either:
                // '}' - end of list
                // ',' - more expressions in this list
                // ':' - this is a map!
                if (PeekToken(TokenKind.RCURLY))
                {
                    // list with one item in it
                    var elements = new List <SpelNode>
                    {
                        firstExpression
                    };
                    closingCurly = EatToken(TokenKind.RCURLY);
                    expr         = new InlineList(t.StartPos, closingCurly.EndPos, elements.ToArray());
                }
                else if (PeekToken(TokenKind.COMMA, true))
                {
                    // multi-item list
                    var elements = new List <SpelNode>
                    {
                        firstExpression
                    };
                    do
                    {
                        elements.Add(EatExpression());
                    }while (PeekToken(TokenKind.COMMA, true));
                    closingCurly = EatToken(TokenKind.RCURLY);
                    expr         = new InlineList(t.StartPos, closingCurly.EndPos, elements.ToArray());
                }
                else if (PeekToken(TokenKind.COLON, true))
                {
                    // map!
                    var elements = new List <SpelNode>
                    {
                        firstExpression,
                        EatExpression()
                    };
                    while (PeekToken(TokenKind.COMMA, true))
                    {
                        elements.Add(EatExpression());
                        EatToken(TokenKind.COLON);
                        elements.Add(EatExpression());
                    }

                    closingCurly = EatToken(TokenKind.RCURLY);
                    expr         = new InlineMap(t.StartPos, closingCurly.EndPos, elements.ToArray());
                }
                else
                {
                    throw InternalException(t.StartPos, SpelMessage.OOD);
                }
            }

            ConstructedNodes.Push(expr);
            return(true);
        }
 private void CheckOperands(Token token, SpelNode left, SpelNode right)
 {
     CheckLeftOperand(token, left);
     CheckRightOperand(token, right);
 }
Esempio n. 6
0
        private readonly SpelNode _node;  // used only for error reporting

        public TypedValueHolderValueRef(ITypedValue typedValue, SpelNode node)
        {
            _typedValue = typedValue;
            _node       = node;
        }