Refcounted-based internal value (#62)

* Refcounted-based internal value

* Fix build on gcc

* Fix build with gcc

* Fix build with gcc

* Fix tests

* Fix build on clang

* Fix build

* Fix .travis.yml

Author: flexferrum

.travis.yml

@@ -60,11 +60,11 @@ matrix:
 before_install:
   - date -u
   - uname -a
-  - sudo add-apt-repository -y ppa:samuel-bachmann/boost
-  - sudo apt-get update -qq
+#  - sudo add-apt-repository -y ppa:samuel-bachmann/boost
+#  - sudo apt-get update -qq
 
 install:
-  - sudo apt-get install libboost1.60-all-dev
+#  - sudo apt-get install libboost1.60-all-dev
 
 script:
   - if [[ "${COMPILER}" != "" ]]; then export CXX=${COMPILER}; fi

src/expression_evaluator.cpp

@@ -9,6 +9,7 @@
 #include <boost/container/small_vector.hpp>
 
 #include <cmath>
+#include <stack>
 
 namespace jinja2
 {
@@ -55,7 +56,18 @@ InternalValue ValueRefExpression::Evaluate(RenderContext& values)
 
 InternalValue SubscriptExpression::Evaluate(RenderContext& values)
 {
-    return Subscript(m_value->Evaluate(values), m_subscriptExpr->Evaluate(values));
+    InternalValue cur = m_value->Evaluate(values);
+
+    for (auto idx : m_subscriptExprs)
+    {
+        auto subscript = idx->Evaluate(values);
+        auto newVal = Subscript(cur, subscript);
+        if (cur.ShouldExtendLifetime())
+            newVal.SetParentData(cur);
+        std::swap(newVal, cur);
+    }
+
+    return cur;
 }
 
 InternalValue UnaryExpression::Evaluate(RenderContext& values)
@@ -252,7 +264,7 @@ InternalValue CallExpression::Evaluate(RenderContext& values)
 void CallExpression::Render(OutStream& stream, RenderContext& values)
 {
     auto fnVal = m_valueRef->Evaluate(values);
-    Callable* callable = GetIf<Callable>(&fnVal);
+    const Callable* callable = GetIf<Callable>(&fnVal);
     if (callable == nullptr)
     {
         fnVal = Subscript(fnVal, std::string("operator()"));
@@ -325,6 +337,7 @@ InternalValue CallExpression::CallGlobalRange(RenderContext& values)
         {
             return m_start + m_step * idx;
         }
+        bool ShouldExtendLifetime() const override {return false;}
 
     private:
         int64_t m_start;

src/expression_evaluator.h

@@ -100,15 +100,19 @@ class ValueRefExpression : public Expression
 class SubscriptExpression : public Expression
 {
 public:
-    SubscriptExpression(ExpressionEvaluatorPtr<Expression> value, ExpressionEvaluatorPtr<Expression> subscriptExpr)
+    SubscriptExpression(ExpressionEvaluatorPtr<Expression> value)
         : m_value(value)
-        , m_subscriptExpr(subscriptExpr)
     {
     }
     InternalValue Evaluate(RenderContext& values) override;
+    void AddIndex(ExpressionEvaluatorPtr<Expression> value)
+    {
+        m_subscriptExprs.push_back(value);
+    }
+
 private:
     ExpressionEvaluatorPtr<Expression> m_value;
-    ExpressionEvaluatorPtr<Expression> m_subscriptExpr;
+    std::vector<ExpressionEvaluatorPtr<Expression>> m_subscriptExprs;
 };
 
 class ConstantExpression : public Expression

src/expression_parser.cpp

@@ -471,6 +471,7 @@ ExpressionParser::ParseResult<CallParams> ExpressionParser::ParseCallParams(LexS
 
 ExpressionParser::ParseResult<ExpressionEvaluatorPtr<Expression>> ExpressionParser::ParseSubscript(LexScanner& lexer, ExpressionEvaluatorPtr<Expression> valueRef)
 {
+    ExpressionEvaluatorPtr<SubscriptExpression> result = std::make_shared<SubscriptExpression>(valueRef);
     for (Token tok = lexer.NextToken(); tok.type == '.' || tok.type == '['; tok = lexer.NextToken())
     {
         ParseResult<ExpressionEvaluatorPtr<Expression>> indexExpr;
@@ -496,12 +497,12 @@ ExpressionParser::ParseResult<ExpressionEvaluatorPtr<Expression>> ExpressionPars
                 return MakeParseError(ErrorCode::ExpectedSquareBracket, lexer.PeekNextToken());
         }
 
-        valueRef = std::make_shared<SubscriptExpression>(valueRef, *indexExpr);
+        result->AddIndex(*indexExpr);
     }
 
     lexer.ReturnToken();
 
-    return valueRef;
+    return result;
 }
 
 ExpressionParser::ParseResult<ExpressionEvaluatorPtr<ExpressionFilter>> ExpressionParser::ParseFilterExpression(LexScanner& lexer)

src/filters.cpp

@@ -256,7 +256,14 @@ InternalValue DictSort::Filter(const InternalValue& baseVal, RenderContext& cont
     else
         std::sort(tempVector.begin(), tempVector.end(), [comparator](auto& l, auto& r) {return comparator(l, r);});
 
-    InternalValueList resultList(tempVector.begin(), tempVector.end());
+    InternalValueList resultList;
+    for (auto& tmpVal : tempVector)
+    {
+        auto resultVal = InternalValue(std::move(tmpVal));
+        if (baseVal.ShouldExtendLifetime())
+            resultVal.SetParentData(baseVal);
+        resultList.push_back(std::move(resultVal));
+    }
 
     return InternalValue(ListAdapter::CreateAdapter(std::move(resultList)));
 }
@@ -879,6 +886,7 @@ struct ValueConverterImpl : visitors::BaseVisitor<>
 
         size_t GetSize() const override {return m_str->size();}
         InternalValue GetValueByIndex(int64_t idx) const override {return InternalValue(m_str->substr(static_cast<size_t>(idx), 1));}
+        bool ShouldExtendLifetime() const override {return false;}
 
         const string* m_str;
     };
@@ -892,6 +900,7 @@ struct ValueConverterImpl : visitors::BaseVisitor<>
 
         size_t GetSize() const override {return m_map->GetSize();}
         InternalValue GetValueByIndex(int64_t idx) const override {return m_map->GetValueByIndex(idx);}
+        bool ShouldExtendLifetime() const override {return false;}
 
         const MapAdapter* m_map;
     };
@@ -988,7 +997,7 @@ struct ValueConverterImpl : visitors::BaseVisitor<>
         params.mode = ValueConverter::ToIntMode;
         params.base = static_cast<int64_t>(10);
         InternalValue intVal = Apply<ValueConverterImpl>(val, params);
-        T* result = GetIf<int64_t>(&intVal);
+        const T* result = GetIf<int64_t>(&intVal);
         if (result == nullptr)
             return defValue;
 
@@ -1006,7 +1015,11 @@ InternalValue ValueConverter::Filter(const InternalValue& baseVal, RenderContext
     params.base = GetArgumentValue("base", context);
     params.prec = GetArgumentValue("precision", context);
     params.roundMethod = GetArgumentValue("method", context);
-    return Apply<ValueConverterImpl>(baseVal, params);
+    auto result = Apply<ValueConverterImpl>(baseVal, params);
+    if (baseVal.ShouldExtendLifetime())
+        result.SetParentData(baseVal);
+
+    return result;
 }
 } // filters
 } // jinja2

