sassc 1.11.1 → 1.11.2

data/ext/libsass/src/emitter.cpp

@@ -45,11 +45,11 @@ namespace Sass {
   void Emitter::set_filename(const std::string& str)
   { wbuf.smap.file = str; }
 
-  void Emitter::schedule_mapping(const AST_Node* node)
+  void Emitter::schedule_mapping(const AST_Node_Ptr node)
   { scheduled_mapping = node; }
-  void Emitter::add_open_mapping(const AST_Node* node)
+  void Emitter::add_open_mapping(const AST_Node_Ptr node)
   { wbuf.smap.add_open_mapping(node); }
-  void Emitter::add_close_mapping(const AST_Node* node)
+  void Emitter::add_close_mapping(const AST_Node_Ptr node)
   { wbuf.smap.add_close_mapping(node); }
   ParserState Emitter::remap(const ParserState& pstate)
   { return wbuf.smap.remap(pstate); }
@@ -139,7 +139,7 @@ namespace Sass {
 
   // append some text or token to the buffer
   // this adds source-mappings for node start and end
-  void Emitter::append_token(const std::string& text, const AST_Node* node)
+  void Emitter::append_token(const std::string& text, const AST_Node_Ptr node)
   {
     flush_schedules();
     add_open_mapping(node);
@@ -239,7 +239,7 @@ namespace Sass {
     }
   }
 
-  void Emitter::append_scope_opener(AST_Node* node)
+  void Emitter::append_scope_opener(AST_Node_Ptr node)
   {
     scheduled_linefeed = 0;
     append_optional_space();
@@ -250,7 +250,7 @@ namespace Sass {
     // append_optional_space();
     ++ indentation;
   }
-  void Emitter::append_scope_closer(AST_Node* node)
+  void Emitter::append_scope_closer(AST_Node_Ptr node)
   {
     -- indentation;
     scheduled_linefeed = 0;

data/ext/libsass/src/emitter.hpp

@@ -25,9 +25,9 @@ namespace Sass {
       // proxy methods for source maps
       void add_source_index(size_t idx);
       void set_filename(const std::string& str);
-      void add_open_mapping(const AST_Node* node);
-      void add_close_mapping(const AST_Node* node);
-      void schedule_mapping(const AST_Node* node);
+      void add_open_mapping(const AST_Node_Ptr node);
+      void add_close_mapping(const AST_Node_Ptr node);
+      void schedule_mapping(const AST_Node_Ptr node);
       std::string render_srcmap(Context &ctx);
       ParserState remap(const ParserState& pstate);
 
@@ -37,7 +37,7 @@ namespace Sass {
       size_t scheduled_space;
       size_t scheduled_linefeed;
       bool scheduled_delimiter;
-      const AST_Node* scheduled_mapping;
+      AST_Node_Ptr scheduled_mapping;
 
     public:
       // output strings different in comments
@@ -70,7 +70,7 @@ namespace Sass {
       void append_wspace(const std::string& text);
       // append some text or token to the buffer
       // this adds source-mappings for node start and end
-      void append_token(const std::string& text, const AST_Node* node);
+      void append_token(const std::string& text, const AST_Node_Ptr node);
 
     public: // syntax sugar
       void append_indentation();
@@ -79,8 +79,8 @@ namespace Sass {
       void append_special_linefeed(void);
       void append_optional_linefeed(void);
       void append_mandatory_linefeed(void);
-      void append_scope_opener(AST_Node* node = 0);
-      void append_scope_closer(AST_Node* node = 0);
+      void append_scope_opener(AST_Node_Ptr node = 0);
+      void append_scope_closer(AST_Node_Ptr node = 0);
       void append_comma_separator(void);
       void append_colon_separator(void);
       void append_delimiter(void);

data/ext/libsass/src/environment.cpp

@@ -179,7 +179,7 @@ namespace Sass {
     for (typename std::map<std::string, T>::iterator i = local_frame_.begin(); i != local_frame_.end(); ++i) {
       if (!ends_with(i->first, "[f]") && !ends_with(i->first, "[f]4") && !ends_with(i->first, "[f]2")) {
         std::cerr << prefix << std::string(indent, ' ') << i->first << " "  << i->second;
-        if (Value* val = dynamic_cast<Value*>(i->second))
+        if (Value_Ptr val = SASS_MEMORY_CAST_PTR(Value, i->second))
         { std::cerr << " : " << val->to_string(); }
         std::cerr << std::endl;
       }
@@ -189,7 +189,7 @@ namespace Sass {
   #endif
 
   // compile implementation for AST_Node
-  template class Environment<AST_Node*>;
+  template class Environment<AST_Node_Obj>;
 
 }
 

data/ext/libsass/src/environment.hpp

@@ -6,7 +6,6 @@
 
 #include "ast_fwd_decl.hpp"
 #include "ast_def_macros.hpp"
-#include "memory_manager.hpp"
 
 namespace Sass {
 
@@ -18,7 +17,6 @@ namespace Sass {
     ADD_PROPERTY(bool, is_shadow)
 
   public:
-    Memory_Manager mem;
     Environment(bool is_shadow = false);
     Environment(Environment* env, bool is_shadow = false);
     Environment(Environment& env, bool is_shadow = false);

data/ext/libsass/src/error_handling.cpp

@@ -21,7 +21,7 @@ namespace Sass {
     { }
 
 
-    InvalidParent::InvalidParent(Selector* parent, Selector* selector)
+    InvalidParent::InvalidParent(Selector_Ptr parent, Selector_Ptr selector)
     : Base(selector->pstate()), parent(parent), selector(selector)
     {
       msg = "Invalid parent selector for \"";
@@ -31,7 +31,7 @@ namespace Sass {
       msg += "\"";
     }
 
-    InvalidArgumentType::InvalidArgumentType(ParserState pstate, std::string fn, std::string arg, std::string type, const Value* value)
+    InvalidArgumentType::InvalidArgumentType(ParserState pstate, std::string fn, std::string arg, std::string type, const Value_Ptr value)
     : Base(pstate), fn(fn), arg(arg), type(type), value(value)
     {
       msg  = arg + ": \"";
@@ -52,7 +52,7 @@ namespace Sass {
     : Base(pstate, msg, import_stack)
     { }
 
-    UndefinedOperation::UndefinedOperation(const Expression* lhs, const Expression* rhs, const std::string& op)
+    UndefinedOperation::UndefinedOperation(Expression_Ptr_Const lhs, Expression_Ptr_Const rhs, const std::string& op)
     : lhs(lhs), rhs(rhs), op(op)
     {
       msg  = def_op_msg + ": \"";
@@ -62,7 +62,7 @@ namespace Sass {
       msg += "\".";
     }
 
-    InvalidNullOperation::InvalidNullOperation(const Expression* lhs, const Expression* rhs, const std::string& op)
+    InvalidNullOperation::InvalidNullOperation(Expression_Ptr_Const lhs, Expression_Ptr_Const rhs, const std::string& op)
     : UndefinedOperation(lhs, rhs, op)
     {
       msg  = def_op_null_msg + ": \"";
@@ -120,7 +120,7 @@ namespace Sass {
       msg += "'.";
     }
 
-    AlphaChannelsNotEqual::AlphaChannelsNotEqual(const Expression* lhs, const Expression* rhs, const std::string& op)
+    AlphaChannelsNotEqual::AlphaChannelsNotEqual(Expression_Ptr_Const lhs, Expression_Ptr_Const rhs, const std::string& op)
     : lhs(lhs), rhs(rhs), op(op)
     {
       msg  = "Alpha channels must be equal: ";

data/ext/libsass/src/error_handling.hpp

@@ -38,10 +38,10 @@ namespace Sass {
 
     class InvalidParent : public Base {
       protected:
-        Selector* parent;
-        Selector* selector;
+        Selector_Ptr parent;
+        Selector_Ptr selector;
       public:
-        InvalidParent(Selector* parent, Selector* selector);
+        InvalidParent(Selector_Ptr parent, Selector_Ptr selector);
         virtual ~InvalidParent() throw() {};
     };
 
@@ -60,9 +60,9 @@ namespace Sass {
         std::string fn;
         std::string arg;
         std::string type;
-        const Value* value;
+        const Value_Ptr value;
       public:
-        InvalidArgumentType(ParserState pstate, std::string fn, std::string arg, std::string type, const Value* value = 0);
+        InvalidArgumentType(ParserState pstate, std::string fn, std::string arg, std::string type, const Value_Ptr value = 0);
         virtual ~InvalidArgumentType() throw() {};
     };
 
@@ -145,28 +145,28 @@ namespace Sass {
 
     class UndefinedOperation : public OperationError {
       protected:
-        const Expression* lhs;
-        const Expression* rhs;
+        Expression_Ptr_Const lhs;
+        Expression_Ptr_Const rhs;
         const std::string op;
       public:
-        UndefinedOperation(const Expression* lhs, const Expression* rhs, const std::string& op);
+        UndefinedOperation(Expression_Ptr_Const lhs, Expression_Ptr_Const rhs, const std::string& op);
         // virtual const char* errtype() const { return "Error"; }
         virtual ~UndefinedOperation() throw() {};
     };
 
     class InvalidNullOperation : public UndefinedOperation {
       public:
-        InvalidNullOperation(const Expression* lhs, const Expression* rhs, const std::string& op);
+        InvalidNullOperation(Expression_Ptr_Const lhs, Expression_Ptr_Const rhs, const std::string& op);
         virtual ~InvalidNullOperation() throw() {};
     };
 
     class AlphaChannelsNotEqual : public OperationError {
       protected:
-        const Expression* lhs;
-        const Expression* rhs;
+        Expression_Ptr_Const lhs;
+        Expression_Ptr_Const rhs;
         const std::string op;
       public:
-        AlphaChannelsNotEqual(const Expression* lhs, const Expression* rhs, const std::string& op);
+        AlphaChannelsNotEqual(Expression_Ptr_Const lhs, Expression_Ptr_Const rhs, const std::string& op);
         // virtual const char* errtype() const { return "Error"; }
         virtual ~AlphaChannelsNotEqual() throw() {};
     };

data/ext/libsass/src/eval.cpp

@@ -54,17 +54,12 @@ namespace Sass {
   { }
   Eval::~Eval() { }
 
-  Context& Eval::context()
-  {
-    return ctx;
-  }
-
   Env* Eval::environment()
   {
     return exp.environment();
   }
 
-  CommaSequence_Selector* Eval::selector()
+  Selector_List_Obj Eval::selector()
   {
     return exp.selector();
   }
@@ -74,24 +69,24 @@ namespace Sass {
     return exp.backtrace();
   }
 
-  Expression* Eval::operator()(Block* b)
+  Expression_Ptr Eval::operator()(Block_Ptr b)
   {
-    Expression* val = 0;
+    Expression_Ptr val = 0;
     for (size_t i = 0, L = b->length(); i < L; ++i) {
-      val = (*b)[i]->perform(this);
+      val = b->at(i)->perform(this);
       if (val) return val;
     }
     return val;
   }
 
-  Expression* Eval::operator()(Assignment* a)
+  Expression_Ptr Eval::operator()(Assignment_Ptr a)
   {
     Env* env = exp.environment();
     std::string var(a->variable());
     if (a->is_global()) {
       if (a->is_default()) {
         if (env->has_global(var)) {
-          Expression* e = dynamic_cast<Expression*>(env->get_global(var));
+          Expression_Ptr e = SASS_MEMORY_CAST(Expression, env->get_global(var));
           if (!e || e->concrete_type() == Expression::NULL_VAL) {
             env->set_global(var, a->value()->perform(this));
           }
@@ -109,8 +104,8 @@ namespace Sass {
         auto cur = env;
         while (cur && cur->is_lexical()) {
           if (cur->has_local(var)) {
-            if (AST_Node* node = cur->get_local(var)) {
-              Expression* e = dynamic_cast<Expression*>(node);
+            if (AST_Node_Obj node = cur->get_local(var)) {
+              Expression_Ptr e = SASS_MEMORY_CAST(Expression, node);
               if (!e || e->concrete_type() == Expression::NULL_VAL) {
                 cur->set_local(var, a->value()->perform(this));
               }
@@ -125,8 +120,8 @@ namespace Sass {
         throw std::runtime_error("Env not in sync");
       }
       else if (env->has_global(var)) {
-        if (AST_Node* node = env->get_global(var)) {
-          Expression* e = dynamic_cast<Expression*>(node);
+        if (AST_Node_Obj node = env->get_global(var)) {
+          Expression_Ptr e = SASS_MEMORY_CAST(Expression, node);
           if (!e || e->concrete_type() == Expression::NULL_VAL) {
             env->set_global(var, a->value()->perform(this));
           }
@@ -145,42 +140,43 @@ namespace Sass {
     return 0;
   }
 
-  Expression* Eval::operator()(If* i)
+  Expression_Ptr Eval::operator()(If_Ptr i)
   {
-    Expression* rv = 0;
+    Expression_Obj rv = 0;
     Env env(exp.environment());
     exp.env_stack.push_back(&env);
-    if (*i->predicate()->perform(this)) {
+    Expression_Obj cond = i->predicate()->perform(this);
+    if (!cond->is_false()) {
       rv = i->block()->perform(this);
     }
     else {
-      Block* alt = i->alternative();
+      Block_Obj alt = i->alternative();
       if (alt) rv = alt->perform(this);
     }
     exp.env_stack.pop_back();
-    return rv;
+    return rv.detach();
   }
 
   // For does not create a new env scope
   // But iteration vars are reset afterwards
-  Expression* Eval::operator()(For* f)
+  Expression_Ptr Eval::operator()(For_Ptr f)
   {
     std::string variable(f->variable());
-    Expression* low = f->lower_bound()->perform(this);
+    Expression_Obj low = f->lower_bound()->perform(this);
     if (low->concrete_type() != Expression::NUMBER) {
       throw Exception::TypeMismatch(*low, "integer");
     }
-    Expression* high = f->upper_bound()->perform(this);
+    Expression_Obj high = f->upper_bound()->perform(this);
     if (high->concrete_type() != Expression::NUMBER) {
       throw Exception::TypeMismatch(*high, "integer");
     }
-    Number* sass_start = static_cast<Number*>(low);
-    Number* sass_end = static_cast<Number*>(high);
+    Number_Obj sass_start = SASS_MEMORY_CAST(Number, low);
+    Number_Obj sass_end = SASS_MEMORY_CAST(Number, high);
     // check if units are valid for sequence
     if (sass_start->unit() != sass_end->unit()) {
       std::stringstream msg; msg << "Incompatible units: '"
-        << sass_start->unit() << "' and '"
-        << sass_end->unit() << "'.";
+        << sass_end->unit() << "' and '"
+        << sass_start->unit() << "'.";
       error(msg.str(), low->pstate(), backtrace());
     }
     double start = sass_start->value();
@@ -188,10 +184,10 @@ namespace Sass {
     // only create iterator once in this environment
     Env env(environment(), true);
     exp.env_stack.push_back(&env);
-    Number* it = SASS_MEMORY_NEW(env.mem, Number, low->pstate(), start, sass_end->unit());
+    Number_Ptr it = SASS_MEMORY_NEW(Number, low->pstate(), start, sass_end->unit());
     env.set_local(variable, it);
-    Block* body = f->block();
-    Expression* val = 0;
+    Block_Obj body = f->block();
+    Expression_Ptr val = 0;
     if (start < end) {
       if (f->is_inclusive()) ++end;
       for (double i = start;
@@ -219,44 +215,45 @@ namespace Sass {
 
   // Eval does not create a new env scope
   // But iteration vars are reset afterwards
-  Expression* Eval::operator()(Each* e)
+  Expression_Ptr Eval::operator()(Each_Ptr e)
   {
     std::vector<std::string> variables(e->variables());
-    Expression* expr = e->list()->perform(this);
+    Expression_Obj expr = e->list()->perform(this);
     Env env(environment(), true);
     exp.env_stack.push_back(&env);
-    Vectorized<Expression*>* list = 0;
-    Map* map = 0;
+    List_Obj list = 0;
+    Map_Ptr map = 0;
     if (expr->concrete_type() == Expression::MAP) {
-      map = static_cast<Map*>(expr);
+      map = SASS_MEMORY_CAST(Map, expr);
     }
-    else if (CommaSequence_Selector* ls = dynamic_cast<CommaSequence_Selector*>(expr)) {
-      Listize listize(ctx.mem);
-      list = dynamic_cast<List*>(ls->perform(&listize));
+    else if (Selector_List_Ptr ls = SASS_MEMORY_CAST(Selector_List, expr)) {
+      Listize listize;
+      Expression_Obj rv = ls->perform(&listize);
+      list = dynamic_cast<List_Ptr>(&rv);
     }
     else if (expr->concrete_type() != Expression::LIST) {
-      list = SASS_MEMORY_NEW(ctx.mem, List, expr->pstate(), 1, SASS_COMMA);
-      *list << expr;
+      list = SASS_MEMORY_NEW(List, expr->pstate(), 1, SASS_COMMA);
+      list->append(expr);
     }
     else {
-      list = static_cast<List*>(expr);
+      list = SASS_MEMORY_CAST(List, expr);
     }
 
-    Block* body = e->block();
-    Expression* val = 0;
+    Block_Obj body = e->block();
+    Expression_Obj val = 0;
 
     if (map) {
-      for (auto key : map->keys()) {
-        Expression* value = map->at(key);
+      for (Expression_Obj key : map->keys()) {
+        Expression_Obj value = map->at(key);
 
         if (variables.size() == 1) {
-          List* variable = SASS_MEMORY_NEW(ctx.mem, List, map->pstate(), 2, SASS_SPACE);
-          *variable << key;
-          *variable << value;
+          List_Ptr variable = SASS_MEMORY_NEW(List, map->pstate(), 2, SASS_SPACE);
+          variable->append(key);
+          variable->append(value);
           env.set_local(variables[0], variable);
         } else {
-          env.set_local(variables[0], key);
-          env.set_local(variables[1], value);
+          env.set_local(variables[0], &key);
+          env.set_local(variables[1], &value);
         }
 
         val = body->perform(this);
@@ -264,33 +261,33 @@ namespace Sass {
       }
     }
     else {
-      if (list->length() == 1 && dynamic_cast<CommaSequence_Selector*>(list)) {
-        list = dynamic_cast<Vectorized<Expression*>*>(list);
+      if (list->length() == 1 && SASS_MEMORY_CAST(Selector_List, list)) {
+        list = SASS_MEMORY_CAST(List, list);
       }
       for (size_t i = 0, L = list->length(); i < L; ++i) {
-        Expression* e = (*list)[i];
+        Expression_Ptr e = &list->at(i);
         // unwrap value if the expression is an argument
-        if (Argument* arg = dynamic_cast<Argument*>(e)) e = arg->value();
+        if (Argument_Ptr arg = SASS_MEMORY_CAST_PTR(Argument, e)) e = &arg->value();
         // check if we got passed a list of args (investigate)
-        if (List* scalars = dynamic_cast<List*>(e)) {
+        if (List_Ptr scalars = SASS_MEMORY_CAST_PTR(List, e)) {
           if (variables.size() == 1) {
-            Expression* var = scalars;
+            Expression_Ptr var = scalars;
             env.set_local(variables[0], var);
           } else {
             // XXX: this is never hit via spec tests
             for (size_t j = 0, K = variables.size(); j < K; ++j) {
-              Expression* res = j >= scalars->length()
-                ? SASS_MEMORY_NEW(ctx.mem, Null, expr->pstate())
-                : (*scalars)[j];
+              Expression_Ptr res = j >= scalars->length()
+                ? SASS_MEMORY_NEW(Null, expr->pstate())
+                : &scalars->at(j);
               env.set_local(variables[j], res);
             }
           }
         } else {
           if (variables.size() > 0) {
-            env.set_local(variables[0], e);
+            env.set_local(variables.at(0), e);
             for (size_t j = 1, K = variables.size(); j < K; ++j) {
               // XXX: this is never hit via spec tests
-              Expression* res = SASS_MEMORY_NEW(ctx.mem, Null, expr->pstate());
+              Expression_Ptr res = SASS_MEMORY_NEW(Null, expr->pstate());
               env.set_local(variables[j], res);
             }
           }
@@ -300,43 +297,45 @@ namespace Sass {
       }
     }
     exp.env_stack.pop_back();
-    return val;
+    return val.detach();
   }
 
-  Expression* Eval::operator()(While* w)
+  Expression_Ptr Eval::operator()(While_Ptr w)
   {
-    Expression* pred = w->predicate();
-    Block* body = w->block();
+    Expression_Obj pred = w->predicate();
+    Block_Obj body = w->block();
     Env env(environment(), true);
     exp.env_stack.push_back(&env);
-    while (*pred->perform(this)) {
-      Expression* val = body->perform(this);
+    Expression_Obj cond = pred->perform(this);
+    while (!cond->is_false()) {
+      Expression_Obj val = body->perform(this);
       if (val) {
         exp.env_stack.pop_back();
-        return val;
+        return val.detach();
       }
+      cond = pred->perform(this);
     }
     exp.env_stack.pop_back();
     return 0;
   }
 
-  Expression* Eval::operator()(Return* r)
+  Expression_Ptr Eval::operator()(Return_Ptr r)
   {
     return r->value()->perform(this);
   }
 
-  Expression* Eval::operator()(Warning* w)
+  Expression_Ptr Eval::operator()(Warning_Ptr w)
   {
     Sass_Output_Style outstyle = ctx.c_options.output_style;
     ctx.c_options.output_style = NESTED;
-    Expression* message = w->message()->perform(this);
+    Expression_Obj message = w->message()->perform(this);
     Env* env = exp.environment();
 
     // try to use generic function
     if (env->has("@warn[f]")) {
 
-      Definition* def = static_cast<Definition*>((*env)["@warn[f]"]);
-      // Block*          body   = def->block();
+      Definition_Ptr def = SASS_MEMORY_CAST(Definition, (*env)["@warn[f]"]);
+      // Block_Obj          body   = def->block();
       // Native_Function func   = def->native_function();
       Sass_Function_Entry c_function = def->c_function();
       Sass_Function_Fn c_func = sass_function_get_function(c_function);
@@ -361,18 +360,18 @@ namespace Sass {
     return 0;
   }
 
-  Expression* Eval::operator()(Error* e)
+  Expression_Ptr Eval::operator()(Error_Ptr e)
   {
     Sass_Output_Style outstyle = ctx.c_options.output_style;
     ctx.c_options.output_style = NESTED;
-    Expression* message = e->message()->perform(this);
+    Expression_Obj message = e->message()->perform(this);
     Env* env = exp.environment();
 
     // try to use generic function
     if (env->has("@error[f]")) {
 
-      Definition* def = static_cast<Definition*>((*env)["@error[f]"]);
-      // Block*          body   = def->block();
+      Definition_Ptr def = SASS_MEMORY_CAST(Definition, (*env)["@error[f]"]);
+      // Block_Obj          body   = def->block();
       // Native_Function func   = def->native_function();
       Sass_Function_Entry c_function = def->c_function();
       Sass_Function_Fn c_func = sass_function_get_function(c_function);
@@ -394,18 +393,18 @@ namespace Sass {
     return 0;
   }
 
-  Expression* Eval::operator()(Debug* d)
+  Expression_Ptr Eval::operator()(Debug_Ptr d)
   {
     Sass_Output_Style outstyle = ctx.c_options.output_style;
     ctx.c_options.output_style = NESTED;
-    Expression* message = d->value()->perform(this);
+    Expression_Obj message = d->value()->perform(this);
     Env* env = exp.environment();
 
     // try to use generic function
     if (env->has("@debug[f]")) {
 
-      Definition* def = static_cast<Definition*>((*env)["@debug[f]"]);
-      // Block*          body   = def->block();
+      Definition_Ptr def = SASS_MEMORY_CAST(Definition, (*env)["@debug[f]"]);
+      // Block_Obj          body   = def->block();
       // Native_Function func   = def->native_function();
       Sass_Function_Entry c_function = def->c_function();
       Sass_Function_Fn c_func = sass_function_get_function(c_function);
@@ -433,17 +432,17 @@ namespace Sass {
     return 0;
   }
 
-  Expression* Eval::operator()(List* l)
+  Expression_Ptr Eval::operator()(List_Ptr l)
   {
     // special case for unevaluated map
     if (l->separator() == SASS_HASH) {
-      Map* lm = SASS_MEMORY_NEW(ctx.mem, Map,
+      Map_Obj lm = SASS_MEMORY_NEW(Map,
                                 l->pstate(),
                                 l->length() / 2);
       for (size_t i = 0, L = l->length(); i < L; i += 2)
       {
-        Expression* key = (*l)[i+0]->perform(this);
-        Expression* val = (*l)[i+1]->perform(this);
+        Expression_Ptr key = (*l)[i+0]->perform(this);
+        Expression_Ptr val = (*l)[i+1]->perform(this);
         // make sure the color key never displays its real name
         key->is_delayed(true); // verified
         *lm << std::make_pair(key, val);
@@ -458,21 +457,21 @@ namespace Sass {
     // check if we should expand it
     if (l->is_expanded()) return l;
     // regular case for unevaluated lists
-    List* ll = SASS_MEMORY_NEW(ctx.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));
     }
     ll->is_interpolant(l->is_interpolant());
     ll->from_selector(l->from_selector());
     ll->is_expanded(true);
-    return ll;
+    return ll.detach();
   }
 
-  Expression* Eval::operator()(Map* m)
+  Expression_Ptr Eval::operator()(Map_Ptr m)
   {
     if (m->is_expanded()) return m;
 
@@ -482,12 +481,12 @@ namespace Sass {
       throw Exception::DuplicateKeyError(*m, *m);
     }
 
-    Map* mm = SASS_MEMORY_NEW(ctx.mem, Map,
+    Map_Obj mm = SASS_MEMORY_NEW(Map,
                                 m->pstate(),
                                 m->length());
     for (auto key : m->keys()) {
-      Expression* ex_key = key->perform(this);
-      Expression* ex_val = m->at(key)->perform(this);
+      Expression_Ptr ex_key = key->perform(this);
+      Expression_Ptr ex_val = m->at(key)->perform(this);
       *mm << std::make_pair(ex_key, ex_val);
     }
 
@@ -497,54 +496,54 @@ namespace Sass {
     }
 
     mm->is_expanded(true);
-    return mm;
+    return mm.detach();
   }
 
-  Expression* Eval::operator()(Binary_Expression* b)
+  Expression_Ptr Eval::operator()(Binary_Expression_Ptr b_in)
   {
 
-    String_Schema* ret_schema = 0;
+    String_Schema_Obj ret_schema;
+    Binary_Expression_Obj b = b_in;
     enum Sass_OP op_type = b->type();
 
     // only the last item will be used to eval the binary expression
-    if (String_Schema* s_l = dynamic_cast<String_Schema*>(b->left())) {
+    if (String_Schema_Ptr s_l = SASS_MEMORY_CAST(String_Schema, b->left())) {
       if (!s_l->has_interpolant() && (!s_l->is_right_interpolant())) {
-        ret_schema = SASS_MEMORY_NEW(ctx.mem, String_Schema, b->pstate());
-        Binary_Expression* bin_ex = SASS_MEMORY_NEW(ctx.mem, Binary_Expression, b->pstate(),
-                                                    b->op(), s_l->last(), b->right());
+        ret_schema = SASS_MEMORY_NEW(String_Schema, b->pstate());
+        Binary_Expression_Obj bin_ex = SASS_MEMORY_NEW(Binary_Expression, b->pstate(),
+                                                    b->op(), &s_l->last(), b->right());
         bin_ex->is_delayed(b->left()->is_delayed() || b->right()->is_delayed()); // unverified
         for (size_t i = 0; i < s_l->length() - 1; ++i) {
-          *ret_schema << s_l->at(i)->perform(this);
+          ret_schema->append(s_l->at(i)->perform(this));
         }
-        *ret_schema << bin_ex->perform(this);
+        ret_schema->append(bin_ex->perform(this));
         return ret_schema->perform(this);
       }
     }
-    if (String_Schema* s_r = dynamic_cast<String_Schema*>(b->right())) {
+    if (String_Schema_Ptr s_r = SASS_MEMORY_CAST(String_Schema, b->right())) {
+
       if (!s_r->has_interpolant() && (!s_r->is_left_interpolant() || op_type == Sass_OP::DIV)) {
-        ret_schema = SASS_MEMORY_NEW(ctx.mem, String_Schema, b->pstate());
-        Binary_Expression* bin_ex = SASS_MEMORY_NEW(ctx.mem, Binary_Expression, b->pstate(),
-                                                    b->op(), b->left(), s_r->first());
+        ret_schema = SASS_MEMORY_NEW(String_Schema, b->pstate());
+        Binary_Expression_Obj bin_ex = SASS_MEMORY_NEW(Binary_Expression, b->pstate(),
+                                                    b->op(), b->left(), &s_r->first());
         bin_ex->is_delayed(b->left()->is_delayed() || b->right()->is_delayed()); // verified
-        *ret_schema << bin_ex->perform(this);
+        ret_schema->append(bin_ex->perform(this));
         for (size_t i = 1; i < s_r->length(); ++i) {
-          *ret_schema << s_r->at(i)->perform(this);
+          ret_schema->append(s_r->at(i)->perform(this));
         }
         return ret_schema->perform(this);
       }
     }
 
-
-    b = SASS_MEMORY_NEW(ctx.mem, Binary_Expression, *b);
     // don't eval delayed expressions (the '/' when used as a separator)
     if (!force && op_type == Sass_OP::DIV && b->is_delayed()) {
       b->right(b->right()->perform(this));
       b->left(b->left()->perform(this));
-      return b;
+      return b.detach();
     }
 
-    Expression* lhs = b->left();
-    Expression* rhs = b->right();
+    Expression_Obj lhs = b->left();
+    Expression_Obj rhs = b->right();
 
     // fully evaluate their values
     if (op_type == Sass_OP::EQ ||
@@ -566,29 +565,32 @@ namespace Sass {
       lhs = lhs->perform(this);
     }
 
+    Binary_Expression_Obj u3 = b;
     switch (op_type) {
-      case Sass_OP::AND:
-        return *lhs ? b->right()->perform(this) : lhs;
-        break;
+      case Sass_OP::AND: {
+        return *lhs ? b->right()->perform(this) : lhs.detach();
+      } break;
 
-      case Sass_OP::OR:
-        return *lhs ? lhs : b->right()->perform(this);
-        break;
+      case Sass_OP::OR: {
+        return *lhs ? lhs.detach() : b->right()->perform(this);
+      } break;
 
       default:
         break;
     }
     // not a logical connective, so go ahead and eval the rhs
     rhs = rhs->perform(this);
+    AST_Node_Obj lu = &lhs;
+    AST_Node_Obj ru = &rhs;
 
     Expression::Concrete_Type l_type = lhs->concrete_type();
     Expression::Concrete_Type r_type = rhs->concrete_type();
 
     // Is one of the operands an interpolant?
-    String_Schema* s1 = dynamic_cast<String_Schema*>(b->left());
-    String_Schema* s2 = dynamic_cast<String_Schema*>(b->right());
-    Binary_Expression* b1 = dynamic_cast<Binary_Expression*>(b->left());
-    Binary_Expression* b2 = dynamic_cast<Binary_Expression*>(b->right());
+    String_Schema_Obj s1 = SASS_MEMORY_CAST(String_Schema, b->left());
+    String_Schema_Obj s2 = SASS_MEMORY_CAST(String_Schema, b->right());
+    Binary_Expression_Obj b1 = SASS_MEMORY_CAST(Binary_Expression, b->left());
+    Binary_Expression_Obj b2 = SASS_MEMORY_CAST(Binary_Expression, b->right());
 
     bool schema_op = false;
 
@@ -599,35 +601,36 @@ namespace Sass {
 
     if ((s1 && s1->has_interpolants()) || (s2 && s2->has_interpolants()) || force_delay)
     {
-      // If possible upgrade LHS to a number
       if (op_type == Sass_OP::DIV || op_type == Sass_OP::MUL || op_type == Sass_OP::MOD || op_type == Sass_OP::ADD || op_type == Sass_OP::SUB ||
           op_type == Sass_OP::EQ) {
-        if (String_Constant* str = dynamic_cast<String_Constant*>(lhs)) {
+        // If possible upgrade LHS to a number (for number to string compare)
+        if (String_Constant_Ptr str = SASS_MEMORY_CAST(String_Constant, lhs)) {
           std::string value(str->value());
           const char* start = value.c_str();
           if (Prelexer::sequence < Prelexer::dimension, Prelexer::end_of_file >(start) != 0) {
-            lhs = SASS_MEMORY_NEW(ctx.mem, Textual, b->pstate(), Textual::DIMENSION, str->value());
-            lhs = lhs->perform(this);
+            Textual_Obj l = SASS_MEMORY_NEW(Textual, b->pstate(), Textual::DIMENSION, str->value());
+            lhs = l->perform(this);
           }
         }
-        if (String_Constant* str = dynamic_cast<String_Constant*>(rhs)) {
+        // If possible upgrade RHS to a number (for string to number compare)
+        if (String_Constant_Ptr str = SASS_MEMORY_CAST(String_Constant, rhs)) {
           std::string value(str->value());
           const char* start = value.c_str();
-          if (Prelexer::sequence < Prelexer::number >(start) != 0) {
-            rhs = SASS_MEMORY_NEW(ctx.mem, Textual, b->pstate(), Textual::DIMENSION, str->value());
-            rhs = rhs->perform(this);
+          if (Prelexer::sequence < Prelexer::dimension, Prelexer::number >(start) != 0) {
+            Textual_Obj r = SASS_MEMORY_NEW(Textual, b->pstate(), Textual::DIMENSION, str->value());
+            rhs = r->perform(this);
           }
         }
       }
 
-      To_Value to_value(ctx, ctx.mem);
-      Value* v_l = dynamic_cast<Value*>(lhs->perform(&to_value));
-      Value* v_r = dynamic_cast<Value*>(rhs->perform(&to_value));
+      To_Value to_value(ctx);
+      Value_Obj v_l = dynamic_cast<Value_Ptr>(lhs->perform(&to_value));
+      Value_Obj v_r = dynamic_cast<Value_Ptr>(rhs->perform(&to_value));
       l_type = lhs->concrete_type();
       r_type = rhs->concrete_type();
 
       if (s2 && s2->has_interpolants() && s2->length()) {
-        Textual* front = dynamic_cast<Textual*>(s2->elements().front());
+        Textual_Obj front = SASS_MEMORY_CAST(Textual, s2->elements().front());
         if (front && !front->is_interpolant())
         {
           // XXX: this is never hit via spec tests
@@ -643,7 +646,7 @@ namespace Sass {
         str += b->separator();
         if (b->op().ws_after) str += " ";
         str += v_r->to_string(ctx.c_options);
-        String_Constant* val = SASS_MEMORY_NEW(ctx.mem, String_Constant, b->pstate(), str);
+        String_Constant_Ptr val = SASS_MEMORY_NEW(String_Constant, b->pstate(), str);
         val->is_interpolant(b->left()->has_interpolant());
         return val;
       }
@@ -652,12 +655,12 @@ namespace Sass {
     // see if it's a relational expression
     try {
       switch(op_type) {
-        case Sass_OP::EQ:  return SASS_MEMORY_NEW(ctx.mem, Boolean, b->pstate(), eq(lhs, rhs));
-        case Sass_OP::NEQ: return SASS_MEMORY_NEW(ctx.mem, Boolean, b->pstate(), !eq(lhs, rhs));
-        case Sass_OP::GT:  return SASS_MEMORY_NEW(ctx.mem, Boolean, b->pstate(), !lt(lhs, rhs, "gt") && !eq(lhs, rhs));
-        case Sass_OP::GTE: return SASS_MEMORY_NEW(ctx.mem, Boolean, b->pstate(), !lt(lhs, rhs, "gte"));
-        case Sass_OP::LT:  return SASS_MEMORY_NEW(ctx.mem, Boolean, b->pstate(), lt(lhs, rhs, "lt"));
-        case Sass_OP::LTE: return SASS_MEMORY_NEW(ctx.mem, Boolean, b->pstate(), lt(lhs, rhs, "lte") || eq(lhs, rhs));
+        case Sass_OP::EQ:  return SASS_MEMORY_NEW(Boolean, b->pstate(), eq(lhs, rhs));
+        case Sass_OP::NEQ: return SASS_MEMORY_NEW(Boolean, b->pstate(), !eq(lhs, rhs));
+        case Sass_OP::GT:  return SASS_MEMORY_NEW(Boolean, b->pstate(), !lt(lhs, rhs, "gt") && !eq(lhs, rhs));
+        case Sass_OP::GTE: return SASS_MEMORY_NEW(Boolean, b->pstate(), !lt(lhs, rhs, "gte"));
+        case Sass_OP::LT:  return SASS_MEMORY_NEW(Boolean, b->pstate(), lt(lhs, rhs, "lt"));
+        case Sass_OP::LTE: return SASS_MEMORY_NEW(Boolean, b->pstate(), lt(lhs, rhs, "lte") || eq(lhs, rhs));
         default:                     break;
       }
     }
@@ -672,33 +675,34 @@ namespace Sass {
 
     // ToDo: throw error in op functions
     // ToDo: then catch and re-throw them
-    Expression* rv = 0;
+    Expression_Obj rv = 0;
     try {
       ParserState pstate(b->pstate());
       if (l_type == Expression::NUMBER && r_type == Expression::NUMBER) {
-        const Number* l_n = dynamic_cast<const Number*>(lhs);
-        const Number* r_n = dynamic_cast<const Number*>(rhs);
-        rv = op_numbers(ctx.mem, op_type, *l_n, *r_n, ctx.c_options, &pstate);
+        Number_Ptr l_n = SASS_MEMORY_CAST(Number, lhs);
+        Number_Ptr r_n = SASS_MEMORY_CAST(Number, rhs);
+        rv = op_numbers(op_type, *l_n, *r_n, ctx.c_options, &pstate);
       }
       else if (l_type == Expression::NUMBER && r_type == Expression::COLOR) {
-        const Number* l_n = dynamic_cast<const Number*>(lhs);
-        const Color* r_c = dynamic_cast<const Color*>(rhs);
-        rv = op_number_color(ctx.mem, op_type, *l_n, *r_c, ctx.c_options, &pstate);
+        Number_Ptr l_n = SASS_MEMORY_CAST(Number, lhs);
+        Color_Ptr r_c = SASS_MEMORY_CAST(Color, rhs);
+        rv = op_number_color(op_type, *l_n, *r_c, ctx.c_options, &pstate);
       }
       else if (l_type == Expression::COLOR && r_type == Expression::NUMBER) {
-        const Color* l_c = dynamic_cast<const Color*>(lhs);
-        const Number* r_n = dynamic_cast<const Number*>(rhs);
-        rv = op_color_number(ctx.mem, op_type, *l_c, *r_n, ctx.c_options, &pstate);
+        Color_Ptr l_c = SASS_MEMORY_CAST(Color, lhs);
+        Number_Ptr r_n = SASS_MEMORY_CAST(Number, rhs);
+        rv = op_color_number(op_type, *l_c, *r_n, ctx.c_options, &pstate);
       }
       else if (l_type == Expression::COLOR && r_type == Expression::COLOR) {
-        const Color* l_c = dynamic_cast<const Color*>(lhs);
-        const Color* r_c = dynamic_cast<const Color*>(rhs);
-        rv = op_colors(ctx.mem, op_type, *l_c, *r_c, ctx.c_options, &pstate);
+        Color_Ptr l_c = SASS_MEMORY_CAST(Color, lhs);
+        Color_Ptr r_c = SASS_MEMORY_CAST(Color, rhs);
+        rv = op_colors(op_type, *l_c, *r_c, ctx.c_options, &pstate);
       }
       else {
-        To_Value to_value(ctx, ctx.mem);
-        Value* v_l = dynamic_cast<Value*>(lhs->perform(&to_value));
-        Value* v_r = dynamic_cast<Value*>(rhs->perform(&to_value));
+        To_Value to_value(ctx);
+        // this will leak if perform does not return a value!
+        Value_Obj v_l = SASS_MEMORY_CAST_PTR(Value, lhs->perform(&to_value));
+        Value_Obj v_r = SASS_MEMORY_CAST_PTR(Value, rhs->perform(&to_value));
         bool interpolant = b->is_right_interpolant() ||
                            b->is_left_interpolant() ||
                            b->is_interpolant();
@@ -711,15 +715,15 @@ namespace Sass {
         if (r_type == Expression::MAP) {
           throw Exception::InvalidValue(*v_r);
         }
-        Value* ex = op_strings(ctx.mem, b->op(), *v_l, *v_r, ctx.c_options, &pstate, !interpolant); // pass true to compress
-        if (String_Constant* str = dynamic_cast<String_Constant*>(ex))
+        Value_Ptr ex = op_strings(b->op(), *v_l, *v_r, ctx.c_options, &pstate, !interpolant); // pass true to compress
+        if (String_Constant_Ptr str = dynamic_cast<String_Constant_Ptr>(ex))
         {
           if (str->concrete_type() == Expression::STRING)
           {
-            String_Constant* lstr = dynamic_cast<String_Constant*>(lhs);
-            String_Constant* rstr = dynamic_cast<String_Constant*>(rhs);
+            String_Constant_Ptr lstr = SASS_MEMORY_CAST(String_Constant, lhs);
+            String_Constant_Ptr rstr = SASS_MEMORY_CAST(String_Constant, rhs);
             if (op_type != Sass_OP::SUB) {
-              if (String_Constant* org = lstr ? lstr : rstr)
+              if (String_Constant_Ptr org = lstr ? lstr : rstr)
               { str->quote_mark(org->quote_mark()); }
             }
           }
@@ -741,20 +745,21 @@ namespace Sass {
         rv = s2->perform(this);
       }
     }
-    return rv;
+
+    return rv.detach();
 
   }
 
-  Expression* Eval::operator()(Unary_Expression* u)
+  Expression_Ptr Eval::operator()(Unary_Expression_Ptr u)
   {
-    Expression* operand = u->operand()->perform(this);
+    Expression_Obj operand = u->operand()->perform(this);
     if (u->type() == Unary_Expression::NOT) {
-      Boolean* result = SASS_MEMORY_NEW(ctx.mem, Boolean, u->pstate(), (bool)*operand);
+      Boolean_Ptr result = SASS_MEMORY_NEW(Boolean, u->pstate(), (bool)*operand);
       result->value(!result->value());
       return result;
     }
     else if (operand->concrete_type() == Expression::NUMBER) {
-      Number* result = SASS_MEMORY_NEW(ctx.mem, Number, *static_cast<Number*>(operand));
+      Number_Ptr result = SASS_MEMORY_NEW(Number, static_cast<Number_Ptr>(&operand));
       result->value(u->type() == Unary_Expression::MINUS
                     ? -result->value()
                     :  result->value());
@@ -763,16 +768,16 @@ namespace Sass {
     else {
       // Special cases: +/- variables which evaluate to null ouput just +/-,
       // but +/- null itself outputs the string
-      if (operand->concrete_type() == Expression::NULL_VAL && dynamic_cast<Variable*>(u->operand())) {
-        u->operand(SASS_MEMORY_NEW(ctx.mem, String_Quoted, u->pstate(), ""));
+      if (operand->concrete_type() == Expression::NULL_VAL && SASS_MEMORY_CAST(Variable, u->operand())) {
+        u->operand(SASS_MEMORY_NEW(String_Quoted, u->pstate(), ""));
       }
       // Never apply unary opertions on colors @see #2140
       else if (operand->concrete_type() == Expression::COLOR) {
-        Color* c = dynamic_cast<Color*>(operand);
+        Color_Ptr c = dynamic_cast<Color_Ptr>(&operand);
 
         // Use the color name if this was eval with one
         if (c->disp().length() > 0) {
-          operand = SASS_MEMORY_NEW(ctx.mem, String_Constant, operand->pstate(), c->disp());
+          operand = SASS_MEMORY_NEW(String_Constant, operand->pstate(), c->disp());
           u->operand(operand);
         }
       }
@@ -780,7 +785,7 @@ namespace Sass {
         u->operand(operand);
       }
 
-      String_Constant* result = SASS_MEMORY_NEW(ctx.mem, String_Quoted,
+      String_Constant_Ptr result = SASS_MEMORY_NEW(String_Quoted,
                                                   u->pstate(),
                                                   u->inspect());
       return result;
@@ -789,7 +794,7 @@ namespace Sass {
     return u;
   }
 
-  Expression* Eval::operator()(Function_Call* c)
+  Expression_Ptr Eval::operator()(Function_Call_Ptr c)
   {
     if (backtrace()->parent != NULL && backtrace()->depth() > Constants::MaxCallStack) {
         // XXX: this is never hit via spec tests
@@ -799,25 +804,26 @@ namespace Sass {
     }
     std::string name(Util::normalize_underscores(c->name()));
     std::string full_name(name + "[f]");
-    Arguments* args = SASS_MEMORY_NEW(ctx.mem, Arguments, *c->arguments());
+    // we make a clone here, need to implement that further
+    Arguments_Obj args = c->arguments();
 
     Env* env = environment();
-    if (!env->has(full_name)) {
+    if (!env->has(full_name) || (!c->via_call() && Prelexer::re_special_fun(name.c_str()))) {
       if (!env->has("*[f]")) {
-        for (Argument* arg : args->elements()) {
-          if (List* ls = dynamic_cast<List*>(arg->value())) {
+        for (Argument_Obj arg : args->elements()) {
+          if (List_Obj ls = SASS_MEMORY_CAST(List, arg->value())) {
             if (ls->size() == 0) error("() isn't a valid CSS value.", c->pstate());
           }
         }
-        args = static_cast<Arguments*>(args->perform(this));
-        Function_Call* lit = SASS_MEMORY_NEW(ctx.mem, Function_Call,
+        args = SASS_MEMORY_CAST_PTR(Arguments, args->perform(this));
+        Function_Call_Obj lit = SASS_MEMORY_NEW(Function_Call,
                                              c->pstate(),
                                              c->name(),
-                                             args);
+                                             &args);
         if (args->has_named_arguments()) {
           error("Function " + c->name() + " doesn't support keyword arguments", c->pstate());
         }
-        String_Quoted* str = SASS_MEMORY_NEW(ctx.mem, String_Quoted,
+        String_Quoted_Ptr str = SASS_MEMORY_NEW(String_Quoted,
                                              c->pstate(),
                                              lit->to_string(ctx.c_options));
         str->is_interpolant(c->is_interpolant());
@@ -833,9 +839,9 @@ namespace Sass {
       args->set_delayed(false); // verified
     }
     if (full_name != "if[f]") {
-      args = static_cast<Arguments*>(args->perform(this));
+      args = SASS_MEMORY_CAST_PTR(Arguments, args->perform(this));
     }
-    Definition* def = static_cast<Definition*>((*env)[full_name]);
+    Definition_Ptr def = SASS_MEMORY_CAST(Definition, (*env)[full_name]);
 
     if (def->is_overload_stub()) {
       std::stringstream ss;
@@ -843,7 +849,7 @@ namespace Sass {
       // account for rest arguments
       if (args->has_rest_argument() && args->length() > 0) {
         // get the rest arguments list
-        List* rest = dynamic_cast<List*>(args->last()->value());
+        List_Ptr rest = SASS_MEMORY_CAST(List, args->last()->value());
         // arguments before rest argument plus rest
         if (rest) L += rest->length() - 1;
       }
@@ -851,15 +857,15 @@ namespace Sass {
       full_name = ss.str();
       std::string resolved_name(full_name);
       if (!env->has(resolved_name)) error("overloaded function `" + std::string(c->name()) + "` given wrong number of arguments", c->pstate());
-      def = static_cast<Definition*>((*env)[resolved_name]);
+      def = SASS_MEMORY_CAST(Definition, (*env)[resolved_name]);
     }
 
-    Expression*     result = c;
-    Block*          body   = def->block();
+    Expression_Obj     result = c;
+    Block_Obj          body   = def->block();
     Native_Function func   = def->native_function();
     Sass_Function_Entry c_function = def->c_function();
 
-    Parameters* params = def->parameters();
+    Parameters_Obj params = def->parameters();
     Env fn_env(def->environment());
     exp.env_stack.push_back(&fn_env);
 
@@ -868,9 +874,15 @@ namespace Sass {
       Backtrace here(backtrace(), c->pstate(), ", in function `" + c->name() + "`");
       exp.backtrace_stack.push_back(&here);
       // eval the body if user-defined or special, invoke underlying CPP function if native
-      if (body && !Prelexer::re_special_fun(name.c_str())) { result = body->perform(this); }
-      else if (func) { result = func(fn_env, *env, ctx, def->signature(), c->pstate(), backtrace(), exp.selector_stack); }
-      if (!result) error(std::string("Function ") + c->name() + " did not return a value", c->pstate());
+      if (body /* && !Prelexer::re_special_fun(name.c_str()) */) {
+        result = body->perform(this);
+      }
+      else if (func) {
+        result = func(fn_env, *env, ctx, def->signature(), c->pstate(), backtrace(), exp.selector_stack);
+      }
+      if (!result) {
+        error(std::string("Function ") + c->name() + " did not return a value", c->pstate());
+      }
       exp.backtrace_stack.pop_back();
     }
 
@@ -879,10 +891,10 @@ namespace Sass {
     else if (c_function) {
       Sass_Function_Fn c_func = sass_function_get_function(c_function);
       if (full_name == "*[f]") {
-        String_Quoted *str = SASS_MEMORY_NEW(ctx.mem, String_Quoted, c->pstate(), c->name());
-        Arguments* new_args = SASS_MEMORY_NEW(ctx.mem, Arguments, c->pstate());
-        *new_args << SASS_MEMORY_NEW(ctx.mem, Argument, c->pstate(), str);
-        *new_args += args;
+        String_Quoted_Obj str = SASS_MEMORY_NEW(String_Quoted, c->pstate(), c->name());
+        Arguments_Obj new_args = SASS_MEMORY_NEW(Arguments, c->pstate());
+        new_args->append(SASS_MEMORY_NEW(Argument, c->pstate(), &str));
+        new_args->concat(&args);
         args = new_args;
       }
 
@@ -894,11 +906,12 @@ namespace Sass {
       exp.backtrace_stack.push_back(&here);
 
       To_C to_c;
-      union Sass_Value* c_args = sass_make_list(params[0].length(), SASS_COMMA);
-      for(size_t i = 0; i < params[0].length(); i++) {
-        std::string key = params[0][i]->name();
-        AST_Node* node = fn_env.get_local(key);
-        Expression* arg = static_cast<Expression*>(node);
+      union Sass_Value* c_args = sass_make_list(params->length(), SASS_COMMA);
+      for(size_t i = 0; i < params->length(); i++) {
+        Parameter_Obj param = params->at(i);
+        std::string key = param->name();
+        AST_Node_Obj node = fn_env.get_local(key);
+        Expression_Obj arg = SASS_MEMORY_CAST(Expression, node);
         sass_list_set_value(c_args, i, arg->perform(&to_c));
       }
       union Sass_Value* c_val = c_func(c_args, c_function, ctx.c_compiler);
@@ -907,7 +920,7 @@ namespace Sass {
       } else if (sass_value_get_tag(c_val) == SASS_WARNING) {
         error("warning in C function " + c->name() + ": " + sass_warning_get_message(c_val), c->pstate(), backtrace());
       }
-      result = cval_to_astnode(ctx.mem, c_val, ctx, backtrace(), c->pstate());
+      result = cval_to_astnode(c_val, backtrace(), c->pstate());
 
       exp.backtrace_stack.pop_back();
       sass_delete_value(c_args);
@@ -923,45 +936,49 @@ namespace Sass {
     result = result->perform(this);
     result->is_interpolant(c->is_interpolant());
     exp.env_stack.pop_back();
-    return result;
+    return result.detach();
   }
 
-  Expression* Eval::operator()(Function_Call_Schema* s)
+  Expression_Ptr Eval::operator()(Function_Call_Schema_Ptr s)
   {
-    Expression* evaluated_name = s->name()->perform(this);
-    Expression* evaluated_args = s->arguments()->perform(this);
-    String_Schema* ss = SASS_MEMORY_NEW(ctx.mem, String_Schema, s->pstate(), 2);
-    (*ss) << evaluated_name << evaluated_args;
+    Expression_Ptr evaluated_name = s->name()->perform(this);
+    Expression_Ptr evaluated_args = s->arguments()->perform(this);
+    String_Schema_Obj ss = SASS_MEMORY_NEW(String_Schema, s->pstate(), 2);
+    ss->append(evaluated_name);
+    ss->append(evaluated_args);
     return ss->perform(this);
   }
 
-  Expression* Eval::operator()(Variable* v)
+  Expression_Ptr Eval::operator()(Variable_Ptr v)
   {
     std::string name(v->name());
-    Expression* value = 0;
+    Expression_Obj value = 0;
     Env* env = environment();
-    if (env->has(name)) value = static_cast<Expression*>((*env)[name]);
+    if (env->has(name)) {
+      value = SASS_MEMORY_CAST(Expression, (*env)[name]);
+    }
     else error("Undefined variable: \"" + v->name() + "\".", v->pstate());
-    if (typeid(*value) == typeid(Argument)) value = static_cast<Argument*>(value)->value();
+    if (typeid(*value) == typeid(Argument)) {
+      value = SASS_MEMORY_CAST(Argument, value)->value();
+    }
 
     // behave according to as ruby sass (add leading zero)
-    if (value->concrete_type() == Expression::NUMBER) {
-      value = SASS_MEMORY_NEW(ctx.mem, Number, *static_cast<Number*>(value));
-      static_cast<Number*>(value)->zero(true);
+    if (Number_Ptr nr = SASS_MEMORY_CAST(Number, value)) {
+      nr->zero(true);
     }
 
     value->is_interpolant(v->is_interpolant());
     if (force) value->is_expanded(false);
     value->set_delayed(false); // verified
     value = value->perform(this);
-    if(!force) (*env)[name] = value;
-    return value;
+    if(!force) (*env)[name] = &value;
+    return value.detach();
   }
 
-  Expression* Eval::operator()(Textual* t)
+  Expression_Ptr Eval::operator()(Textual_Ptr t)
   {
     using Prelexer::number;
-    Expression* result = 0;
+    Expression_Obj result = 0;
     size_t L = t->value().length();
     bool zero = !( (L > 0 && t->value().substr(0, 1) == ".") ||
                    (L > 1 && t->value().substr(0, 2) == "0.") ||
@@ -979,21 +996,21 @@ namespace Sass {
     switch (t->type())
     {
       case Textual::NUMBER:
-        result = SASS_MEMORY_NEW(ctx.mem, Number,
+        result = SASS_MEMORY_NEW(Number,
                                  t->pstate(),
                                  sass_atof(num.c_str()),
                                  "",
                                  zero);
         break;
       case Textual::PERCENTAGE:
-        result = SASS_MEMORY_NEW(ctx.mem, Number,
+        result = SASS_MEMORY_NEW(Number,
                                  t->pstate(),
                                  sass_atof(num.c_str()),
                                  "%",
                                  true);
         break;
       case Textual::DIMENSION:
-        result = SASS_MEMORY_NEW(ctx.mem, Number,
+        result = SASS_MEMORY_NEW(Number,
                                  t->pstate(),
                                  sass_atof(num.c_str()),
                                  Token(number(text.c_str())),
@@ -1001,7 +1018,7 @@ namespace Sass {
         break;
       case Textual::HEX: {
         if (t->value().substr(0, 1) != "#") {
-          result = SASS_MEMORY_NEW(ctx.mem, String_Quoted, t->pstate(), t->value());
+          result = SASS_MEMORY_NEW(String_Quoted, t->pstate(), t->value());
           break;
         }
         std::string hext(t->value().substr(1)); // chop off the '#'
@@ -1009,7 +1026,7 @@ namespace Sass {
           std::string r(hext.substr(0,2));
           std::string g(hext.substr(2,2));
           std::string b(hext.substr(4,2));
-          result = SASS_MEMORY_NEW(ctx.mem, Color,
+          result = SASS_MEMORY_NEW(Color,
                                    t->pstate(),
                                    static_cast<double>(strtol(r.c_str(), NULL, 16)),
                                    static_cast<double>(strtol(g.c_str(), NULL, 16)),
@@ -1018,7 +1035,7 @@ namespace Sass {
                                    t->value());
         }
         else {
-          result = SASS_MEMORY_NEW(ctx.mem, Color,
+          result = SASS_MEMORY_NEW(Color,
                                    t->pstate(),
                                    static_cast<double>(strtol(std::string(2,hext[0]).c_str(), NULL, 16)),
                                    static_cast<double>(strtol(std::string(2,hext[1]).c_str(), NULL, 16)),
@@ -1029,71 +1046,71 @@ namespace Sass {
       } break;
     }
     result->is_interpolant(t->is_interpolant());
-    return result;
+    return result.detach();
   }
 
-  Expression* Eval::operator()(Color* c)
+  Expression_Ptr Eval::operator()(Color_Ptr c)
   {
     return c;
   }
 
-  Expression* Eval::operator()(Number* n)
+  Expression_Ptr Eval::operator()(Number_Ptr n)
   {
     return n;
   }
 
-  Expression* Eval::operator()(Boolean* b)
+  Expression_Ptr Eval::operator()(Boolean_Ptr b)
   {
     return b;
   }
 
-  void Eval::interpolation(Context& ctx, std::string& res, Expression* ex, bool into_quotes, bool was_itpl) {
+  void Eval::interpolation(Context& ctx, std::string& res, Expression_Obj ex, bool into_quotes, bool was_itpl) {
 
     bool needs_closing_brace = false;
 
-    if (Arguments* args = dynamic_cast<Arguments*>(ex)) {
-      List* ll = SASS_MEMORY_NEW(ctx.mem, List, args->pstate(), 0, SASS_COMMA);
-      for(auto arg : *args) {
-        *ll << arg->value();
+    if (Arguments_Ptr args = SASS_MEMORY_CAST(Arguments, ex)) {
+      List_Ptr ll = SASS_MEMORY_NEW(List, args->pstate(), 0, SASS_COMMA);
+      for(auto arg : args->elements()) {
+        ll->append(arg->value());
       }
       ll->is_interpolant(args->is_interpolant());
       needs_closing_brace = true;
       res += "(";
       ex = ll;
     }
-    if (Number* nr = dynamic_cast<Number*>(ex)) {
+    if (Number_Ptr nr = SASS_MEMORY_CAST(Number, ex)) {
       if (!nr->is_valid_css_unit()) {
         throw Exception::InvalidValue(*nr);
       }
     }
-    if (Argument* arg = dynamic_cast<Argument*>(ex)) {
-      ex = arg->value();
+    if (Argument_Ptr arg = SASS_MEMORY_CAST(Argument, ex)) {
+      ex = &arg->value();
     }
-    if (String_Quoted* sq = dynamic_cast<String_Quoted*>(ex)) {
+    if (String_Quoted_Ptr sq = SASS_MEMORY_CAST(String_Quoted, ex)) {
       if (was_itpl) {
         bool was_interpolant = ex->is_interpolant();
-        ex = SASS_MEMORY_NEW(ctx.mem, String_Constant, sq->pstate(), sq->value());
+        ex = SASS_MEMORY_NEW(String_Constant, sq->pstate(), sq->value());
         ex->is_interpolant(was_interpolant);
       }
     }
 
-    if (dynamic_cast<Null*>(ex)) { return; }
+    if (SASS_MEMORY_CAST(Null, ex)) { return; }
 
     // parent selector needs another go
-    if (dynamic_cast<Parent_Selector*>(ex)) {
+    if (SASS_MEMORY_CAST(Parent_Selector, ex)) {
       // XXX: this is never hit via spec tests
       ex = ex->perform(this);
     }
 
-    if (List* l = dynamic_cast<List*>(ex)) {
-      List* ll = SASS_MEMORY_NEW(ctx.mem, List, l->pstate(), 0, l->separator());
+    if (List_Ptr l = SASS_MEMORY_CAST(List, ex)) {
+      List_Obj ll = SASS_MEMORY_NEW(List, l->pstate(), 0, l->separator());
       // this fixes an issue with bourbon sample, not really sure why
-      // if (l->size() && dynamic_cast<Null*>((*l)[0])) { res += ""; }
-      for(auto item : *l) {
+      // if (l->size() && dynamic_cast<Null_Ptr>((*l)[0])) { res += ""; }
+      for(Expression_Obj item : *l) {
         item->is_interpolant(l->is_interpolant());
-        std::string rl(""); interpolation(ctx, rl, item, into_quotes, l->is_interpolant());
-        bool is_null = dynamic_cast<Null*>(item) != 0; // rl != ""
-        if (!is_null) *ll << SASS_MEMORY_NEW(ctx.mem, String_Quoted, item->pstate(), rl);
+        std::string rl(""); interpolation(ctx, rl, &item, into_quotes, l->is_interpolant());
+        bool is_null = dynamic_cast<Null_Ptr>(&item) != 0; // rl != ""
+        if (!is_null) ll->append(SASS_MEMORY_NEW(String_Quoted, item->pstate(), rl));
       }
       // Check indicates that we probably should not get a list
       // here. Normally single list items are already unwrapped.
@@ -1111,7 +1128,7 @@ namespace Sass {
     // Value
     // Textual
     // Function_Call
-    // CommaSequence_Selector
+    // Selector_List
     // String_Quoted
     // String_Constant
     // Parent_Selector
@@ -1129,14 +1146,14 @@ namespace Sass {
 
   }
 
-  Expression* Eval::operator()(String_Schema* s)
+  Expression_Ptr Eval::operator()(String_Schema_Ptr s)
   {
     size_t L = s->length();
     bool into_quotes = false;
     if (L > 1) {
-      if (!dynamic_cast<String_Quoted*>((*s)[0]) && !dynamic_cast<String_Quoted*>((*s)[L - 1])) {
-      if (String_Constant* l = dynamic_cast<String_Constant*>((*s)[0])) {
-        if (String_Constant* r = dynamic_cast<String_Constant*>((*s)[L - 1])) {
+      if (!SASS_MEMORY_CAST(String_Quoted, (*s)[0]) && !SASS_MEMORY_CAST(String_Quoted, (*s)[L - 1])) {
+      if (String_Constant_Ptr l = SASS_MEMORY_CAST(String_Constant, (*s)[0])) {
+        if (String_Constant_Ptr r = SASS_MEMORY_CAST(String_Constant, (*s)[L - 1])) {
           if (r->value().size() > 0) {
             if (l->value()[0] == '"' && r->value()[r->value().size() - 1] == '"') into_quotes = true;
             if (l->value()[0] == '\'' && r->value()[r->value().size() - 1] == '\'') into_quotes = true;
@@ -1149,34 +1166,34 @@ namespace Sass {
     bool was_interpolant = false;
     std::string res("");
     for (size_t i = 0; i < L; ++i) {
-      bool is_quoted = dynamic_cast<String_Quoted*>((*s)[i]) != NULL;
+      bool is_quoted = SASS_MEMORY_CAST(String_Quoted, (*s)[i]) != NULL;
       if (was_quoted && !(*s)[i]->is_interpolant() && !was_interpolant) { res += " "; }
       else if (i > 0 && is_quoted && !(*s)[i]->is_interpolant() && !was_interpolant) { res += " "; }
-      Expression* ex = (*s)[i]->perform(this);
+      Expression_Obj ex = (*s)[i]->perform(this);
       interpolation(ctx, res, ex, into_quotes, ex->is_interpolant());
-      was_quoted = dynamic_cast<String_Quoted*>((*s)[i]) != NULL;
+      was_quoted = SASS_MEMORY_CAST(String_Quoted, (*s)[i]) != NULL;
       was_interpolant = (*s)[i]->is_interpolant();
 
     }
     if (!s->is_interpolant()) {
-      if (s->length() > 1 && res == "") return SASS_MEMORY_NEW(ctx.mem, Null, s->pstate());
-      return SASS_MEMORY_NEW(ctx.mem, String_Constant, s->pstate(), res);
+      if (s->length() > 1 && res == "") return SASS_MEMORY_NEW(Null, s->pstate());
+      return SASS_MEMORY_NEW(String_Constant, s->pstate(), res);
     }
     // string schema seems to have a special unquoting behavior (also handles "nested" quotes)
-    String_Quoted* str = SASS_MEMORY_NEW(ctx.mem, String_Quoted, s->pstate(), res, 0, false, false, false);
+    String_Quoted_Obj str = SASS_MEMORY_NEW(String_Quoted, s->pstate(), res, 0, false, false, false);
     // if (s->is_interpolant()) str->quote_mark(0);
-    // String_Constant* str = SASS_MEMORY_NEW(ctx.mem, String_Constant, s->pstate(), res);
+    // String_Constant_Ptr str = SASS_MEMORY_NEW(String_Constant, s->pstate(), res);
     if (str->quote_mark()) str->quote_mark('*');
     else if (!is_in_comment) str->value(string_to_output(str->value()));
     str->is_interpolant(s->is_interpolant());
-    return str;
+    return str.detach();
   }
 
 
-  Expression* Eval::operator()(String_Constant* s)
+  Expression_Ptr Eval::operator()(String_Constant_Ptr s)
   {
     if (!s->is_delayed() && name_to_color(s->value())) {
-      Color* c = SASS_MEMORY_NEW(ctx.mem, Color, *name_to_color(s->value()));
+      Color_Ptr c = SASS_MEMORY_COPY(name_to_color(s->value())); // copy
       c->pstate(s->pstate());
       c->disp(s->value());
       c->is_delayed(true);
@@ -1185,119 +1202,117 @@ namespace Sass {
     return s;
   }
 
-  Expression* Eval::operator()(String_Quoted* s)
+  Expression_Ptr Eval::operator()(String_Quoted_Ptr s)
   {
-    String_Quoted* str = SASS_MEMORY_NEW(ctx.mem, String_Quoted, s->pstate(), "");
+    String_Quoted_Ptr str = SASS_MEMORY_NEW(String_Quoted, s->pstate(), "");
     str->value(s->value());
     str->quote_mark(s->quote_mark());
     str->is_interpolant(s->is_interpolant());
     return str;
   }
 
-  Expression* Eval::operator()(Supports_Operator* c)
+  Expression_Ptr Eval::operator()(Supports_Operator_Ptr c)
   {
-    Expression* left = c->left()->perform(this);
-    Expression* right = c->right()->perform(this);
-    Supports_Operator* cc = SASS_MEMORY_NEW(ctx.mem, Supports_Operator,
+    Expression_Ptr left = c->left()->perform(this);
+    Expression_Ptr right = c->right()->perform(this);
+    Supports_Operator_Ptr cc = SASS_MEMORY_NEW(Supports_Operator,
                                  c->pstate(),
-                                 static_cast<Supports_Condition*>(left),
-                                 static_cast<Supports_Condition*>(right),
+                                 dynamic_cast<Supports_Condition_Ptr>(left),
+                                 dynamic_cast<Supports_Condition_Ptr>(right),
                                  c->operand());
     return cc;
   }
 
-  Expression* Eval::operator()(Supports_Negation* c)
+  Expression_Ptr Eval::operator()(Supports_Negation_Ptr c)
   {
-    Expression* condition = c->condition()->perform(this);
-    Supports_Negation* cc = SASS_MEMORY_NEW(ctx.mem, Supports_Negation,
+    Expression_Ptr condition = c->condition()->perform(this);
+    Supports_Negation_Ptr cc = SASS_MEMORY_NEW(Supports_Negation,
                                  c->pstate(),
-                                 static_cast<Supports_Condition*>(condition));
+                                 dynamic_cast<Supports_Condition_Ptr>(condition));
     return cc;
   }
 
-  Expression* Eval::operator()(Supports_Declaration* c)
+  Expression_Ptr Eval::operator()(Supports_Declaration_Ptr c)
   {
-    Expression* feature = c->feature()->perform(this);
-    Expression* value = c->value()->perform(this);
-    Supports_Declaration* cc = SASS_MEMORY_NEW(ctx.mem, Supports_Declaration,
+    Expression_Ptr feature = c->feature()->perform(this);
+    Expression_Ptr value = c->value()->perform(this);
+    Supports_Declaration_Ptr cc = SASS_MEMORY_NEW(Supports_Declaration,
                               c->pstate(),
                               feature,
                               value);
     return cc;
   }
 
-  Expression* Eval::operator()(Supports_Interpolation* c)
+  Expression_Ptr Eval::operator()(Supports_Interpolation_Ptr c)
   {
-    Expression* value = c->value()->perform(this);
-    Supports_Interpolation* cc = SASS_MEMORY_NEW(ctx.mem, Supports_Interpolation,
+    Expression_Ptr value = c->value()->perform(this);
+    Supports_Interpolation_Ptr cc = SASS_MEMORY_NEW(Supports_Interpolation,
                             c->pstate(),
                             value);
     return cc;
   }
 
-  Expression* Eval::operator()(At_Root_Query* e)
+  Expression_Ptr Eval::operator()(At_Root_Query_Ptr e)
   {
-    Expression* feature = e->feature();
+    Expression_Obj feature = e->feature();
     feature = (feature ? feature->perform(this) : 0);
-    Expression* value = e->value();
+    Expression_Obj value = e->value();
     value = (value ? value->perform(this) : 0);
-    Expression* ee = SASS_MEMORY_NEW(ctx.mem, At_Root_Query,
+    Expression_Ptr ee = SASS_MEMORY_NEW(At_Root_Query,
                                      e->pstate(),
-                                     static_cast<String*>(feature),
+                                     dynamic_cast<String_Ptr>(&feature),
                                      value);
     return ee;
   }
 
-  Expression* Eval::operator()(Media_Query* q)
+  Expression_Ptr Eval::operator()(Media_Query_Ptr q)
   {
-    String* t = q->media_type();
-    t = static_cast<String*>(t ? t->perform(this) : 0);
-    Media_Query* qq = SASS_MEMORY_NEW(ctx.mem, Media_Query,
+    String_Obj t = q->media_type();
+    t = static_cast<String_Ptr>(&t ? t->perform(this) : 0);
+    Media_Query_Obj qq = SASS_MEMORY_NEW(Media_Query,
                                       q->pstate(),
-                                      t,
+                                      &t,
                                       q->length(),
                                       q->is_negated(),
                                       q->is_restricted());
     for (size_t i = 0, L = q->length(); i < L; ++i) {
-      *qq << static_cast<Media_Query_Expression*>((*q)[i]->perform(this));
+      qq->append(static_cast<Media_Query_Expression_Ptr>((*q)[i]->perform(this)));
     }
-    return qq;
+    return qq.detach();
   }
 
-  Expression* Eval::operator()(Media_Query_Expression* e)
+  Expression_Ptr Eval::operator()(Media_Query_Expression_Ptr e)
   {
-    Expression* feature = e->feature();
+    Expression_Obj feature = e->feature();
     feature = (feature ? feature->perform(this) : 0);
-    if (feature && dynamic_cast<String_Quoted*>(feature)) {
-      feature = SASS_MEMORY_NEW(ctx.mem, String_Quoted,
+    if (feature && SASS_MEMORY_CAST(String_Quoted, feature)) {
+      feature = SASS_MEMORY_NEW(String_Quoted,
                                   feature->pstate(),
-                                  dynamic_cast<String_Quoted*>(feature)->value());
+                                  SASS_MEMORY_CAST(String_Quoted, feature)->value());
     }
-    Expression* value = e->value();
+    Expression_Obj value = e->value();
     value = (value ? value->perform(this) : 0);
-    if (value && dynamic_cast<String_Quoted*>(value)) {
+    if (value && SASS_MEMORY_CAST(String_Quoted, value)) {
       // XXX: this is never hit via spec tests
-      value = SASS_MEMORY_NEW(ctx.mem, String_Quoted,
+      value = SASS_MEMORY_NEW(String_Quoted,
                                 value->pstate(),
-                                dynamic_cast<String_Quoted*>(value)->value());
+                                SASS_MEMORY_CAST(String_Quoted, value)->value());
     }
-    return SASS_MEMORY_NEW(ctx.mem, Media_Query_Expression,
+    return SASS_MEMORY_NEW(Media_Query_Expression,
                            e->pstate(),
                            feature,
                            value,
                            e->is_interpolated());
   }
 
-  Expression* Eval::operator()(Null* n)
+  Expression_Ptr Eval::operator()(Null_Ptr n)
   {
     return n;
   }
 
-  Expression* Eval::operator()(Argument* a)
+  Expression_Ptr Eval::operator()(Argument_Ptr a)
   {
-    Expression* val = a->value();
-    val = val->perform(this);
-
+    Expression_Obj val = a->value()->perform(this);
     bool is_rest_argument = a->is_rest_argument();
     bool is_keyword_argument = a->is_keyword_argument();
 
@@ -1307,16 +1322,16 @@ namespace Sass {
         is_keyword_argument = true;
       }
       else if(val->concrete_type() != Expression::LIST) {
-        List* wrapper = SASS_MEMORY_NEW(ctx.mem, List,
+        List_Obj wrapper = SASS_MEMORY_NEW(List,
                                         val->pstate(),
                                         0,
                                         SASS_COMMA,
                                         true);
-        *wrapper << val;
-        val = wrapper;
+        wrapper->append(val);
+        val = &wrapper;
       }
     }
-    return SASS_MEMORY_NEW(ctx.mem, Argument,
+    return SASS_MEMORY_NEW(Argument,
                            a->pstate(),
                            val,
                            a->name(),
@@ -1324,104 +1339,103 @@ namespace Sass {
                            is_keyword_argument);
   }
 
-  Expression* Eval::operator()(Arguments* a)
+  Expression_Ptr Eval::operator()(Arguments_Ptr a)
   {
-    Arguments* aa = SASS_MEMORY_NEW(ctx.mem, Arguments, a->pstate());
-    if (a->length() == 0) return aa;
+    Arguments_Obj aa = SASS_MEMORY_NEW(Arguments, a->pstate());
+    if (a->length() == 0) return aa.detach();
     for (size_t i = 0, L = a->length(); i < L; ++i) {
-      Argument* arg = static_cast<Argument*>((*a)[i]->perform(this));
+      Expression_Obj rv = (*a)[i]->perform(this);
+      Argument_Ptr arg = SASS_MEMORY_CAST(Argument, rv);
       if (!(arg->is_rest_argument() || arg->is_keyword_argument())) {
-        *aa << arg;
+        aa->append(arg);
       }
     }
 
     if (a->has_rest_argument()) {
-      Expression* splat = static_cast<Argument*>(
-                            a->get_rest_argument()->perform(this)
-                          )->value()->perform(this);
+      Expression_Obj rest = a->get_rest_argument()->perform(this);
+      Expression_Obj splat = SASS_MEMORY_CAST(Argument, rest)->value()->perform(this);
 
       Sass_Separator separator = SASS_COMMA;
-      List* ls = dynamic_cast<List*>(splat);
-      Map* ms = dynamic_cast<Map*>(splat);
+      List_Ptr ls = SASS_MEMORY_CAST(List, splat);
+      Map_Ptr ms = SASS_MEMORY_CAST(Map, splat);
 
-      List* arglist = SASS_MEMORY_NEW(ctx.mem, List,
+      List_Obj arglist = SASS_MEMORY_NEW(List,
                                       splat->pstate(),
                                       0,
                                       ls ? ls->separator() : separator,
                                       true);
 
       if (ls && ls->is_arglist()) {
-        for (auto as : *ls) *arglist << as;
+        arglist->concat(ls);
       } else if (ms) {
-        *aa << SASS_MEMORY_NEW(ctx.mem, Argument, splat->pstate(), ms, "", false, true);
+        aa->append(SASS_MEMORY_NEW(Argument, splat->pstate(), ms, "", false, true));
       } else if (ls) {
-        for (auto as : *ls) *arglist << as;
+        arglist->concat(ls);
       } else {
-        *arglist << splat;
+        arglist->append(splat);
       }
       if (arglist->length()) {
-        *aa << SASS_MEMORY_NEW(ctx.mem, Argument, splat->pstate(), arglist, "", true);
+        aa->append(SASS_MEMORY_NEW(Argument, splat->pstate(), &arglist, "", true));
       }
     }
 
     if (a->has_keyword_argument()) {
-      Expression* kwarg = static_cast<Argument*>(
-                            a->get_keyword_argument()->perform(this)
-                          )->value()->perform(this);
+      Expression_Obj rv = a->get_keyword_argument()->perform(this);
+      Argument_Ptr rvarg = SASS_MEMORY_CAST(Argument, rv);
+      Expression_Obj kwarg = rvarg->value()->perform(this);
 
-      *aa << SASS_MEMORY_NEW(ctx.mem, Argument, kwarg->pstate(), kwarg, "", false, true);
+      aa->append(SASS_MEMORY_NEW(Argument, kwarg->pstate(), kwarg, "", false, true));
     }
-
-    return aa;
+    return aa.detach();
   }
 
-  Expression* Eval::operator()(Comment* c)
+  Expression_Ptr Eval::operator()(Comment_Ptr c)
   {
     return 0;
   }
 
-  inline Expression* Eval::fallback_impl(AST_Node* n)
+  inline Expression_Ptr Eval::fallback_impl(AST_Node_Ptr n)
   {
-    return static_cast<Expression*>(n);
+    return static_cast<Expression_Ptr>(n);
   }
 
   // All the binary helpers.
 
-  bool Eval::eq(Expression* lhs, Expression* rhs)
+  bool Eval::eq(Expression_Obj lhs, Expression_Obj rhs)
   {
     // use compare operator from ast node
     return lhs && rhs && *lhs == *rhs;
   }
 
-  bool Eval::lt(Expression* lhs, Expression* rhs, std::string op)
+  bool Eval::lt(Expression_Obj lhs, Expression_Obj rhs, std::string op)
   {
-    Number* l = dynamic_cast<Number*>(lhs);
-    Number* r = dynamic_cast<Number*>(rhs);
+    Number_Obj l = SASS_MEMORY_CAST(Number, lhs);
+    Number_Obj r = SASS_MEMORY_CAST(Number, rhs);
     // use compare operator from ast node
-    if (!l || !r) throw Exception::UndefinedOperation(lhs, rhs, op);
+    if (!l || !r) throw Exception::UndefinedOperation(&lhs, &rhs, op);
     // use compare operator from ast node
     return *l < *r;
   }
 
-  Value* Eval::op_numbers(Memory_Manager& mem, enum Sass_OP op, const Number& l, const Number& r, struct Sass_Inspect_Options opt, ParserState* pstate)
+  Value_Ptr Eval::op_numbers(enum Sass_OP op, const Number& l, const Number& r, struct Sass_Inspect_Options opt, ParserState* pstate)
   {
     double lv = l.value();
     double rv = r.value();
     if (op == Sass_OP::DIV && rv == 0) {
       // XXX: this is never hit via spec tests
-      return SASS_MEMORY_NEW(mem, String_Quoted, pstate ? *pstate : l.pstate(), lv ? "Infinity" : "NaN");
+      return SASS_MEMORY_NEW(String_Quoted, pstate ? *pstate : l.pstate(), lv ? "Infinity" : "NaN");
     }
     if (op == Sass_OP::MOD && !rv) {
       // XXX: this is never hit via spec tests
       throw Exception::ZeroDivisionError(l, r);
     }
 
-    Number tmp(r);
+    Number tmp(&r); // copy
     bool strict = op != Sass_OP::MUL && op != Sass_OP::DIV;
     tmp.normalize(l.find_convertible_unit(), strict);
     std::string l_unit(l.unit());
     std::string r_unit(tmp.unit());
-    Number* v = SASS_MEMORY_NEW(mem, Number, l);
+    Number_Obj v = SASS_MEMORY_COPY(&l); // copy
     v->pstate(pstate ? *pstate : l.pstate());
     if (l_unit.empty() && (op == Sass_OP::ADD || op == Sass_OP::SUB || op == Sass_OP::MOD)) {
       v->numerator_units() = r.numerator_units();
@@ -1446,25 +1460,23 @@ namespace Sass {
         v->numerator_units().push_back(r.denominator_units()[i]);
       }
     } else {
-      Number rh(r);
-      v->value(ops[op](lv, rh.value() * r.convert_factor(l)));
+      v->value(ops[op](lv, r.value() * r.convert_factor(l)));
       // v->normalize();
-      return v;
+      return v.detach();
 
       v->value(ops[op](lv, tmp.value()));
     }
     v->normalize();
-    return v;
+    return v.detach();
   }
 
-  Value* Eval::op_number_color(Memory_Manager& mem, enum Sass_OP op, const Number& l, const Color& rh, struct Sass_Inspect_Options opt, ParserState* pstate)
+  Value_Ptr Eval::op_number_color(enum Sass_OP op, const Number& l, const Color& r, struct Sass_Inspect_Options opt, ParserState* pstate)
   {
-    Color r(rh);
     double lv = l.value();
     switch (op) {
       case Sass_OP::ADD:
       case Sass_OP::MUL: {
-        return SASS_MEMORY_NEW(mem, Color,
+        return SASS_MEMORY_NEW(Color,
                                pstate ? *pstate : l.pstate(),
                                ops[op](lv, r.r()),
                                ops[op](lv, r.g()),
@@ -1475,7 +1487,7 @@ namespace Sass {
       case Sass_OP::DIV: {
         std::string sep(op == Sass_OP::SUB ? "-" : "/");
         std::string color(r.to_string(opt));
-        return SASS_MEMORY_NEW(mem, String_Quoted,
+        return SASS_MEMORY_NEW(String_Quoted,
                                pstate ? *pstate : l.pstate(),
                                l.to_string(opt)
                                + sep
@@ -1487,17 +1499,17 @@ namespace Sass {
       default: break; // caller should ensure that we don't get here
     }
     // unreachable
-    return SASS_MEMORY_NEW(mem, Color, rh);
+    return NULL;
   }
 
-  Value* Eval::op_color_number(Memory_Manager& mem, enum Sass_OP op, const Color& l, const Number& r, struct Sass_Inspect_Options opt, ParserState* pstate)
+  Value_Ptr Eval::op_color_number(enum Sass_OP op, const Color& l, const Number& r, struct Sass_Inspect_Options opt, ParserState* pstate)
   {
     double rv = r.value();
     if (op == Sass_OP::DIV && !rv) {
       // comparison of Fixnum with Float failed?
       throw Exception::ZeroDivisionError(l, r);
     }
-    return SASS_MEMORY_NEW(mem, Color,
+    return SASS_MEMORY_NEW(Color,
                            pstate ? *pstate : l.pstate(),
                            ops[op](l.r(), rv),
                            ops[op](l.g(), rv),
@@ -1505,7 +1517,7 @@ namespace Sass {
                            l.a());
   }
 
-  Value* Eval::op_colors(Memory_Manager& mem, enum Sass_OP op, const Color& l, const Color& r, struct Sass_Inspect_Options opt, ParserState* pstate)
+  Value_Ptr Eval::op_colors(enum Sass_OP op, const Color& l, const Color& r, struct Sass_Inspect_Options opt, ParserState* pstate)
   {
     if (l.a() != r.a()) {
       throw Exception::AlphaChannelsNotEqual(&l, &r, "+");
@@ -1514,7 +1526,7 @@ namespace Sass {
       // comparison of Fixnum with Float failed?
       throw Exception::ZeroDivisionError(l, r);
     }
-    return SASS_MEMORY_NEW(mem, Color,
+    return SASS_MEMORY_NEW(Color,
                            pstate ? *pstate : l.pstate(),
                            ops[op](l.r(), r.r()),
                            ops[op](l.g(), r.g()),
@@ -1522,14 +1534,14 @@ namespace Sass {
                            l.a());
   }
 
-  Value* Eval::op_strings(Memory_Manager& mem, Sass::Operand operand, Value& lhs, Value& rhs, struct Sass_Inspect_Options opt, ParserState* pstate, bool delayed)
+  Value_Ptr Eval::op_strings(Sass::Operand operand, Value& lhs, Value& rhs, struct Sass_Inspect_Options opt, ParserState* pstate, bool delayed)
   {
     Expression::Concrete_Type ltype = lhs.concrete_type();
     Expression::Concrete_Type rtype = rhs.concrete_type();
     enum Sass_OP op = operand.operand;
 
-    String_Quoted* lqstr = dynamic_cast<String_Quoted*>(&lhs);
-    String_Quoted* rqstr = dynamic_cast<String_Quoted*>(&rhs);
+    String_Quoted_Ptr lqstr = dynamic_cast<String_Quoted_Ptr>(&lhs);
+    String_Quoted_Ptr rqstr = dynamic_cast<String_Quoted_Ptr>(&rhs);
 
     std::string lstr(lqstr ? lqstr->value() : lhs.to_string(opt));
     std::string rstr(rqstr ? rqstr->value() : rhs.to_string(opt));
@@ -1557,7 +1569,7 @@ namespace Sass {
          (sep != "/" || !rqstr || !rqstr->quote_mark()) */
     ) {
       // create a new string that might be quoted on output (but do not unquote what we pass)
-      return SASS_MEMORY_NEW(mem, String_Quoted, pstate ? *pstate : lhs.pstate(), lstr + rstr, 0, false, true);
+      return SASS_MEMORY_NEW(String_Quoted, pstate ? *pstate : lhs.pstate(), lstr + rstr, 0, false, true);
     }
 
     if (sep != "" && !delayed) {
@@ -1570,49 +1582,49 @@ namespace Sass {
       if (rqstr && rqstr->quote_mark()) rstr = quote(rstr);
     }
 
-    return SASS_MEMORY_NEW(mem, String_Constant, pstate ? *pstate : lhs.pstate(), lstr + sep + rstr);
+    return SASS_MEMORY_NEW(String_Constant, pstate ? *pstate : lhs.pstate(), lstr + sep + rstr);
   }
 
-  Expression* cval_to_astnode(Memory_Manager& mem, union Sass_Value* v, Context& ctx, Backtrace* backtrace, ParserState pstate)
+  Expression_Ptr cval_to_astnode(union Sass_Value* v, Backtrace* backtrace, ParserState pstate)
   {
     using std::strlen;
     using std::strcpy;
-    Expression* e = 0;
+    Expression_Ptr e = NULL;
     switch (sass_value_get_tag(v)) {
       case SASS_BOOLEAN: {
-        e = SASS_MEMORY_NEW(mem, Boolean, pstate, !!sass_boolean_get_value(v));
+        e = SASS_MEMORY_NEW(Boolean, pstate, !!sass_boolean_get_value(v));
       } break;
       case SASS_NUMBER: {
-        e = SASS_MEMORY_NEW(mem, Number, pstate, sass_number_get_value(v), sass_number_get_unit(v));
+        e = SASS_MEMORY_NEW(Number, pstate, sass_number_get_value(v), sass_number_get_unit(v));
       } break;
       case SASS_COLOR: {
-        e = SASS_MEMORY_NEW(mem, Color, pstate, sass_color_get_r(v), sass_color_get_g(v), sass_color_get_b(v), sass_color_get_a(v));
+        e = SASS_MEMORY_NEW(Color, pstate, sass_color_get_r(v), sass_color_get_g(v), sass_color_get_b(v), sass_color_get_a(v));
       } break;
       case SASS_STRING: {
         if (sass_string_is_quoted(v))
-          e = SASS_MEMORY_NEW(mem, String_Quoted, pstate, sass_string_get_value(v));
+          e = SASS_MEMORY_NEW(String_Quoted, pstate, sass_string_get_value(v));
         else {
-          e = SASS_MEMORY_NEW(mem, String_Constant, pstate, sass_string_get_value(v));
+          e = SASS_MEMORY_NEW(String_Constant, pstate, sass_string_get_value(v));
         }
       } break;
       case SASS_LIST: {
-        List* l = SASS_MEMORY_NEW(mem, List, pstate, sass_list_get_length(v), sass_list_get_separator(v));
+        List_Ptr l = SASS_MEMORY_NEW(List, pstate, sass_list_get_length(v), sass_list_get_separator(v));
         for (size_t i = 0, L = sass_list_get_length(v); i < L; ++i) {
-          *l << cval_to_astnode(mem, sass_list_get_value(v, i), ctx, backtrace, pstate);
+          l->append(cval_to_astnode(sass_list_get_value(v, i), backtrace, pstate));
         }
         e = l;
       } break;
       case SASS_MAP: {
-        Map* m = SASS_MEMORY_NEW(mem, Map, pstate);
+        Map_Ptr m = SASS_MEMORY_NEW(Map, pstate);
         for (size_t i = 0, L = sass_map_get_length(v); i < L; ++i) {
           *m << std::make_pair(
-            cval_to_astnode(mem, sass_map_get_key(v, i), ctx, backtrace, pstate),
-            cval_to_astnode(mem, sass_map_get_value(v, i), ctx, backtrace, pstate));
+            cval_to_astnode(sass_map_get_key(v, i), backtrace, pstate),
+            cval_to_astnode(sass_map_get_value(v, i), backtrace, pstate));
         }
         e = m;
       } break;
       case SASS_NULL: {
-        e = SASS_MEMORY_NEW(mem, Null, pstate);
+        e = SASS_MEMORY_NEW(Null, pstate);
       } break;
       case SASS_ERROR: {
         error("Error in C function: " + std::string(sass_error_get_message(v)), pstate, backtrace);
@@ -1624,15 +1636,15 @@ namespace Sass {
     return e;
   }
 
-  CommaSequence_Selector* Eval::operator()(CommaSequence_Selector* s)
+  Selector_List_Ptr Eval::operator()(Selector_List_Ptr s)
   {
-    std::vector<CommaSequence_Selector*> rv;
-    CommaSequence_Selector* sl = SASS_MEMORY_NEW(ctx.mem, CommaSequence_Selector, s->pstate());
+    std::vector<Selector_List_Obj> rv;
+    Selector_List_Obj sl = SASS_MEMORY_NEW(Selector_List, s->pstate());
     sl->is_optional(s->is_optional());
     sl->media_block(s->media_block());
     sl->is_optional(s->is_optional());
     for (size_t i = 0, iL = s->length(); i < iL; ++i) {
-      rv.push_back(operator()((*s)[i]));
+      rv.push_back(operator()(&(*s)[i]));
     }
 
     // we should actually permutate parent first
@@ -1642,7 +1654,7 @@ namespace Sass {
       bool abort = true;
       for (size_t i = 0, iL = rv.size(); i < iL; ++i) {
         if (rv[i]->length() > round) {
-          *sl << (*rv[i])[round];
+          sl->append((*rv[i])[round]);
           abort = false;
         }
       }
@@ -1653,49 +1665,48 @@ namespace Sass {
       }
 
     }
-    return sl;
+    return sl.detach();
   }
 
 
-  CommaSequence_Selector* Eval::operator()(Sequence_Selector* s)
+  Selector_List_Ptr Eval::operator()(Complex_Selector_Ptr s)
   {
     bool implicit_parent = !exp.old_at_root_without_rule;
-    return s->resolve_parent_refs(ctx, selector(), implicit_parent);
-
+    return s->resolve_parent_refs(ctx, exp.selector_stack, implicit_parent);
   }
 
   // XXX: this is never hit via spec tests
-  Attribute_Selector* Eval::operator()(Attribute_Selector* s)
+  Attribute_Selector_Ptr Eval::operator()(Attribute_Selector_Ptr s)
   {
-    String* attr = s->value();
-    if (attr) { attr = static_cast<String*>(attr->perform(this)); }
-    Attribute_Selector* ss = SASS_MEMORY_NEW(ctx.mem, Attribute_Selector, *s);
+    String_Obj attr = s->value();
+    if (attr) { attr = static_cast<String_Ptr>(attr->perform(this)); }
+    Attribute_Selector_Ptr ss = SASS_MEMORY_COPY(s);
     ss->value(attr);
     return ss;
   }
 
-  CommaSequence_Selector* Eval::operator()(Selector_Schema* s)
+  Selector_List_Ptr Eval::operator()(Selector_Schema_Ptr s)
   {
     // the parser will look for a brace to end the selector
-    std::string result_str(s->contents()->perform(this)->to_string(ctx.c_options));
+    Expression_Obj sel = s->contents()->perform(this);
+    std::string result_str(sel->to_string(ctx.c_options));
     result_str = unquote(Util::rtrim(result_str)) + "\n{";
     Parser p = Parser::from_c_str(result_str.c_str(), ctx, s->pstate());
     p.last_media_block = s->media_block();
-    CommaSequence_Selector* sl = p.parse_selector_list(exp.block_stack.back()->is_root());
+    Selector_List_Obj sl = p.parse_selector_list(exp.block_stack.back()->is_root());
     if (s->has_parent_ref()) sl->remove_parent_selectors();
-    return operator()(sl);
+    return operator()(&sl);
   }
 
-  Expression* Eval::operator()(Parent_Selector* p)
+  Expression_Ptr Eval::operator()(Parent_Selector_Ptr p)
   {
-    CommaSequence_Selector* pr = selector();
-    if (pr) {
+    if (Selector_List_Obj pr = selector()) {
       exp.selector_stack.pop_back();
-      pr = operator()(pr);
-      exp.selector_stack.push_back(pr);
-      return pr;
+      Selector_List_Obj rv = operator()(&pr);
+      exp.selector_stack.push_back(rv);
+      return rv.detach();
     } else {
-      return SASS_MEMORY_NEW(ctx.mem, Null, p->pstate());
+      return SASS_MEMORY_NEW(Null, p->pstate());
     }
   }