sassc 1.11.1 → 1.11.2

data/ext/libsass/src/sass_context.hpp

@@ -124,7 +124,7 @@ struct Sass_Compiler {
   // Sass::Context
   Sass::Context* cpp_ctx;
   // Sass::Block
-  Sass::Block* root;
+  Sass::Block_Obj root;
 };
 
 #endif

data/ext/libsass/src/sass_util.hpp

@@ -40,7 +40,7 @@ namespace Sass {
     bool operator()(const Node& one, const Node& two, Node& out) const {
       // TODO: Is this the correct C++ interpretation?
       // block ||= proc {|a, b| a == b && a}
-      if (one == two) {
+      if (nodesEqual(one, two, true)) {
         out = one;
         return true;
       }
@@ -228,21 +228,21 @@ namespace Sass {
 
       KeyType key = keyFunc(e);
 
-      if (grouped.find(key.hash()) == grouped.end()) {
+      if (grouped.find(key->hash()) == grouped.end()) {
         order.insert(std::make_pair((unsigned int)order.size(), key));
 
         std::vector<EnumType> newCollection;
         newCollection.push_back(e);
-        grouped.insert(std::make_pair(key.hash(), newCollection));
+        grouped.insert(std::make_pair(key->hash(), newCollection));
       } else {
-        std::vector<EnumType>& collection = grouped.at(key.hash());
+        std::vector<EnumType>& collection = grouped.at(key->hash());
         collection.push_back(e);
       }
     }
 
     for (unsigned int index = 0; index < order.size(); index++) {
       KeyType& key = order.at(index);
-      std::vector<EnumType>& values = grouped.at(key.hash());
+      std::vector<EnumType>& values = grouped.at(key->hash());
 
       std::pair<KeyType, std::vector<EnumType> > grouping = std::make_pair(key, values);
 

data/ext/libsass/src/sass_values.cpp

@@ -275,8 +275,7 @@ 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);
+    Value_Obj val = sass_value_to_ast_node(v);
     Sass_Inspect_Options options(compressed ? COMPRESSED : NESTED, precision);
     std::string str(val->to_string(options));
     return sass_make_qstring(str.c_str());
@@ -285,50 +284,51 @@ extern "C" {
   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;
+    Sass::Value_Ptr rv = 0;
 
     try {
 
-      Value* lhs = sass_value_to_ast_node(mem, a);
-      Value* rhs = sass_value_to_ast_node(mem, b);
+      Value_Obj lhs = sass_value_to_ast_node(a);
+      Value_Obj rhs = sass_value_to_ast_node(b);
       struct Sass_Inspect_Options options(NESTED, 5);
 
       // 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, "gt") && !Eval::eq(lhs, rhs));
-        case Sass_OP::GTE: return sass_make_boolean(!Eval::lt(lhs, rhs, "gte"));
-        case Sass_OP::LT:  return sass_make_boolean(Eval::lt(lhs, rhs, "lt"));
-        case Sass_OP::LTE: return sass_make_boolean(Eval::lt(lhs, rhs, "lte") || Eval::eq(lhs, rhs));
+        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, "gt") && !Eval::eq(&lhs, &rhs));
+        case Sass_OP::GTE: return sass_make_boolean(!Eval::lt(&lhs, &rhs, "gte"));
+        case Sass_OP::LT:  return sass_make_boolean(Eval::lt(&lhs, &rhs, "lt"));
+        case Sass_OP::LTE: return sass_make_boolean(Eval::lt(&lhs, &rhs, "lte") || Eval::eq(&lhs, &rhs));
+        case Sass_OP::AND: return ast_node_to_sass_value(lhs->is_false() ? &lhs : &rhs);
+        case Sass_OP::OR:  return ast_node_to_sass_value(lhs->is_false() ? &rhs : &lhs);
         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, options);
+        Number_Ptr_Const l_n = SASS_MEMORY_CAST(Number, lhs);
+        Number_Ptr_Const r_n = SASS_MEMORY_CAST(Number, rhs);
+        rv = Eval::op_numbers(op, *l_n, *r_n, options);
       }
       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, options);
+        Number_Ptr_Const l_n = SASS_MEMORY_CAST(Number, lhs);
+        Color_Ptr_Const r_c = SASS_MEMORY_CAST(Color, rhs);
+        rv = Eval::op_number_color(op, *l_n, *r_c, options);
       }
       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, options);
