sassc 2.1.0.pre3 → 2.4.0

data/ext/libsass/src/ast_supports.cpp

@@ -1,99 +1,83 @@
 // sass.hpp must go before all system headers to get the
 // __EXTENSIONS__ fix on Solaris.
 #include "sass.hpp"
-
 #include "ast.hpp"
-#include "context.hpp"
-#include "node.hpp"
-#include "eval.hpp"
-#include "extend.hpp"
-#include "emitter.hpp"
-#include "color_maps.hpp"
-#include "ast_fwd_decl.hpp"
-#include <set>
-#include <iomanip>
-#include <iostream>
-#include <algorithm>
-#include <functional>
-#include <cctype>
-#include <locale>
-
-#include "ast_values.hpp"
+
 
 namespace Sass {
 
   /////////////////////////////////////////////////////////////////////////
   /////////////////////////////////////////////////////////////////////////
 
-  Supports_Block::Supports_Block(ParserState pstate, Supports_Condition_Obj condition, Block_Obj block)
-  : Has_Block(pstate, block), condition_(condition)
+  SupportsRule::SupportsRule(SourceSpan pstate, SupportsConditionObj condition, Block_Obj block)
+  : ParentStatement(pstate, block), condition_(condition)
   { statement_type(SUPPORTS); }
-  Supports_Block::Supports_Block(const Supports_Block* ptr)
-  : Has_Block(ptr), condition_(ptr->condition_)
+  SupportsRule::SupportsRule(const SupportsRule* ptr)
+  : ParentStatement(ptr), condition_(ptr->condition_)
   { statement_type(SUPPORTS); }
-  bool Supports_Block::bubbles() { return true; }
+  bool SupportsRule::bubbles() { return true; }
 
   /////////////////////////////////////////////////////////////////////////
   /////////////////////////////////////////////////////////////////////////
 
-  Supports_Condition::Supports_Condition(ParserState pstate)
+  SupportsCondition::SupportsCondition(SourceSpan pstate)
   : Expression(pstate)
   { }
 
-  Supports_Condition::Supports_Condition(const Supports_Condition* ptr)
+  SupportsCondition::SupportsCondition(const SupportsCondition* ptr)
   : Expression(ptr)
   { }
 
   /////////////////////////////////////////////////////////////////////////
   /////////////////////////////////////////////////////////////////////////
 
-  Supports_Operator::Supports_Operator(ParserState pstate, Supports_Condition_Obj l, Supports_Condition_Obj r, Operand o)
-  : Supports_Condition(pstate), left_(l), right_(r), operand_(o)
+  SupportsOperation::SupportsOperation(SourceSpan pstate, SupportsConditionObj l, SupportsConditionObj r, Operand o)
+  : SupportsCondition(pstate), left_(l), right_(r), operand_(o)
   { }
-  Supports_Operator::Supports_Operator(const Supports_Operator* ptr)
-  : Supports_Condition(ptr),
+  SupportsOperation::SupportsOperation(const SupportsOperation* ptr)
+  : SupportsCondition(ptr),
     left_(ptr->left_),
     right_(ptr->right_),
     operand_(ptr->operand_)
   { }
 
-  bool Supports_Operator::needs_parens(Supports_Condition_Obj cond) const
+  bool SupportsOperation::needs_parens(SupportsConditionObj cond) const
   {
-    if (Supports_Operator_Obj op = Cast<Supports_Operator>(cond)) {
+    if (SupportsOperationObj op = Cast<SupportsOperation>(cond)) {
       return op->operand() != operand();
     }
-    return Cast<Supports_Negation>(cond) != NULL;
+    return Cast<SupportsNegation>(cond) != NULL;
   }
 
   /////////////////////////////////////////////////////////////////////////
   /////////////////////////////////////////////////////////////////////////
 
-  Supports_Negation::Supports_Negation(ParserState pstate, Supports_Condition_Obj c)
-  : Supports_Condition(pstate), condition_(c)
+  SupportsNegation::SupportsNegation(SourceSpan pstate, SupportsConditionObj c)
+  : SupportsCondition(pstate), condition_(c)
   { }
-  Supports_Negation::Supports_Negation(const Supports_Negation* ptr)
-  : Supports_Condition(ptr), condition_(ptr->condition_)
+  SupportsNegation::SupportsNegation(const SupportsNegation* ptr)
+  : SupportsCondition(ptr), condition_(ptr->condition_)
   { }
 
-  bool Supports_Negation::needs_parens(Supports_Condition_Obj cond) const
+  bool SupportsNegation::needs_parens(SupportsConditionObj cond) const
   {
-    return Cast<Supports_Negation>(cond) ||
-           Cast<Supports_Operator>(cond);
+    return Cast<SupportsNegation>(cond) ||
+           Cast<SupportsOperation>(cond);
   }
 
   /////////////////////////////////////////////////////////////////////////
   /////////////////////////////////////////////////////////////////////////
 
-  Supports_Declaration::Supports_Declaration(ParserState pstate, Expression_Obj f, Expression_Obj v)
-  : Supports_Condition(pstate), feature_(f), value_(v)
+  SupportsDeclaration::SupportsDeclaration(SourceSpan pstate, ExpressionObj f, ExpressionObj v)
+  : SupportsCondition(pstate), feature_(f), value_(v)
   { }
-  Supports_Declaration::Supports_Declaration(const Supports_Declaration* ptr)
-  : Supports_Condition(ptr),
+  SupportsDeclaration::SupportsDeclaration(const SupportsDeclaration* ptr)
+  : SupportsCondition(ptr),
     feature_(ptr->feature_),
     value_(ptr->value_)
   { }
 
-  bool Supports_Declaration::needs_parens(Supports_Condition_Obj cond) const
+  bool SupportsDeclaration::needs_parens(SupportsConditionObj cond) const
   {
     return false;
   }
@@ -101,15 +85,15 @@ namespace Sass {
   /////////////////////////////////////////////////////////////////////////
   /////////////////////////////////////////////////////////////////////////
 
-  Supports_Interpolation::Supports_Interpolation(ParserState pstate, Expression_Obj v)
-  : Supports_Condition(pstate), value_(v)
+  Supports_Interpolation::Supports_Interpolation(SourceSpan pstate, ExpressionObj v)
+  : SupportsCondition(pstate), value_(v)
   { }
   Supports_Interpolation::Supports_Interpolation(const Supports_Interpolation* ptr)
-  : Supports_Condition(ptr),
+  : SupportsCondition(ptr),
     value_(ptr->value_)
   { }
 
-  bool Supports_Interpolation::needs_parens(Supports_Condition_Obj cond) const
+  bool Supports_Interpolation::needs_parens(SupportsConditionObj cond) const
   {
     return false;
   }
@@ -117,11 +101,11 @@ namespace Sass {
   /////////////////////////////////////////////////////////////////////////
   /////////////////////////////////////////////////////////////////////////
 
-  IMPLEMENT_AST_OPERATORS(Supports_Block);
-  IMPLEMENT_AST_OPERATORS(Supports_Condition);
-  IMPLEMENT_AST_OPERATORS(Supports_Operator);
-  IMPLEMENT_AST_OPERATORS(Supports_Negation);
-  IMPLEMENT_AST_OPERATORS(Supports_Declaration);
+  IMPLEMENT_AST_OPERATORS(SupportsRule);
+  IMPLEMENT_AST_OPERATORS(SupportsCondition);
+  IMPLEMENT_AST_OPERATORS(SupportsOperation);
+  IMPLEMENT_AST_OPERATORS(SupportsNegation);
+  IMPLEMENT_AST_OPERATORS(SupportsDeclaration);
   IMPLEMENT_AST_OPERATORS(Supports_Interpolation);
 
   /////////////////////////////////////////////////////////////////////////

data/ext/libsass/src/ast_supports.hpp

@@ -39,79 +39,79 @@ namespace Sass {
   ////////////////////
   // `@supports` rule.
   ////////////////////
-  class Supports_Block : public Has_Block {
-    ADD_PROPERTY(Supports_Condition_Obj, condition)
+  class SupportsRule : public ParentStatement {
+    ADD_PROPERTY(SupportsConditionObj, condition)
   public:
-    Supports_Block(ParserState pstate, Supports_Condition_Obj condition, Block_Obj block = {});
+    SupportsRule(SourceSpan pstate, SupportsConditionObj condition, Block_Obj block = {});
     bool bubbles() override;
-    ATTACH_AST_OPERATIONS(Supports_Block)
+    ATTACH_AST_OPERATIONS(SupportsRule)
     ATTACH_CRTP_PERFORM_METHODS()
   };
 
   //////////////////////////////////////////////////////
   // The abstract superclass of all Supports conditions.
   //////////////////////////////////////////////////////
-  class Supports_Condition : public Expression {
+  class SupportsCondition : public Expression {
   public:
-    Supports_Condition(ParserState pstate);
-    virtual bool needs_parens(Supports_Condition_Obj cond) const { return false; }
-    ATTACH_AST_OPERATIONS(Supports_Condition)
+    SupportsCondition(SourceSpan pstate);
+    virtual bool needs_parens(SupportsConditionObj cond) const { return false; }
+    ATTACH_AST_OPERATIONS(SupportsCondition)
     ATTACH_CRTP_PERFORM_METHODS()
   };
 
   ////////////////////////////////////////////////////////////
   // An operator condition (e.g. `CONDITION1 and CONDITION2`).
   ////////////////////////////////////////////////////////////
-  class Supports_Operator : public Supports_Condition {
+  class SupportsOperation : public SupportsCondition {
   public:
     enum Operand { AND, OR };
   private:
-    ADD_PROPERTY(Supports_Condition_Obj, left);
-    ADD_PROPERTY(Supports_Condition_Obj, right);
+    ADD_PROPERTY(SupportsConditionObj, left);
+    ADD_PROPERTY(SupportsConditionObj, right);
     ADD_PROPERTY(Operand, operand);
   public:
-    Supports_Operator(ParserState pstate, Supports_Condition_Obj l, Supports_Condition_Obj r, Operand o);
-    virtual bool needs_parens(Supports_Condition_Obj cond) const override;
-    ATTACH_AST_OPERATIONS(Supports_Operator)
+    SupportsOperation(SourceSpan pstate, SupportsConditionObj l, SupportsConditionObj r, Operand o);
+    virtual bool needs_parens(SupportsConditionObj cond) const override;
+    ATTACH_AST_OPERATIONS(SupportsOperation)
     ATTACH_CRTP_PERFORM_METHODS()
   };
 
   //////////////////////////////////////////
   // A negation condition (`not CONDITION`).
   //////////////////////////////////////////
-  class Supports_Negation : public Supports_Condition {
+  class SupportsNegation : public SupportsCondition {
   private:
-    ADD_PROPERTY(Supports_Condition_Obj, condition);
+    ADD_PROPERTY(SupportsConditionObj, condition);
   public:
-    Supports_Negation(ParserState pstate, Supports_Condition_Obj c);
-    virtual bool needs_parens(Supports_Condition_Obj cond) const override;
-    ATTACH_AST_OPERATIONS(Supports_Negation)
+    SupportsNegation(SourceSpan pstate, SupportsConditionObj c);
+    virtual bool needs_parens(SupportsConditionObj cond) const override;
+    ATTACH_AST_OPERATIONS(SupportsNegation)
     ATTACH_CRTP_PERFORM_METHODS()
   };
 
   /////////////////////////////////////////////////////
   // A declaration condition (e.g. `(feature: value)`).
   /////////////////////////////////////////////////////
-  class Supports_Declaration : public Supports_Condition {
+  class SupportsDeclaration : public SupportsCondition {
   private:
-    ADD_PROPERTY(Expression_Obj, feature);
-    ADD_PROPERTY(Expression_Obj, value);
+    ADD_PROPERTY(ExpressionObj, feature);
+    ADD_PROPERTY(ExpressionObj, value);
   public:
-    Supports_Declaration(ParserState pstate, Expression_Obj f, Expression_Obj v);
-    virtual bool needs_parens(Supports_Condition_Obj cond) const override;
-    ATTACH_AST_OPERATIONS(Supports_Declaration)
+    SupportsDeclaration(SourceSpan pstate, ExpressionObj f, ExpressionObj v);
+    virtual bool needs_parens(SupportsConditionObj cond) const override;
+    ATTACH_AST_OPERATIONS(SupportsDeclaration)
     ATTACH_CRTP_PERFORM_METHODS()
   };
 
   ///////////////////////////////////////////////
   // An interpolation condition (e.g. `#{$var}`).
   ///////////////////////////////////////////////
-  class Supports_Interpolation : public Supports_Condition {
+  class Supports_Interpolation : public SupportsCondition {
   private:
-    ADD_PROPERTY(Expression_Obj, value);
+    ADD_PROPERTY(ExpressionObj, value);
   public:
-    Supports_Interpolation(ParserState pstate, Expression_Obj v);
-    virtual bool needs_parens(Supports_Condition_Obj cond) const override;
+    Supports_Interpolation(SourceSpan pstate, ExpressionObj v);
+    virtual bool needs_parens(SupportsConditionObj cond) const override;
     ATTACH_AST_OPERATIONS(Supports_Interpolation)
     ATTACH_CRTP_PERFORM_METHODS()
   };

data/ext/libsass/src/ast_values.cpp

@@ -1,28 +1,11 @@
 // sass.hpp must go before all system headers to get the
 // __EXTENSIONS__ fix on Solaris.
 #include "sass.hpp"
-
 #include "ast.hpp"
-#include "context.hpp"
-#include "node.hpp"
-#include "eval.hpp"
-#include "extend.hpp"
-#include "emitter.hpp"
-#include "color_maps.hpp"
-#include "ast_fwd_decl.hpp"
-#include <set>
-#include <iomanip>
-#include <iostream>
-#include <algorithm>
-#include <functional>
-#include <cctype>
-#include <locale>
-
-#include "ast_values.hpp"
 
 namespace Sass {
 
-  void str_rtrim(std::string& str, const std::string& delimiters = " \f\n\r\t\v")
+  void str_rtrim(sass::string& str, const sass::string& delimiters = " \f\n\r\t\v")
   {
     str.erase( str.find_last_not_of( delimiters ) + 1 );
   }
@@ -30,7 +13,7 @@ namespace Sass {
   /////////////////////////////////////////////////////////////////////////
   /////////////////////////////////////////////////////////////////////////
 
-  PreValue::PreValue(ParserState pstate, bool d, bool e, bool i, Type ct)
+  PreValue::PreValue(SourceSpan pstate, bool d, bool e, bool i, Type ct)
   : Expression(pstate, d, e, i, ct)
   { }
   PreValue::PreValue(const PreValue* ptr)
@@ -40,7 +23,7 @@ namespace Sass {
   /////////////////////////////////////////////////////////////////////////
   /////////////////////////////////////////////////////////////////////////
 
-  Value::Value(ParserState pstate, bool d, bool e, bool i, Type ct)
+  Value::Value(SourceSpan pstate, bool d, bool e, bool i, Type ct)
   : PreValue(pstate, d, e, i, ct)
   { }
   Value::Value(const Value* ptr)
@@ -50,9 +33,9 @@ namespace Sass {
   /////////////////////////////////////////////////////////////////////////
   /////////////////////////////////////////////////////////////////////////
 
-  List::List(ParserState pstate, size_t size, enum Sass_Separator sep, bool argl, bool bracket)
+  List::List(SourceSpan pstate, size_t size, enum Sass_Separator sep, bool argl, bool bracket)
   : Value(pstate),
-    Vectorized<Expression_Obj>(size),
+    Vectorized<ExpressionObj>(size),
     separator_(sep),
     is_arglist_(argl),
     is_bracketed_(bracket),
@@ -61,7 +44,7 @@ namespace Sass {
 
   List::List(const List* ptr)
   : Value(ptr),
-    Vectorized<Expression_Obj>(*ptr),
+    Vectorized<ExpressionObj>(*ptr),
     separator_(ptr->separator_),
     is_arglist_(ptr->is_arglist_),
     is_bracketed_(ptr->is_bracketed_),
@@ -71,7 +54,7 @@ namespace Sass {
   size_t List::hash() const
   {
     if (hash_ == 0) {
-      hash_ = std::hash<std::string>()(sep_string());
+      hash_ = std::hash<sass::string>()(sep_string());
       hash_combine(hash_, std::hash<bool>()(is_bracketed()));
       for (size_t i = 0, L = length(); i < L; ++i)
         hash_combine(hash_, (elements()[i])->hash());
@@ -85,6 +68,24 @@ namespace Sass {
     // don't set children
   }
 
+  bool List::operator< (const Expression& rhs) const
+  {
+    if (auto r = Cast<List>(&rhs)) {
+      if (length() < r->length()) return true;
+      if (length() > r->length()) return false;
+      const auto& left = elements();
+      const auto& right = r->elements();
+      for (size_t i = 0; i < left.size(); i += 1) {
+        if (*left[i] < *right[i]) return true;
+        if (*left[i] == *right[i]) continue;
+        return false;
+      }
+      return false;
+    }
+    // compare/sort by type
+    return type() < rhs.type();
+  }
+
   bool List::operator== (const Expression& rhs) const
   {
     if (auto r = Cast<List>(&rhs)) {
@@ -108,7 +109,7 @@ namespace Sass {
     // arglist expects a list of arguments
     // so we need to break before keywords
     for (size_t i = 0, L = length(); i < L; ++i) {
-      Expression_Obj obj = this->at(i);
+      ExpressionObj obj = this->at(i);
       if (Argument* arg = Cast<Argument>(obj)) {
         if (!arg->name().empty()) return i;
       }
@@ -117,8 +118,8 @@ namespace Sass {
   }
 
 
-  Expression_Obj List::value_at_index(size_t i) {
-    Expression_Obj obj = this->at(i);
+  ExpressionObj List::value_at_index(size_t i) {
+    ExpressionObj obj = this->at(i);
     if (is_arglist_) {
       if (Argument* arg = Cast<Argument>(obj)) {
         return arg->value();
@@ -133,7 +134,7 @@ namespace Sass {
   /////////////////////////////////////////////////////////////////////////
   /////////////////////////////////////////////////////////////////////////
 
-  Map::Map(ParserState pstate, size_t size)
+  Map::Map(SourceSpan pstate, size_t size)
   : Value(pstate),
     Hashed(size)
   { concrete_type(MAP); }
@@ -143,6 +144,31 @@ namespace Sass {
     Hashed(*ptr)
   { concrete_type(MAP); }
 
+  bool Map::operator< (const Expression& rhs) const
+  {
+    if (auto r = Cast<Map>(&rhs)) {
+      if (length() < r->length()) return true;
+      if (length() > r->length()) return false;
+      const auto& lkeys = keys();
+      const auto& rkeys = r->keys();
+      for (size_t i = 0; i < lkeys.size(); i += 1) {
+        if (*lkeys[i] < *rkeys[i]) return true;
+        if (*lkeys[i] == *rkeys[i]) continue;
+        return false;
+      }
+      const auto& lvals = values();
+      const auto& rvals = r->values();
+      for (size_t i = 0; i < lvals.size(); i += 1) {
+        if (*lvals[i] < *rvals[i]) return true;
+        if (*lvals[i] == *rvals[i]) continue;
+        return false;
+      }
+      return false;
+    }
+    // compare/sort by type
+    return type() < rhs.type();
+  }
+
   bool Map::operator== (const Expression& rhs) const
   {
     if (auto r = Cast<Map>(&rhs)) {
@@ -159,7 +185,7 @@ namespace Sass {
     return false;
   }
 
-  List_Obj Map::to_list(ParserState& pstate) {
+  List_Obj Map::to_list(SourceSpan& pstate) {
     List_Obj ret = SASS_MEMORY_NEW(List, pstate, length(), SASS_COMMA);
 
     for (auto key : keys()) {
@@ -187,8 +213,8 @@ namespace Sass {
   /////////////////////////////////////////////////////////////////////////
   /////////////////////////////////////////////////////////////////////////
 
-  Binary_Expression::Binary_Expression(ParserState pstate,
-                    Operand op, Expression_Obj lhs, Expression_Obj rhs)
+  Binary_Expression::Binary_Expression(SourceSpan pstate,
+                    Operand op, ExpressionObj lhs, ExpressionObj rhs)
   : PreValue(pstate), op_(op), left_(lhs), right_(rhs), hash_(0)
   { }
 
@@ -209,12 +235,12 @@ namespace Sass {
     return is_interpolant() || (right() && right()->is_right_interpolant());
   }
 
-  const std::string Binary_Expression::type_name()
+  const sass::string Binary_Expression::type_name()
   {
     return sass_op_to_name(optype());
   }
 
-  const std::string Binary_Expression::separator()
+  const sass::string Binary_Expression::separator()
   {
     return sass_op_separator(optype());
   }
@@ -232,6 +258,17 @@ namespace Sass {
     is_delayed(delayed);
   }
 
+  bool Binary_Expression::operator<(const Expression& rhs) const
+  {
+    if (auto m = Cast<Binary_Expression>(&rhs)) {
+      return type() < m->type() ||
+        *left() < *m->left() ||
+        *right() < *m->right();
+    }
+    // compare/sort by type
+    return type() < rhs.type();
+  }
+
   bool Binary_Expression::operator==(const Expression& rhs) const
   {
     if (auto m = Cast<Binary_Expression>(&rhs)) {
@@ -255,7 +292,7 @@ namespace Sass {
   /////////////////////////////////////////////////////////////////////////
   /////////////////////////////////////////////////////////////////////////
 
-  Function::Function(ParserState pstate, Definition_Obj def, bool css)
+  Function::Function(SourceSpan pstate, Definition_Obj def, bool css)
   : Value(pstate), definition_(def), is_css_(css)
   { concrete_type(FUNCTION_VAL); }
 
@@ -263,6 +300,22 @@ namespace Sass {
   : Value(ptr), definition_(ptr->definition_), is_css_(ptr->is_css_)
   { concrete_type(FUNCTION_VAL); }
 
+  bool Function::operator< (const Expression& rhs) const
+  {
+    if (auto r = Cast<Function>(&rhs)) {
+      auto d1 = Cast<Definition>(definition());
+      auto d2 = Cast<Definition>(r->definition());
+      if (d1 == nullptr) return d2 != nullptr;
+      else if (d2 == nullptr) return false;
+      if (is_css() == r->is_css()) {
+        return d1 < d2;
+      }
+      return r->is_css();
+    }
+    // compare/sort by type
+    return type() < rhs.type();
+  }
+
   bool Function::operator== (const Expression& rhs) const
   {
     if (auto r = Cast<Function>(&rhs)) {
@@ -273,7 +326,7 @@ namespace Sass {
     return false;
   }
 
-  std::string Function::name() {
+  sass::string Function::name() {
     if (definition_) {
       return definition_->name();
     }
@@ -283,23 +336,23 @@ namespace Sass {
   /////////////////////////////////////////////////////////////////////////
   /////////////////////////////////////////////////////////////////////////
 
-  Function_Call::Function_Call(ParserState pstate, String_Obj n, Arguments_Obj args, void* cookie)
+  Function_Call::Function_Call(SourceSpan pstate, String_Obj n, Arguments_Obj args, void* cookie)
   : PreValue(pstate), sname_(n), arguments_(args), func_(), via_call_(false), cookie_(cookie), hash_(0)
   { concrete_type(FUNCTION); }
-  Function_Call::Function_Call(ParserState pstate, String_Obj n, Arguments_Obj args, Function_Obj func)
+  Function_Call::Function_Call(SourceSpan pstate, String_Obj n, Arguments_Obj args, Function_Obj func)
   : PreValue(pstate), sname_(n), arguments_(args), func_(func), via_call_(false), cookie_(0), hash_(0)
   { concrete_type(FUNCTION); }
-  Function_Call::Function_Call(ParserState pstate, String_Obj n, Arguments_Obj args)
+  Function_Call::Function_Call(SourceSpan pstate, String_Obj n, Arguments_Obj args)
   : PreValue(pstate), sname_(n), arguments_(args), via_call_(false), cookie_(0), hash_(0)
   { concrete_type(FUNCTION); }
 
-  Function_Call::Function_Call(ParserState pstate, std::string n, Arguments_Obj args, void* cookie)
+  Function_Call::Function_Call(SourceSpan pstate, sass::string n, Arguments_Obj args, void* cookie)
   : PreValue(pstate), sname_(SASS_MEMORY_NEW(String_Constant, pstate, n)), arguments_(args), func_(), via_call_(false), cookie_(cookie), hash_(0)
   { concrete_type(FUNCTION); }
-  Function_Call::Function_Call(ParserState pstate, std::string n, Arguments_Obj args, Function_Obj func)
+  Function_Call::Function_Call(SourceSpan pstate, sass::string n, Arguments_Obj args, Function_Obj func)
   : PreValue(pstate), sname_(SASS_MEMORY_NEW(String_Constant, pstate, n)), arguments_(args), func_(func), via_call_(false), cookie_(0), hash_(0)
   { concrete_type(FUNCTION); }
-  Function_Call::Function_Call(ParserState pstate, std::string n, Arguments_Obj args)
+  Function_Call::Function_Call(SourceSpan pstate, sass::string n, Arguments_Obj args)
   : PreValue(pstate), sname_(SASS_MEMORY_NEW(String_Constant, pstate, n)), arguments_(args), via_call_(false), cookie_(0), hash_(0)
   { concrete_type(FUNCTION); }
 
@@ -328,14 +381,14 @@ namespace Sass {
   size_t Function_Call::hash() const
   {
     if (hash_ == 0) {
-      hash_ = std::hash<std::string>()(name());
+      hash_ = std::hash<sass::string>()(name());
       for (auto argument : arguments()->elements())
         hash_combine(hash_, argument->hash());
     }
     return hash_;
   }
 
-  std::string Function_Call::name() const
+  sass::string Function_Call::name() const
   {
     return sname();
   }
@@ -348,7 +401,7 @@ namespace Sass {
   /////////////////////////////////////////////////////////////////////////
   /////////////////////////////////////////////////////////////////////////
 
-  Variable::Variable(ParserState pstate, std::string n)
+  Variable::Variable(SourceSpan pstate, sass::string n)
   : PreValue(pstate), name_(n)
   { concrete_type(VARIABLE); }
 
@@ -366,13 +419,13 @@ namespace Sass {
 
   size_t Variable::hash() const
   {
-    return std::hash<std::string>()(name());
+    return std::hash<sass::string>()(name());
   }
 
   /////////////////////////////////////////////////////////////////////////
   /////////////////////////////////////////////////////////////////////////
 
-  Number::Number(ParserState pstate, double val, std::string u, bool zero)
+  Number::Number(SourceSpan pstate, double val, sass::string u, bool zero)
   : Value(pstate),
     Units(),
     value_(val),
@@ -385,12 +438,12 @@ namespace Sass {
       bool nominator = true;
       while (true) {
         r = u.find_first_of("*/", l);
-        std::string unit(u.substr(l, r == std::string::npos ? r : r - l));
+        sass::string unit(u.substr(l, r == sass::string::npos ? r : r - l));
         if (!unit.empty()) {
           if (nominator) numerators.push_back(unit);
           else denominators.push_back(unit);
         }
-        if (r == std::string::npos) break;
+        if (r == sass::string::npos) break;
         // ToDo: should error for multiple slashes
         // if (!nominator && u[r] == '/') error(...)
         if (u[r] == '/')
@@ -429,13 +482,21 @@ namespace Sass {
     if (hash_ == 0) {
       hash_ = std::hash<double>()(value_);
       for (const auto numerator : numerators)
-        hash_combine(hash_, std::hash<std::string>()(numerator));
+        hash_combine(hash_, std::hash<sass::string>()(numerator));
       for (const auto denominator : denominators)
-        hash_combine(hash_, std::hash<std::string>()(denominator));
+        hash_combine(hash_, std::hash<sass::string>()(denominator));
     }
     return hash_;
   }
 
+  bool Number::operator< (const Expression& rhs) const
+  {
+    if (auto n = Cast<Number>(&rhs)) {
+      return *this < *n;
+    }
+    return false;
+  }
+
   bool Number::operator== (const Expression& rhs) const
   {
     if (auto n = Cast<Number>(&rhs)) {
@@ -475,7 +536,7 @@ namespace Sass {
     l.normalize(); r.normalize();
     Units &lhs_unit = l, &rhs_unit = r;
     if (!(lhs_unit == rhs_unit)) {
-      /* ToDo: do we always get usefull backtraces? */
+      /* ToDo: do we always get useful backtraces? */
       throw Exception::IncompatibleUnits(rhs, *this);
     }
     if (lhs_unit == rhs_unit) {
@@ -488,7 +549,7 @@ namespace Sass {
   /////////////////////////////////////////////////////////////////////////
   /////////////////////////////////////////////////////////////////////////
 
-  Color::Color(ParserState pstate, double a, const std::string disp)
+  Color::Color(SourceSpan pstate, double a, const sass::string disp)
   : Value(pstate),
     disp_(disp), a_(a),
     hash_(0)
@@ -502,6 +563,21 @@ namespace Sass {
     hash_(ptr->hash_)
   { concrete_type(COLOR); }
 
+  bool Color::operator< (const Expression& rhs) const
+  {
+    if (auto r = Cast<Color_RGBA>(&rhs)) {
+      return *this < *r;
+    }
+    else if (auto r = Cast<Color_HSLA>(&rhs)) {
+      return *this < *r;
+    }
+    else if (auto r = Cast<Color>(&rhs)) {
+      return a_ < r->a();
+    }
+    // compare/sort by type
+    return type() < rhs.type();
+  }
+
   bool Color::operator== (const Expression& rhs) const
   {
     if (auto r = Cast<Color_RGBA>(&rhs)) {
@@ -519,7 +595,7 @@ namespace Sass {
   /////////////////////////////////////////////////////////////////////////
   /////////////////////////////////////////////////////////////////////////
 
-  Color_RGBA::Color_RGBA(ParserState pstate, double r, double g, double b, double a, const std::string disp)
+  Color_RGBA::Color_RGBA(SourceSpan pstate, double r, double g, double b, double a, const sass::string disp)
   : Color(pstate, a, disp),
     r_(r), g_(g), b_(b)
   { concrete_type(COLOR); }
@@ -531,6 +607,23 @@ namespace Sass {
     b_(ptr->b_)
   { concrete_type(COLOR); }
 
+  bool Color_RGBA::operator< (const Expression& rhs) const
+  {
+    if (auto r = Cast<Color_RGBA>(&rhs)) {
+      if (r_ < r->r()) return true;
+      if (r_ > r->r()) return false;
+      if (g_ < r->g()) return true;
+      if (g_ > r->g()) return false;
+      if (b_ < r->b()) return true;
+      if (b_ > r->b()) return false;
+      if (a_ < r->a()) return true;
+      if (a_ > r->a()) return false;
+      return false; // is equal
+    }
+    // compare/sort by type
+    return type() < rhs.type();
+  }
+
   bool Color_RGBA::operator== (const Expression& rhs) const
   {
     if (auto r = Cast<Color_RGBA>(&rhs)) {
@@ -545,7 +638,7 @@ namespace Sass {
   size_t Color_RGBA::hash() const
   {
     if (hash_ == 0) {
-      hash_ = std::hash<std::string>()("RGBA");
+      hash_ = std::hash<sass::string>()("RGBA");
       hash_combine(hash_, std::hash<double>()(a_));
       hash_combine(hash_, std::hash<double>()(r_));
       hash_combine(hash_, std::hash<double>()(g_));
@@ -600,7 +693,7 @@ namespace Sass {
   /////////////////////////////////////////////////////////////////////////
   /////////////////////////////////////////////////////////////////////////
 
-  Color_HSLA::Color_HSLA(ParserState pstate, double h, double s, double l, double a, const std::string disp)
+  Color_HSLA::Color_HSLA(SourceSpan pstate, double h, double s, double l, double a, const sass::string disp)
   : Color(pstate, a, disp),
     h_(absmod(h, 360.0)),
     s_(clip(s, 0.0, 100.0)),
@@ -616,6 +709,23 @@ namespace Sass {
     // hash_(ptr->hash_)
   { concrete_type(COLOR); }
 
+  bool Color_HSLA::operator< (const Expression& rhs) const
+  {
+    if (auto r = Cast<Color_HSLA>(&rhs)) {
+      if (h_ < r->h()) return true;
+      if (h_ > r->h()) return false;
+      if (s_ < r->s()) return true;
+      if (s_ > r->s()) return false;
+      if (l_ < r->l()) return true;
+      if (l_ > r->l()) return false;
+      if (a_ < r->a()) return true;
+      if (a_ > r->a()) return false;
+      return false; // is equal
+    }
+    // compare/sort by type
+    return type() < rhs.type();
+  }
+
   bool Color_HSLA::operator== (const Expression& rhs) const
   {
     if (auto r = Cast<Color_HSLA>(&rhs)) {
@@ -630,7 +740,7 @@ namespace Sass {
   size_t Color_HSLA::hash() const
   {
     if (hash_ == 0) {
-      hash_ = std::hash<std::string>()("HSLA");
+      hash_ = std::hash<sass::string>()("HSLA");
       hash_combine(hash_, std::hash<double>()(a_));
       hash_combine(hash_, std::hash<double>()(h_));
       hash_combine(hash_, std::hash<double>()(s_));
@@ -679,7 +789,7 @@ namespace Sass {
   /////////////////////////////////////////////////////////////////////////
   /////////////////////////////////////////////////////////////////////////
 
-  Custom_Error::Custom_Error(ParserState pstate, std::string msg)
+  Custom_Error::Custom_Error(SourceSpan pstate, sass::string msg)
   : Value(pstate), message_(msg)
   { concrete_type(C_ERROR); }
 
@@ -687,6 +797,15 @@ namespace Sass {
   : Value(ptr), message_(ptr->message_)
   { concrete_type(C_ERROR); }
 
+  bool Custom_Error::operator< (const Expression& rhs) const
+  {
+    if (auto r = Cast<Custom_Error>(&rhs)) {
+      return message() < r->message();
+    }
+    // compare/sort by type
+    return type() < rhs.type();
+  }
+
   bool Custom_Error::operator== (const Expression& rhs) const
   {
     if (auto r = Cast<Custom_Error>(&rhs)) {
@@ -698,7 +817,7 @@ namespace Sass {
   /////////////////////////////////////////////////////////////////////////
   /////////////////////////////////////////////////////////////////////////
 
-  Custom_Warning::Custom_Warning(ParserState pstate, std::string msg)
+  Custom_Warning::Custom_Warning(SourceSpan pstate, sass::string msg)
   : Value(pstate), message_(msg)
   { concrete_type(C_WARNING); }
 
@@ -706,6 +825,15 @@ namespace Sass {
   : Value(ptr), message_(ptr->message_)
   { concrete_type(C_WARNING); }
 
+  bool Custom_Warning::operator< (const Expression& rhs) const
+  {
+    if (auto r = Cast<Custom_Warning>(&rhs)) {
+      return message() < r->message();
+    }
+    // compare/sort by type
+    return type() < rhs.type();
+  }
+
   bool Custom_Warning::operator== (const Expression& rhs) const
   {
     if (auto r = Cast<Custom_Warning>(&rhs)) {
@@ -717,7 +845,7 @@ namespace Sass {
   /////////////////////////////////////////////////////////////////////////
   /////////////////////////////////////////////////////////////////////////
 
-  Boolean::Boolean(ParserState pstate, bool val)
+  Boolean::Boolean(SourceSpan pstate, bool val)
   : Value(pstate), value_(val),
     hash_(0)
   { concrete_type(BOOLEAN); }
@@ -728,15 +856,23 @@ namespace Sass {
     hash_(ptr->hash_)
   { concrete_type(BOOLEAN); }
 
- bool Boolean::operator== (const Expression& rhs) const
+ bool Boolean::operator< (const Expression& rhs) const
   {
     if (auto r = Cast<Boolean>(&rhs)) {
-      return (value() == r->value());
+      return (value() < r->value());
     }
     return false;
   }
 
-  size_t Boolean::hash() const
+ bool Boolean::operator== (const Expression& rhs) const
+ {
+   if (auto r = Cast<Boolean>(&rhs)) {
+     return (value() == r->value());
+   }
+   return false;
+ }
+
+ size_t Boolean::hash() const
   {
     if (hash_ == 0) {
       hash_ = std::hash<bool>()(value_);
@@ -747,7 +883,7 @@ namespace Sass {
   /////////////////////////////////////////////////////////////////////////
   /////////////////////////////////////////////////////////////////////////
 
-  String::String(ParserState pstate, bool delayed)
+  String::String(SourceSpan pstate, bool delayed)
   : Value(pstate, delayed)
   { concrete_type(STRING); }
   String::String(const String* ptr)
@@ -757,13 +893,13 @@ namespace Sass {
   /////////////////////////////////////////////////////////////////////////
   /////////////////////////////////////////////////////////////////////////
 
-  String_Schema::String_Schema(ParserState pstate, size_t size, bool css)
-  : String(pstate), Vectorized<PreValue_Obj>(size), css_(css), hash_(0)
+  String_Schema::String_Schema(SourceSpan pstate, size_t size, bool css)
+  : String(pstate), Vectorized<PreValueObj>(size), css_(css), hash_(0)
   { concrete_type(STRING); }
 
   String_Schema::String_Schema(const String_Schema* ptr)
   : String(ptr),
-    Vectorized<PreValue_Obj>(*ptr),
+    Vectorized<PreValueObj>(*ptr),
     css_(ptr->css_),
     hash_(ptr->hash_)
   { concrete_type(STRING); }
@@ -784,6 +920,23 @@ namespace Sass {
     return length() && last()->is_right_interpolant();
   }
 
+  bool String_Schema::operator< (const Expression& rhs) const
+  {
+    if (auto r = Cast<String_Schema>(&rhs)) {
+      if (length() < r->length()) return true;
+      if (length() > r->length()) return false;
+      for (size_t i = 0, L = length(); i < L; ++i) {
+        if (*get(i) < *r->get(i)) return true;
+        if (*get(i) == *r->get(i)) continue;
+        return false;
+      }
+      // Is equal
+      return false;
+    }
+    // compare/sort by type
+    return type() < rhs.type();
+  }
+
   bool String_Schema::operator== (const Expression& rhs) const
   {
     if (auto r = Cast<String_Schema>(&rhs)) {
@@ -823,23 +976,22 @@ namespace Sass {
   /////////////////////////////////////////////////////////////////////////
   /////////////////////////////////////////////////////////////////////////
 
-  String_Constant::String_Constant(ParserState pstate, std::string val, bool css)
-  : String(pstate), quote_mark_(0), can_compress_whitespace_(false), value_(read_css_string(val, css)), hash_(0)
+  String_Constant::String_Constant(SourceSpan pstate, sass::string val, bool css)
+  : String(pstate), quote_mark_(0), value_(read_css_string(val, css)), hash_(0)
   { }
-  String_Constant::String_Constant(ParserState pstate, const char* beg, bool css)
-  : String(pstate), quote_mark_(0), can_compress_whitespace_(false), value_(read_css_string(std::string(beg), css)), hash_(0)
+  String_Constant::String_Constant(SourceSpan pstate, const char* beg, bool css)
+  : String(pstate), quote_mark_(0), value_(read_css_string(sass::string(beg), css)), hash_(0)
   { }
-  String_Constant::String_Constant(ParserState pstate, const char* beg, const char* end, bool css)
-  : String(pstate), quote_mark_(0), can_compress_whitespace_(false), value_(read_css_string(std::string(beg, end-beg), css)), hash_(0)
+  String_Constant::String_Constant(SourceSpan pstate, const char* beg, const char* end, bool css)
+  : String(pstate), quote_mark_(0), value_(read_css_string(sass::string(beg, end-beg), css)), hash_(0)
   { }
-  String_Constant::String_Constant(ParserState pstate, const Token& tok, bool css)
-  : String(pstate), quote_mark_(0), can_compress_whitespace_(false), value_(read_css_string(std::string(tok.begin, tok.end), css)), hash_(0)
+  String_Constant::String_Constant(SourceSpan pstate, const Token& tok, bool css)
+  : String(pstate), quote_mark_(0), value_(read_css_string(sass::string(tok.begin, tok.end), css)), hash_(0)
   { }
 
   String_Constant::String_Constant(const String_Constant* ptr)
   : String(ptr),
     quote_mark_(ptr->quote_mark_),
-    can_compress_whitespace_(ptr->can_compress_whitespace_),
     value_(ptr->value_),
     hash_(ptr->hash_)
   { }
@@ -848,17 +1000,30 @@ namespace Sass {
     return value_.empty() && quote_mark_ == 0;
   }
 
+  bool String_Constant::operator< (const Expression& rhs) const
+  {
+    if (auto qstr = Cast<String_Quoted>(&rhs)) {
+      return value() < qstr->value();
+    }
+    else if (auto cstr = Cast<String_Constant>(&rhs)) {
+      return value() < cstr->value();
+    }
+    // compare/sort by type
+    return type() < rhs.type();
+  }
+
   bool String_Constant::operator== (const Expression& rhs) const
   {
     if (auto qstr = Cast<String_Quoted>(&rhs)) {
       return value() == qstr->value();
-    } else if (auto cstr = Cast<String_Constant>(&rhs)) {
+    }
+    else if (auto cstr = Cast<String_Constant>(&rhs)) {
       return value() == cstr->value();
     }
     return false;
   }
 
-  std::string String_Constant::inspect() const
+  sass::string String_Constant::inspect() const
   {
     return quote(value_, '*');
   }
@@ -871,7 +1036,7 @@ namespace Sass {
   size_t String_Constant::hash() const
   {
     if (hash_ == 0) {
-      hash_ = std::hash<std::string>()(value_);
+      hash_ = std::hash<sass::string>()(value_);
     }
     return hash_;
   }
@@ -879,7 +1044,7 @@ namespace Sass {
   /////////////////////////////////////////////////////////////////////////
   /////////////////////////////////////////////////////////////////////////
 
-  String_Quoted::String_Quoted(ParserState pstate, std::string val, char q,
+  String_Quoted::String_Quoted(SourceSpan pstate, sass::string val, char q,
     bool keep_utf8_escapes, bool skip_unquoting,
     bool strict_unquoting, bool css)
   : String_Constant(pstate, val, css)
@@ -894,17 +1059,30 @@ namespace Sass {
   : String_Constant(ptr)
   { }
 
+  bool String_Quoted::operator< (const Expression& rhs) const
+  {
+    if (auto qstr = Cast<String_Quoted>(&rhs)) {
+      return value() < qstr->value();
+    }
+    else if (auto cstr = Cast<String_Constant>(&rhs)) {
+      return value() < cstr->value();
+    }
+    // compare/sort by type
+    return type() < rhs.type();
+  }
+
   bool String_Quoted::operator== (const Expression& rhs) const
   {
     if (auto qstr = Cast<String_Quoted>(&rhs)) {
       return value() == qstr->value();
-    } else if (auto cstr = Cast<String_Constant>(&rhs)) {
+    }
+    else if (auto cstr = Cast<String_Constant>(&rhs)) {
       return value() == cstr->value();
     }
     return false;
   }
 
-  std::string String_Quoted::inspect() const
+  sass::string String_Quoted::inspect() const
   {
     return quote(value_, '*');
   }
@@ -912,16 +1090,25 @@ namespace Sass {
   /////////////////////////////////////////////////////////////////////////
   /////////////////////////////////////////////////////////////////////////
 
-  Null::Null(ParserState pstate)
+  Null::Null(SourceSpan pstate)
   : Value(pstate)
   { concrete_type(NULL_VAL); }
 
   Null::Null(const Null* ptr) : Value(ptr)
   { concrete_type(NULL_VAL); }
 
+  bool Null::operator< (const Expression& rhs) const
+  {
+    if (Cast<Null>(&rhs)) {
+      return false;
+    }
+    // compare/sort by type
+    return type() < rhs.type();
+  }
+
   bool Null::operator== (const Expression& rhs) const
   {
-    return Cast<Null>(&rhs) != NULL;
+    return Cast<Null>(&rhs) != nullptr;
   }
 
   size_t Null::hash() const
@@ -932,7 +1119,7 @@ namespace Sass {
   /////////////////////////////////////////////////////////////////////////
   /////////////////////////////////////////////////////////////////////////
 
-  Parent_Reference::Parent_Reference(ParserState pstate)
+  Parent_Reference::Parent_Reference(SourceSpan pstate)
   : Value(pstate)
   { concrete_type(PARENT); }