src/internal_value.cpp

@@ -149,6 +149,7 @@ class ByRef
 
     const T& Get() const {return *m_val;}
     T& Get() {return *const_cast<T*>(m_val);}
+    bool ShouldExtendLifetime() const {return false;}
 private:
     const T* m_val;
 };
@@ -166,10 +167,29 @@ class ByVal
 
     const T& Get() const {return m_val;}
     T& Get() {return m_val;}
+    bool ShouldExtendLifetime() const {return false;}
 private:
     T m_val;
 };
 
+template<typename T>
+class BySharedVal
+{
+public:
+    BySharedVal(T&& val)
+        : m_val(std::make_shared<T>(std::move(val)))
+    {}
+    ~BySharedVal()
+    {
+    }
+
+    const T& Get() const {return *m_val;}
+    T& Get() {return *m_val;}
+    bool ShouldExtendLifetime() const {return true;}
+private:
+    std::shared_ptr<T> m_val;
+};
+
 template<template<typename> class Holder>
 class GenericListAdapter : public IListAccessor
 {
@@ -183,6 +203,7 @@ class GenericListAdapter : public IListAccessor
         const auto& val = m_values.Get().GetValueByIndex(idx);
         return visit(visitors::InputValueConvertor(true), val.data()).get();
     }
+    bool ShouldExtendLifetime() const override {return m_values.ShouldExtendLifetime();}
 private:
     Holder<GenericList> m_values;
 };
