Add to_value class for value handling

So far only needed to convert selectors!

Author: mgreter

Makefile

@@ -190,6 +190,7 @@ SOURCES = \
 	source_map.cpp \
 	to_c.cpp \
 	to_string.cpp \
+	to_value.cpp \
 	units.cpp \
 	utf8_string.cpp \
 	util.cpp

Makefile.am

@@ -77,6 +77,7 @@ libsass_la_SOURCES = \
 	source_map.cpp source_map.hpp \
 	to_c.cpp to_c.hpp \
 	to_string.cpp to_string.hpp \
+	to_value.cpp to_value.hpp \
 	units.cpp units.hpp \
 	utf8_string.cpp utf8_string.hpp \
 	util.cpp util.hpp

ast_def_macros.hpp

@@ -33,7 +33,8 @@ virtual Statement* perform(Operation<Statement*>* op) { return (*op)(this); }\
 virtual Expression* perform(Operation<Expression*>* op) { return (*op)(this); }\
 virtual Selector* perform(Operation<Selector*>* op) { return (*op)(this); }\
 virtual string perform(Operation<string>* op) { return (*op)(this); }\
-virtual union Sass_Value* perform(Operation<union Sass_Value*>* op) { return (*op)(this); }
+virtual union Sass_Value* perform(Operation<union Sass_Value*>* op) { return (*op)(this); }\
+virtual Value* perform(Operation<Value*>* op) { return (*op)(this); }
 
 #define ADD_PROPERTY(type, name)\
 protected:\

eval.cpp

@@ -15,6 +15,7 @@
 #include "environment.hpp"
 #include "position.hpp"
 #include "sass_values.h"
+#include "to_value.hpp"
 #include "to_c.hpp"
 #include "context.hpp"
 #include "backtrace.hpp"
@@ -532,7 +533,10 @@ namespace Sass {
       return op_colors(ctx, op_type, l_c, r_c);
     }
 
