sassc 1.7.1 → 1.8.0.pre1

data/ext/libsass/{sass_interface.cpp → src/sass_interface.cpp}

@@ -1,11 +1,3 @@
-#ifdef _WIN32
-#include <io.h>
-#define LFEED "\n"
-#else
-#include <unistd.h>
-#define LFEED "\n"
-#endif
-
 #include <string>
 #include <cstdlib>
 #include <cstring>
@@ -16,47 +8,16 @@
 #include "context.hpp"
 #include "inspect.hpp"
 #include "error_handling.hpp"
-#include "sass_interface.h"
+#include "sass/base.h"
+#include "sass/interface.h"
 
+#define LFEED "\n"
 
 extern "C" {
-  using namespace std;
 
   sass_context* sass_new_context()
   { return (sass_context*) calloc(1, sizeof(sass_context)); }
 
-  // helper for safe access to c_ctx
-  static const char* safe_str (const char* str) {
-    return str == NULL ? "" : str;
-  }
-
-  static void copy_strings(const std::vector<std::string>& strings, char*** array, int skip = 0) {
-    int num = static_cast<int>(strings.size());
-    char** arr = (char**) malloc(sizeof(char*) * (num + 1));
-
-    for(int i = skip; i < num; i++) {
-      arr[i-skip] = (char*) malloc(sizeof(char) * (strings[i].size() + 1));
-      std::copy(strings[i].begin(), strings[i].end(), arr[i-skip]);
-      arr[i-skip][strings[i].size()] = '\0';
-    }
-
-    arr[num-skip] = 0;
-    *array = arr;
-  }
-
-  static void free_string_array(char ** arr) {
-    if(!arr)
-        return;
-
-    char **it = arr;
-    while (it && (*it)) {
-      free(*it);
-      ++it;
-    }
-
-    free(arr);
-  }
-
   void sass_free_context(sass_context* ctx)
   {
     if (ctx->output_string)     free(ctx->output_string);
@@ -64,7 +25,7 @@ extern "C" {
     if (ctx->error_message)     free(ctx->error_message);
     if (ctx->c_functions)       free(ctx->c_functions);
 
-    free_string_array(ctx->included_files);
+    Sass::free_string_array(ctx->included_files);
 
     free(ctx);
   }
@@ -79,7 +40,7 @@ extern "C" {
     if (ctx->error_message)     free(ctx->error_message);
     if (ctx->c_functions)       free(ctx->c_functions);
 
-    free_string_array(ctx->included_files);
+    Sass::free_string_array(ctx->included_files);
 
     free(ctx);
   }
@@ -89,7 +50,7 @@ extern "C" {
 
   void sass_free_folder_context(sass_folder_context* ctx)
   {
-    free_string_array(ctx->included_files);
+    Sass::free_string_array(ctx->included_files);
     free(ctx);
   }
 
@@ -97,9 +58,9 @@ extern "C" {
   {
     using namespace Sass;
     try {
-      string input_path = safe_str(c_ctx->input_path);
+      std::string input_path = safe_str(c_ctx->input_path);
       int lastindex = static_cast<int>(input_path.find_last_of("."));
-      string output_path;
+      std::string output_path;
       if (!c_ctx->output_path) {
         if (input_path != "") {
           output_path = (lastindex > -1 ? input_path.substr(0, lastindex) : input_path) + ".css";
@@ -123,8 +84,8 @@ extern "C" {
                        .plugin_paths_c_str(c_ctx->options.plugin_paths)
                        // .include_paths_array(0)
                        // .plugin_paths_array(0)
-                       .include_paths(vector<string>())
-                       .plugin_paths(vector<string>())
+                       .include_paths(std::vector<std::string>())
+                       .plugin_paths(std::vector<std::string>())
                        .precision(c_ctx->options.precision ? c_ctx->options.precision : 5)
                        .indent(c_ctx->options.indent ? c_ctx->options.indent : "  ")
                        .linefeed(c_ctx->options.linefeed ? c_ctx->options.linefeed : LFEED)
@@ -141,35 +102,36 @@ extern "C" {
       c_ctx->error_message = 0;
       c_ctx->error_status = 0;
 
-      copy_strings(cpp_ctx.get_included_files(1), &c_ctx->included_files, 1);
+      if (copy_strings(cpp_ctx.get_included_files(true), &c_ctx->included_files, 1) == NULL)
+        throw(std::bad_alloc());
     }
-    catch (Sass_Error& e) {
-      stringstream msg_stream;
-      msg_stream << e.pstate.path << ":" << e.pstate.line << ": " << e.message << endl;
+    catch (Error_Invalid& e) {
+      std::stringstream msg_stream;
+      msg_stream << e.pstate.path << ":" << e.pstate.line << ": " << e.message << std::endl;
       c_ctx->error_message = sass_strdup(msg_stream.str().c_str());
       c_ctx->error_status = 1;
       c_ctx->output_string = 0;
       c_ctx->source_map_string = 0;
     }
-    catch(bad_alloc& ba) {
-      stringstream msg_stream;
-      msg_stream << "Unable to allocate memory: " << ba.what() << endl;
+    catch(std::bad_alloc& ba) {
+      std::stringstream msg_stream;
+      msg_stream << "Unable to allocate memory: " << ba.what() << std::endl;
       c_ctx->error_message = sass_strdup(msg_stream.str().c_str());
       c_ctx->error_status = 1;
       c_ctx->output_string = 0;
       c_ctx->source_map_string = 0;
     }
     catch (std::exception& e) {
-      stringstream msg_stream;
-      msg_stream << "Error: " << e.what() << endl;
+      std::stringstream msg_stream;
+      msg_stream << "Error: " << e.what() << std::endl;
       c_ctx->error_message = sass_strdup(msg_stream.str().c_str());
       c_ctx->error_status = 1;
       c_ctx->output_string = 0;
       c_ctx->source_map_string = 0;
     }
-    catch (string& e) {
-      stringstream msg_stream;
-      msg_stream << "Error: " << e << endl;
+    catch (std::string& e) {
+      std::stringstream msg_stream;
+      msg_stream << "Error: " << e << std::endl;
       c_ctx->error_message = sass_strdup(msg_stream.str().c_str());
       c_ctx->error_status = 1;
       c_ctx->output_string = 0;
@@ -177,8 +139,8 @@ extern "C" {
     }
     catch (...) {
       // couldn't find the specified file in the include paths; report an error
-      stringstream msg_stream;
-      msg_stream << "Unknown error occurred" << endl;
+      std::stringstream msg_stream;
+      msg_stream << "Unknown error occurred" << std::endl;
       c_ctx->error_message = sass_strdup(msg_stream.str().c_str());
       c_ctx->error_status = 1;
       c_ctx->output_string = 0;
@@ -191,9 +153,9 @@ extern "C" {
   {
     using namespace Sass;
     try {
-      string input_path = safe_str(c_ctx->input_path);
+      std::string input_path = safe_str(c_ctx->input_path);
       int lastindex = static_cast<int>(input_path.find_last_of("."));
-      string output_path;
+      std::string output_path;
       if (!c_ctx->output_path) {
           output_path = (lastindex > -1 ? input_path.substr(0, lastindex) : input_path) + ".css";
       }
@@ -215,8 +177,8 @@ extern "C" {
                        .plugin_paths_c_str(c_ctx->options.plugin_paths)
                        // .include_paths_array(0)
                        // .plugin_paths_array(0)
-                       .include_paths(vector<string>())
-                       .plugin_paths(vector<string>())
+                       .include_paths(std::vector<std::string>())
+                       .plugin_paths(std::vector<std::string>())
                        .precision(c_ctx->options.precision ? c_ctx->options.precision : 5)
                        .indent(c_ctx->options.indent ? c_ctx->options.indent : "  ")
                        .linefeed(c_ctx->options.linefeed ? c_ctx->options.linefeed : LFEED)
@@ -233,35 +195,36 @@ extern "C" {
       c_ctx->error_message = 0;
       c_ctx->error_status = 0;
 
-      copy_strings(cpp_ctx.get_included_files(), &c_ctx->included_files);
+      if (copy_strings(cpp_ctx.get_included_files(false), &c_ctx->included_files) == NULL)
+        throw(std::bad_alloc());
     }
-    catch (Sass_Error& e) {
-      stringstream msg_stream;
-      msg_stream << e.pstate.path << ":" << e.pstate.line << ": " << e.message << endl;
+    catch (Error_Invalid& e) {
+      std::stringstream msg_stream;
+      msg_stream << e.pstate.path << ":" << e.pstate.line << ": " << e.message << std::endl;
       c_ctx->error_message = sass_strdup(msg_stream.str().c_str());
       c_ctx->error_status = 1;
       c_ctx->output_string = 0;
       c_ctx->source_map_string = 0;
     }
-    catch(bad_alloc& ba) {
-      stringstream msg_stream;
-      msg_stream << "Unable to allocate memory: " << ba.what() << endl;
+    catch(std::bad_alloc& ba) {
+      std::stringstream msg_stream;
+      msg_stream << "Unable to allocate memory: " << ba.what() << std::endl;
       c_ctx->error_message = sass_strdup(msg_stream.str().c_str());
       c_ctx->error_status = 1;
       c_ctx->output_string = 0;
       c_ctx->source_map_string = 0;
     }
     catch (std::exception& e) {
-      stringstream msg_stream;
-      msg_stream << "Error: " << e.what() << endl;
+      std::stringstream msg_stream;
+      msg_stream << "Error: " << e.what() << std::endl;
       c_ctx->error_message = sass_strdup(msg_stream.str().c_str());
       c_ctx->error_status = 1;
       c_ctx->output_string = 0;
       c_ctx->source_map_string = 0;
     }
-    catch (string& e) {
-      stringstream msg_stream;
-      msg_stream << "Error: " << e << endl;
+    catch (std::string& e) {
+      std::stringstream msg_stream;
+      msg_stream << "Error: " << e << std::endl;
       c_ctx->error_message = sass_strdup(msg_stream.str().c_str());
       c_ctx->error_status = 1;
       c_ctx->output_string = 0;
@@ -269,8 +232,8 @@ extern "C" {
     }
     catch (...) {
       // couldn't find the specified file in the include paths; report an error
-      stringstream msg_stream;
-      msg_stream << "Unknown error occurred" << endl;
+      std::stringstream msg_stream;
+      msg_stream << "Unknown error occurred" << std::endl;
       c_ctx->error_message = sass_strdup(msg_stream.str().c_str());
       c_ctx->error_status = 1;
       c_ctx->output_string = 0;

data/ext/libsass/{sass_util.cpp → src/sass_util.cpp}

@@ -5,8 +5,8 @@ namespace Sass {
 
 
   /*
-		This is the equivalent of ruby's Sass::Util.paths.
-
+    # This is the equivalent of ruby's Sass::Util.paths.
+    #
     # Return an array of all possible paths through the given arrays.
     #
     # @param arrs [NodeCollection<NodeCollection<Node>>]
@@ -23,7 +23,7 @@ namespace Sass {
    should be able to drop it into ruby 3.2.19 and get the same results from ruby sass.
 
     def paths(arrs)
-     	// I changed the inject and maps to an iterative approach to make it easier to implement in C++
+        // I changed the inject and maps to an iterative approach to make it easier to implement in C++
       loopStart = [[]]
 
       for arr in arrs do
@@ -36,7 +36,7 @@ namespace Sass {
         loopStart = permutations
       end
     end
-	*/
+  */
   Node paths(const Node& arrs, Context& ctx) {
     To_String to_string(&ctx);
 
@@ -61,6 +61,7 @@ namespace Sass {
           Node& path = *loopStartIter;
 
           Node newPermutation = Node::createCollection();
+          newPermutation.got_line_feed = arr.got_line_feed;
           newPermutation.plus(path);
           newPermutation.collection()->push_back(e);
 
@@ -75,7 +76,7 @@ namespace Sass {
   }
 
 
-	/*
+  /*
   This is the equivalent of ruby sass' Sass::Util.flatten and [].flatten.
   Sass::Util.flatten requires the number of levels to flatten, while
   [].flatten doesn't and will flatten the entire array. This function
@@ -108,20 +109,37 @@ namespace Sass {
     return flattened
   end
   */
-  Node flatten(const Node& arr, Context& ctx, int n = -1) {
+  Node flatten(Node& arr, Context& ctx, int n) {
     if (n != -1 && n == 0) {
       return arr;
     }
 
     Node flattened = Node::createCollection();
+    if (arr.got_line_feed) flattened.got_line_feed = true;
 
     for (NodeDeque::iterator iter = arr.collection()->begin(), iterEnd = arr.collection()->end();
     	iter != iterEnd; iter++) {
     	Node& e = *iter;
 
+      // e has the lf set
       if (e.isCollection()) {
+
+      	// e.collection().got_line_feed = e.got_line_feed;
       	Node recurseFlattened = flatten(e, ctx, n - 1);
-        flattened.collection()->insert(flattened.collection()->end(), recurseFlattened.collection()->begin(), recurseFlattened.collection()->end());
+
+      	if(e.got_line_feed) {
+      		 flattened.got_line_feed = e.got_line_feed;
+      	  recurseFlattened.got_line_feed = e.got_line_feed;
+      	}
+
+      	for(auto i : (*recurseFlattened.collection())) {
+          if (recurseFlattened.got_line_feed) {
+
+            i.got_line_feed = true;
+          }
+          flattened.collection()->push_back(i);
+      	}
+
       } else {
       	flattened.collection()->push_back(e);
       }
@@ -129,4 +147,4 @@ namespace Sass {
 
     return flattened;
   }
-}
+}

data/ext/libsass/{sass_util.hpp → src/sass_util.hpp}

@@ -1,9 +1,6 @@
 #ifndef SASS_SASS_UTIL_H
 #define SASS_SASS_UTIL_H
 
-#include <deque>
-#include <iostream>
-
 #include "ast.hpp"
 #include "node.hpp"
 #include "debug.hpp"
@@ -11,7 +8,6 @@
 namespace Sass {
 
 
-  using namespace std;
 
 
   /*
@@ -54,7 +50,7 @@ namespace Sass {
   };
 
 
-  typedef vector<vector<int> > LCSTable;
+  typedef std::vector<std::vector<int> > LCSTable;
 
 
   /*
@@ -106,7 +102,7 @@ namespace Sass {
     NodeDeque& xChildren = *(x.collection());
     NodeDeque& yChildren = *(y.collection());
 
-    LCSTable c(xChildren.size(), vector<int>(yChildren.size()));
+    LCSTable c(xChildren.size(), std::vector<int>(yChildren.size()));
 
     // These shouldn't be necessary since the vector will be initialized to 0 already.
     // x.size.times {|i| c[i][0] = 0}
@@ -119,7 +115,7 @@ namespace Sass {
         if (comparator(xChildren[i], yChildren[j], compareOut)) {
           c[i][j] = c[i - 1][j - 1] + 1;
         } else {
-          c[i][j] = max(c[i][j - 1], c[i - 1][j]);
+          c[i][j] = std::max(c[i][j - 1], c[i - 1][j]);
         }
       }
     }
@@ -173,7 +169,7 @@ namespace Sass {
   # @param n [int] The number of levels to flatten
   # @return [NodeCollection] The flattened array
   */
-  Node flatten(const Node& arr, Context& ctx, int n = -1);
+  Node flatten(Node& arr, Context& ctx, int n = -1);
 
 
   /*
@@ -221,34 +217,34 @@ namespace Sass {
 
   */
   template<typename EnumType, typename KeyType, typename KeyFunctorType>
-  void group_by_to_a(vector<EnumType>& enumeration, KeyFunctorType& keyFunc, vector<pair<KeyType, vector<EnumType> > >& arr /*out*/) {
+  void group_by_to_a(std::vector<EnumType>& enumeration, KeyFunctorType& keyFunc, std::vector<std::pair<KeyType, std::vector<EnumType> > >& arr /*out*/) {
 
-    map<unsigned int, KeyType> order;
+    std::map<unsigned int, KeyType> order;
 
-    map<KeyType, vector<EnumType> > grouped;
+    std::map<KeyType, std::vector<EnumType> > grouped;
 
-    for (typename vector<EnumType>::iterator enumIter = enumeration.begin(), enumIterEnd = enumeration.end(); enumIter != enumIterEnd; enumIter++) {
+    for (typename std::vector<EnumType>::iterator enumIter = enumeration.begin(), enumIterEnd = enumeration.end(); enumIter != enumIterEnd; enumIter++) {
       EnumType& e = *enumIter;
 
       KeyType key = keyFunc(e);
 
       if (grouped.find(key) == grouped.end()) {
-        order.insert(make_pair(order.size(), key));
+        order.insert(std::make_pair((unsigned int)order.size(), key));
 
-        vector<EnumType> newCollection;
+        std::vector<EnumType> newCollection;
         newCollection.push_back(e);
-        grouped.insert(make_pair(key, newCollection));
+        grouped.insert(std::make_pair(key, newCollection));
       } else {
-        vector<EnumType>& collection = grouped.at(key);
+        std::vector<EnumType>& collection = grouped.at(key);
         collection.push_back(e);
       }
     }
 
     for (unsigned int index = 0; index < order.size(); index++) {
       KeyType& key = order.at(index);
-      vector<EnumType>& values = grouped.at(key);
+      std::vector<EnumType>& values = grouped.at(key);
 
-      pair<KeyType, vector<EnumType> > grouping = make_pair(key, values);
+      std::pair<KeyType, std::vector<EnumType> > grouping = std::make_pair(key, values);
 
       arr.push_back(grouping);
     }

data/ext/libsass/{sass_values.cpp → src/sass_values.cpp}

@@ -1,16 +1,11 @@
-#ifdef _WIN32
-#include <io.h>
-#else
-#include <unistd.h>
-#endif
-
 #include <cstdlib>
 #include <cstring>
 #include "util.hpp"
-#include "sass_values.h"
+#include "eval.hpp"
+#include "values.hpp"
+#include "sass/values.h"
 
 extern "C" {
-  using namespace std;
   using namespace Sass;
 
   struct Sass_Unknown {
@@ -80,7 +75,7 @@ extern "C" {
     struct Sass_Map     map;
     struct Sass_Null    null;
     struct Sass_Error   error;
-    struct Sass_Warning   warning;
+    struct Sass_Warning warning;
   };
 
   struct Sass_MapPair {
@@ -156,7 +151,7 @@ extern "C" {
 
   union Sass_Value* ADDCALL sass_make_boolean(bool val)
   {
-    Sass_Value* v = (Sass_Value*) calloc(1, sizeof(Sass_Value));
+    union Sass_Value* v = (Sass_Value*) calloc(1, sizeof(Sass_Value));
     if (v == 0) return 0;
     v->boolean.tag = SASS_BOOLEAN;
     v->boolean.value = val;
@@ -165,7 +160,7 @@ extern "C" {
 
   union Sass_Value* ADDCALL sass_make_number(double val, const char* unit)
   {
-    Sass_Value* v = (Sass_Value*) calloc(1, sizeof(Sass_Value));
+    union Sass_Value* v = (Sass_Value*) calloc(1, sizeof(Sass_Value));
     if (v == 0) return 0;
     v->number.tag = SASS_NUMBER;
     v->number.value = val;
@@ -176,7 +171,7 @@ extern "C" {
 
   union Sass_Value* ADDCALL sass_make_color(double r, double g, double b, double a)
   {
-    Sass_Value* v = (Sass_Value*) calloc(1, sizeof(Sass_Value));
+    union Sass_Value* v = (Sass_Value*) calloc(1, sizeof(Sass_Value));
     if (v == 0) return 0;
     v->color.tag = SASS_COLOR;
     v->color.r = r;
@@ -188,7 +183,7 @@ extern "C" {
 
   union Sass_Value* ADDCALL sass_make_string(const char* val)
   {
-    Sass_Value* v = (Sass_Value*) calloc(1, sizeof(Sass_Value));
+    union Sass_Value* v = (Sass_Value*) calloc(1, sizeof(Sass_Value));
     if (v == 0) return 0;
     v->string.quoted = false;
     v->string.tag = SASS_STRING;
@@ -199,7 +194,7 @@ extern "C" {
 
   union Sass_Value* ADDCALL sass_make_qstring(const char* val)
   {
-    Sass_Value* v = (Sass_Value*) calloc(1, sizeof(Sass_Value));
+    union Sass_Value* v = (Sass_Value*) calloc(1, sizeof(Sass_Value));
     if (v == 0) return 0;
     v->string.quoted = true;
     v->string.tag = SASS_STRING;
@@ -210,7 +205,7 @@ extern "C" {
 
   union Sass_Value* ADDCALL sass_make_list(size_t len, enum Sass_Separator sep)
   {
-    Sass_Value* v = (Sass_Value*) calloc(1, sizeof(Sass_Value));
+    union Sass_Value* v = (Sass_Value*) calloc(1, sizeof(Sass_Value));
     if (v == 0) return 0;
     v->list.tag = SASS_LIST;
     v->list.length = len;
@@ -222,7 +217,7 @@ extern "C" {
 
   union Sass_Value* ADDCALL sass_make_map(size_t len)
   {
-    Sass_Value* v = (Sass_Value*) calloc(1, sizeof(Sass_Value));
+    union Sass_Value* v = (Sass_Value*) calloc(1, sizeof(Sass_Value));
     if (v == 0) return 0;
     v->map.tag = SASS_MAP;
     v->map.length = len;
@@ -233,7 +228,7 @@ extern "C" {
 
   union Sass_Value* ADDCALL sass_make_null(void)
   {
-    Sass_Value* v = (Sass_Value*) calloc(1, sizeof(Sass_Value));
+    union Sass_Value* v = (Sass_Value*) calloc(1, sizeof(Sass_Value));
     if (v == 0) return 0;
     v->null.tag = SASS_NULL;
     return v;
@@ -241,7 +236,7 @@ extern "C" {
 
   union Sass_Value* ADDCALL sass_make_error(const char* msg)
   {
-    Sass_Value* v = (Sass_Value*) calloc(1, sizeof(Sass_Value));
+    union Sass_Value* v = (Sass_Value*) calloc(1, sizeof(Sass_Value));
     if (v == 0) return 0;
     v->error.tag = SASS_ERROR;
     v->error.message = msg ? sass_strdup(msg) : 0;
@@ -251,7 +246,7 @@ extern "C" {
 
   union Sass_Value* ADDCALL sass_make_warning(const char* msg)
   {
-    Sass_Value* v = (Sass_Value*) calloc(1, sizeof(Sass_Value));
+    union Sass_Value* v = (Sass_Value*) calloc(1, sizeof(Sass_Value));
     if (v == 0) return 0;
     v->warning.tag = SASS_WARNING;
     v->warning.message = msg ? sass_strdup(msg) : 0;
@@ -322,7 +317,7 @@ extern "C" {
                 return sass_make_color(val->color.r, val->color.g, val->color.b, val->color.a);
         }   break;
         case SASS_STRING: {
-                return sass_make_string(val->string.value);
+                return sass_string_is_quoted(val) ? sass_make_qstring(val->string.value) : sass_make_string(val->string.value);
         }   break;
         case SASS_LIST: {
                 union Sass_Value* list = sass_make_list(val->list.length, val->list.separator);
@@ -351,4 +346,80 @@ extern "C" {
 
   }
 
+  union Sass_Value* ADDCALL sass_value_stringify (const union Sass_Value* v, bool compressed, int precision)
+  {
+    Memory_Manager mem;
+    Value* val = sass_value_to_ast_node(mem, v);
+    std::string str(val->to_string(compressed, precision));
+    return sass_make_qstring(str.c_str());
+  }
+
+  union Sass_Value* ADDCALL sass_value_op (enum Sass_OP op, const union Sass_Value* a, const union Sass_Value* b)
+  {
+
+    Sass::Value* rv = 0;
+    Memory_Manager mem;
+
+    try {
+
+      Value* lhs = sass_value_to_ast_node(mem, a);
+      Value* rhs = sass_value_to_ast_node(mem, b);
+
+      // see if it's a relational expression
+      switch(op) {
+        case Sass_OP::EQ:  return sass_make_boolean(Eval::eq(lhs, rhs));
+        case Sass_OP::NEQ: return sass_make_boolean(!Eval::eq(lhs, rhs));
+        case Sass_OP::GT:  return sass_make_boolean(!Eval::lt(lhs, rhs) && !Eval::eq(lhs, rhs));
+        case Sass_OP::GTE: return sass_make_boolean(!Eval::lt(lhs, rhs));
+        case Sass_OP::LT:  return sass_make_boolean(Eval::lt(lhs, rhs));
+        case Sass_OP::LTE: return sass_make_boolean(Eval::lt(lhs, rhs) || Eval::eq(lhs, rhs));
+        default:           break;
+      }
+
+      if (sass_value_is_number(a) && sass_value_is_number(b)) {
+        const Number* l_n = dynamic_cast<const Number*>(lhs);
+        const Number* r_n = dynamic_cast<const Number*>(rhs);
+        rv = Eval::op_numbers(mem, op, *l_n, *r_n);
+      }
+      else if (sass_value_is_number(a) && sass_value_is_color(a)) {
+        const Number* l_n = dynamic_cast<const Number*>(lhs);
+        const Color* r_c = dynamic_cast<const Color*>(rhs);
+        rv = Eval::op_number_color(mem, op, *l_n, *r_c);
+      }
+      else if (sass_value_is_color(a) && sass_value_is_number(b)) {
+        const Color* l_c = dynamic_cast<const Color*>(lhs);
+        const Number* r_n = dynamic_cast<const Number*>(rhs);
+        rv = Eval::op_color_number(mem, op, *l_c, *r_n);
+      }
+      else if (sass_value_is_color(a) && sass_value_is_color(b)) {
+        const Color* l_c = dynamic_cast<const Color*>(lhs);
+        const Color* r_c = dynamic_cast<const Color*>(rhs);
+        rv = Eval::op_colors(mem, op, *l_c, *r_c);
+      }
+      else /* convert other stuff to string and apply operation */ {
+        Value* l_v = dynamic_cast<Value*>(lhs);
+        Value* r_v = dynamic_cast<Value*>(rhs);
+        rv = Eval::op_strings(mem, op, *l_v, *r_v);
+      }
+
+      // ToDo: maybe we should should return null value?
+      if (!rv) return sass_make_error("invalid return value");
+
+      // convert result back to ast node
+      return ast_node_to_sass_value(rv);
+
+    }
+
+    // simply pass the error message back to the caller for now
+    catch (Error_Invalid& e) { return sass_make_error(e.message.c_str()); }
+    catch (std::bad_alloc& ba) { return sass_make_error("memory exhausted"); }
+    catch (std::exception& e) { return sass_make_error(e.what()); }
+    catch (std::string& e) { return sass_make_error(e.c_str()); }
+    catch (const char* e) { return sass_make_error(e); }
+    catch (...) { return sass_make_error("unknown"); }
+
+    return 0;
+
+  }
+
 }