sassc 2.0.1 → 2.1.0.pre1

data/ext/libsass/src/constants.cpp

@@ -1,4 +1,7 @@
+// sass.hpp must go before all system headers to get the
+// __EXTENSIONS__ fix on Solaris.
 #include "sass.hpp"
+
 #include "constants.hpp"
 
 namespace Sass {
@@ -18,6 +21,15 @@ namespace Sass {
     extern const unsigned long Specificity_Pseudo = 1000;
     extern const unsigned long Specificity_ID = 1000000;
 
+    extern const int UnificationOrder_Element = 1;
+    extern const int UnificationOrder_Id = 2;
+    extern const int UnificationOrder_Class = 2;
+    extern const int UnificationOrder_Attribute = 3;
+    extern const int UnificationOrder_PseudoClass = 4;
+    extern const int UnificationOrder_Wrapped = 5;
+    extern const int UnificationOrder_PseudoElement = 6;
+    extern const int UnificationOrder_Placeholder = 7;
+
     // sass keywords
     extern const char at_root_kwd[]       = "@at-root";
     extern const char import_kwd[]        = "@import";
@@ -116,6 +128,9 @@ namespace Sass {
     extern const char true_kwd[]  = "true";
     extern const char false_kwd[] = "false";
 
+    // definition keywords
+    extern const char using_kwd[]   = "using";
+
     // miscellaneous punctuation and delimiters
     extern const char percent_str[]     = "%";
     extern const char empty_str[]       = "";

data/ext/libsass/src/constants.hpp

@@ -18,6 +18,16 @@ namespace Sass {
     extern const unsigned long Specificity_Pseudo;
     extern const unsigned long Specificity_ID;
 
+    // Selector unification order;
+    extern const int UnificationOrder_Element;
+    extern const int UnificationOrder_Id;
+    extern const int UnificationOrder_Class;
+    extern const int UnificationOrder_Attribute;
+    extern const int UnificationOrder_PseudoClass;
+    extern const int UnificationOrder_Wrapped;
+    extern const int UnificationOrder_PseudoElement;
+    extern const int UnificationOrder_Placeholder;
+
     // sass keywords
     extern const char at_root_kwd[];
     extern const char import_kwd[];
@@ -117,6 +127,9 @@ namespace Sass {
     extern const char true_kwd[];
     extern const char false_kwd[];
 
+    // definition keywords
+    extern const char using_kwd[];
+
     // miscellaneous punctuation and delimiters
     extern const char percent_str[];
     extern const char empty_str[];

data/ext/libsass/src/context.cpp

@@ -1,4 +1,7 @@
+// sass.hpp must go before all system headers to get the
+// __EXTENSIONS__ fix on Solaris.
 #include "sass.hpp"
+
 #include <string>
 #include <cstdlib>
 #include <cstring>
@@ -23,12 +26,19 @@
 #include "listize.hpp"
 #include "extend.hpp"
 #include "remove_placeholders.hpp"
-#include "functions.hpp"
 #include "sass_functions.hpp"
 #include "backtrace.hpp"
 #include "sass2scss.h"
 #include "prelexer.hpp"
 #include "emitter.hpp"
+#include "fn_utils.hpp"
+#include "fn_miscs.hpp"
+#include "fn_maps.hpp"
+#include "fn_lists.hpp"
+#include "fn_colors.hpp"
+#include "fn_numbers.hpp"
+#include "fn_strings.hpp"
+#include "fn_selectors.hpp"
 
 namespace Sass {
   using namespace Constants;
@@ -382,7 +392,7 @@ namespace Sass {
 
   }
 
-  void Context::import_url (Import_Ptr imp, std::string load_path, const std::string& ctx_path) {
+  void Context::import_url (Import* imp, std::string load_path, const std::string& ctx_path) {
 
     ParserState pstate(imp->pstate());
     std::string imp_path(unquote(load_path));
@@ -401,11 +411,11 @@ namespace Sass {
       imp->urls().push_back(SASS_MEMORY_NEW(String_Quoted, imp->pstate(), load_path));
     }
     else if (imp_path.length() > 4 && imp_path.substr(imp_path.length() - 4, 4) == ".css") {
-      String_Constant_Ptr loc = SASS_MEMORY_NEW(String_Constant, pstate, unquote(load_path));
+      String_Constant* loc = SASS_MEMORY_NEW(String_Constant, pstate, unquote(load_path));
       Argument_Obj loc_arg = SASS_MEMORY_NEW(Argument, pstate, loc);
       Arguments_Obj loc_args = SASS_MEMORY_NEW(Arguments, pstate);
       loc_args->append(loc_arg);
-      Function_Call_Ptr new_url = SASS_MEMORY_NEW(Function_Call, pstate, "url", loc_args);
+      Function_Call* new_url = SASS_MEMORY_NEW(Function_Call, pstate, std::string("url"), loc_args);
       imp->urls().push_back(new_url);
     }
     else {
@@ -421,7 +431,7 @@ namespace Sass {
 
 
   // call custom importers on the given (unquoted) load_path and eventually parse the resulting style_sheet
-  bool Context::call_loader(const std::string& load_path, const char* ctx_path, ParserState& pstate, Import_Ptr imp, std::vector<Sass_Importer_Entry> importers, bool only_one)
+  bool Context::call_loader(const std::string& load_path, const char* ctx_path, ParserState& pstate, Import* imp, std::vector<Sass_Importer_Entry> importers, bool only_one)
   {
     // unique counter
     size_t count = 0;
@@ -556,7 +566,7 @@ namespace Sass {
   {
 
     // check if entry file is given
-    if (input_path.empty()) return 0;
+    if (input_path.empty()) return {};
 
     // create absolute path from input filename
     // ToDo: this should be resolved via custom importers
@@ -602,7 +612,7 @@ namespace Sass {
   {
 
     // check if source string is given
-    if (!source_c_str) return 0;
+    if (!source_c_str) return {};
 
     // convert indented sass syntax
     if(c_options.is_indented_syntax_src) {
@@ -645,11 +655,11 @@ namespace Sass {
   Block_Obj Context::compile()
   {
     // abort if there is no data
-    if (resources.size() == 0) return 0;
+    if (resources.size() == 0) return {};
     // get root block from the first style sheet
     Block_Obj root = sheets.at(entry_path).root;
     // abort on invalid root
-    if (root.isNull()) return 0;
+    if (root.isNull()) return {};
     Env global; // create root environment
     // register built-in functions on env
     register_built_in_functions(*this, &global);
@@ -732,14 +742,14 @@ namespace Sass {
 
   void register_function(Context& ctx, Signature sig, Native_Function f, Env* env)
   {
-    Definition_Ptr def = make_native_function(sig, f, ctx);
+    Definition* def = make_native_function(sig, f, ctx);
     def->environment(env);
     (*env)[def->name() + "[f]"] = def;
   }
 
   void register_function(Context& ctx, Signature sig, Native_Function f, size_t arity, Env* env)
   {
-    Definition_Ptr def = make_native_function(sig, f, ctx);
+    Definition* def = make_native_function(sig, f, ctx);
     std::stringstream ss;
     ss << def->name() << "[f]" << arity;
     def->environment(env);
@@ -748,11 +758,11 @@ namespace Sass {
 
   void register_overload_stub(Context& ctx, std::string name, Env* env)
   {
-    Definition_Ptr stub = SASS_MEMORY_NEW(Definition,
+    Definition* stub = SASS_MEMORY_NEW(Definition,
                                        ParserState("[built-in function]"),
                                        0,
                                        name,
-                                       0,
+                                       {},
                                        0,
                                        true);
     (*env)[name + "[f]"] = stub;
@@ -872,7 +882,7 @@ namespace Sass {
   }
   void register_c_function(Context& ctx, Env* env, Sass_Function_Entry descr)
   {
-    Definition_Ptr def = make_c_function(descr, ctx);
+    Definition* def = make_c_function(descr, ctx);
     def->environment(env);
     (*env)[def->name() + "[f]"] = def;
   }

data/ext/libsass/src/context.hpp

@@ -27,14 +27,14 @@ namespace Sass {
 
   class Context {
   public:
-    void import_url (Import_Ptr imp, std::string load_path, const std::string& ctx_path);
-    bool call_headers(const std::string& load_path, const char* ctx_path, ParserState& pstate, Import_Ptr imp)
+    void import_url (Import* imp, std::string load_path, const std::string& ctx_path);
+    bool call_headers(const std::string& load_path, const char* ctx_path, ParserState& pstate, Import* imp)
     { return call_loader(load_path, ctx_path, pstate, imp, c_headers, false); };
-    bool call_importers(const std::string& load_path, const char* ctx_path, ParserState& pstate, Import_Ptr imp)
+    bool call_importers(const std::string& load_path, const char* ctx_path, ParserState& pstate, Import* imp)
     { return call_loader(load_path, ctx_path, pstate, imp, c_importers, true); };
 
   private:
-    bool call_loader(const std::string& load_path, const char* ctx_path, ParserState& pstate, Import_Ptr imp, std::vector<Sass_Importer_Entry> importers, bool only_one = true);
+    bool call_loader(const std::string& load_path, const char* ctx_path, ParserState& pstate, Import* imp, std::vector<Sass_Importer_Entry> importers, bool only_one = true);
 
   public:
     const std::string CWD;
@@ -46,14 +46,14 @@ namespace Sass {
 
     // generic ast node garbage container
     // used to avoid possible circular refs
-    std::vector<AST_Node_Obj> ast_gc;
+    CallStack ast_gc;
     // resources add under our control
     // these are guaranteed to be freed
     std::vector<char*> strings;
     std::vector<Resource> resources;
     std::map<const std::string, StyleSheet> sheets;
     Subset_Map subset_map;
-    std::vector<Sass_Import_Entry> import_stack;
+    ImporterStack import_stack;
     std::vector<Sass_Callee> callee_stack;
     std::vector<Backtrace> traces;
 

data/ext/libsass/src/cssize.cpp

@@ -1,4 +1,7 @@
+// sass.hpp must go before all system headers to get the
+// __EXTENSIONS__ fix on Solaris.
 #include "sass.hpp"
+
 #include <iostream>
 #include <typeinfo>
 #include <vector>
@@ -11,16 +14,16 @@ namespace Sass {
   Cssize::Cssize(Context& ctx)
   : ctx(ctx),
     traces(ctx.traces),
-    block_stack(std::vector<Block_Ptr>()),
-    p_stack(std::vector<Statement_Ptr>())
+    block_stack(BlockStack()),
+    p_stack(std::vector<Statement*>())
   { }
 
-  Statement_Ptr Cssize::parent()
+  Statement* Cssize::parent()
   {
     return p_stack.size() ? p_stack.back() : block_stack.front();
   }
 
-  Block_Ptr Cssize::operator()(Block_Ptr b)
+  Block* Cssize::operator()(Block* b)
   {
     Block_Obj bb = SASS_MEMORY_NEW(Block, b->pstate(), b->length(), b->is_root());
     // bb->tabs(b->tabs());
@@ -30,7 +33,7 @@ namespace Sass {
     return bb.detach();
   }
 
-  Statement_Ptr Cssize::operator()(Trace_Ptr t)
+  Statement* Cssize::operator()(Trace* t)
   {
     traces.push_back(Backtrace(t->pstate()));
     auto result = t->block()->perform(this);
@@ -38,11 +41,11 @@ namespace Sass {
     return result;
   }
 
-  Statement_Ptr Cssize::operator()(Declaration_Ptr d)
+  Statement* Cssize::operator()(Declaration* d)
   {
     String_Obj property = Cast<String>(d->property());
 
-    if (Declaration_Ptr dd = Cast<Declaration>(parent())) {
+    if (Declaration* dd = Cast<Declaration>(parent())) {
       String_Obj parent_property = Cast<String>(dd->property());
       property = SASS_MEMORY_NEW(String_Constant,
                                  d->property()->pstate(),
@@ -78,7 +81,7 @@ namespace Sass {
     return 0;
   }
 
-  Statement_Ptr Cssize::operator()(Directive_Ptr r)
+  Statement* Cssize::operator()(Directive* r)
   {
     if (!r->block() || !r->block()->length()) return r;
 
@@ -110,10 +113,10 @@ namespace Sass {
 
     }
 
-    Block_Ptr result = SASS_MEMORY_NEW(Block, rr->pstate());
+    Block* result = SASS_MEMORY_NEW(Block, rr->pstate());
     if (!(directive_exists || rr->is_keyframes()))
     {
-      Directive_Ptr empty_node = Cast<Directive>(rr);
+      Directive* empty_node = Cast<Directive>(rr);
       empty_node->block(SASS_MEMORY_NEW(Block, rr->block() ? rr->block()->pstate() : rr->pstate()));
       result->append(empty_node);
     }
@@ -128,7 +131,7 @@ namespace Sass {
     return result;
   }
 
-  Statement_Ptr Cssize::operator()(Keyframe_Rule_Ptr r)
+  Statement* Cssize::operator()(Keyframe_Rule* r)
   {
     if (!r->block() || !r->block()->length()) return r;
 
@@ -140,14 +143,14 @@ namespace Sass {
     return debubble(rr->block(), rr);
   }
 
-  Statement_Ptr Cssize::operator()(Ruleset_Ptr r)
+  Statement* Cssize::operator()(Ruleset* r)
   {
     p_stack.push_back(r);
     // this can return a string schema
     // string schema is not a statement!
     // r->block() is already a string schema
     // and that is comming from propset expand
-    Block_Ptr bb = operator()(r->block());
+    Block* bb = operator()(r->block());
     // this should protect us (at least a bit) from our mess
     // fixing this properly is harder that it should be ...
     if (Cast<Statement>(bb) == NULL) {
@@ -167,10 +170,10 @@ namespace Sass {
     }
 
     Block_Obj props = SASS_MEMORY_NEW(Block, rr->block()->pstate());
-    Block_Ptr rules = SASS_MEMORY_NEW(Block, rr->block()->pstate());
+    Block* rules = SASS_MEMORY_NEW(Block, rr->block()->pstate());
     for (size_t i = 0, L = rr->block()->length(); i < L; i++)
     {
-      Statement_Ptr s = rr->block()->at(i);
+      Statement* s = rr->block()->at(i);
       if (bubblable(s)) rules->append(s);
       if (!bubblable(s)) props->append(s);
     }
@@ -183,14 +186,14 @@ namespace Sass {
 
       for (size_t i = 0, L = rules->length(); i < L; i++)
       {
-        Statement_Ptr stm = rules->at(i);
+        Statement* stm = rules->at(i);
         stm->tabs(stm->tabs() + 1);
       }
 
       rules->unshift(rr);
     }
 
-    Block_Ptr ptr = rules;
+    Block* ptr = rules;
     rules = debubble(rules);
     void* lp = ptr;
     void* rp = rules;
@@ -207,12 +210,12 @@ namespace Sass {
     return rules;
   }
 
-  Statement_Ptr Cssize::operator()(Null_Ptr m)
+  Statement* Cssize::operator()(Null* m)
   {
     return 0;
   }
 
-  Statement_Ptr Cssize::operator()(Media_Block_Ptr m)
+  Statement* Cssize::operator()(Media_Block* m)
   {
     if (parent()->statement_type() == Statement::RULESET)
     { return bubble(m); }
@@ -233,7 +236,7 @@ namespace Sass {
     return debubble(mm->block(), mm);
   }
 
-  Statement_Ptr Cssize::operator()(Supports_Block_Ptr m)
+  Statement* Cssize::operator()(Supports_Block* m)
   {
     if (!m->block()->length())
     { return m; }
@@ -254,17 +257,17 @@ namespace Sass {
     return debubble(mm->block(), mm);
   }
 
-  Statement_Ptr Cssize::operator()(At_Root_Block_Ptr m)
+  Statement* Cssize::operator()(At_Root_Block* m)
   {
     bool tmp = false;
     for (size_t i = 0, L = p_stack.size(); i < L; ++i) {
-      Statement_Ptr s = p_stack[i];
+      Statement* s = p_stack[i];
       tmp |= m->exclude_node(s);
     }
 
     if (!tmp && m->block())
     {
-      Block_Ptr bb = operator()(m->block());
+      Block* bb = operator()(m->block());
       for (size_t i = 0, L = bb->length(); i < L; ++i) {
         // (bb->elements())[i]->tabs(m->tabs());
         Statement_Obj stm = bb->at(i);
@@ -282,9 +285,9 @@ namespace Sass {
     return bubble(m);
   }
 
-  Statement_Ptr Cssize::bubble(Directive_Ptr m)
+  Statement* Cssize::bubble(Directive* m)
   {
-    Block_Ptr bb = SASS_MEMORY_NEW(Block, this->parent()->pstate());
+    Block* bb = SASS_MEMORY_NEW(Block, this->parent()->pstate());
     Has_Block_Obj new_rule = Cast<Has_Block>(SASS_MEMORY_COPY(this->parent()));
     new_rule->block(bb);
     new_rule->tabs(this->parent()->tabs());
@@ -299,16 +302,16 @@ namespace Sass {
                                   wrapper_block);
     if (m->value()) mm->value(m->value());
 
-    Bubble_Ptr bubble = SASS_MEMORY_NEW(Bubble, mm->pstate(), mm);
+    Bubble* bubble = SASS_MEMORY_NEW(Bubble, mm->pstate(), mm);
     return bubble;
   }
 
-  Statement_Ptr Cssize::bubble(At_Root_Block_Ptr m)
+  Statement* Cssize::bubble(At_Root_Block* m)
   {
     if (!m || !m->block()) return NULL;
-    Block_Ptr bb = SASS_MEMORY_NEW(Block, this->parent()->pstate());
+    Block* bb = SASS_MEMORY_NEW(Block, this->parent()->pstate());
     Has_Block_Obj new_rule = Cast<Has_Block>(SASS_MEMORY_COPY(this->parent()));
-    Block_Ptr wrapper_block = SASS_MEMORY_NEW(Block, m->block()->pstate());
+    Block* wrapper_block = SASS_MEMORY_NEW(Block, m->block()->pstate());
     if (new_rule) {
       new_rule->block(bb);
       new_rule->tabs(this->parent()->tabs());
@@ -316,52 +319,52 @@ namespace Sass {
       wrapper_block->append(new_rule);
     }
 
-    At_Root_Block_Ptr mm = SASS_MEMORY_NEW(At_Root_Block,
+    At_Root_Block* mm = SASS_MEMORY_NEW(At_Root_Block,
                                         m->pstate(),
                                         wrapper_block,
                                         m->expression());
-    Bubble_Ptr bubble = SASS_MEMORY_NEW(Bubble, mm->pstate(), mm);
+    Bubble* bubble = SASS_MEMORY_NEW(Bubble, mm->pstate(), mm);
     return bubble;
   }
 
-  Statement_Ptr Cssize::bubble(Supports_Block_Ptr m)
+  Statement* Cssize::bubble(Supports_Block* m)
   {
     Ruleset_Obj parent = Cast<Ruleset>(SASS_MEMORY_COPY(this->parent()));
 
-    Block_Ptr bb = SASS_MEMORY_NEW(Block, parent->block()->pstate());
-    Ruleset_Ptr new_rule = SASS_MEMORY_NEW(Ruleset,
+    Block* bb = SASS_MEMORY_NEW(Block, parent->block()->pstate());
+    Ruleset* new_rule = SASS_MEMORY_NEW(Ruleset,
                                         parent->pstate(),
                                         parent->selector(),
                                         bb);
     new_rule->tabs(parent->tabs());
     new_rule->block()->concat(m->block());
 
-    Block_Ptr wrapper_block = SASS_MEMORY_NEW(Block, m->block()->pstate());
+    Block* wrapper_block = SASS_MEMORY_NEW(Block, m->block()->pstate());
     wrapper_block->append(new_rule);
-    Supports_Block_Ptr mm = SASS_MEMORY_NEW(Supports_Block,
+    Supports_Block* mm = SASS_MEMORY_NEW(Supports_Block,
                                        m->pstate(),
                                        m->condition(),
                                        wrapper_block);
 
     mm->tabs(m->tabs());
 
-    Bubble_Ptr bubble = SASS_MEMORY_NEW(Bubble, mm->pstate(), mm);
+    Bubble* bubble = SASS_MEMORY_NEW(Bubble, mm->pstate(), mm);
     return bubble;
   }
 
-  Statement_Ptr Cssize::bubble(Media_Block_Ptr m)
+  Statement* Cssize::bubble(Media_Block* m)
   {
     Ruleset_Obj parent = Cast<Ruleset>(SASS_MEMORY_COPY(this->parent()));
 
-    Block_Ptr bb = SASS_MEMORY_NEW(Block, parent->block()->pstate());
-    Ruleset_Ptr new_rule = SASS_MEMORY_NEW(Ruleset,
+    Block* bb = SASS_MEMORY_NEW(Block, parent->block()->pstate());
+    Ruleset* new_rule = SASS_MEMORY_NEW(Ruleset,
                                         parent->pstate(),
                                         parent->selector(),
                                         bb);
     new_rule->tabs(parent->tabs());
     new_rule->block()->concat(m->block());
 
-    Block_Ptr wrapper_block = SASS_MEMORY_NEW(Block, m->block()->pstate());
+    Block* wrapper_block = SASS_MEMORY_NEW(Block, m->block()->pstate());
     wrapper_block->append(new_rule);
     Media_Block_Obj mm = SASS_MEMORY_NEW(Media_Block,
                                       m->pstate(),
@@ -373,17 +376,17 @@ namespace Sass {
     return SASS_MEMORY_NEW(Bubble, mm->pstate(), mm);
   }
 
-  bool Cssize::bubblable(Statement_Ptr s)
+  bool Cssize::bubblable(Statement* s)
   {
     return Cast<Ruleset>(s) || s->bubbles();
   }
 
-  Block_Ptr Cssize::flatten(Block_Ptr b)
+  Block* Cssize::flatten(Block* b)
   {
-    Block_Ptr result = SASS_MEMORY_NEW(Block, b->pstate(), 0, b->is_root());
+    Block* result = SASS_MEMORY_NEW(Block, b->pstate(), 0, b->is_root());
     for (size_t i = 0, L = b->length(); i < L; ++i) {
-      Statement_Ptr ss = b->at(i);
-      if (Block_Ptr bb = Cast<Block>(ss)) {
+      Statement* ss = b->at(i);
+      if (Block* bb = Cast<Block>(ss)) {
         Block_Obj bs = flatten(bb);
         for (size_t j = 0, K = bs->length(); j < K; ++j) {
           result->append(bs->at(j));
@@ -396,7 +399,7 @@ namespace Sass {
     return result;
   }
 
-  std::vector<std::pair<bool, Block_Obj>> Cssize::slice_by_bubble(Block_Ptr b)
+  std::vector<std::pair<bool, Block_Obj>> Cssize::slice_by_bubble(Block* b)
   {
     std::vector<std::pair<bool, Block_Obj>> results;
 
@@ -411,7 +414,7 @@ namespace Sass {
       }
       else
       {
-        Block_Ptr wrapper_block = SASS_MEMORY_NEW(Block, value->pstate());
+        Block* wrapper_block = SASS_MEMORY_NEW(Block, value->pstate());
         wrapper_block->append(value);
         results.push_back(std::make_pair(key, wrapper_block));
       }
@@ -419,9 +422,9 @@ namespace Sass {
     return results;
   }
 
-  Block_Ptr Cssize::debubble(Block_Ptr children, Statement_Ptr parent)
+  Block* Cssize::debubble(Block* children, Statement* parent)
   {
-    Has_Block_Obj previous_parent = 0;
+    Has_Block_Obj previous_parent;
     std::vector<std::pair<bool, Block_Obj>> baz = slice_by_bubble(children);
     Block_Obj result = SASS_MEMORY_NEW(Block, children->pstate());
 
@@ -448,12 +451,12 @@ namespace Sass {
 
       for (size_t j = 0, K = slice->length(); j < K; ++j)
       {
-        Statement_Ptr ss;
+        Statement* ss;
         Statement_Obj stm = slice->at(j);
         // this has to go now here (too bad)
         Bubble_Obj node = Cast<Bubble>(stm);
-        Media_Block_Ptr m1 = NULL;
-        Media_Block_Ptr m2 = NULL;
+        Media_Block* m1 = NULL;
+        Media_Block* m2 = NULL;
         if (parent) m1 = Cast<Media_Block>(parent);
         if (node) m2 = Cast<Media_Block>(node->node());
         if (!parent ||
@@ -493,11 +496,11 @@ namespace Sass {
                                               children->length(),
                                               children->is_root());
 
-        Block_Ptr wrapper = flatten(bb);
+        Block* wrapper = flatten(bb);
         wrapper_block->append(wrapper);
 
         if (wrapper->length()) {
-          previous_parent = NULL;
+          previous_parent = {};
         }
 
         if (wrapper_block) {
@@ -509,16 +512,11 @@ namespace Sass {
     return flatten(result);
   }
 
-  Statement_Ptr Cssize::fallback_impl(AST_Node_Ptr n)
-  {
-    return static_cast<Statement_Ptr>(n);
-  }
-
-  void Cssize::append_block(Block_Ptr b, Block_Ptr cur)
+  void Cssize::append_block(Block* b, Block* cur)
   {
     for (size_t i = 0, L = b->length(); i < L; ++i) {
       Statement_Obj ith = b->at(i)->perform(this);
-      if (Block_Ptr bb = Cast<Block>(ith)) {
+      if (Block* bb = Cast<Block>(ith)) {
         for (size_t j = 0, K = bb->length(); j < K; ++j) {
           cur->append(bb->at(j));
         }
@@ -529,9 +527,9 @@ namespace Sass {
     }
   }
 
-  List_Ptr Cssize::merge_media_queries(Media_Block_Ptr m1, Media_Block_Ptr m2)
+  List* Cssize::merge_media_queries(Media_Block* m1, Media_Block* m2)
   {
-    List_Ptr qq = SASS_MEMORY_NEW(List,
+    List* qq = SASS_MEMORY_NEW(List,
                                m1->media_queries()->pstate(),
                                m1->media_queries()->length(),
                                SASS_COMMA);
@@ -540,9 +538,9 @@ namespace Sass {
       for (size_t j = 0, K = m2->media_queries()->length(); j < K; j++) {
         Expression_Obj l1 = m1->media_queries()->at(i);
         Expression_Obj l2 = m2->media_queries()->at(j);
-        Media_Query_Ptr mq1 = Cast<Media_Query>(l1);
-        Media_Query_Ptr mq2 = Cast<Media_Query>(l2);
-        Media_Query_Ptr mq = merge_media_query(mq1, mq2);
+        Media_Query* mq1 = Cast<Media_Query>(l1);
+        Media_Query* mq2 = Cast<Media_Query>(l2);
+        Media_Query* mq = merge_media_query(mq1, mq2);
         if (mq) qq->append(mq);
       }
     }
@@ -551,7 +549,7 @@ namespace Sass {
   }
 
 
-  Media_Query_Ptr Cssize::merge_media_query(Media_Query_Ptr mq1, Media_Query_Ptr mq2)
+  Media_Query* Cssize::merge_media_query(Media_Query* mq1, Media_Query* mq2)
   {
 
     std::string type;
@@ -559,7 +557,7 @@ namespace Sass {
 
     std::string m1 = std::string(mq1->is_restricted() ? "only" : mq1->is_negated() ? "not" : "");
     std::string t1 = mq1->media_type() ? mq1->media_type()->to_string(ctx.c_options) : "";
-    std::string m2 = std::string(mq2->is_restricted() ? "only" : mq1->is_negated() ? "not" : "");
+    std::string m2 = std::string(mq2->is_restricted() ? "only" : mq2->is_negated() ? "not" : "");
     std::string t2 = mq2->media_type() ? mq2->media_type()->to_string(ctx.c_options) : "";
 
 
@@ -587,9 +585,9 @@ namespace Sass {
       mod = m1.empty() ? m2 : m1;
     }
 
-    Media_Query_Ptr mm = SASS_MEMORY_NEW(Media_Query,
+    Media_Query* mm = SASS_MEMORY_NEW(Media_Query,
                                          mq1->pstate(),
-                                         0,
+                                         {},
                                          mq1->length() + mq2->length(),
                                          mod == "not",
                                          mod == "only");