Fix values subscription parser

Author: flexferrum

src/expression_evaluator.cpp

@@ -172,12 +172,31 @@ InternalValue DictionaryCreator::Evaluate(RenderContext& context)
 
 InternalValue CallExpression::Evaluate(RenderContext& values)
 {
-    std::string valueRef = boost::algorithm::join(m_valueRef, ".");
+    enum
+    {
+        InvalidFn = -1,
+        RangeFn = 1,
+        LoopCycleFn = 2
+    };
+
+    auto& scope = values.EnterScope();
+    scope["range"] = InternalValue(static_cast<int64_t>(RangeFn));
+    scope["loop"] = MapAdapter::CreateAdapter(InternalValueMap{{"cycle", InternalValue(static_cast<int64_t>(LoopCycleFn))}});
+    auto fn = m_valueRef->Evaluate(values);
+    values.ExitScope();
+
+    auto fnId = ConvertToInt(fn, InvalidFn);
+
 
-    if (valueRef == "range")
+    switch (fnId)
+    {
+    case RangeFn:
         return CallGlobalRange(values);
-    else if (valueRef == "loop.cycle")
+    case LoopCycleFn:
         return CallLoopCycle(values);
+    default:
+        break;
+    }
 
     return InternalValue();
 }

src/expression_evaluator.h

@@ -252,7 +252,7 @@ class CallExpression : public Expression
 public:
     virtual ~CallExpression() {}
 
-    CallExpression(std::vector<std::string> valueRef, CallParams params)
+    CallExpression(ExpressionEvaluatorPtr<> valueRef, CallParams params)
         : m_valueRef(std::move(valueRef))
         , m_params(std::move(params))
     {
@@ -268,7 +268,7 @@ class CallExpression : public Expression
     InternalValue CallLoopCycle(RenderContext &values);
 
 private:
-    std::vector<std::string> m_valueRef;
+    ExpressionEvaluatorPtr<> m_valueRef;
     CallParams m_params;
 };
 

src/expression_parser.cpp