+        Color_Ptr_Const l_c = SASS_MEMORY_CAST(Color, lhs);
+        Number_Ptr_Const r_n = SASS_MEMORY_CAST(Number, rhs);
+        rv = Eval::op_color_number(op, *l_c, *r_n, options);
       }
       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, options);
+        Color_Ptr_Const l_c = SASS_MEMORY_CAST(Color, lhs);
+        Color_Ptr_Const r_c = SASS_MEMORY_CAST(Color, rhs);
+        rv = Eval::op_colors(op, *l_c, *r_c, options);
       }
       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, options);
+        Value_Ptr l_v = SASS_MEMORY_CAST(Value, lhs);
+        Value_Ptr r_v = SASS_MEMORY_CAST(Value, rhs);
+        rv = Eval::op_strings(op, *l_v, *r_v, options);
       }
 
       // ToDo: maybe we should should return null value?

data/ext/libsass/src/source_map.cpp

@@ -172,12 +172,12 @@ namespace Sass {
     current_position += offset;
   }
 
-  void SourceMap::add_open_mapping(const AST_Node* node)
+  void SourceMap::add_open_mapping(const AST_Node_Ptr node)
   {
     mappings.push_back(Mapping(node->pstate(), current_position));
   }
 
-  void SourceMap::add_close_mapping(const AST_Node* node)
+  void SourceMap::add_close_mapping(const AST_Node_Ptr node)
   {
     mappings.push_back(Mapping(node->pstate() + node->pstate().offset, current_position));
   }

data/ext/libsass/src/source_map.hpp

