sassc 1.11.1 → 1.11.2

data/ext/libsass/src/to_value.hpp

@@ -7,42 +7,41 @@
 
 namespace Sass {
 
-  class To_Value : public Operation_CRTP<Value*, To_Value> {
+  class To_Value : public Operation_CRTP<Value_Ptr, To_Value> {
 
-    Value* fallback_impl(AST_Node* n);
+    Value_Ptr fallback_impl(AST_Node_Ptr n);
 
   private:
 
     Context& ctx;
-    Memory_Manager& mem;
 
   public:
 
-    To_Value(Context& ctx, Memory_Manager& mem)
-    : ctx(ctx), mem(mem)
+    To_Value(Context& ctx)
+    : ctx(ctx)
     { }
     ~To_Value() { }
-    using Operation<Value*>::operator();
-
-    Value* operator()(Argument*);
-    Value* operator()(Boolean*);
-    Value* operator()(Number*);
-    Value* operator()(Color*);
-    Value* operator()(String_Constant*);
-    Value* operator()(String_Quoted*);
-    Value* operator()(Custom_Warning*);
-    Value* operator()(Custom_Error*);
-    Value* operator()(List*);
-    Value* operator()(Map*);
-    Value* operator()(Null*);
+    using Operation<Value_Ptr>::operator();
+
+    Value_Ptr operator()(Argument_Ptr);
+    Value_Ptr operator()(Boolean_Ptr);
+    Value_Ptr operator()(Number_Ptr);
+    Value_Ptr operator()(Color_Ptr);
+    Value_Ptr operator()(String_Constant_Ptr);
+    Value_Ptr operator()(String_Quoted_Ptr);
+    Value_Ptr operator()(Custom_Warning_Ptr);
+    Value_Ptr operator()(Custom_Error_Ptr);
+    Value_Ptr operator()(List_Ptr);
+    Value_Ptr operator()(Map_Ptr);
+    Value_Ptr operator()(Null_Ptr);
 
     // convert to string via `To_String`
-    Value* operator()(CommaSequence_Selector*);
-    Value* operator()(Binary_Expression*);
+    Value_Ptr operator()(Selector_List_Ptr);
+    Value_Ptr operator()(Binary_Expression_Ptr);
 
     // fallback throws error
     template <typename U>
-    Value* fallback(U x) { return fallback_impl(x); }
+    Value_Ptr fallback(U x) { return fallback_impl(x); }
   };
 
 }

data/ext/libsass/src/util.cpp

@@ -438,30 +438,15 @@ namespace Sass {
       return normalized[0] == '.' ? normalized.insert(0, prefix) : normalized;
     }
 
-    // compress a color sixtuplet if possible
-    // input: "#CC9900" -> output: "#C90"
-    std::string normalize_sixtuplet(const std::string& col) {
-      if(
-        col.substr(1, 1) == col.substr(2, 1) &&
-        col.substr(3, 1) == col.substr(4, 1) &&
-        col.substr(5, 1) == col.substr(6, 1)
-      ) {
-        return std::string("#" + col.substr(1, 1)
-                          + col.substr(3, 1)
-                          + col.substr(5, 1));
-      } else {
-        return std::string(col);
-      }
-    }
-
-    bool isPrintable(Ruleset* r, Sass_Output_Style style) {
+    bool isPrintable(Ruleset_Ptr r, Sass_Output_Style style) {
       if (r == NULL) {
         return false;
       }
 
-      Block* b = r->block();
+      Block_Obj b = r->block();
 
-      bool hasSelectors = static_cast<CommaSequence_Selector*>(r->selector())->length() > 0;
+      Selector_List_Ptr sl = SASS_MEMORY_CAST(Selector_List, r->selector());
+      bool hasSelectors = sl ? sl->length() > 0 : false;
 
       if (!hasSelectors) {
         return false;
@@ -470,17 +455,17 @@ namespace Sass {
       bool hasDeclarations = false;
       bool hasPrintableChildBlocks = false;
       for (size_t i = 0, L = b->length(); i < L; ++i) {
-        Statement* stm = (*b)[i];
-        if (dynamic_cast<Directive*>(stm)) {
+        Statement_Obj stm = b->at(i);
+        if (dynamic_cast<Directive_Ptr>(&stm)) {
           return true;
-        } else if (Declaration* d = dynamic_cast<Declaration*>(stm)) {
+        } else if (Declaration_Ptr d = dynamic_cast<Declaration_Ptr>(&stm)) {
           return isPrintable(d, style);
-        } else if (dynamic_cast<Has_Block*>(stm)) {
-          Block* pChildBlock = ((Has_Block*)stm)->block();
-          if (isPrintable(pChildBlock, style)) {
+        } else if (dynamic_cast<Has_Block_Ptr>(&stm)) {
+          Block_Obj pChildBlock = ((Has_Block_Ptr)&stm)->block();
+          if (isPrintable(&pChildBlock, style)) {
             hasPrintableChildBlocks = true;
           }
-        } else if (Comment* c = dynamic_cast<Comment*>(stm)) {
+        } else if (Comment_Ptr c = dynamic_cast<Comment_Ptr>(&stm)) {
           // keep for uncompressed
           if (style != COMPRESSED) {
             hasDeclarations = true;
@@ -501,43 +486,43 @@ namespace Sass {
       return false;
     }
 
-    bool isPrintable(String_Constant* s, Sass_Output_Style style)
+    bool isPrintable(String_Constant_Ptr s, Sass_Output_Style style)
     {
       return ! s->value().empty();
     }
 
-    bool isPrintable(String_Quoted* s, Sass_Output_Style style)
+    bool isPrintable(String_Quoted_Ptr s, Sass_Output_Style style)
     {
       return true;
     }
 
-    bool isPrintable(Declaration* d, Sass_Output_Style style)
+    bool isPrintable(Declaration_Ptr d, Sass_Output_Style style)
     {
-      Expression* val = d->value();
-      if (String_Quoted* sq = dynamic_cast<String_Quoted*>(val)) return isPrintable(sq, style);
-      if (String_Constant* sc = dynamic_cast<String_Constant*>(val)) return isPrintable(sc, style);
+      Expression_Obj val = d->value();
+      if (String_Quoted_Obj sq = SASS_MEMORY_CAST(String_Quoted, val)) return isPrintable(&sq, style);
+      if (String_Constant_Obj sc = SASS_MEMORY_CAST(String_Constant, val)) return isPrintable(&sc, style);
       return true;
     }
 
-    bool isPrintable(Supports_Block* f, Sass_Output_Style style) {
+    bool isPrintable(Supports_Block_Ptr f, Sass_Output_Style style) {
       if (f == NULL) {
         return false;
       }
 
-      Block* b = f->block();
+      Block_Obj b = f->block();
 
-//      bool hasSelectors = f->selector() && static_cast<CommaSequence_Selector*>(f->selector())->length() > 0;
+//      bool hasSelectors = f->selector() && static_cast<Selector_List_Ptr>(f->selector())->length() > 0;
 
       bool hasDeclarations = false;
       bool hasPrintableChildBlocks = false;
       for (size_t i = 0, L = b->length(); i < L; ++i) {
-        Statement* stm = (*b)[i];
-        if (typeid(*stm) == typeid(Declaration) || typeid(*stm) == typeid(Directive)) {
+        Statement_Obj stm = b->at(i);
+        if (dynamic_cast<Declaration_Ptr>(&stm) || dynamic_cast<Directive_Ptr>(&stm)) {
           hasDeclarations = true;
         }
-        else if (dynamic_cast<Has_Block*>(stm)) {
-          Block* pChildBlock = ((Has_Block*)stm)->block();
-          if (isPrintable(pChildBlock, style)) {
+        else if (dynamic_cast<Has_Block_Ptr>(&stm)) {
+          Block_Obj pChildBlock = ((Has_Block_Ptr)&stm)->block();
+          if (isPrintable(&pChildBlock, style)) {
             hasPrintableChildBlocks = true;
           }
         }
@@ -550,47 +535,47 @@ namespace Sass {
       return false;
     }
 
-    bool isPrintable(Media_Block* m, Sass_Output_Style style)
+    bool isPrintable(Media_Block_Ptr m, Sass_Output_Style style)
     {
       if (m == 0) return false;
-      Block* b = m->block();
+      Block_Obj b = m->block();
       if (b == 0) return false;
       for (size_t i = 0, L = b->length(); i < L; ++i) {
-        Statement* stm = (*b)[i];
-        if (typeid(*stm) == typeid(Directive)) return true;
-        else if (typeid(*stm) == typeid(Declaration)) return true;
-        else if (typeid(*stm) == typeid(Comment)) {
-          Comment* c = (Comment*) stm;
+        Statement_Obj stm = b->at(i);
+        if (dynamic_cast<Directive_Ptr>(&stm)) return true;
+        else if (dynamic_cast<Declaration_Ptr>(&stm)) return true;
+        else if (dynamic_cast<Comment_Ptr>(&stm)) {
+          Comment_Ptr c = (Comment_Ptr) &stm;
           if (isPrintable(c, style)) {
             return true;
           }
         }
-        else if (typeid(*stm) == typeid(Ruleset)) {
-          Ruleset* r = (Ruleset*) stm;
+        else if (dynamic_cast<Ruleset_Ptr>(&stm)) {
+          Ruleset_Ptr r = (Ruleset_Ptr) &stm;
           if (isPrintable(r, style)) {
             return true;
           }
         }
-        else if (typeid(*stm) == typeid(Supports_Block)) {
-          Supports_Block* f = (Supports_Block*) stm;
+        else if (dynamic_cast<Supports_Block_Ptr>(&stm)) {
+          Supports_Block_Ptr f = (Supports_Block_Ptr) &stm;
           if (isPrintable(f, style)) {
             return true;
           }
         }
-        else if (typeid(*stm) == typeid(Media_Block)) {
-          Media_Block* m = (Media_Block*) stm;
+        else if (dynamic_cast<Media_Block_Ptr>(&stm)) {
+          Media_Block_Ptr m = (Media_Block_Ptr) &stm;
           if (isPrintable(m, style)) {
             return true;
           }
         }
-        else if (dynamic_cast<Has_Block*>(stm) && isPrintable(((Has_Block*)stm)->block(), style)) {
+        else if (dynamic_cast<Has_Block_Ptr>(&stm) && isPrintable(((Has_Block_Ptr)&stm)->block(), style)) {
           return true;
         }
       }
       return false;
     }
 
-    bool isPrintable(Comment* c, Sass_Output_Style style)
+    bool isPrintable(Comment_Ptr c, Sass_Output_Style style)
     {
       // keep for uncompressed
       if (style != COMPRESSED) {
@@ -604,41 +589,41 @@ namespace Sass {
       return false;
     };
 
-    bool isPrintable(Block* b, Sass_Output_Style style) {
-      if (b == NULL) {
+    bool isPrintable(Block_Obj b, Sass_Output_Style style) {
+      if (!b) {
         return false;
       }
 
       for (size_t i = 0, L = b->length(); i < L; ++i) {
-        Statement* stm = (*b)[i];
-        if (typeid(*stm) == typeid(Declaration) || typeid(*stm) == typeid(Directive)) {
+        Statement_Obj stm = b->at(i);
+        if (dynamic_cast<Declaration_Ptr>(&stm) || dynamic_cast<Directive_Ptr>(&stm)) {
           return true;
         }
-        else if (typeid(*stm) == typeid(Comment)) {
-          Comment* c = (Comment*) stm;
+        else if (dynamic_cast<Comment_Ptr>(&stm)) {
+          Comment_Ptr c = (Comment_Ptr) &stm;
           if (isPrintable(c, style)) {
             return true;
           }
         }
-        else if (typeid(*stm) == typeid(Ruleset)) {
-          Ruleset* r = (Ruleset*) stm;
+        else if (dynamic_cast<Ruleset_Ptr>(&stm)) {
+          Ruleset_Ptr r = (Ruleset_Ptr) &stm;
           if (isPrintable(r, style)) {
             return true;
           }
         }
-        else if (typeid(*stm) == typeid(Supports_Block)) {
-          Supports_Block* f = (Supports_Block*) stm;
+        else if (dynamic_cast<Supports_Block_Ptr>(&stm)) {
+          Supports_Block_Ptr f = (Supports_Block_Ptr) &stm;
           if (isPrintable(f, style)) {
             return true;
           }
         }
-        else if (typeid(*stm) == typeid(Media_Block)) {
-          Media_Block* m = (Media_Block*) stm;
+        else if (dynamic_cast<Media_Block_Ptr>(&stm)) {
+          Media_Block_Ptr m = (Media_Block_Ptr) &stm;
           if (isPrintable(m, style)) {
             return true;
           }
         }
-        else if (dynamic_cast<Has_Block*>(stm) && isPrintable(((Has_Block*)stm)->block(), style)) {
+        else if (dynamic_cast<Has_Block_Ptr>(&stm) && isPrintable(((Has_Block_Ptr)&stm)->block(), style)) {
           return true;
         }
       }
@@ -646,27 +631,9 @@ namespace Sass {
       return false;
     }
 
-    std::string vecJoin(const std::vector<std::string>& vec, const std::string& sep)
-    {
-      switch (vec.size())
-      {
-        case 0:
-            return std::string("");
-        case 1:
-            return vec[0];
-        default:
-            std::ostringstream os;
-            os << vec[0];
-            for (size_t i = 1; i < vec.size(); i++) {
-              os << sep << vec[i];
-            }
-            return os.str();
-      }
+    bool isAscii(const char chr) {
+      return unsigned(chr) < 128;
     }
 
-     bool isAscii(const char chr) {
-       return unsigned(chr) < 128;
-     }
-
   }
 }

data/ext/libsass/src/util.hpp

@@ -43,19 +43,15 @@ namespace Sass {
 
     std::string normalize_underscores(const std::string& str);
     std::string normalize_decimals(const std::string& str);
-    std::string normalize_sixtuplet(const std::string& col);
-
-    std::string vecJoin(const std::vector<std::string>& vec, const std::string& sep);
-    bool containsAnyPrintableStatements(Block* b);
-
-    bool isPrintable(Ruleset* r, Sass_Output_Style style = NESTED);
-    bool isPrintable(Supports_Block* r, Sass_Output_Style style = NESTED);
-    bool isPrintable(Media_Block* r, Sass_Output_Style style = NESTED);
-    bool isPrintable(Comment* b, Sass_Output_Style style = NESTED);
-    bool isPrintable(Block* b, Sass_Output_Style style = NESTED);
-    bool isPrintable(String_Constant* s, Sass_Output_Style style = NESTED);
-    bool isPrintable(String_Quoted* s, Sass_Output_Style style = NESTED);
-    bool isPrintable(Declaration* d, Sass_Output_Style style = NESTED);
+
+    bool isPrintable(Ruleset_Ptr r, Sass_Output_Style style = NESTED);
+    bool isPrintable(Supports_Block_Ptr r, Sass_Output_Style style = NESTED);
+    bool isPrintable(Media_Block_Ptr r, Sass_Output_Style style = NESTED);
+    bool isPrintable(Comment_Ptr b, Sass_Output_Style style = NESTED);
+    bool isPrintable(Block_Obj b, Sass_Output_Style style = NESTED);
+    bool isPrintable(String_Constant_Ptr s, Sass_Output_Style style = NESTED);
+    bool isPrintable(String_Quoted_Ptr s, Sass_Output_Style style = NESTED);
+    bool isPrintable(Declaration_Ptr d, Sass_Output_Style style = NESTED);
     bool isAscii(const char chr);
 
   }

data/ext/libsass/src/values.cpp

@@ -7,35 +7,36 @@
 namespace Sass {
 
   // convert value from C++ side to C-API
-  union Sass_Value* ast_node_to_sass_value (const Expression* val)
+  union Sass_Value* ast_node_to_sass_value (const Expression_Ptr val)
   {
     if (val->concrete_type() == Expression::NUMBER)
     {
-      const Number* res = dynamic_cast<const Number*>(val);
+      Number_Ptr_Const res = dynamic_cast<Number_Ptr_Const>(val);
       return sass_make_number(res->value(), res->unit().c_str());
     }
     else if (val->concrete_type() == Expression::COLOR)
     {
-      const Color* col = dynamic_cast<const Color*>(val);
+      Color_Ptr_Const col = dynamic_cast<Color_Ptr_Const>(val);
       return sass_make_color(col->r(), col->g(), col->b(), col->a());
     }
     else if (val->concrete_type() == Expression::LIST)
     {
-      const List* l = dynamic_cast<const List*>(val);
+      List_Ptr_Const l = dynamic_cast<List_Ptr_Const>(val);
       union Sass_Value* list = sass_make_list(l->size(), l->separator());
       for (size_t i = 0, L = l->length(); i < L; ++i) {
-        auto val = ast_node_to_sass_value((*l)[i]);
+        Expression_Obj obj = l->at(i);
+        auto val = ast_node_to_sass_value(&obj);
         sass_list_set_value(list, i, val);
       }
       return list;
     }
     else if (val->concrete_type() == Expression::MAP)
     {
-      const Map* m = dynamic_cast<const Map*>(val);
+      Map_Ptr_Const m = dynamic_cast<Map_Ptr_Const>(val);
       union Sass_Value* map = sass_make_map(m->length());
-      size_t i = 0; for (auto key : m->keys()) {
-        sass_map_set_key(map, i, ast_node_to_sass_value(key));
-        sass_map_set_value(map, i, ast_node_to_sass_value(m->at(key)));
+      size_t i = 0; for (Expression_Obj key : m->keys()) {
+        sass_map_set_key(map, i, ast_node_to_sass_value(&key));
+        sass_map_set_value(map, i, ast_node_to_sass_value(&m->at(key)));
         ++ i;
       }
       return map;
@@ -46,16 +47,16 @@ namespace Sass {
     }
     else if (val->concrete_type() == Expression::BOOLEAN)
     {
-      const Boolean* res = dynamic_cast<const Boolean*>(val);
+      Boolean_Ptr_Const res = dynamic_cast<Boolean_Ptr_Const>(val);
       return sass_make_boolean(res->value());
     }
     else if (val->concrete_type() == Expression::STRING)
     {
-      if (const String_Quoted* qstr = dynamic_cast<const String_Quoted*>(val))
+      if (String_Quoted_Ptr_Const qstr = dynamic_cast<String_Quoted_Ptr_Const>(val))
       {
         return sass_make_qstring(qstr->value().c_str());
       }
-      else if (const String_Constant* cstr = dynamic_cast<const String_Constant*>(val))
+      else if (String_Constant_Ptr_Const cstr = dynamic_cast<String_Constant_Ptr_Const>(val))
       {
         return sass_make_string(cstr->value().c_str());
       }
@@ -64,22 +65,22 @@ namespace Sass {
   }
 
   // convert value from C-API to C++ side
-  Value* sass_value_to_ast_node (Memory_Manager& mem, const union Sass_Value* val)
+  Value_Ptr sass_value_to_ast_node (const union Sass_Value* val)
   {
     switch (sass_value_get_tag(val)) {
       case SASS_NUMBER:
-        return SASS_MEMORY_NEW(mem, Number,
+        return SASS_MEMORY_NEW(Number,
                                ParserState("[C-VALUE]"),
                                sass_number_get_value(val),
                                sass_number_get_unit(val));
       break;
       case SASS_BOOLEAN:
-        return SASS_MEMORY_NEW(mem, Boolean,
+        return SASS_MEMORY_NEW(Boolean,
                                ParserState("[C-VALUE]"),
                                sass_boolean_get_value(val));
       break;
       case SASS_COLOR:
-        return SASS_MEMORY_NEW(mem, Color,
+        return SASS_MEMORY_NEW(Color,
                                ParserState("[C-VALUE]"),
                                sass_color_get_r(val),
                                sass_color_get_g(val),
@@ -88,46 +89,46 @@ namespace Sass {
       break;
       case SASS_STRING:
         if (sass_string_is_quoted(val)) {
-          return SASS_MEMORY_NEW(mem, String_Quoted,
+          return SASS_MEMORY_NEW(String_Quoted,
                                  ParserState("[C-VALUE]"),
                                  sass_string_get_value(val));
         } else {
-          return SASS_MEMORY_NEW(mem, String_Constant,
+          return SASS_MEMORY_NEW(String_Constant,
                                  ParserState("[C-VALUE]"),
                                  sass_string_get_value(val));
         }
       break;
       case SASS_LIST: {
-        List* l = SASS_MEMORY_NEW(mem, List,
+        List_Ptr l = SASS_MEMORY_NEW(List,
                                   ParserState("[C-VALUE]"),
                                   sass_list_get_length(val),
                                   sass_list_get_separator(val));
         for (size_t i = 0, L = sass_list_get_length(val); i < L; ++i) {
-          *l << sass_value_to_ast_node(mem, sass_list_get_value(val, i));
+          l->append(sass_value_to_ast_node(sass_list_get_value(val, i)));
         }
         return l;
       }
       break;
       case SASS_MAP: {
-        Map* m = SASS_MEMORY_NEW(mem, Map, ParserState("[C-VALUE]"));
+        Map_Ptr m = SASS_MEMORY_NEW(Map, ParserState("[C-VALUE]"));
         for (size_t i = 0, L = sass_map_get_length(val); i < L; ++i) {
           *m << std::make_pair(
-            sass_value_to_ast_node(mem, sass_map_get_key(val, i)),
-            sass_value_to_ast_node(mem, sass_map_get_value(val, i)));
+            sass_value_to_ast_node(sass_map_get_key(val, i)),
+            sass_value_to_ast_node(sass_map_get_value(val, i)));
         }
         return m;
       }
       break;
       case SASS_NULL:
-        return SASS_MEMORY_NEW(mem, Null, ParserState("[C-VALUE]"));
+        return SASS_MEMORY_NEW(Null, ParserState("[C-VALUE]"));
       break;
       case SASS_ERROR:
-        return SASS_MEMORY_NEW(mem, Custom_Error,
+        return SASS_MEMORY_NEW(Custom_Error,
                                ParserState("[C-VALUE]"),
                                sass_error_get_message(val));
       break;
       case SASS_WARNING:
-        return SASS_MEMORY_NEW(mem, Custom_Warning,
+        return SASS_MEMORY_NEW(Custom_Warning,
                                ParserState("[C-VALUE]"),
                                sass_warning_get_message(val));
       break;