-    Expression* ex = op_strings(ctx, op_type, lhs, rhs);
+    To_Value to_value(ctx, ctx.mem);
+    Value* v_l = dynamic_cast<Value*>(lhs->perform(&to_value));
+    Value* v_r = dynamic_cast<Value*>(rhs->perform(&to_value));
+    Value* ex = op_strings(ctx, op_type, v_l, v_r);
     if (String_Constant* str = dynamic_cast<String_Constant*>(ex))
     {
       if (str->concrete_type() != Expression::STRING) return ex;
@@ -1163,7 +1167,7 @@ namespace Sass {
     return l->value() < tmp_r.value();
   }
 
-  Expression* Eval::op_numbers(Context& ctx, enum Sass_OP op, Number* l, Number* r)
+  Value* Eval::op_numbers(Context& ctx, enum Sass_OP op, Number* l, Number* r)
   {
     double lv = l->value();
     double rv = r->value();
@@ -1213,7 +1217,7 @@ namespace Sass {
     return v;
   }
 
-  Expression* Eval::op_number_color(Context& ctx, enum Sass_OP op, Number* l, Color* r)
+  Value* Eval::op_number_color(Context& ctx, enum Sass_OP op, Number* l, Color* r)
   {
     // TODO: currently SASS converts colors to standard form when adding to strings;
     // when https://github.com/nex3/sass/issues/363 is added this can be removed to
@@ -1250,7 +1254,7 @@ namespace Sass {
     return l;
   }
 
-  Expression* Eval::op_color_number(Context& ctx, enum Sass_OP op, Color* l, Number* r)
+  Value* Eval::op_color_number(Context& ctx, enum Sass_OP op, Color* l, Number* r)
   {
     double rv = r->value();
     if (op == Sass_OP::DIV && !rv) error("division by zero", r->pstate());
@@ -1261,7 +1265,7 @@ namespace Sass {
                                l->a());
   }
 
-  Expression* Eval::op_colors(Context& ctx, enum Sass_OP op, Color* l, Color* r)
+  Value* Eval::op_colors(Context& ctx, enum Sass_OP op, Color* l, Color* r)
   {
     if (l->a() != r->a()) {
       error("alpha channels must be equal when combining colors", r->pstate());
@@ -1277,7 +1281,7 @@ namespace Sass {
                                l->a());
   }
 
-  Expression* Eval::op_strings(Context& ctx, enum Sass_OP op, Expression* lhs, Expression*rhs)
+  Value* Eval::op_strings(Context& ctx, enum Sass_OP op, Value* lhs, Value*rhs)
   {
     To_String to_string(&ctx);
     Expression::Concrete_Type ltype = lhs->concrete_type();

eval.hpp

@@ -89,11 +89,11 @@ namespace Sass {
     static bool eq(Expression*, Expression*);
     static bool lt(Expression*, Expression*);
     // -- arithmetic on the combinations that matter
-    static Expression* op_numbers(Context&, enum Sass_OP, Number*, Number*);
-    static Expression* op_number_color(Context&, enum Sass_OP, Number*, Color*);
-    static Expression* op_color_number(Context&, enum Sass_OP, Color*, Number*);
-    static Expression* op_colors(Context&, enum Sass_OP, Color*, Color*);
-    static Expression* op_strings(Context&, enum Sass_OP, Expression*, Expression*);
+    static Value* op_numbers(Context&, enum Sass_OP, Number*, Number*);
+    static Value* op_number_color(Context&, enum Sass_OP, Number*, Color*);
+    static Value* op_color_number(Context&, enum Sass_OP, Color*, Number*);
+    static Value* op_colors(Context&, enum Sass_OP, Color*, Color*);
+    static Value* op_strings(Context&, enum Sass_OP, Value*, Value*);
 
   private:
     string interpolation(Expression* s);

to_value.cpp

@@ -0,0 +1,96 @@
+#include "ast.hpp"
+#include "sass_values.h"
+#include "to_value.hpp"
+#include "to_string.hpp"
+
+namespace Sass {
+  using namespace std;
+
+  Value* To_Value::fallback_impl(AST_Node* n)
+  {
+    // throw a runtime error if this happens
+    // we want a well defined set of possible nodes
+    throw runtime_error("invalid node for to_value");
+    // mute warning
+    return 0;
+  }
+
+  // Boolean is a valid value
+  Value* To_Value::operator()(Boolean* b)
+  {
+    return b;
+  }
+
+  // Number is a valid value
+  Value* To_Value::operator()(Number* n)
+  {
+    return n;
+  }
+
+  // Color is a valid value
+  Value* To_Value::operator()(Color* c)
+  {
+    return c;
+  }
+
+  // String_Constant is a valid value
+  Value* To_Value::operator()(String_Constant* s)
+  {
+    return s;
+  }
+
+  // String_Quoted is a valid value
+  Value* To_Value::operator()(String_Quoted* s)
+  {
+    return s;
+  }
+
+  // List is a valid value
+  Value* To_Value::operator()(List* l)
+  {
+    List* ll = new (mem) List(l->pstate(),
+                              l->length(),
+                              l->separator(),
+                              l->is_arglist());
+    for (size_t i = 0, L = l->length(); i < L; ++i) {
+      *ll << (*l)[i]->perform(this);
+    }
+    return ll;
+  }
+
+  // Map is a valid value
+  Value* To_Value::operator()(Map* m)
+  {
+    return m;
+  }
+
+  // Null is a valid value
+  Value* To_Value::operator()(Null* n)
+  {
+    return n;
+  }
+
+  // Argument returns its value
+  Value* To_Value::operator()(Argument* arg)
+  {
+    if (!arg->name().empty()) return 0;
+    return arg->value()->perform(this);
+  }
+
+  // Selector_List is converted to a string
+  Value* To_Value::operator()(Selector_List* s)
+  {
+    To_String to_string(&ctx);
+    return new (mem) String_Quoted(s->pstate(),
+                                   s->perform(&to_string));
+  }
+
+  // Binary_Expression is converted to a string
+  Value* To_Value::operator()(Binary_Expression* s)
+  {
+    To_String to_string(&ctx);
+    return new (mem) String_Quoted(s->pstate(),
+                                   s->perform(&to_string));
+  }
+
+};

to_value.hpp

@@ -0,0 +1,49 @@
+#ifndef SASS_TO_VALUE_H
+#define SASS_TO_VALUE_H
+
+#include "operation.hpp"
+#include "sass_values.h"
+#include "ast_fwd_decl.hpp"
+
+namespace Sass {
+  using namespace std;
+
+  class To_Value : public Operation_CRTP<Value*, To_Value> {
+
+    Value* fallback_impl(AST_Node* n);
+
+  private:
+
+    Context& ctx;
+    Memory_Manager<AST_Node>& mem;
+
+  public:
+
+    To_Value(Context& ctx, Memory_Manager<AST_Node>& mem)
+    : ctx(ctx), mem(mem)
+    { }
+    virtual ~To_Value() { }
+    using Operation<Value*>::operator();
+
+    Value* operator()(Argument*);
+    Value* operator()(Boolean*);
+    Value* operator()(Number*);
+    Value* operator()(Color*);
+    Value* operator()(String_Constant*);
+    Value* operator()(String_Quoted*);
+    Value* operator()(List*);
+    Value* operator()(Map*);
+    Value* operator()(Null*);
+
+    // convert to string via `To_String`
+    Value* operator()(Selector_List*);
+    Value* operator()(Binary_Expression*);
+
+    // fallback throws error
+    template <typename U>
+    Value* fallback(U x) { return fallback_impl(x); }
+  };
+
+}
+
+#endif

win/libsass.filters

@@ -120,6 +120,9 @@
     <ClCompile Include="..\to_string.cpp">
       <Filter>Source Files</Filter>
     </ClCompile>
+    <ClCompile Include="..\to_value.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
     <ClCompile Include="..\units.cpp">
       <Filter>Source Files</Filter>
     </ClCompile>
@@ -281,6 +284,9 @@
     <ClInclude Include="..\to_c.hpp">
       <Filter>Header Files</Filter>
     </ClInclude>
+    <ClInclude Include="..\to_value.hpp">
+      <Filter>Header Files</Filter>
+    </ClInclude>
     <ClInclude Include="..\to_string.hpp">
       <Filter>Header Files</Filter>
     </ClInclude>

win/libsass.vcxproj

@@ -199,6 +199,7 @@
     <ClCompile Include="..\source_map.cpp" />
     <ClCompile Include="..\to_c.cpp" />
     <ClCompile Include="..\to_string.cpp" />
+    <ClCompile Include="..\to_value.cpp" />
     <ClCompile Include="..\units.cpp" />
     <ClCompile Include="..\utf8_string.cpp" />
     <ClCompile Include="..\util.cpp" />
@@ -253,6 +254,7 @@
     <ClInclude Include="..\token.hpp" />
     <ClInclude Include="..\to_c.hpp" />
     <ClInclude Include="..\to_string.hpp" />
+    <ClInclude Include="..\to_value.hpp" />
     <ClInclude Include="..\units.hpp" />
     <ClInclude Include="..\utf8.h" />
     <ClInclude Include="..\utf8\checked.h" />