@@ -200,6 +221,7 @@ class ValuesListAdapter : public IListAccessor
         const auto& val = m_values.Get()[idx];
         return visit(visitors::InputValueConvertor(false), val.data()).get();
     }
+    bool ShouldExtendLifetime() const override {return m_values.ShouldExtendLifetime();}
 private:
     Holder<ValuesList> m_values;
 };
@@ -214,6 +236,7 @@ ListAdapter ListAdapter::CreateAdapter(InternalValueList&& values)
 
         size_t GetSize() const override {return m_values.size();}
         InternalValue GetValueByIndex(int64_t idx) const override {return m_values[static_cast<size_t>(idx)];}
+        bool ShouldExtendLifetime() const override {return false;}
     private:
         InternalValueList m_values;
     };
@@ -233,12 +256,12 @@ ListAdapter ListAdapter::CreateAdapter(const ValuesList& values)
 
 ListAdapter ListAdapter::CreateAdapter(GenericList&& values)
 {
-    return ListAdapter([accessor = GenericListAdapter<ByVal>(std::move(values))]() {return &accessor;});
+    return ListAdapter([accessor = GenericListAdapter<BySharedVal>(std::move(values))]() {return &accessor;});
 }
 
 ListAdapter ListAdapter::CreateAdapter(ValuesList&& values)
 {
-    return ListAdapter([accessor = ValuesListAdapter<ByVal>(std::move(values))]() {return &accessor;});
+    return ListAdapter([accessor = ValuesListAdapter<BySharedVal>(std::move(values))]() {return &accessor;});
 }
 
 template<template<typename> class Holder>
@@ -253,6 +276,7 @@ class SubscriptedListAdapter : public IListAccessor
     {
         return Subscript(m_values.Get().GetValueByIndex(idx), m_subscript);
     }
+    bool ShouldExtendLifetime() const override {return m_values.ShouldExtendLifetime();}
 private:
     Holder<ListAdapter> m_values;
     InternalValue m_subscript;
@@ -264,7 +288,7 @@ ListAdapter ListAdapter::ToSubscriptedList(const InternalValue& subscript, bool
         return ListAdapter([accessor = SubscriptedListAdapter<ByRef>(*this, subscript)]() {return &accessor;});
 
     ListAdapter tmp(*this);
-    return ListAdapter([accessor = SubscriptedListAdapter<ByVal>(std::move(tmp), subscript)]() {return &accessor;});
+    return ListAdapter([accessor = SubscriptedListAdapter<BySharedVal>(std::move(tmp), subscript)]() {return &accessor;});
 }
 
 InternalValueList ListAdapter::ToValueList() const
@@ -325,6 +349,7 @@ class InternalValueMapAdapter : public IMapAccessor
         }
         return false;
     }
+    bool ShouldExtendLifetime() const override {return m_values.ShouldExtendLifetime();}
 private:
     Holder<InternalValueMap> m_values;
 };
@@ -380,7 +405,7 @@ class GenericMapAdapter : public IMapAccessor
     {
         return m_values.Get().GetKeys();
     }
-
+    bool ShouldExtendLifetime() const override {return m_values.ShouldExtendLifetime();}
 
 private:
     Holder<GenericMap> m_values;
@@ -428,6 +453,7 @@ class ValuesMapAdapter : public IMapAccessor
 
         return result;
     }
+    bool ShouldExtendLifetime() const override {return m_values.ShouldExtendLifetime();}
 private:
     Holder<ValuesMap> m_values;
 };
@@ -450,7 +476,7 @@ MapAdapter MapAdapter::CreateAdapter(const GenericMap& values)
 
 MapAdapter MapAdapter::CreateAdapter(GenericMap&& values)
 {
-    return MapAdapter([accessor = GenericMapAdapter<ByVal>(std::move(values))]() mutable {return &accessor;});
+    return MapAdapter([accessor = GenericMapAdapter<BySharedVal>(std::move(values))]() mutable {return &accessor;});
 }
 
 MapAdapter MapAdapter::CreateAdapter(const ValuesMap& values)
@@ -460,7 +486,7 @@ MapAdapter MapAdapter::CreateAdapter(const ValuesMap& values)
 
 MapAdapter MapAdapter::CreateAdapter(ValuesMap&& values)
 {
-    return MapAdapter([accessor = ValuesMapAdapter<ByVal>(std::move(values))]() mutable {return &accessor;});
+    return MapAdapter([accessor = ValuesMapAdapter<BySharedVal>(std::move(values))]() mutable {return &accessor;});
 }
 
 } // jinja2