sassc 2.2.1 → 2.3.0

data/ext/libsass/src/ast_supports.cpp

@@ -1,24 +1,8 @@
 // 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 {
 

data/ext/libsass/src/ast_values.cpp

@@ -1,24 +1,7 @@
 // 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 {
 
@@ -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)) {
@@ -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)) {
@@ -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)) {
@@ -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)) {
@@ -436,6 +489,14 @@ namespace Sass {
     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) {
@@ -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)) {
@@ -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)) {
@@ -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)) {
@@ -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)) {
@@ -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)) {
@@ -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_);
@@ -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)) {
@@ -824,22 +977,21 @@ 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(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(pstate), quote_mark_(0), value_(read_css_string(std::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(pstate), quote_mark_(0), value_(read_css_string(std::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(pstate), quote_mark_(0), value_(read_css_string(std::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,11 +1000,24 @@ 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;
@@ -894,11 +1059,24 @@ 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;
@@ -919,9 +1097,18 @@ namespace Sass {
   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

data/ext/libsass/src/ast_values.hpp

@@ -4,35 +4,7 @@
 // sass.hpp must go before all system headers to get the
 // __EXTENSIONS__ fix on Solaris.
 #include "sass.hpp"
-
-#include <set>
-#include <deque>
-#include <vector>
-#include <string>
-#include <sstream>
-#include <iostream>
-#include <typeinfo>
-#include <algorithm>
-#include "sass/base.h"
-#include "ast_fwd_decl.hpp"
-
-#include "util.hpp"
-#include "units.hpp"
-#include "context.hpp"
-#include "position.hpp"
-#include "constants.hpp"
-#include "operation.hpp"
-#include "position.hpp"
-#include "inspect.hpp"
-#include "source_map.hpp"
-#include "environment.hpp"
-#include "error_handling.hpp"
-#include "ast_def_macros.hpp"
-#include "ast_fwd_decl.hpp"
-#include "source_map.hpp"
-#include "fn_utils.hpp"
-
-#include "sass.h"
+#include "ast.hpp"
 
 namespace Sass {
 
@@ -52,8 +24,23 @@ namespace Sass {
   class Value : public PreValue {
   public:
     Value(ParserState pstate, bool d = false, bool e = false, bool i = false, Type ct = NONE);
-    ATTACH_VIRTUAL_AST_OPERATIONS(Value);
+
+    // Some obects are not meant to be compared
+    // ToDo: maybe fallback to pointer comparison?
+    virtual bool operator< (const Expression& rhs) const override = 0;
     virtual bool operator== (const Expression& rhs) const override = 0;
+
+    // We can give some reasonable implementations by using
+    // inverst operators on the specialized implementations
+    virtual bool operator> (const Expression& rhs) const {
+      return rhs < *this;
+    }
+    virtual bool operator!= (const Expression& rhs) const {
+      return !(*this == rhs);
+    }
+
+    ATTACH_VIRTUAL_AST_OPERATIONS(Value);
+
   };
 
   ///////////////////////////////////////////////////////////////////////
@@ -81,6 +68,8 @@ namespace Sass {
     virtual size_t hash() const override;
     virtual size_t size() const;
     virtual void set_delayed(bool delayed) override;
+
+    virtual bool operator< (const Expression& rhs) const override;
     virtual bool operator== (const Expression& rhs) const override;
 
     ATTACH_AST_OPERATIONS(List)
@@ -90,7 +79,7 @@ namespace Sass {
   ///////////////////////////////////////////////////////////////////////
   // Key value paris.
   ///////////////////////////////////////////////////////////////////////
-  class Map : public Value, public Hashed {
+  class Map : public Value, public Hashed<Expression_Obj, Expression_Obj, Map_Obj> {
     void adjust_after_pushing(std::pair<Expression_Obj, Expression_Obj> p) override { is_expanded(false); }
   public:
     Map(ParserState pstate, size_t size = 0);
@@ -100,6 +89,8 @@ namespace Sass {
     List_Obj to_list(ParserState& pstate);
 
     virtual size_t hash() const override;
+
+    virtual bool operator< (const Expression& rhs) const override;
     virtual bool operator== (const Expression& rhs) const override;
 
     ATTACH_AST_OPERATIONS(Map)
@@ -130,6 +121,7 @@ namespace Sass {
 
     virtual void set_delayed(bool delayed) override;
 
+    virtual bool operator< (const Expression& rhs) const override;
     virtual bool operator==(const Expression& rhs) const override;
 
     virtual size_t hash() const override;
@@ -154,6 +146,7 @@ namespace Sass {
 
     std::string name();
 
+    bool operator< (const Expression& rhs) const override;
     bool operator== (const Expression& rhs) const override;
 
     ATTACH_AST_OPERATIONS(Function)
@@ -230,6 +223,7 @@ namespace Sass {
 
     bool operator< (const Number& rhs) const;
     bool operator== (const Number& rhs) const;
+    bool operator< (const Expression& rhs) const override;
     bool operator== (const Expression& rhs) const override;
     ATTACH_AST_OPERATIONS(Number)
     ATTACH_CRTP_PERFORM_METHODS()
@@ -251,6 +245,7 @@ namespace Sass {
 
     virtual size_t hash() const override = 0;
 
+    bool operator< (const Expression& rhs) const override;
     bool operator== (const Expression& rhs) const override;
 
     virtual Color_RGBA* copyAsRGBA() const = 0;
@@ -283,6 +278,7 @@ namespace Sass {
     Color_HSLA* copyAsHSLA() const override;
     Color_HSLA* toHSLA() override { return copyAsHSLA(); }
 
+    bool operator< (const Expression& rhs) const override;
     bool operator== (const Expression& rhs) const override;
 
     ATTACH_AST_OPERATIONS(Color_RGBA)
@@ -311,6 +307,7 @@ namespace Sass {
     Color_HSLA* copyAsHSLA() const override;
     Color_HSLA* toHSLA() override { return this; }
 
+    bool operator< (const Expression& rhs) const override;
     bool operator== (const Expression& rhs) const override;
 
     ATTACH_AST_OPERATIONS(Color_HSLA)
@@ -324,6 +321,7 @@ namespace Sass {
     ADD_CONSTREF(std::string, message)
   public:
     Custom_Error(ParserState pstate, std::string msg);
+    bool operator< (const Expression& rhs) const override;
     bool operator== (const Expression& rhs) const override;
     ATTACH_AST_OPERATIONS(Custom_Error)
     ATTACH_CRTP_PERFORM_METHODS()
@@ -336,6 +334,7 @@ namespace Sass {
     ADD_CONSTREF(std::string, message)
   public:
     Custom_Warning(ParserState pstate, std::string msg);
+    bool operator< (const Expression& rhs) const override;
     bool operator== (const Expression& rhs) const override;
     ATTACH_AST_OPERATIONS(Custom_Warning)
     ATTACH_CRTP_PERFORM_METHODS()
@@ -358,6 +357,7 @@ namespace Sass {
 
     bool is_false() override { return !value_; }
 
+    bool operator< (const Expression& rhs) const override;
     bool operator== (const Expression& rhs) const override;
 
     ATTACH_AST_OPERATIONS(Boolean)
@@ -377,6 +377,9 @@ namespace Sass {
     virtual bool operator<(const Expression& rhs) const override {
       return this->to_string() < rhs.to_string();
     };
+    virtual bool operator==(const Expression& rhs) const override {
+      return this->to_string() == rhs.to_string();
+    };
     ATTACH_VIRTUAL_AST_OPERATIONS(String);
     ATTACH_CRTP_PERFORM_METHODS()
   };
@@ -403,6 +406,7 @@ namespace Sass {
     size_t hash() const override;
     virtual void set_delayed(bool delayed) override;
 
+    bool operator< (const Expression& rhs) const override;
     bool operator==(const Expression& rhs) const override;
     ATTACH_AST_OPERATIONS(String_Schema)
     ATTACH_CRTP_PERFORM_METHODS()
@@ -413,7 +417,6 @@ namespace Sass {
   ////////////////////////////////////////////////////////
   class String_Constant : public String {
     ADD_PROPERTY(char, quote_mark)
-    ADD_PROPERTY(bool, can_compress_whitespace)
     HASH_CONSTREF(std::string, value)
   protected:
     mutable size_t hash_;
@@ -427,6 +430,7 @@ namespace Sass {
     bool is_invisible() const override;
     virtual void rtrim() override;
     size_t hash() const override;
+    bool operator< (const Expression& rhs) const override;
     bool operator==(const Expression& rhs) const override;
     // quotes are forced on inspection
     virtual std::string inspect() const override;
@@ -442,6 +446,7 @@ namespace Sass {
     String_Quoted(ParserState pstate, std::string val, char q = 0,
       bool keep_utf8_escapes = false, bool skip_unquoting = false,
       bool strict_unquoting = true, bool css = true);
+    bool operator< (const Expression& rhs) const override;
     bool operator==(const Expression& rhs) const override;
     // quotes are forced on inspection
     std::string inspect() const override;
@@ -463,6 +468,7 @@ namespace Sass {
 
     size_t hash() const override;
 
+    bool operator< (const Expression& rhs) const override;
     bool operator== (const Expression& rhs) const override;
 
     ATTACH_AST_OPERATIONS(Null)
@@ -477,8 +483,11 @@ namespace Sass {
     Parent_Reference(ParserState pstate);
     std::string type() const override { return "parent"; }
     static std::string type_name() { return "parent"; }
+    bool operator< (const Expression& rhs) const override {
+      return false; // they are always equal
+    }
     bool operator==(const Expression& rhs) const override {
-      return true; // can they ever be not equal?
+      return true; // they are always equal
     };
     ATTACH_AST_OPERATIONS(Parent_Reference)
     ATTACH_CRTP_PERFORM_METHODS()