@@ -28,8 +28,8 @@ namespace Sass {
     void prepend(const Offset& offset);
     void append(const OutputBuffer& out);
     void prepend(const OutputBuffer& out);
-    void add_open_mapping(const AST_Node* node);
-    void add_close_mapping(const AST_Node* node);
+    void add_open_mapping(const AST_Node_Ptr node);
+    void add_close_mapping(const AST_Node_Ptr node);
 
     std::string render_srcmap(Context &ctx);
     ParserState remap(const ParserState& pstate);

data/ext/libsass/src/subset_map.cpp

@@ -0,0 +1,57 @@
+#include "sass.hpp"
+#include "ast.hpp"
+#include "subset_map.hpp"
+
+namespace Sass {
+
+  void Subset_Map::put(const Compound_Selector_Obj& sel, const Subset_Map_Val& value)
+  {
+    if (sel->empty()) throw std::runtime_error("internal error: subset map keys may not be empty");
+    size_t index = values_.size();
+    values_.push_back(value);
+    for (size_t i = 0, S = sel->length(); i < S; ++i)
+    {
+      hash_[(*sel)[i]].push_back(std::make_pair(&sel, index));
+    }
+  }
+
+  std::vector<Subset_Map_Val> Subset_Map::get_kv(const Compound_Selector_Obj& sel)
+  {
+    // std::vector<Subset_Map_Key> s = sel->to_str_vec();
+    // std::set<std::string> dict(s.begin(), s.end());
+    std::unordered_set<Simple_Selector_Obj, HashSimpleSelector, CompareSimpleSelector> dict(sel->begin(), sel->end());
+    std::vector<size_t> indices;
+    for (size_t i = 0, S = sel->length(); i < S; ++i) {
+      if (!hash_.count((*sel)[i])) {
+        continue;
+      }
+      const std::vector<std::pair<Compound_Selector_Obj, size_t> >& subsets = hash_[(*sel)[i]];
+      for (const std::pair<Compound_Selector_Obj, size_t>& item : subsets) {
+        bool include = true;
+        for (const Simple_Selector_Obj& it : item.first->elements()) {
+          auto found = dict.find(it);
+          if (found == dict.end()) {
+            include = false;
+            break;
+          }
+        }
+        if (include) indices.push_back(item.second);
+      }
+    }
+    sort(indices.begin(), indices.end());
+    std::vector<size_t>::iterator indices_end = unique(indices.begin(), indices.end());
+    indices.resize(distance(indices.begin(), indices_end));
+
+    std::vector<Subset_Map_Val> results;
+    for (size_t i = 0, S = indices.size(); i < S; ++i) {
+      results.push_back(values_[indices[i]]);
+    }
+    return results;
+  }
+
+  std::vector<Subset_Map_Val> Subset_Map::get_v(const Compound_Selector_Obj& sel)
+  {
+    return get_kv(sel);
+  }
+
+}

data/ext/libsass/src/subset_map.hpp

@@ -7,6 +7,8 @@
 #include <algorithm>
 #include <iterator>
 
+#include "ast_fwd_decl.hpp"
+
 
 // #include <iostream>
 // #include <sstream>
@@ -56,89 +58,19 @@
 
 namespace Sass {
 
-  template<typename F, typename S, typename T>
-  struct triple {
-    F first;
-    S second;
-    T third;
-
-    triple(const F& f, const S& s, const T& t) : first(f), second(s), third(t) { }
-  };
-
-  template<typename F, typename S, typename T>
-  triple<F, S, T> make_triple(const F& f, const S& s, const T& t)
-  { return triple<F, S, T>(f, s, t); }
-
-  template<typename K, typename V>
   class Subset_Map {
   private:
-    std::vector<V> values_;
-    std::map<K, std::vector<triple<std::vector<K>, std::set<K>, size_t> > > hash_;
+    std::vector<Subset_Map_Val> values_;
+    std::map<Simple_Selector_Obj, std::vector<std::pair<Compound_Selector_Obj, size_t> > > hash_;
   public:
-    void put(const std::vector<K>& s, const V& value);
-    std::vector<std::pair<V, std::vector<K> > > get_kv(const std::vector<K>& s);
-    std::vector<V> get_v(const std::vector<K>& s);
+    void put(const Compound_Selector_Obj& sel, const Subset_Map_Val& value);
+    std::vector<Subset_Map_Val> get_kv(const Compound_Selector_Obj& s);
+    std::vector<Subset_Map_Val> get_v(const Compound_Selector_Obj& s);
     bool empty() { return values_.empty(); }
     void clear() { values_.clear(); hash_.clear(); }
-    const std::vector<V> values(void) { return values_; }
+    const std::vector<Subset_Map_Val> values(void) { return values_; }
   };
 
-  template<typename K, typename V>
-  void Subset_Map<K, V>::put(const std::vector<K>& s, const V& value)
-  {
-    if (s.empty()) throw "internal error: subset map keys may not be empty";
-    size_t index = values_.size();
-    values_.push_back(value);
-    std::set<K> ss;
-    for (size_t i = 0, S = s.size(); i < S; ++i)
-    { ss.insert(s[i]); }
-    for (size_t i = 0, S = s.size(); i < S; ++i)
-    {
-      hash_[s[i]].push_back(make_triple(s, ss, index));
-    }
-  }
-
-  template<typename K, typename V>
-  std::vector<std::pair<V, std::vector<K> > > Subset_Map<K, V>::get_kv(const std::vector<K>& s)
-  {
-    std::vector<K> sorted = s;
-    sort(sorted.begin(), sorted.end());
-    std::vector<std::pair<size_t, std::vector<K> > > indices;
-    for (size_t i = 0, S = s.size(); i < S; ++i) {
-      if (!hash_.count(s[i])) {
-        continue;
-      }
-      std::vector<triple<std::vector<K>, std::set<K>, size_t> > subsets = hash_[s[i]];
-      // std::cerr << "length of subsets: " << subsets.size() << std::endl;
-      for (size_t j = 0, T = subsets.size(); j < T; ++j) {
-        if (!includes(sorted.begin(), sorted.end(), subsets[j].second.begin(), subsets[j].second.end())) {
-          // std::cout << vector_to_string(s) << " doesn't include " << set_to_string(subsets[j].second) << std::endl;
-          continue;
-        }
-        indices.push_back(std::make_pair(subsets[j].third, subsets[j].first));
-        // std::cerr << "pushed " << subsets[j].third << " and " << vector_to_string(subsets[j].first) << " onto indices" << std::endl;
-      }
-    }
-    sort(indices.begin(), indices.end());
-    typename std::vector<std::pair<size_t, std::vector<K> > >::iterator indices_end = unique(indices.begin(), indices.end());
-    indices.resize(distance(indices.begin(), indices_end));
-
-    std::vector<std::pair<V, std::vector<K> > > results;
-    for (size_t i = 0, S = indices.size(); i < S; ++i) {
-      results.push_back(std::make_pair(values_[indices[i].first], indices[i].second));
-    }
-    return results;
-  }
-
-  template<typename K, typename V>
-  std::vector<V> Subset_Map<K, V>::get_v(const std::vector<K>& s)
-  {
-    std::vector<std::pair<V, std::vector<K> > > kvs = get_kv(s);
-    std::vector<V> results;
-    for (size_t i = 0, S = kvs.size(); i < S; ++i) results.push_back(kvs[i].first);
-    return results;
-  }
-
 }
 
 #endif

data/ext/libsass/src/to_c.cpp

@@ -4,25 +4,25 @@
 
 namespace Sass {
 
-  union Sass_Value* To_C::fallback_impl(AST_Node* n)
+  union Sass_Value* To_C::fallback_impl(AST_Node_Ptr n)
   { return sass_make_error("unknown type for C-API"); }
 
-  union Sass_Value* To_C::operator()(Boolean* b)
+  union Sass_Value* To_C::operator()(Boolean_Ptr b)
   { return sass_make_boolean(b->value()); }
 
-  union Sass_Value* To_C::operator()(Number* n)
+  union Sass_Value* To_C::operator()(Number_Ptr n)
   { return sass_make_number(n->value(), n->unit().c_str()); }
 
-  union Sass_Value* To_C::operator()(Custom_Warning* w)
+  union Sass_Value* To_C::operator()(Custom_Warning_Ptr w)
   { return sass_make_warning(w->message().c_str()); }
 
-  union Sass_Value* To_C::operator()(Custom_Error* e)
+  union Sass_Value* To_C::operator()(Custom_Error_Ptr e)
   { return sass_make_error(e->message().c_str()); }
 
-  union Sass_Value* To_C::operator()(Color* c)
+  union Sass_Value* To_C::operator()(Color_Ptr c)
   { return sass_make_color(c->r(), c->g(), c->b(), c->a()); }
 
-  union Sass_Value* To_C::operator()(String_Constant* s)
+  union Sass_Value* To_C::operator()(String_Constant_Ptr s)
   {
     if (s->quote_mark()) {
       return sass_make_qstring(s->value().c_str());
@@ -31,10 +31,10 @@ namespace Sass {
     }
   }
 
-  union Sass_Value* To_C::operator()(String_Quoted* s)
+  union Sass_Value* To_C::operator()(String_Quoted_Ptr s)
   { return sass_make_qstring(s->value().c_str()); }
 
-  union Sass_Value* To_C::operator()(List* l)
+  union Sass_Value* To_C::operator()(List_Ptr l)
   {
     union Sass_Value* v = sass_make_list(l->length(), l->separator());
     for (size_t i = 0, L = l->length(); i < L; ++i) {
@@ -43,7 +43,7 @@ namespace Sass {
     return v;
   }
 
-  union Sass_Value* To_C::operator()(Map* m)
+  union Sass_Value* To_C::operator()(Map_Ptr m)
   {
     union Sass_Value* v = sass_make_map(m->length());
     int i = 0;
@@ -55,7 +55,7 @@ namespace Sass {
     return v;
   }
 
-  union Sass_Value* To_C::operator()(Arguments* a)
+  union Sass_Value* To_C::operator()(Arguments_Ptr a)
   {
     union Sass_Value* v = sass_make_list(a->length(), SASS_COMMA);
     for (size_t i = 0, L = a->length(); i < L; ++i) {
@@ -64,11 +64,11 @@ namespace Sass {
     return v;
   }
 
-  union Sass_Value* To_C::operator()(Argument* a)
+  union Sass_Value* To_C::operator()(Argument_Ptr a)
   { return a->value()->perform(this); }
 
   // not strictly necessary because of the fallback
-  union Sass_Value* To_C::operator()(Null* n)
+  union Sass_Value* To_C::operator()(Null_Ptr n)
   { return sass_make_null(); }
 
 };

data/ext/libsass/src/to_c.hpp

@@ -9,28 +9,28 @@ namespace Sass {
 
   class To_C : public Operation_CRTP<union Sass_Value*, To_C> {
     // override this to define a catch-all
-    union Sass_Value* fallback_impl(AST_Node* n);
+    union Sass_Value* fallback_impl(AST_Node_Ptr n);
 
   public:
 
     To_C() { }
     ~To_C() { }
 
-    union Sass_Value* operator()(Boolean*);
-    union Sass_Value* operator()(Number*);
-    union Sass_Value* operator()(Color*);
-    union Sass_Value* operator()(String_Constant*);
-    union Sass_Value* operator()(String_Quoted*);
-    union Sass_Value* operator()(Custom_Warning*);
-    union Sass_Value* operator()(Custom_Error*);
-    union Sass_Value* operator()(List*);
-    union Sass_Value* operator()(Map*);
-    union Sass_Value* operator()(Null*);
-    union Sass_Value* operator()(Arguments*);
-    union Sass_Value* operator()(Argument*);
+    union Sass_Value* operator()(Boolean_Ptr);
+    union Sass_Value* operator()(Number_Ptr);
+    union Sass_Value* operator()(Color_Ptr);
+    union Sass_Value* operator()(String_Constant_Ptr);
+    union Sass_Value* operator()(String_Quoted_Ptr);
+    union Sass_Value* operator()(Custom_Warning_Ptr);
+    union Sass_Value* operator()(Custom_Error_Ptr);
+    union Sass_Value* operator()(List_Ptr);
+    union Sass_Value* operator()(Map_Ptr);
+    union Sass_Value* operator()(Null_Ptr);
+    union Sass_Value* operator()(Arguments_Ptr);
+    union Sass_Value* operator()(Argument_Ptr);
 
     // dispatch to fallback implementation
-    union Sass_Value* fallback(AST_Node* x)
+    union Sass_Value* fallback(AST_Node_Ptr x)
     { return fallback_impl(x); }
   };
 

data/ext/libsass/src/to_value.cpp

@@ -4,7 +4,7 @@
 
 namespace Sass {
 
-  Value* To_Value::fallback_impl(AST_Node* n)
+  Value_Ptr To_Value::fallback_impl(AST_Node_Ptr n)
   {
     // throw a runtime error if this happens
     // we want a well defined set of possible nodes
@@ -14,92 +14,92 @@ namespace Sass {
   }
 
   // Custom_Error is a valid value
-  Value* To_Value::operator()(Custom_Error* e)
+  Value_Ptr To_Value::operator()(Custom_Error_Ptr e)
   {
     return e;
   }
 
   // Custom_Warning is a valid value
-  Value* To_Value::operator()(Custom_Warning* w)
+  Value_Ptr To_Value::operator()(Custom_Warning_Ptr w)
   {
     return w;
   }
 
   // Boolean is a valid value
-  Value* To_Value::operator()(Boolean* b)
+  Value_Ptr To_Value::operator()(Boolean_Ptr b)
   {
     return b;
   }
 
   // Number is a valid value
-  Value* To_Value::operator()(Number* n)
+  Value_Ptr To_Value::operator()(Number_Ptr n)
   {
     return n;
   }
 
   // Color is a valid value
-  Value* To_Value::operator()(Color* c)
+  Value_Ptr To_Value::operator()(Color_Ptr c)
   {
     return c;
   }
 
   // String_Constant is a valid value
-  Value* To_Value::operator()(String_Constant* s)
+  Value_Ptr To_Value::operator()(String_Constant_Ptr s)
   {
     return s;
   }
 
   // String_Quoted is a valid value
-  Value* To_Value::operator()(String_Quoted* s)
+  Value_Ptr To_Value::operator()(String_Quoted_Ptr s)
   {
     return s;
   }
 
   // List is a valid value
-  Value* To_Value::operator()(List* l)
+  Value_Ptr To_Value::operator()(List_Ptr l)
   {
-    List* ll = SASS_MEMORY_NEW(mem, List,
+    List_Obj ll = SASS_MEMORY_NEW(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);
+      ll->append((*l)[i]->perform(this));
     }
-    return ll;
+    return ll.detach();
   }
 
   // Map is a valid value
-  Value* To_Value::operator()(Map* m)
+  Value_Ptr To_Value::operator()(Map_Ptr m)
   {
     return m;
   }
 
   // Null is a valid value
-  Value* To_Value::operator()(Null* n)
+  Value_Ptr To_Value::operator()(Null_Ptr n)
   {
     return n;
   }
 
   // Argument returns its value
-  Value* To_Value::operator()(Argument* arg)
+  Value_Ptr To_Value::operator()(Argument_Ptr arg)
   {
     if (!arg->name().empty()) return 0;
     return arg->value()->perform(this);
   }
 
-  // CommaSequence_Selector is converted to a string
-  Value* To_Value::operator()(CommaSequence_Selector* s)
+  // Selector_List is converted to a string
+  Value_Ptr To_Value::operator()(Selector_List_Ptr s)
   {
-    return SASS_MEMORY_NEW(mem, String_Quoted,
+    return SASS_MEMORY_NEW(String_Quoted,
                            s->pstate(),
                            s->to_string(ctx.c_options));
   }
 
   // Binary_Expression is converted to a string
-  Value* To_Value::operator()(Binary_Expression* s)
+  Value_Ptr To_Value::operator()(Binary_Expression_Ptr s)
   {
-    return SASS_MEMORY_NEW(mem, String_Quoted,
+    return SASS_MEMORY_NEW(String_Quoted,
                            s->pstate(),
                            s->to_string(ctx.c_options));
   }