sassc 1.11.1 → 1.11.2

data/ext/libsass/src/check_nesting.hpp

@@ -6,53 +6,57 @@
 
 namespace Sass {
 
-  typedef Environment<AST_Node*> Env;
+  typedef Environment<AST_Node_Obj> Env;
 
-  class CheckNesting : public Operation_CRTP<Statement*, CheckNesting> {
+  class CheckNesting : public Operation_CRTP<Statement_Ptr, CheckNesting> {
 
-    std::vector<Statement*>  parents;
-    Statement*               parent;
-    Definition*              current_mixin_definition;
+    std::vector<Statement_Ptr>  parents;
+    Statement_Ptr               parent;
+    Definition_Ptr              current_mixin_definition;
 
-    Statement* fallback_impl(Statement*);
-    Statement* before(Statement*);
-    Statement* visit_children(Statement*);
+    Statement_Ptr fallback_impl(Statement_Ptr);
+    Statement_Ptr before(Statement_Ptr);
+    Statement_Ptr visit_children(Statement_Ptr);
 
   public:
     CheckNesting();
     ~CheckNesting() { }
 
-    Statement* operator()(Block*);
-    Statement* operator()(Definition*);
+    Statement_Ptr operator()(Block_Ptr);
+    Statement_Ptr operator()(Definition_Ptr);
 
     template <typename U>
-    Statement* fallback(U x) {
-        return fallback_impl(this->before(dynamic_cast<Statement*>(x)));
+    Statement_Ptr fallback(U x) {
+      Statement_Ptr n = SASS_MEMORY_CAST_PTR(Statement, x);
+      if (this->should_visit(n)) {
+        return fallback_impl(n);
+      }
+      return NULL;
     }
 
   private:
-    void invalid_content_parent(Statement*);
-    void invalid_charset_parent(Statement*);
-    void invalid_extend_parent(Statement*);
-    // void invalid_import_parent(Statement*);
-    void invalid_mixin_definition_parent(Statement*);
-    void invalid_function_parent(Statement*);
-
-    void invalid_function_child(Statement*);
-    void invalid_prop_child(Statement*);
-    void invalid_prop_parent(Statement*);
-    void invalid_return_parent(Statement*);
-
-    bool is_transparent_parent(Statement*, Statement*);
-
-    bool should_visit(Statement*);
-
-    bool is_charset(Statement*);
-    bool is_mixin(Statement*);
-    bool is_function(Statement*);
-    bool is_root_node(Statement*);
-    bool is_at_root_node(Statement*);
-    bool is_directive_node(Statement*);
+    void invalid_content_parent(Statement_Ptr);
+    void invalid_charset_parent(Statement_Ptr);
+    void invalid_extend_parent(Statement_Ptr);
+    // void invalid_import_parent(Statement_Ptr);
+    void invalid_mixin_definition_parent(Statement_Ptr);
+    void invalid_function_parent(Statement_Ptr);
+
+    void invalid_function_child(Statement_Ptr);
+    void invalid_prop_child(Statement_Ptr);
+    void invalid_prop_parent(Statement_Ptr);
+    void invalid_return_parent(Statement_Ptr);
+
+    bool is_transparent_parent(Statement_Ptr, Statement_Ptr);
+
+    bool should_visit(Statement_Ptr);
+
+    bool is_charset(Statement_Ptr);
+    bool is_mixin(Statement_Ptr);
+    bool is_function(Statement_Ptr);
+    bool is_root_node(Statement_Ptr);
+    bool is_at_root_node(Statement_Ptr);
+    bool is_directive_node(Statement_Ptr);
   };
 
 }

data/ext/libsass/src/color_maps.cpp

@@ -452,7 +452,7 @@ namespace Sass {
     { 102 * 0x10000 +  51 * 0x100 + 153, ColorNames::rebeccapurple }
   };
 
-  const std::map<const char*, const Color*, map_cmp_str> names_to_colors
+  const std::map<const char*, Color_Ptr_Const, map_cmp_str> names_to_colors
   {
     { ColorNames::aliceblue, &Colors::aliceblue },
     { ColorNames::antiquewhite, &Colors::antiquewhite },
@@ -605,7 +605,7 @@ namespace Sass {
     { ColorNames::transparent, &Colors::transparent }
   };
 
-  const Color* name_to_color(const char* key)
+  Color_Ptr_Const name_to_color(const char* key)
   {
     auto p = names_to_colors.find(key);
     if (p != names_to_colors.end()) {
@@ -614,7 +614,7 @@ namespace Sass {
     return 0;
   }
 
-  const Color* name_to_color(const std::string& key)
+  Color_Ptr_Const name_to_color(const std::string& key)
   {
     return name_to_color(key.c_str());
   }

data/ext/libsass/src/color_maps.hpp

@@ -320,10 +320,10 @@ namespace Sass {
   }
 
   extern const std::map<const int, const char*> colors_to_names;
-  extern const std::map<const char*, const Color*, map_cmp_str> names_to_colors;
+  extern const std::map<const char*, Color_Ptr_Const, map_cmp_str> names_to_colors;
 
-  extern const Color* name_to_color(const char*);
-  extern const Color* name_to_color(const std::string&);
+  extern Color_Ptr_Const name_to_color(const char*);
+  extern Color_Ptr_Const name_to_color(const std::string&);
   extern const char* color_to_name(const int);
   extern const char* color_to_name(const Color&);
   extern const char* color_to_name(const double);

data/ext/libsass/src/context.cpp

@@ -64,7 +64,6 @@ namespace Sass {
     c_options(c_ctx),
     entry_path(""),
     head_imports(0),
-    mem(Memory_Manager()),
     plugins(),
     emitter(c_options),
 
@@ -146,6 +145,7 @@ namespace Sass {
     }
     // clear inner structures (vectors) and input source
     resources.clear(); import_stack.clear();
+    subset_map.clear(), sheets.clear();
   }
 
   Data_Context::~Data_Context()
@@ -316,13 +316,13 @@ namespace Sass {
     sass_import_take_source(import);
     sass_import_take_srcmap(import);
     // then parse the root block
-    Block* root = p.parse();
+    Block_Obj root = p.parse();
     // delete memory of current stack frame
     sass_delete_import(import_stack.back());
     // remove current stack frame
     import_stack.pop_back();
     // create key/value pair for ast node
-    std::pair<const std::string, const StyleSheet>
+    std::pair<const std::string, StyleSheet>
       ast_pair(inc.abs_path, { res, root });
     // register resulting resource
     sheets.insert(ast_pair);
@@ -369,7 +369,7 @@ namespace Sass {
 
   }
 
-  void Context::import_url (Import* imp, std::string load_path, const std::string& ctx_path) {
+  void Context::import_url (Import_Ptr imp, std::string load_path, const std::string& ctx_path) {
 
     ParserState pstate(imp->pstate());
     std::string imp_path(unquote(load_path));
@@ -384,15 +384,15 @@ namespace Sass {
 
     // add urls (protocol other than file) and urls without procotol to `urls` member
     // ToDo: if ctx_path is already a file resource, we should not add it here?
-    if (imp->media_queries() || protocol != "file" || imp_path.substr(0, 2) == "//") {
-      imp->urls().push_back(SASS_MEMORY_NEW(mem, String_Quoted, imp->pstate(), load_path));
+    if (imp->import_queries() || protocol != "file" || imp_path.substr(0, 2) == "//") {
+      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* loc = SASS_MEMORY_NEW(mem, String_Constant, pstate, unquote(load_path));
-      Argument* loc_arg = SASS_MEMORY_NEW(mem, Argument, pstate, loc);
-      Arguments* loc_args = SASS_MEMORY_NEW(mem, Arguments, pstate);
-      (*loc_args) << loc_arg;
-      Function_Call* new_url = SASS_MEMORY_NEW(mem, Function_Call, pstate, "url", loc_args);
+      String_Constant_Ptr 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);
       imp->urls().push_back(new_url);
     }
     else {
@@ -408,7 +408,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* 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_Ptr imp, std::vector<Sass_Importer_Entry> importers, bool only_one)
   {
     // unique counter
     size_t count = 0;
@@ -494,7 +494,7 @@ namespace Sass {
   void register_c_functions(Context&, Env* env, Sass_Function_List);
   void register_c_function(Context&, Env* env, Sass_Function_Entry);
 
-  char* Context::render(Block* root)
+  char* Context::render(Block_Obj root)
   {
     // check for valid block
     if (!root) return 0;
@@ -522,24 +522,24 @@ namespace Sass {
     return sass_copy_c_string(emitted.buffer.c_str());
   }
 
-  void Context::apply_custom_headers(Block* root, const char* ctx_path, ParserState pstate)
+  void Context::apply_custom_headers(Block_Obj root, const char* ctx_path, ParserState pstate)
   {
     // create a custom import to resolve headers
-    Import* imp = SASS_MEMORY_NEW(mem, Import, pstate);
+    Import_Obj imp = SASS_MEMORY_NEW(Import, pstate);
     // dispatch headers which will add custom functions
     // custom headers are added to the import instance
-    call_headers(entry_path, ctx_path, pstate, imp);
+    call_headers(entry_path, ctx_path, pstate, &imp);
     // increase head count to skip later
     head_imports += resources.size() - 1;
     // add the statement if we have urls
-    if (!imp->urls().empty()) (*root) << imp;
+    if (!imp->urls().empty()) root->append(&imp);
     // process all other resources (add Import_Stub nodes)
     for (size_t i = 0, S = imp->incs().size(); i < S; ++i) {
-      (*root) << SASS_MEMORY_NEW(mem, Import_Stub, pstate, imp->incs()[i]);
+      root->append(SASS_MEMORY_NEW(Import_Stub, pstate, imp->incs()[i]));
     }
   }
 
-  Block* File_Context::parse()
+  Block_Obj File_Context::parse()
   {
 
     // check if entry file is given
@@ -562,7 +562,7 @@ namespace Sass {
     }
 
     // abort early if no content could be loaded (various reasons)
-    if (!contents) throw "File to read not found or unreadable: " + input_path;
+    if (!contents) throw std::runtime_error("File to read not found or unreadable: " + input_path);
 
     // store entry path
     entry_path = abs_path;
@@ -585,7 +585,7 @@ namespace Sass {
 
   }
 
-  Block* Data_Context::parse()
+  Block_Obj Data_Context::parse()
   {
 
     // check if source string is given
@@ -629,15 +629,14 @@ namespace Sass {
 
 
   // parse root block from includes
-  Block* Context::compile()
+  Block_Obj Context::compile()
   {
     // abort if there is no data
     if (resources.size() == 0) return 0;
     // get root block from the first style sheet
-    Block* root = sheets.at(entry_path).root;
+    Block_Obj root = sheets.at(entry_path).root;
     // abort on invalid root
-    if (root == 0) return 0;
-
+    if (root.isNull()) return 0;
     Env global; // create root environment
     // register built-in functions on env
     register_built_in_functions(*this, &global);
@@ -651,19 +650,19 @@ namespace Sass {
     Cssize cssize(*this, &backtrace);
     CheckNesting check_nesting;
     // check nesting
-    root->perform(&check_nesting)->block();
+    check_nesting(&root);
     // expand and eval the tree
-    root = root->perform(&expand)->block();
+    root = expand(&root);
     // check nesting
-    root->perform(&check_nesting)->block();
+    check_nesting(&root);
     // merge and bubble certain rules
-    root = root->perform(&cssize)->block();
+    root = cssize(&root);
     // should we extend something?
     if (!subset_map.empty()) {
       // create crtp visitor object
       Extend extend(*this, subset_map);
       // extend tree nodes
-      root->perform(&extend);
+      extend(&root);
     }
 
     // clean up by removing empty placeholders
@@ -719,14 +718,14 @@ namespace Sass {
 
   void register_function(Context& ctx, Signature sig, Native_Function f, Env* env)
   {
-    Definition* def = make_native_function(sig, f, ctx);
+    Definition_Ptr 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* def = make_native_function(sig, f, ctx);
+    Definition_Ptr def = make_native_function(sig, f, ctx);
     std::stringstream ss;
     ss << def->name() << "[f]" << arity;
     def->environment(env);
@@ -735,7 +734,7 @@ namespace Sass {
 
   void register_overload_stub(Context& ctx, std::string name, Env* env)
   {
-    Definition* stub = SASS_MEMORY_NEW(ctx.mem, Definition,
+    Definition_Ptr stub = SASS_MEMORY_NEW(Definition,
                                        ParserState("[built-in function]"),
                                        0,
                                        name,
@@ -856,7 +855,7 @@ namespace Sass {
   }
   void register_c_function(Context& ctx, Env* env, Sass_Function_Entry descr)
   {
-    Definition* def = make_c_function(descr, ctx);
+    Definition_Ptr def = make_c_function(descr, ctx);
     def->environment(env);
     (*env)[def->name() + "[f]"] = def;
   }

data/ext/libsass/src/context.hpp

@@ -10,7 +10,6 @@
 
 #include "ast_fwd_decl.hpp"
 #include "kwd_arg_macros.hpp"
-#include "memory_manager.hpp"
 #include "ast_fwd_decl.hpp"
 #include "sass_context.hpp"
 #include "environment.hpp"
@@ -27,21 +26,20 @@ namespace Sass {
 
   class Context {
   public:
-    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)
+    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)
     { 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* imp)
+    bool call_importers(const std::string& load_path, const char* ctx_path, ParserState& pstate, Import_Ptr 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* 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_Ptr imp, std::vector<Sass_Importer_Entry> importers, bool only_one = true);
 
   public:
     const std::string CWD;
     struct Sass_Options& c_options;
     std::string entry_path;
     size_t head_imports;
-    Memory_Manager mem;
     Plugins plugins;
     Output emitter;
 
@@ -49,8 +47,8 @@ namespace Sass {
     // these are guaranteed to be freed
     std::vector<char*> strings;
     std::vector<Resource> resources;
-    std::map<const std::string, const StyleSheet> sheets;
-    Subset_Map<std::string, std::pair<Sequence_Selector*, SimpleSequence_Selector*> > subset_map;
+    std::map<const std::string, StyleSheet> sheets;
+    Subset_Map subset_map;
     std::vector<Sass_Import_Entry> import_stack;
 
     struct Sass_Compiler* c_compiler;
@@ -68,7 +66,7 @@ namespace Sass {
 
 
 
-    void apply_custom_headers(Block* root, const char* path, ParserState pstate);
+    void apply_custom_headers(Block_Obj root, const char* path, ParserState pstate);
 
     std::vector<Sass_Importer_Entry> c_headers;
     std::vector<Sass_Importer_Entry> c_importers;
@@ -87,9 +85,9 @@ namespace Sass {
 
     virtual ~Context();
     Context(struct Sass_Context&);
-    virtual Block* parse() = 0;
-    virtual Block* compile();
-    virtual char* render(Block* root);
+    virtual Block_Obj parse() = 0;
+    virtual Block_Obj compile();
+    virtual char* render(Block_Obj root);
     virtual char* render_srcmap();
 
     void register_resource(const Include&, const Resource&, ParserState* = 0);
@@ -123,7 +121,7 @@ namespace Sass {
     : Context(ctx)
     { }
     virtual ~File_Context();
-    virtual Block* parse();
+    virtual Block_Obj parse();
   };
 
   class Data_Context : public Context {
@@ -139,7 +137,7 @@ namespace Sass {
       ctx.srcmap_string = 0; // passed away
     }
     virtual ~Data_Context();
-    virtual Block* parse();
+    virtual Block_Obj parse();
   };
 
 }

data/ext/libsass/src/cssize.cpp

@@ -11,38 +11,38 @@ namespace Sass {
 
   Cssize::Cssize(Context& ctx, Backtrace* bt)
   : ctx(ctx),
-    block_stack(std::vector<Block*>()),
-    p_stack(std::vector<Statement*>()),
+    block_stack(std::vector<Block_Ptr>()),
+    p_stack(std::vector<Statement_Ptr>()),
     backtrace(bt)
   { }
 
-  Statement* Cssize::parent()
+  Statement_Ptr Cssize::parent()
   {
     return p_stack.size() ? p_stack.back() : block_stack.front();
   }
 
-  Statement* Cssize::operator()(Block* b)
+  Block_Ptr Cssize::operator()(Block_Ptr b)
   {
-    Block* bb = SASS_MEMORY_NEW(ctx.mem, Block, b->pstate(), b->length(), b->is_root());
+    Block_Ptr bb = SASS_MEMORY_NEW(Block, b->pstate(), b->length(), b->is_root());
     // bb->tabs(b->tabs());
     block_stack.push_back(bb);
-    append_block(b);
+    append_block(b, bb);
     block_stack.pop_back();
     return bb;
   }
 
-  Statement* Cssize::operator()(Trace* t)
+  Statement_Ptr Cssize::operator()(Trace_Ptr t)
   {
     return t->block()->perform(this);
   }
 
-  Statement* Cssize::operator()(Declaration* d)
+  Statement_Ptr Cssize::operator()(Declaration_Ptr d)
   {
-    String* property = dynamic_cast<String*>(d->property());
+    String_Obj property = SASS_MEMORY_CAST(String, d->property());
 
-    if (Declaration* dd = dynamic_cast<Declaration*>(parent())) {
-      String* parent_property = dynamic_cast<String*>(dd->property());
-      property = SASS_MEMORY_NEW(ctx.mem, String_Constant,
+    if (Declaration_Ptr dd = dynamic_cast<Declaration_Ptr>(parent())) {
+      String_Obj parent_property = SASS_MEMORY_CAST(String, dd->property());
+      property = SASS_MEMORY_NEW(String_Constant,
                                  d->property()->pstate(),
                                  parent_property->to_string() + "-" + property->to_string());
       if (!dd->value()) {
@@ -50,7 +50,7 @@ namespace Sass {
       }
     }
 
-    Declaration* dd = SASS_MEMORY_NEW(ctx.mem, Declaration,
+    Declaration_Obj dd = SASS_MEMORY_NEW(Declaration,
                                       d->pstate(),
                                       property,
                                       d->value(),
@@ -58,99 +58,101 @@ namespace Sass {
     dd->is_indented(d->is_indented());
     dd->tabs(d->tabs());
 
-    p_stack.push_back(dd);
-    Block* bb = d->block() ? d->block()->perform(this)->block() : 0;
+    p_stack.push_back(&dd);
+    Block_Obj bb = d->block() ? operator()(&d->block()) : NULL;
     p_stack.pop_back();
 
     if (bb && bb->length()) {
       if (dd->value() && !dd->value()->is_invisible()) {
-        bb->unshift(dd);
+        bb->unshift(&dd);
       }
-      return bb;
+      return bb.detach();
     }
     else if (dd->value() && !dd->value()->is_invisible()) {
-      return dd;
+      return dd.detach();
     }
 
     return 0;
   }
 
-  Statement* Cssize::operator()(Directive* r)
+  Statement_Ptr Cssize::operator()(Directive_Ptr r)
   {
     if (!r->block() || !r->block()->length()) return r;
 
     if (parent()->statement_type() == Statement::RULESET)
     {
-      return (r->is_keyframes()) ? SASS_MEMORY_NEW(ctx.mem, Bubble, r->pstate(), r) : bubble(r);
+      return (r->is_keyframes()) ? SASS_MEMORY_NEW(Bubble, r->pstate(), r) : bubble(r);
     }
 
     p_stack.push_back(r);
-    Directive* rr = SASS_MEMORY_NEW(ctx.mem, Directive,
+    Directive_Obj rr = SASS_MEMORY_NEW(Directive,
                                   r->pstate(),
                                   r->keyword(),
                                   r->selector(),
-                                  r->block() ? r->block()->perform(this)->block() : 0);
+                                  r->block() ? operator()(&r->block()) : 0);
     if (r->value()) rr->value(r->value());
     p_stack.pop_back();
 
     bool directive_exists = false;
     size_t L = rr->block() ? rr->block()->length() : 0;
     for (size_t i = 0; i < L && !directive_exists; ++i) {
-      Statement* s = (*r->block())[i];
+      Statement_Obj s = r->block()->at(i);
       if (s->statement_type() != Statement::BUBBLE) directive_exists = true;
       else {
-        s = static_cast<Bubble*>(s)->node();
+        Bubble_Obj s_obj = SASS_MEMORY_CAST(Bubble, s);
+        s = s_obj->node();
         if (s->statement_type() != Statement::DIRECTIVE) directive_exists = false;
-        else directive_exists = (static_cast<Directive*>(s)->keyword() == rr->keyword());
+        else directive_exists = (static_cast<Directive_Ptr>(&s)->keyword() == rr->keyword());
       }
 
     }
 
-    Block* result = SASS_MEMORY_NEW(ctx.mem, Block, rr->pstate());
+    Block_Ptr result = SASS_MEMORY_NEW(Block, rr->pstate());
     if (!(directive_exists || rr->is_keyframes()))
     {
-      Directive* empty_node = static_cast<Directive*>(rr);
-      empty_node->block(SASS_MEMORY_NEW(ctx.mem, Block, rr->block() ? rr->block()->pstate() : rr->pstate()));
-      *result << empty_node;
+      Directive_Ptr empty_node = SASS_MEMORY_CAST(Directive, rr);
+      empty_node->block(SASS_MEMORY_NEW(Block, rr->block() ? rr->block()->pstate() : rr->pstate()));
+      result->append(empty_node);
     }
 
-    Statement* ss = debubble(rr->block() ? rr->block() : SASS_MEMORY_NEW(ctx.mem, Block, rr->pstate()), rr);
-    for (size_t i = 0, L = ss->block()->length(); i < L; ++i) {
-      *result << (*ss->block())[i];
+    Block_Obj ss = debubble(rr->block() ? &rr->block() : SASS_MEMORY_NEW(Block, rr->pstate()), &rr);
+    for (size_t i = 0, L = ss->length(); i < L; ++i) {
+      result->append(ss->at(i));
     }
 
     return result;
   }
 
-  Statement* Cssize::operator()(Keyframe_Rule* r)
+  Statement_Ptr Cssize::operator()(Keyframe_Rule_Ptr r)
   {
     if (!r->block() || !r->block()->length()) return r;
 
-    Keyframe_Rule* rr = SASS_MEMORY_NEW(ctx.mem, Keyframe_Rule,
+    Keyframe_Rule_Obj rr = SASS_MEMORY_NEW(Keyframe_Rule,
                                         r->pstate(),
-                                        r->block()->perform(this)->block());
-    if (r->selector()) rr->selector(r->selector());
+                                        operator()(&r->block()));
+    if (&r->name()) rr->name(r->name());
 
-    return debubble(rr->block(), rr)->block();
+    return debubble(&rr->block(), &rr);
   }
 
-  Statement* Cssize::operator()(Ruleset* r)
+  Statement_Ptr Cssize::operator()(Ruleset_Ptr 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
-    Statement* stmt = r->block()->perform(this);
+    Block_Ptr 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 (dynamic_cast<Statement*>((AST_Node*)stmt) == NULL) {
+    if (dynamic_cast<Statement_Ptr>(bb) == NULL) {
       error("Illegal nesting: Only properties may be nested beneath properties.", r->block()->pstate());
     }
-    Ruleset* rr = SASS_MEMORY_NEW(ctx.mem, Ruleset,
+    Ruleset_Obj rr = SASS_MEMORY_NEW(Ruleset,
                                   r->pstate(),
                                   r->selector(),
-                                  stmt->block());
+                                  bb);
+
     rr->is_root(r->is_root());
     // rr->tabs(r->block()->tabs());
     p_stack.pop_back();
@@ -159,68 +161,74 @@ namespace Sass {
       error("Illegal nesting: Only properties may be nested beneath properties.", r->block()->pstate());
     }
 
-    Block* props = SASS_MEMORY_NEW(ctx.mem, Block, rr->block()->pstate());
-    Block* rules = SASS_MEMORY_NEW(ctx.mem, Block, rr->block()->pstate());
+    Block_Obj props = SASS_MEMORY_NEW(Block, rr->block()->pstate());
+    Block_Ptr rules = SASS_MEMORY_NEW(Block, rr->block()->pstate());
     for (size_t i = 0, L = rr->block()->length(); i < L; i++)
     {
-      Statement* s = (*rr->block())[i];
-      if (bubblable(s)) *rules << s;
-      if (!bubblable(s)) *props << s;
+      Statement_Ptr s = &rr->block()->at(i);
+      if (bubblable(s)) rules->append(s);
+      if (!bubblable(s)) props->append(s);
     }
 
     if (props->length())
     {
-      Block* bb = SASS_MEMORY_NEW(ctx.mem, Block, rr->block()->pstate());
-      *bb += props;
+      Block_Obj bb = SASS_MEMORY_NEW(Block, rr->block()->pstate());
+      bb->concat(&props);
       rr->block(bb);
 
       for (size_t i = 0, L = rules->length(); i < L; i++)
       {
-        (*rules)[i]->tabs((*rules)[i]->tabs() + 1);
+        Statement_Ptr stm = &rules->at(i);
+        stm->tabs(stm->tabs() + 1);
       }
 
-      rules->unshift(rr);
+      rules->unshift(&rr);
     }
 
-    rules = debubble(rules)->block();
+    Block_Ptr ptr = rules;
+    rules = debubble(rules);
+    void* lp = ptr;
+    void* rp = rules;
+    if (lp != rp) {
+      Block_Obj obj = ptr;
+    }
 
     if (!(!rules->length() ||
-          !bubblable(rules->last()) ||
+          !bubblable(&rules->last()) ||
           parent()->statement_type() == Statement::RULESET))
     {
       rules->last()->group_end(true);
     }
-
     return rules;
   }
 
-  Statement* Cssize::operator()(Null* m)
+  Statement_Ptr Cssize::operator()(Null_Ptr m)
   {
     return 0;
   }
 
-  Statement* Cssize::operator()(Media_Block* m)
+  Statement_Ptr Cssize::operator()(Media_Block_Ptr m)
   {
     if (parent()->statement_type() == Statement::RULESET)
     { return bubble(m); }
 
     if (parent()->statement_type() == Statement::MEDIA)
-    { return SASS_MEMORY_NEW(ctx.mem, Bubble, m->pstate(), m); }
+    { return SASS_MEMORY_NEW(Bubble, m->pstate(), m); }
 
     p_stack.push_back(m);
 
-    Media_Block* mm = SASS_MEMORY_NEW(ctx.mem, Media_Block,
+    Media_Block_Obj mm = SASS_MEMORY_NEW(Media_Block,
                                       m->pstate(),
-                                      m->media_queries(),
-                                      m->block()->perform(this)->block());
+                                      &m->media_queries(),
+                                      operator()(&m->block()));
     mm->tabs(m->tabs());
 
     p_stack.pop_back();
 
-    return debubble(mm->block(), mm)->block();
+    return debubble(&mm->block(), &mm);
   }
 
-  Statement* Cssize::operator()(Supports_Block* m)
+  Statement_Ptr Cssize::operator()(Supports_Block_Ptr m)
   {
     if (!m->block()->length())
     { return m; }
@@ -230,267 +238,231 @@ namespace Sass {
 
     p_stack.push_back(m);
 
-    Supports_Block* mm = SASS_MEMORY_NEW(ctx.mem, Supports_Block,
+    Supports_Block_Obj mm = SASS_MEMORY_NEW(Supports_Block,
                                        m->pstate(),
-                                       m->condition(),
-                                       m->block()->perform(this)->block());
+                                       &m->condition(),
+                                       operator()(&m->block()));
     mm->tabs(m->tabs());
 
     p_stack.pop_back();
 
-    return debubble(mm->block(), mm)->block();
+    return debubble(&mm->block(), &mm);
   }
 
-  Statement* Cssize::operator()(At_Root_Block* m)
+  Statement_Ptr Cssize::operator()(At_Root_Block_Ptr m)
   {
     bool tmp = false;
     for (size_t i = 0, L = p_stack.size(); i < L; ++i) {
-      Statement* s = p_stack[i];
+      Statement_Ptr s = p_stack[i];
       tmp |= m->exclude_node(s);
     }
 
     if (!tmp)
     {
-      Block* bb = m->block()->perform(this)->block();
+      Block_Ptr bb = operator()(&m->block());
       for (size_t i = 0, L = bb->length(); i < L; ++i) {
         // (bb->elements())[i]->tabs(m->tabs());
-        if (bubblable((*bb)[i])) (*bb)[i]->tabs((*bb)[i]->tabs() + m->tabs());
+        Statement_Obj stm = bb->at(i);
+        if (bubblable(&stm)) stm->tabs(stm->tabs() + m->tabs());
       }
-      if (bb->length() && bubblable(bb->last())) bb->last()->group_end(m->group_end());
+      if (bb->length() && bubblable(&bb->last())) bb->last()->group_end(m->group_end());
       return bb;
     }
 
     if (m->exclude_node(parent()))
     {
-      return SASS_MEMORY_NEW(ctx.mem, Bubble, m->pstate(), m);
+      return SASS_MEMORY_NEW(Bubble, m->pstate(), m);
     }
 
     return bubble(m);
   }
 
-  Statement* Cssize::bubble(Directive* m)
+  Statement_Ptr Cssize::bubble(Directive_Ptr m)
   {
-    Block* bb = SASS_MEMORY_NEW(ctx.mem, Block, this->parent()->pstate());
-    Has_Block* new_rule = static_cast<Has_Block*>(shallow_copy(this->parent()));
+    Block_Ptr bb = SASS_MEMORY_NEW(Block, this->parent()->pstate());
+    Has_Block_Obj new_rule = static_cast<Has_Block_Ptr>(SASS_MEMORY_COPY(this->parent()));
     new_rule->block(bb);
     new_rule->tabs(this->parent()->tabs());
+    new_rule->block()->concat(&m->block());
 
-    size_t L = m->block() ? m->block()->length() : 0;
-    for (size_t i = 0; i < L; ++i) {
-      *new_rule->block() << (*m->block())[i];
-    }
-
-    Block* wrapper_block = SASS_MEMORY_NEW(ctx.mem, Block, m->block() ? m->block()->pstate() : m->pstate());
-    *wrapper_block << new_rule;
-    Directive* mm = SASS_MEMORY_NEW(ctx.mem, Directive,
+    Block_Obj wrapper_block = SASS_MEMORY_NEW(Block, m->block() ? m->block()->pstate() : m->pstate());
+    wrapper_block->append(&new_rule);
+    Directive_Obj mm = SASS_MEMORY_NEW(Directive,
                                   m->pstate(),
                                   m->keyword(),
                                   m->selector(),
                                   wrapper_block);
     if (m->value()) mm->value(m->value());
 
-    Bubble* bubble = SASS_MEMORY_NEW(ctx.mem, Bubble, mm->pstate(), mm);
+    Bubble_Ptr bubble = SASS_MEMORY_NEW(Bubble, mm->pstate(), &mm);
     return bubble;
   }
 
-  Statement* Cssize::bubble(At_Root_Block* m)
+  Statement_Ptr Cssize::bubble(At_Root_Block_Ptr m)
   {
-    Block* bb = SASS_MEMORY_NEW(ctx.mem, Block, this->parent()->pstate());
-    Has_Block* new_rule = static_cast<Has_Block*>(shallow_copy(this->parent()));
+    Block_Ptr bb = SASS_MEMORY_NEW(Block, this->parent()->pstate());
+    Has_Block_Obj new_rule = static_cast<Has_Block_Ptr>(SASS_MEMORY_COPY(this->parent()));
     new_rule->block(bb);
     new_rule->tabs(this->parent()->tabs());
+    new_rule->block()->concat(&m->block());
 
-    for (size_t i = 0, L = m->block()->length(); i < L; ++i) {
-      *new_rule->block() << (*m->block())[i];
-    }
-
-    Block* wrapper_block = SASS_MEMORY_NEW(ctx.mem, Block, m->block()->pstate());
-    *wrapper_block << new_rule;
-    At_Root_Block* mm = SASS_MEMORY_NEW(ctx.mem, At_Root_Block,
+    Block_Ptr wrapper_block = SASS_MEMORY_NEW(Block, m->block()->pstate());
+    wrapper_block->append(&new_rule);
+    At_Root_Block_Ptr mm = SASS_MEMORY_NEW(At_Root_Block,
                                         m->pstate(),
                                         wrapper_block,
                                         m->expression());
-    Bubble* bubble = SASS_MEMORY_NEW(ctx.mem, Bubble, mm->pstate(), mm);
+    Bubble_Ptr bubble = SASS_MEMORY_NEW(Bubble, mm->pstate(), mm);
     return bubble;
   }
 
-  Statement* Cssize::bubble(Supports_Block* m)
+  Statement_Ptr Cssize::bubble(Supports_Block_Ptr m)
   {
-    Ruleset* parent = static_cast<Ruleset*>(shallow_copy(this->parent()));
+    Ruleset_Obj parent = static_cast<Ruleset_Ptr>(SASS_MEMORY_COPY(this->parent()));
 
-    Block* bb = SASS_MEMORY_NEW(ctx.mem, Block, parent->block()->pstate());
-    Ruleset* new_rule = SASS_MEMORY_NEW(ctx.mem, Ruleset,
+    Block_Ptr bb = SASS_MEMORY_NEW(Block, parent->block()->pstate());
+    Ruleset_Ptr new_rule = SASS_MEMORY_NEW(Ruleset,
                                         parent->pstate(),
                                         parent->selector(),
                                         bb);
     new_rule->tabs(parent->tabs());
+    new_rule->block()->concat(&m->block());
 
-    for (size_t i = 0, L = m->block()->length(); i < L; ++i) {
-      *new_rule->block() << (*m->block())[i];
-    }
-
-    Block* wrapper_block = SASS_MEMORY_NEW(ctx.mem, Block, m->block()->pstate());
-    *wrapper_block << new_rule;
-    Supports_Block* mm = SASS_MEMORY_NEW(ctx.mem, Supports_Block,
+    Block_Ptr wrapper_block = SASS_MEMORY_NEW(Block, m->block()->pstate());
+    wrapper_block->append(new_rule);
+    Supports_Block_Ptr mm = SASS_MEMORY_NEW(Supports_Block,
                                        m->pstate(),
-                                       m->condition(),
+                                       &m->condition(),
                                        wrapper_block);
 
     mm->tabs(m->tabs());
 
-    Bubble* bubble = SASS_MEMORY_NEW(ctx.mem, Bubble, mm->pstate(), mm);
+    Bubble_Ptr bubble = SASS_MEMORY_NEW(Bubble, mm->pstate(), mm);
     return bubble;
   }
 
-  Statement* Cssize::bubble(Media_Block* m)
+  Statement_Ptr Cssize::bubble(Media_Block_Ptr m)
   {
-    Ruleset* parent = static_cast<Ruleset*>(shallow_copy(this->parent()));
+    Ruleset_Obj parent = static_cast<Ruleset_Ptr>(SASS_MEMORY_COPY(this->parent()));
 
-    Block* bb = SASS_MEMORY_NEW(ctx.mem, Block, parent->block()->pstate());
-    Ruleset* new_rule = SASS_MEMORY_NEW(ctx.mem, Ruleset,
+    Block_Ptr bb = SASS_MEMORY_NEW(Block, parent->block()->pstate());
+    Ruleset_Ptr new_rule = SASS_MEMORY_NEW(Ruleset,
                                         parent->pstate(),
                                         parent->selector(),
                                         bb);
     new_rule->tabs(parent->tabs());
+    new_rule->block()->concat(&m->block());
 
-    for (size_t i = 0, L = m->block()->length(); i < L; ++i) {
-      *new_rule->block() << (*m->block())[i];
-    }
-
-    Block* wrapper_block = SASS_MEMORY_NEW(ctx.mem, Block, m->block()->pstate());
-    *wrapper_block << new_rule;
-    Media_Block* mm = SASS_MEMORY_NEW(ctx.mem, Media_Block,
+    Block_Ptr 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(),
-                                      m->media_queries(),
+                                      &m->media_queries(),
                                       wrapper_block,
                                       0);
 
     mm->tabs(m->tabs());
 
-    Bubble* bubble = SASS_MEMORY_NEW(ctx.mem, Bubble, mm->pstate(), mm);
-
-    return bubble;
+    return SASS_MEMORY_NEW(Bubble, mm->pstate(), &mm);
   }
 
-  bool Cssize::bubblable(Statement* s)
+  bool Cssize::bubblable(Statement_Ptr s)
   {
-    return s->statement_type() == Statement::RULESET || s->bubbles();
+    return dynamic_cast<Ruleset_Ptr>(s) || s->bubbles();
   }
 
-  Statement* Cssize::flatten(Statement* s)
+  Block_Ptr Cssize::flatten(Block_Ptr b)
   {
-    Block* bb = s->block();
-    Block* result = SASS_MEMORY_NEW(ctx.mem, Block, bb->pstate(), 0, bb->is_root());
-    for (size_t i = 0, L = bb->length(); i < L; ++i) {
-      Statement* ss = (*bb)[i];
-      if (ss->block()) {
-        ss = flatten(ss);
-        for (size_t j = 0, K = ss->block()->length(); j < K; ++j) {
-          *result << (*ss->block())[j];
+    Block_Ptr 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 = SASS_MEMORY_CAST_PTR(Block, ss)) {
+        Block_Obj bs = flatten(bb);
+        for (size_t j = 0, K = bs->length(); j < K; ++j) {
+          result->append(bs->at(j));
         }
       }
       else {
-        *result << ss;
+        result->append(ss);
       }
     }
     return result;
   }
 
-  std::vector<std::pair<bool, Block*>> Cssize::slice_by_bubble(Statement* b)
+  std::vector<std::pair<bool, Block_Obj>> Cssize::slice_by_bubble(Block_Ptr b)
   {
-    std::vector<std::pair<bool, Block*>> results;
-    for (size_t i = 0, L = b->block()->length(); i < L; ++i) {
-      Statement* value = (*b->block())[i];
-      bool key = value->statement_type() == Statement::BUBBLE;
+    std::vector<std::pair<bool, Block_Obj>> results;
+
+    for (size_t i = 0, L = b->length(); i < L; ++i) {
+      Statement_Obj value = b->at(i);
+      bool key = dynamic_cast<Bubble_Ptr>(&value) != NULL;
 
       if (!results.empty() && results.back().first == key)
       {
-        Block* wrapper_block = results.back().second;
-        *wrapper_block << value;
+        Block_Obj wrapper_block = results.back().second;
+        wrapper_block->append(value);
       }
       else
       {
-        Block* wrapper_block = SASS_MEMORY_NEW(ctx.mem, Block, value->pstate());
-        *wrapper_block << value;
+        Block_Ptr wrapper_block = SASS_MEMORY_NEW(Block, value->pstate());
+        wrapper_block->append(value);
         results.push_back(std::make_pair(key, wrapper_block));
       }
     }
     return results;
   }
 
-  Statement* Cssize::shallow_copy(Statement* s)
+  Block_Ptr Cssize::debubble(Block_Ptr children, Statement_Ptr parent)
   {
-    switch (s->statement_type())
-    {
-      case Statement::RULESET:
-        return SASS_MEMORY_NEW(ctx.mem, Ruleset, *static_cast<Ruleset*>(s));
-      case Statement::MEDIA:
-        return SASS_MEMORY_NEW(ctx.mem, Media_Block, *static_cast<Media_Block*>(s));
-      case Statement::BUBBLE:
-        return SASS_MEMORY_NEW(ctx.mem, Bubble, *static_cast<Bubble*>(s));
-      case Statement::DIRECTIVE:
-        return SASS_MEMORY_NEW(ctx.mem, Directive, *static_cast<Directive*>(s));
-      case Statement::SUPPORTS:
-        return SASS_MEMORY_NEW(ctx.mem, Supports_Block, *static_cast<Supports_Block*>(s));
-      case Statement::ATROOT:
-        return SASS_MEMORY_NEW(ctx.mem, At_Root_Block, *static_cast<At_Root_Block*>(s));
-      case Statement::KEYFRAMERULE:
-        return SASS_MEMORY_NEW(ctx.mem, Keyframe_Rule, *static_cast<Keyframe_Rule*>(s));
-      case Statement::NONE:
-      default:
-        error("unknown internal error; please contact the LibSass maintainers", s->pstate(), backtrace);
-        String_Quoted* msg = SASS_MEMORY_NEW(ctx.mem, String_Quoted, ParserState("[WARN]"), std::string("`CSSize` can't clone ") + typeid(*s).name());
-        return SASS_MEMORY_NEW(ctx.mem, Warning, ParserState("[WARN]"), msg);
-    }
-  }
-
-  Statement* Cssize::debubble(Block* children, Statement* parent)
-  {
-    Has_Block* previous_parent = 0;
-    std::vector<std::pair<bool, Block*>> baz = slice_by_bubble(children);
-    Block* result = SASS_MEMORY_NEW(ctx.mem, Block, children->pstate());
+    Has_Block_Obj previous_parent = 0;
+    std::vector<std::pair<bool, Block_Obj>> baz = slice_by_bubble(children);
+    Block_Obj result = SASS_MEMORY_NEW(Block, children->pstate());
 
     for (size_t i = 0, L = baz.size(); i < L; ++i) {
       bool is_bubble = baz[i].first;
-      Block* slice = baz[i].second;
+      Block_Obj slice = baz[i].second;
 
       if (!is_bubble) {
         if (!parent) {
-          *result << slice;
+          result->append(&slice);
         }
         else if (previous_parent) {
-          *previous_parent->block() += slice;
+          previous_parent->block()->concat(&slice);
         }
         else {
-          previous_parent = static_cast<Has_Block*>(shallow_copy(parent));
+          previous_parent = static_cast<Has_Block_Ptr>(SASS_MEMORY_COPY(parent));
           previous_parent->block(slice);
           previous_parent->tabs(parent->tabs());
 
-          Has_Block* new_parent = previous_parent;
-
-          *result << new_parent;
+          result->append(&previous_parent);
         }
         continue;
       }
 
       for (size_t j = 0, K = slice->length(); j < K; ++j)
       {
-        Statement* ss = 0;
-        Bubble* node = static_cast<Bubble*>((*slice)[j]);
-
+        Statement_Ptr ss = NULL;
+        Statement_Obj stm = slice->at(j);
+        // this has to go now here (too bad)
+        Bubble_Obj node = SASS_MEMORY_CAST(Bubble, stm);
+        Media_Block_Ptr m1 = NULL;
+        Media_Block_Ptr m2 = NULL;
+        if (parent) m1 = SASS_MEMORY_CAST(Media_Block, *parent);
+        if (node) m2 = SASS_MEMORY_CAST(Media_Block, node->node());
         if (!parent ||
             parent->statement_type() != Statement::MEDIA ||
             node->node()->statement_type() != Statement::MEDIA ||
-            static_cast<Media_Block*>(node->node())->media_queries() == static_cast<Media_Block*>(parent)->media_queries())
+            (m1 && m2 && &m1->media_queries() == &m2->media_queries())
+          )
         {
-          ss = node->node();
+          ss = &node->node();
         }
         else
         {
-          List* mq = merge_media_queries(static_cast<Media_Block*>(node->node()), static_cast<Media_Block*>(parent));
+          List_Obj mq = merge_media_queries(static_cast<Media_Block_Ptr>(&node->node()), static_cast<Media_Block_Ptr>(parent));
           if (!mq->length()) continue;
-          static_cast<Media_Block*>(node->node())->media_queries(mq);
-          ss = node->node();
+          static_cast<Media_Block_Ptr>(&node->node())->media_queries(mq);
+          ss = &node->node();
         }
 
         if (!ss) continue;
@@ -500,69 +472,68 @@ namespace Sass {
 
         if (!ss) continue;
 
-        Block* bb = SASS_MEMORY_NEW(ctx.mem, Block,
-                                    children->block()->pstate(),
-                                    children->block()->length(),
-                                    children->block()->is_root());
-        *bb << ss->perform(this);
+        Block_Obj bb = SASS_MEMORY_NEW(Block,
+                                    children->pstate(),
+                                    children->length(),
+                                    children->is_root());
+        bb->append(ss->perform(this));
 
-        Block* wrapper_block = SASS_MEMORY_NEW(ctx.mem, Block,
-                                              children->block()->pstate(),
-                                              children->block()->length(),
-                                              children->block()->is_root());
+        Block_Obj wrapper_block = SASS_MEMORY_NEW(Block,
+                                              children->pstate(),
+                                              children->length(),
+                                              children->is_root());
 
-        Statement* wrapper = flatten(bb);
-        *wrapper_block << wrapper;
+        Block_Ptr wrapper = flatten(&bb);
+        wrapper_block->append(wrapper);
 
-        if (wrapper->block()->length()) {
-          previous_parent = 0;
+        if (wrapper->length()) {
+          previous_parent = NULL;
         }
 
         if (wrapper_block) {
-          *result << wrapper_block;
+          result->append(&wrapper_block);
         }
       }
     }
 
-    return flatten(result);
+    return flatten(&result);
   }
 
-  Statement* Cssize::fallback_impl(AST_Node* n)
+  Statement_Ptr Cssize::fallback_impl(AST_Node_Ptr n)
   {
-    return static_cast<Statement*>(n);
+    return static_cast<Statement_Ptr>(n);
   }
 
-  void Cssize::append_block(Block* b)
+  void Cssize::append_block(Block_Ptr b, Block_Ptr cur)
   {
-    Block* current_block = block_stack.back();
-
     for (size_t i = 0, L = b->length(); i < L; ++i) {
-      Statement* ith = (*b)[i]->perform(this);
-      if (ith && ith->block()) {
-        for (size_t j = 0, K = ith->block()->length(); j < K; ++j) {
-          *current_block << (*ith->block())[j];
+      Statement_Obj ith = b->at(i)->perform(this);
+      if (Block_Ptr bb = SASS_MEMORY_CAST(Block, ith)) {
+        for (size_t j = 0, K = bb->length(); j < K; ++j) {
+          cur->append(bb->at(j));
         }
       }
       else if (ith) {
-        *current_block << ith;
+        cur->append(ith);
       }
     }
   }
 
-  List* Cssize::merge_media_queries(Media_Block* m1, Media_Block* m2)
+  List_Ptr Cssize::merge_media_queries(Media_Block_Ptr m1, Media_Block_Ptr m2)
   {
-    List* qq = SASS_MEMORY_NEW(ctx.mem, List,
+    List_Ptr qq = SASS_MEMORY_NEW(List,
                                m1->media_queries()->pstate(),
                                m1->media_queries()->length(),
                                SASS_COMMA);
 
     for (size_t i = 0, L = m1->media_queries()->length(); i < L; i++) {
       for (size_t j = 0, K = m2->media_queries()->length(); j < K; j++) {
-        Media_Query* mq1 = static_cast<Media_Query*>((*m1->media_queries())[i]);
-        Media_Query* mq2 = static_cast<Media_Query*>((*m2->media_queries())[j]);
-        Media_Query* mq = merge_media_query(mq1, mq2);
-
-        if (mq) *qq << mq;
+        Expression_Obj l1 = m1->media_queries()->at(i);
+        Expression_Obj l2 = m2->media_queries()->at(j);
+        Media_Query_Ptr mq1 = SASS_MEMORY_CAST(Media_Query, l1);
+        Media_Query_Ptr mq2 = SASS_MEMORY_CAST(Media_Query, l2);
+        Media_Query_Ptr mq = merge_media_query(mq1, mq2);
+        if (mq) qq->append(mq);
       }
     }
 
@@ -570,16 +541,16 @@ namespace Sass {
   }
 
 
-  Media_Query* Cssize::merge_media_query(Media_Query* mq1, Media_Query* mq2)
+  Media_Query_Ptr Cssize::merge_media_query(Media_Query_Ptr mq1, Media_Query_Ptr mq2)
   {
 
     std::string type;
     std::string mod;
 
     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 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 t2 = mq2->media_type() ? mq2->media_type()->to_string(ctx.c_options) : "";
+    std::string t2 = &mq2->media_type() ? mq2->media_type()->to_string(ctx.c_options) : "";
 
 
     if (t1.empty()) t1 = t2;
@@ -606,18 +577,19 @@ namespace Sass {
       mod = m1.empty() ? m2 : m1;
     }
 
-    Media_Query* mm = SASS_MEMORY_NEW(ctx.mem, Media_Query,
+    Media_Query_Ptr mm = SASS_MEMORY_NEW(Media_Query,
 
 mq1->pstate(), 0,
 mq1->length() + mq2->length(), mod == "not", mod == "only"
 );
 
     if (!type.empty()) {
-      mm->media_type(SASS_MEMORY_NEW(ctx.mem, String_Quoted, mq1->pstate(), type));
+      mm->media_type(SASS_MEMORY_NEW(String_Quoted, mq1->pstate(), type));
     }
 
-    *mm += mq2;
-    *mm += mq1;
+    mm->concat(mq2);
+    mm->concat(mq1);
+
     return mm;
   }
 }