@@ -280,31 +280,13 @@ ExpressionEvaluatorPtr<Expression> ExpressionParser::ParseValueExpression(LexSca
     {
         lexer.ReturnToken();
         auto valueRef = ParseValueRef(lexer);
-        if (valueRef.empty())
-            return ExpressionEvaluatorPtr<Expression>();
 
-        Token nextTok = lexer.NextToken();
-        if (nextTok == '[')
-        {
-            return ParseSubsicpt(lexer, valueRef);
-        }
-        else if (nextTok == '(')
+        if (lexer.EatIfEqual('('))
         {
             return ParseCall(lexer, valueRef);
         }
 
-        lexer.ReturnToken();
-
-        ExpressionEvaluatorPtr<Expression> baseValueRef = std::make_shared<ValueRefExpression>(valueRef[0]);
-        if (valueRef.size() != 1)
-        {
-            for (size_t i = 1; i < valueRef.size(); ++ i)
-            {
-                auto indexExpr = std::make_shared<ConstantExpression>(InternalValue(valueRef[i]));
-                baseValueRef = std::make_shared<SubscriptExpression>(baseValueRef, indexExpr);
-            }
-        }
-        return baseValueRef;
+        return valueRef;
     }
     case Token::IntegerNum:
     case Token::FloatNum:
@@ -407,32 +389,7 @@ ExpressionEvaluatorPtr<Expression> ExpressionParser::ParseTuple(LexScanner& lexe
     return result;
 }
 
-ExpressionEvaluatorPtr<SubscriptExpression> ExpressionParser::ParseSubsicpt(LexScanner& lexer, const std::vector<std::string>& valueRef)
-{
-    ExpressionEvaluatorPtr<SubscriptExpression> result;
-
-    auto finalIndexExpr = ParseFullExpression(lexer);
-    if (!finalIndexExpr || lexer.PeekNextToken() != ']')
-        return result;
-
-    lexer.EatToken();
-
-    ExpressionEvaluatorPtr<Expression> baseValueRef = std::make_shared<ValueRefExpression>(valueRef[0]);
-    if (valueRef.size() != 1)
-    {
-        for (size_t i = 1; i < valueRef.size(); ++ i)
-        {
-            auto indexExpr = std::make_shared<ConstantExpression>(InternalValue(valueRef[i]));
-            baseValueRef = std::make_shared<SubscriptExpression>(baseValueRef, indexExpr);
-        }
-    }
-
-    result = std::make_shared<SubscriptExpression>(baseValueRef, finalIndexExpr);
-
-    return result;
-}
-
-ExpressionEvaluatorPtr<Expression> ExpressionParser::ParseCall(LexScanner& lexer, const std::vector<std::string>& valueRef)
+ExpressionEvaluatorPtr<Expression> ExpressionParser::ParseCall(LexScanner& lexer, ExpressionEvaluatorPtr<Expression> valueRef)
 {
     ExpressionEvaluatorPtr<Expression> result;
 
@@ -484,25 +441,37 @@ CallParams ExpressionParser::ParseCallParams(LexScanner& lexer, bool& isValid)
     return result;
 }
 
-std::vector<std::string> ExpressionParser::ParseValueRef(LexScanner& lexer)
+ExpressionEvaluatorPtr<Expression> ExpressionParser::ParseValueRef(LexScanner& lexer)
 {
     Token tok = lexer.NextToken();
     auto valueName = AsString(tok.value);
+    ExpressionEvaluatorPtr<Expression> valueRef = std::make_shared<ValueRefExpression>(valueName);
 
-    std::vector<std::string> result;
-    result.push_back(valueName);
-
-    while (lexer.NextToken() == '.')
+    for (tok = lexer.NextToken(); tok.type == '.' || tok.type == '['; tok = lexer.NextToken())
     {
-        tok = lexer.NextToken();
-        if (tok != Token::Identifier)
-            return std::vector<std::string>();
+        ExpressionEvaluatorPtr<Expression> indexExpr;
+        if (tok == '.')
+        {
+            tok = lexer.NextToken();
+            if (tok.type != Token::Identifier)
+                return ExpressionEvaluatorPtr<>();
+            valueName = AsString(tok.value);
+            indexExpr = std::make_shared<ConstantExpression>(InternalValue(valueName));
+        }
+        else
+        {
+            indexExpr = ParseFullExpression(lexer);
 
-        result.push_back(AsString(tok.value));
+            if (!indexExpr || !lexer.EatIfEqual(']'))
+                return ExpressionEvaluatorPtr<>();
+        }
+
+        valueRef = std::make_shared<SubscriptExpression>(valueRef, indexExpr);
     }
+
     lexer.ReturnToken();
 
-    return result;
+    return valueRef;
 }
 
 ExpressionEvaluatorPtr<ExpressionFilter> ExpressionParser::ParseFilterExpression(LexScanner& lexer)

src/expression_parser.h

@@ -27,10 +27,9 @@ class ExpressionParser
     ExpressionEvaluatorPtr<Expression> ParseBracedExpressionOrTuple(LexScanner& lexer);
     ExpressionEvaluatorPtr<Expression> ParseDictionary(LexScanner& lexer);
     ExpressionEvaluatorPtr<Expression> ParseTuple(LexScanner& lexer);
-    ExpressionEvaluatorPtr<SubscriptExpression> ParseSubsicpt(LexScanner& lexer, const std::vector<std::string>& valueRef);
-    ExpressionEvaluatorPtr<Expression> ParseCall(LexScanner& lexer, const std::vector<std::string>& valueRef);
+    ExpressionEvaluatorPtr<Expression> ParseCall(LexScanner& lexer, ExpressionEvaluatorPtr<Expression> valueRef);
     CallParams ParseCallParams(LexScanner& lexer, bool& isValid);
-    std::vector<std::string> ParseValueRef(LexScanner& lexer);
+    ExpressionEvaluatorPtr<Expression> ParseValueRef(LexScanner& lexer);
     ExpressionEvaluatorPtr<ExpressionFilter> ParseFilterExpression(LexScanner& lexer);
     ExpressionEvaluatorPtr<IfExpression> ParseIfExpression(LexScanner& lexer);
 

src/lexer.h

@@ -227,6 +227,25 @@ class LexScanner
         return *m_state.m_cur;
     }
 
+    bool EatIfEqual(char type)
+    {
+        return EatIfEqual(static_cast<Token::Type>(type));
+    }
+
+    bool EatIfEqual(Token::Type type)
+    {
+        if (m_state.m_cur == m_state.m_end)
+            return type == Token::Type::Eof;
+
+        if (m_state.m_cur->type == type)
+        {
+            ++ m_state.m_cur;
+            return true;
+        }
+
+        return false;
+    }
+
 private:
     State m_state;
     static const Token& EofToken()

test/expressions_test.cpp

@@ -142,6 +142,10 @@ INSTANTIATE_TEST_CASE_P(DotSubscriptionTest, ExpressionSubstitutionTest, ::testi
 
 
 INSTANTIATE_TEST_CASE_P(ComplexSubscriptionTest, ExpressionSubstitutionTest, ::testing::Values(
-//                            InputOutputPair{"mapValue.reflectedList[1]['intValue']",    "1"},
+                            InputOutputPair{"mapValue.reflectedList[1]['intValue']",    "1"},
+                            InputOutputPair{"mapValue['reflectedList'][1]['intValue']",    "1"},
+                            InputOutputPair{"mapValue.reflectedList[1].intValue",    "1"},
+                            InputOutputPair{"reflectedList[1].intValue",    "1"},
+                            InputOutputPair{"reflectedList[1].strValue[0]",    "t"},
                             InputOutputPair{"reflectedVal.strValue[0]",        "t"}
                             ));