sassc 1.11.4 → 1.12.0

data/ext/libsass/src/ast.hpp

@@ -1,6 +1,7 @@
 #ifndef SASS_AST_H
 #define SASS_AST_H
 
+#include "sass.hpp"
 #include <set>
 #include <deque>
 #include <vector>
@@ -74,6 +75,9 @@ namespace Sass {
   // Note: most methods follow precision option
   const double NUMBER_EPSILON = 0.00000000000001;
 
+  // macro to test if numbers are equal within a small error margin
+  #define NEAR_EQUAL(lhs, rhs) std::fabs(lhs - rhs) < NUMBER_EPSILON
+
   // ToDo: where does this fit best?
   // We don't share this with C-API?
   class Operand {
@@ -120,12 +124,14 @@ namespace Sass {
     ATTACH_VIRTUAL_AST_OPERATIONS(AST_Node);
     virtual std::string inspect() const { return to_string({ INSPECT, 5 }); }
     virtual std::string to_sass() const { return to_string({ TO_SASS, 5 }); }
-    virtual std::string to_string(Sass_Inspect_Options opt) const;
-    virtual std::string to_string() const;
+    virtual const std::string to_string(Sass_Inspect_Options opt) const;
+    virtual const std::string to_string() const;
     virtual void cloneChildren() {};
+    // generic find function (not fully implemented yet)
+    // ToDo: add specific implementions to all children
+    virtual bool find ( bool (*f)(AST_Node_Obj) ) { return f(this); };
   public:
     void update_pstate(const ParserState& pstate);
-    void set_pstate_offset(const Offset& offset);
   public:
     Offset off() { return pstate(); }
     Position pos() { return pstate(); }
@@ -133,6 +139,21 @@ namespace Sass {
   };
   inline AST_Node::~AST_Node() { }
 
+  //////////////////////////////////////////////////////////////////////
+  // define cast template now (need complete type)
+  //////////////////////////////////////////////////////////////////////
+
+  template<class T>
+  T* Cast(AST_Node* ptr) {
+    return ptr && typeid(T) == typeid(*ptr) ?
+           static_cast<T*>(ptr) : NULL;
+  };
+
+  template<class T>
+  const T* Cast(const AST_Node* ptr) {
+    return ptr && typeid(T) == typeid(*ptr) ?
+           static_cast<const T*>(ptr) : NULL;
+  };
 
   //////////////////////////////////////////////////////////////////////
   // Abstract base class for expressions. This side of the AST hierarchy
@@ -151,9 +172,11 @@ namespace Sass {
       MAP,
       SELECTOR,
       NULL_VAL,
+      FUNCTION_VAL,
       C_WARNING,
       C_ERROR,
       FUNCTION,
+      VARIABLE,
       NUM_TYPES
     };
     enum Simple_Type {
@@ -186,7 +209,7 @@ namespace Sass {
     { }
     virtual operator bool() { return true; }
     virtual ~Expression() { }
-    virtual std::string type() { return ""; /* TODO: raise an error? */ }
+    virtual std::string type() const { return ""; /* TODO: raise an error? */ }
     virtual bool is_invisible() const { return false; }
     static std::string type_name() { return ""; }
     virtual bool is_false() { return false; }
@@ -343,8 +366,11 @@ namespace Sass {
     void reset_duplicate_key() { duplicate_key_ = 0; }
     virtual void adjust_after_pushing(std::pair<Expression_Obj, Expression_Obj> p) { }
   public:
-    Hashed(size_t s = 0) : elements_(ExpressionMap(s)), list_(std::vector<Expression_Obj>())
-    { elements_.reserve(s); list_.reserve(s); reset_duplicate_key(); }
+    Hashed(size_t s = 0)
+    : elements_(ExpressionMap(s)),
+      list_(std::vector<Expression_Obj>()),
+      hash_(0), duplicate_key_(NULL)
+    { elements_.reserve(s); list_.reserve(s); }
     virtual ~Hashed();
     size_t length() const                  { return list_.size(); }
     bool empty() const                     { return list_.empty(); }
@@ -454,7 +480,6 @@ namespace Sass {
   ////////////////////////
   class Block : public Statement, public Vectorized<Statement_Obj> {
     ADD_PROPERTY(bool, is_root)
-    ADD_PROPERTY(bool, is_at_root);
     // needed for properly formatted CSS emission
   protected:
     void adjust_after_pushing(Statement_Obj s)
@@ -464,14 +489,12 @@ namespace Sass {
     Block(ParserState pstate, size_t s = 0, bool r = false)
     : Statement(pstate),
       Vectorized<Statement_Obj>(s),
-      is_root_(r),
-      is_at_root_(false)
+      is_root_(r)
     { }
     Block(const Block* ptr)
     : Statement(ptr),
       Vectorized<Statement_Obj>(*ptr),
-      is_root_(ptr->is_root_),
-      is_at_root_(ptr->is_at_root_)
+      is_root_(ptr->is_root_)
     { }
     virtual bool has_content()
     {
@@ -509,17 +532,15 @@ namespace Sass {
   // of style declarations.
   /////////////////////////////////////////////////////////////////////////////
   class Ruleset : public Has_Block {
-    ADD_PROPERTY(Selector_Obj, selector)
-    ADD_PROPERTY(bool, at_root);
+    ADD_PROPERTY(Selector_List_Obj, selector)
     ADD_PROPERTY(bool, is_root);
   public:
-    Ruleset(ParserState pstate, Selector_Obj s = 0, Block_Obj b = 0)
-    : Has_Block(pstate, b), selector_(s), at_root_(false), is_root_(false)
+    Ruleset(ParserState pstate, Selector_List_Obj s = 0, Block_Obj b = 0)
+    : Has_Block(pstate, b), selector_(s), is_root_(false)
     { statement_type(RULESET); }
     Ruleset(const Ruleset* ptr)
     : Has_Block(ptr),
       selector_(ptr->selector_),
-      at_root_(ptr->at_root_),
       is_root_(ptr->is_root_)
     { statement_type(RULESET); }
     bool is_invisible() const;
@@ -551,13 +572,15 @@ namespace Sass {
   // Trace.
   /////////////////
   class Trace : public Has_Block {
-    ADD_PROPERTY(std::string, name)
+    ADD_CONSTREF(char, type)
+    ADD_CONSTREF(std::string, name)
   public:
-    Trace(ParserState pstate, std::string n, Block_Obj b = 0)
-    : Has_Block(pstate, b), name_(n)
+    Trace(ParserState pstate, std::string n, Block_Obj b = 0, char type = 'm')
+    : Has_Block(pstate, b), type_(type), name_(n)
     { }
     Trace(const Trace* ptr)
     : Has_Block(ptr),
+      type_(ptr->type_),
       name_(ptr->name_)
     { }
     ATTACH_AST_OPERATIONS(Trace)
@@ -573,9 +596,6 @@ namespace Sass {
     Media_Block(ParserState pstate, List_Obj mqs, Block_Obj b)
     : Has_Block(pstate, b), media_queries_(mqs)
     { statement_type(MEDIA); }
-    Media_Block(ParserState pstate, List_Obj mqs, Block_Obj b, Selector_Obj s)
-    : Has_Block(pstate, b), media_queries_(mqs)
-    { statement_type(MEDIA); }
     Media_Block(const Media_Block* ptr)
     : Has_Block(ptr), media_queries_(ptr->media_queries_)
     { statement_type(MEDIA); }
@@ -590,11 +610,11 @@ namespace Sass {
   // optional statement block.
   ///////////////////////////////////////////////////////////////////////
   class Directive : public Has_Block {
-    ADD_PROPERTY(std::string, keyword)
-    ADD_PROPERTY(Selector_Obj, selector)
+    ADD_CONSTREF(std::string, keyword)
+    ADD_PROPERTY(Selector_List_Obj, selector)
     ADD_PROPERTY(Expression_Obj, value)
   public:
-    Directive(ParserState pstate, std::string kwd, Selector_Obj sel = 0, Block_Obj b = 0, Expression_Obj val = 0)
+    Directive(ParserState pstate, std::string kwd, Selector_List_Obj sel = 0, Block_Obj b = 0, Expression_Obj val = 0)
     : Has_Block(pstate, b), keyword_(kwd), selector_(sel), value_(val) // set value manually if needed
     { statement_type(DIRECTIVE); }
     Directive(const Directive* ptr)
@@ -626,7 +646,7 @@ namespace Sass {
   class Keyframe_Rule : public Has_Block {
     // according to css spec, this should be <keyframes-name>
     // <keyframes-name> = <custom-ident> | <string>
-    ADD_PROPERTY(Selector_Obj, name)
+    ADD_PROPERTY(Selector_List_Obj, name)
   public:
     Keyframe_Rule(ParserState pstate, Block_Obj b)
     : Has_Block(pstate, b), name_()
@@ -645,19 +665,22 @@ namespace Sass {
     ADD_PROPERTY(String_Obj, property)
     ADD_PROPERTY(Expression_Obj, value)
     ADD_PROPERTY(bool, is_important)
+    ADD_PROPERTY(bool, is_custom_property)
     ADD_PROPERTY(bool, is_indented)
   public:
     Declaration(ParserState pstate,
-                String_Obj prop, Expression_Obj val, bool i = false, Block_Obj b = 0)
-    : Has_Block(pstate, b), property_(prop), value_(val), is_important_(i), is_indented_(false)
+                String_Obj prop, Expression_Obj val, bool i = false, bool c = false, Block_Obj b = 0)
+    : Has_Block(pstate, b), property_(prop), value_(val), is_important_(i), is_custom_property_(c), is_indented_(false)
     { statement_type(DECLARATION); }
     Declaration(const Declaration* ptr)
     : Has_Block(ptr),
       property_(ptr->property_),
       value_(ptr->value_),
       is_important_(ptr->is_important_),
+      is_custom_property_(ptr->is_custom_property_),
       is_indented_(ptr->is_indented_)
     { statement_type(DECLARATION); }
+    virtual bool is_invisible() const;
     ATTACH_AST_OPERATIONS(Declaration)
     ATTACH_OPERATIONS()
   };
@@ -666,7 +689,7 @@ namespace Sass {
   // Assignments -- variable and value.
   /////////////////////////////////////
   class Assignment : public Statement {
-    ADD_PROPERTY(std::string, variable)
+    ADD_CONSTREF(std::string, variable)
     ADD_PROPERTY(Expression_Obj, value)
     ADD_PROPERTY(bool, is_default)
     ADD_PROPERTY(bool, is_global)
@@ -811,7 +834,7 @@ namespace Sass {
     ADD_PROPERTY(Block_Obj, alternative)
   public:
     If(ParserState pstate, Expression_Obj pred, Block_Obj con, Block_Obj alt = 0)
-    : Has_Block(pstate, &con), predicate_(pred), alternative_(alt)
+    : Has_Block(pstate, con), predicate_(pred), alternative_(alt)
     { statement_type(IF); }
     If(const If* ptr)
     : Has_Block(ptr),
@@ -830,7 +853,7 @@ namespace Sass {
   // The Sass `@for` control directive.
   /////////////////////////////////////
   class For : public Has_Block {
-    ADD_PROPERTY(std::string, variable)
+    ADD_CONSTREF(std::string, variable)
     ADD_PROPERTY(Expression_Obj, lower_bound)
     ADD_PROPERTY(Expression_Obj, upper_bound)
     ADD_PROPERTY(bool, is_inclusive)
@@ -904,9 +927,9 @@ namespace Sass {
   // The Sass `@extend` directive.
   ////////////////////////////////
   class Extension : public Statement {
-    ADD_PROPERTY(Selector_Obj, selector)
+    ADD_PROPERTY(Selector_List_Obj, selector)
   public:
-    Extension(ParserState pstate, Selector_Obj s)
+    Extension(ParserState pstate, Selector_List_Obj s)
     : Statement(pstate), selector_(s)
     { statement_type(EXTEND); }
     Extension(const Extension* ptr)
@@ -921,13 +944,12 @@ namespace Sass {
   // by a type tag.
   /////////////////////////////////////////////////////////////////////////////
   struct Backtrace;
-  typedef Environment<AST_Node_Obj> Env;
   typedef const char* Signature;
-  typedef Expression_Ptr (*Native_Function)(Env&, Env&, Context&, Signature, ParserState, Backtrace*, std::vector<Selector_List_Obj>);
+  typedef Expression_Ptr (*Native_Function)(Env&, Env&, Context&, Signature, ParserState, Backtraces, std::vector<Selector_List_Obj>);
   class Definition : public Has_Block {
   public:
     enum Type { MIXIN, FUNCTION };
-    ADD_PROPERTY(std::string, name)
+    ADD_CONSTREF(std::string, name)
     ADD_PROPERTY(Parameters_Obj, parameters)
     ADD_PROPERTY(Env*, environment)
     ADD_PROPERTY(Type, type)
@@ -1009,7 +1031,7 @@ namespace Sass {
   // Mixin calls (i.e., `@include ...`).
   //////////////////////////////////////
   class Mixin_Call : public Has_Block {
-    ADD_PROPERTY(std::string, name)
+    ADD_CONSTREF(std::string, name)
     ADD_PROPERTY(Arguments_Obj, arguments)
   public:
     Mixin_Call(ParserState pstate, std::string n, Arguments_Obj args, Block_Obj b = 0)
@@ -1028,11 +1050,15 @@ namespace Sass {
   // The @content directive for mixin content blocks.
   ///////////////////////////////////////////////////
   class Content : public Statement {
-    ADD_PROPERTY(Media_Block_Obj, media_block)
+    ADD_PROPERTY(Media_Block_Ptr, media_block)
   public:
-    Content(ParserState pstate) : Statement(pstate)
+    Content(ParserState pstate)
+    : Statement(pstate),
+      media_block_(NULL)
     { statement_type(CONTENT); }
-    Content(const Content* ptr) : Statement(ptr)
+    Content(const Content* ptr)
+    : Statement(ptr),
+      media_block_(ptr->media_block_)
     { statement_type(CONTENT); }
     ATTACH_AST_OPERATIONS(Content)
     ATTACH_OPERATIONS()
@@ -1047,14 +1073,16 @@ namespace Sass {
   private:
     ADD_PROPERTY(enum Sass_Separator, separator)
     ADD_PROPERTY(bool, is_arglist)
+    ADD_PROPERTY(bool, is_bracketed)
     ADD_PROPERTY(bool, from_selector)
   public:
     List(ParserState pstate,
-         size_t size = 0, enum Sass_Separator sep = SASS_SPACE, bool argl = false)
+         size_t size = 0, enum Sass_Separator sep = SASS_SPACE, bool argl = false, bool bracket = false)
     : Value(pstate),
       Vectorized<Expression_Obj>(size),
       separator_(sep),
       is_arglist_(argl),
+      is_bracketed_(bracket),
       from_selector_(false)
     { concrete_type(LIST); }
     List(const List* ptr)
@@ -1062,15 +1090,16 @@ namespace Sass {
       Vectorized<Expression_Obj>(*ptr),
       separator_(ptr->separator_),
       is_arglist_(ptr->is_arglist_),
+      is_bracketed_(ptr->is_bracketed_),
       from_selector_(ptr->from_selector_)
     { concrete_type(LIST); }
-    std::string type() { return is_arglist_ ? "arglist" : "list"; }
+    std::string type() const { return is_arglist_ ? "arglist" : "list"; }
     static std::string type_name() { return "list"; }
     const char* sep_string(bool compressed = false) const {
       return separator() == SASS_SPACE ?
         " " : (compressed ? "," : ", ");
     }
-    bool is_invisible() const { return empty(); }
+    bool is_invisible() const { return empty() && !is_bracketed(); }
     Expression_Obj value_at_index(size_t i);
 
     virtual size_t size() const;
@@ -1079,6 +1108,7 @@ namespace Sass {
     {
       if (hash_ == 0) {
         hash_ = std::hash<std::string>()(sep_string());
+        hash_combine(hash_, std::hash<bool>()(is_bracketed()));
         for (size_t i = 0, L = length(); i < L; ++i)
           hash_combine(hash_, (elements()[i])->hash());
       }
@@ -1112,10 +1142,10 @@ namespace Sass {
     : Value(ptr),
       Hashed(*ptr)
     { concrete_type(MAP); }
-    std::string type() { return "map"; }
+    std::string type() const { return "map"; }
     static std::string type_name() { return "map"; }
     bool is_invisible() const { return empty(); }
-    List_Obj to_list(Context& ctx, ParserState& pstate);
+    List_Obj to_list(ParserState& pstate);
 
     virtual size_t hash()
     {
@@ -1137,22 +1167,43 @@ namespace Sass {
 
   inline static const std::string sass_op_to_name(enum Sass_OP op) {
     switch (op) {
-      case AND: return "and"; break;
-      case OR: return "or"; break;
-      case EQ: return "eq"; break;
-      case NEQ: return "neq"; break;
-      case GT: return "gt"; break;
-      case GTE: return "gte"; break;
-      case LT: return "lt"; break;
-      case LTE: return "lte"; break;
-      case ADD: return "plus"; break;
-      case SUB: return "sub"; break;
-      case MUL: return "times"; break;
-      case DIV: return "div"; break;
-      case MOD: return "mod"; break;
+      case AND: return "and";
+      case OR: return "or";
+      case EQ: return "eq";
+      case NEQ: return "neq";
+      case GT: return "gt";
+      case GTE: return "gte";
+      case LT: return "lt";
+      case LTE: return "lte";
+      case ADD: return "plus";
+      case SUB: return "sub";
+      case MUL: return "times";
+      case DIV: return "div";
+      case MOD: return "mod";
+      // this is only used internally!
+      case NUM_OPS: return "[OPS]";
+      default: return "invalid";
+    }
+  }
+
+  inline static const std::string sass_op_separator(enum Sass_OP op) {
+    switch (op) {
+      case AND: return "&&";
+      case OR: return "||";
+      case EQ: return "==";
+      case NEQ: return "!=";
+      case GT: return ">";
+      case GTE: return ">=";
+      case LT: return "<";
+      case LTE: return "<=";
+      case ADD: return "+";
+      case SUB: return "-";
+      case MUL: return "*";
+      case DIV: return "/";
+      case MOD: return "%";
       // this is only used internally!
-      case NUM_OPS: return "[OPS]"; break;
-      default: return "invalid"; break;
+      case NUM_OPS: return "[OPS]";
+      default: return "invalid";
     }
   }
 
@@ -1163,9 +1214,9 @@ namespace Sass {
   //////////////////////////////////////////////////////////////////////////
   class Binary_Expression : public PreValue {
   private:
-    ADD_HASHED(Operand, op)
-    ADD_HASHED(Expression_Obj, left)
-    ADD_HASHED(Expression_Obj, right)
+    HASH_PROPERTY(Operand, op)
+    HASH_PROPERTY(Expression_Obj, left)
+    HASH_PROPERTY(Expression_Obj, right)
     size_t hash_;
   public:
     Binary_Expression(ParserState pstate,
@@ -1180,44 +1231,10 @@ namespace Sass {
       hash_(ptr->hash_)
     { }
     const std::string type_name() {
-      switch (type()) {
-        case AND: return "and"; break;
-        case OR: return "or"; break;
-        case EQ: return "eq"; break;
-        case NEQ: return "neq"; break;
-        case GT: return "gt"; break;
-        case GTE: return "gte"; break;
-        case LT: return "lt"; break;
-        case LTE: return "lte"; break;
-        case ADD: return "add"; break;
-        case SUB: return "sub"; break;
-        case MUL: return "mul"; break;
-        case DIV: return "div"; break;
-        case MOD: return "mod"; break;
-        // this is only used internally!
-        case NUM_OPS: return "[OPS]"; break;
-        default: return "invalid"; break;
-      }
+      return sass_op_to_name(optype());
     }
     const std::string separator() {
-      switch (type()) {
-        case AND: return "&&"; break;
-        case OR: return "||"; break;
-        case EQ: return "=="; break;
-        case NEQ: return "!="; break;
-        case GT: return ">"; break;
-        case GTE: return ">="; break;
-        case LT: return "<"; break;
-        case LTE: return "<="; break;
-        case ADD: return "+"; break;
-        case SUB: return "-"; break;
-        case MUL: return "*"; break;
-        case DIV: return "/"; break;
-        case MOD: return "%"; break;
-        // this is only used internally!
-        case NUM_OPS: return "[OPS]"; break;
-        default: return "invalid"; break;
-      }
+      return sass_op_separator(optype());
     }
     bool is_left_interpolant(void) const;
     bool is_right_interpolant(void) const;
@@ -1236,11 +1253,11 @@ namespace Sass {
     {
       try
       {
-        Binary_Expression_Ptr_Const m = dynamic_cast<Binary_Expression_Ptr_Const>(&rhs);
+        Binary_Expression_Ptr_Const m = Cast<Binary_Expression>(&rhs);
         if (m == 0) return false;
         return type() == m->type() &&
-               left() == m->left() &&
-               right() == m->right();
+               *left() == *m->left() &&
+               *right() == *m->right();
       }
       catch (std::bad_cast&)
       {
@@ -1251,13 +1268,13 @@ namespace Sass {
     virtual size_t hash()
     {
       if (hash_ == 0) {
-        hash_ = std::hash<size_t>()(type());
+        hash_ = std::hash<size_t>()(optype());
         hash_combine(hash_, left()->hash());
         hash_combine(hash_, right()->hash());
       }
       return hash_;
     }
-    enum Sass_OP type() const { return op_.operand; }
+    enum Sass_OP optype() const { return op_.operand; }
     ATTACH_AST_OPERATIONS(Binary_Expression)
     ATTACH_OPERATIONS()
   };
@@ -1267,37 +1284,38 @@ namespace Sass {
   ////////////////////////////////////////////////////////////////////////////
   class Unary_Expression : public Expression {
   public:
-    enum Type { PLUS, MINUS, NOT };
+    enum Type { PLUS, MINUS, NOT, SLASH };
   private:
-    ADD_HASHED(Type, type)
-    ADD_HASHED(Expression_Obj, operand)
+    HASH_PROPERTY(Type, optype)
+    HASH_PROPERTY(Expression_Obj, operand)
     size_t hash_;
   public:
     Unary_Expression(ParserState pstate, Type t, Expression_Obj o)
-    : Expression(pstate), type_(t), operand_(o), hash_(0)
+    : Expression(pstate), optype_(t), operand_(o), hash_(0)
     { }
     Unary_Expression(const Unary_Expression* ptr)
     : Expression(ptr),
-      type_(ptr->type_),
+      optype_(ptr->optype_),
       operand_(ptr->operand_),
       hash_(ptr->hash_)
     { }
     const std::string type_name() {
-      switch (type_) {
-        case PLUS: return "plus"; break;
-        case MINUS: return "minus"; break;
-        case NOT: return "not"; break;
-        default: return "invalid"; break;
+      switch (optype_) {
+        case PLUS: return "plus";
+        case MINUS: return "minus";
+        case SLASH: return "slash";
+        case NOT: return "not";
+        default: return "invalid";
       }
     }
     virtual bool operator==(const Expression& rhs) const
     {
       try
       {
-        Unary_Expression_Ptr_Const m = dynamic_cast<Unary_Expression_Ptr_Const>(&rhs);
+        Unary_Expression_Ptr_Const m = Cast<Unary_Expression>(&rhs);
         if (m == 0) return false;
         return type() == m->type() &&
-               operand() == m->operand();
+               *operand() == *m->operand();
       }
       catch (std::bad_cast&)
       {
@@ -1308,7 +1326,7 @@ namespace Sass {
     virtual size_t hash()
     {
       if (hash_ == 0) {
-        hash_ = std::hash<size_t>()(type_);
+        hash_ = std::hash<size_t>()(optype_);
         hash_combine(hash_, operand()->hash());
       };
       return hash_;
@@ -1321,8 +1339,8 @@ namespace Sass {
   // Individual argument objects for mixin and function calls.
   ////////////////////////////////////////////////////////////
   class Argument : public Expression {
-    ADD_HASHED(Expression_Obj, value)
-    ADD_HASHED(std::string, name)
+    HASH_PROPERTY(Expression_Obj, value)
+    HASH_CONSTREF(std::string, name)
     ADD_PROPERTY(bool, is_rest_argument)
     ADD_PROPERTY(bool, is_keyword_argument)
     size_t hash_;
@@ -1331,7 +1349,7 @@ namespace Sass {
     : Expression(pstate), value_(val), name_(n), is_rest_argument_(rest), is_keyword_argument_(keyword), hash_(0)
     {
       if (!name_.empty() && is_rest_argument_) {
-        error("variable-length argument may not be passed by name", pstate_);
+        coreError("variable-length argument may not be passed by name", pstate_);
       }
     }
     Argument(const Argument* ptr)
@@ -1343,7 +1361,7 @@ namespace Sass {
       hash_(ptr->hash_)
     {
       if (!name_.empty() && is_rest_argument_) {
-        error("variable-length argument may not be passed by name", pstate_);
+        coreError("variable-length argument may not be passed by name", pstate_);
       }
     }
 
@@ -1352,7 +1370,7 @@ namespace Sass {
     {
       try
       {
-        Argument_Ptr_Const m = dynamic_cast<Argument_Ptr_Const>(&rhs);
+        Argument_Ptr_Const m = Cast<Argument>(&rhs);
         if (!(m && name() == m->name())) return false;
         return *value() == *m->value();
       }
@@ -1412,18 +1430,54 @@ namespace Sass {
     ATTACH_OPERATIONS()
   };
 
+  ////////////////////////////////////////////////////
+  // Function reference.
+  ////////////////////////////////////////////////////
+  class Function : public Value {
+  public:
+    ADD_PROPERTY(Definition_Obj, definition)
+    ADD_PROPERTY(bool, is_css)
+  public:
+    Function(ParserState pstate, Definition_Obj def, bool css)
+    : Value(pstate), definition_(def), is_css_(css)
+    { concrete_type(FUNCTION_VAL); }
+    Function(const Function* ptr)
+    : Value(ptr), definition_(ptr->definition_), is_css_(ptr->is_css_)
+    { concrete_type(FUNCTION_VAL); }
+
+    std::string type() const { return "function"; }
+    static std::string type_name() { return "function"; }
+    bool is_invisible() const { return true; }
+
+    std::string name() {
+      if (definition_) {
+        return definition_->name();
+      }
+      return "";
+    }
+
+    virtual bool operator== (const Expression& rhs) const;
+
+    ATTACH_AST_OPERATIONS(Function)
+    ATTACH_OPERATIONS()
+  };
+
   //////////////////
   // Function calls.
   //////////////////
   class Function_Call : public PreValue {
-    ADD_HASHED(std::string, name)
-    ADD_HASHED(Arguments_Obj, arguments)
+    HASH_CONSTREF(std::string, name)
+    HASH_PROPERTY(Arguments_Obj, arguments)
+    HASH_PROPERTY(Function_Obj, func)
     ADD_PROPERTY(bool, via_call)
     ADD_PROPERTY(void*, cookie)
     size_t hash_;
   public:
     Function_Call(ParserState pstate, std::string n, Arguments_Obj args, void* cookie)
-    : PreValue(pstate), name_(n), arguments_(args), via_call_(false), cookie_(cookie), hash_(0)
+    : PreValue(pstate), name_(n), arguments_(args), func_(0), via_call_(false), cookie_(cookie), hash_(0)
+    { concrete_type(FUNCTION); }
+    Function_Call(ParserState pstate, std::string n, Arguments_Obj args, Function_Obj func)
+    : PreValue(pstate), name_(n), arguments_(args), func_(func), via_call_(false), cookie_(0), hash_(0)
     { concrete_type(FUNCTION); }
     Function_Call(ParserState pstate, std::string n, Arguments_Obj args)
     : PreValue(pstate), name_(n), arguments_(args), via_call_(false), cookie_(0), hash_(0)
@@ -1432,20 +1486,26 @@ namespace Sass {
     : PreValue(ptr),
       name_(ptr->name_),
       arguments_(ptr->arguments_),
+      func_(ptr->func_),
       via_call_(ptr->via_call_),
       cookie_(ptr->cookie_),
       hash_(ptr->hash_)
     { concrete_type(FUNCTION); }
 
+    bool is_css() {
+      if (func_) return func_->is_css();
+      return false;
+    }
+
     virtual bool operator==(const Expression& rhs) const
     {
       try
       {
-        Function_Call_Ptr_Const m = dynamic_cast<Function_Call_Ptr_Const>(&rhs);
+        Function_Call_Ptr_Const m = Cast<Function_Call>(&rhs);
         if (!(m && name() == m->name())) return false;
         if (!(m && arguments()->length() == m->arguments()->length())) return false;
         for (size_t i =0, L = arguments()->length(); i < L; ++i)
-          if (!((*arguments())[i] == (*m->arguments())[i])) return false;
+          if (!(*(*arguments())[i] == *(*m->arguments())[i])) return false;
         return true;
       }
       catch (std::bad_cast&)
@@ -1491,20 +1551,20 @@ namespace Sass {
   // Variable references.
   ///////////////////////
   class Variable : public PreValue {
-    ADD_PROPERTY(std::string, name)
+    ADD_CONSTREF(std::string, name)
   public:
     Variable(ParserState pstate, std::string n)
     : PreValue(pstate), name_(n)
-    { }
+    { concrete_type(VARIABLE); }
     Variable(const Variable* ptr)
     : PreValue(ptr), name_(ptr->name_)
-    { }
+    { concrete_type(VARIABLE); }
 
     virtual bool operator==(const Expression& rhs) const
     {
       try
       {
-        Variable_Ptr_Const e = dynamic_cast<Variable_Ptr_Const>(&rhs);
+        Variable_Ptr_Const e = Cast<Variable>(&rhs);
         return e && name() == e->name();
       }
       catch (std::bad_cast&)
@@ -1523,108 +1583,45 @@ namespace Sass {
     ATTACH_OPERATIONS()
   };
 
-  ////////////////////////////////////////////////////////////////////////////
-  // Textual (i.e., unevaluated) numeric data. Variants are distinguished with
-  // a type tag.
-  ////////////////////////////////////////////////////////////////////////////
-  class Textual : public Expression {
-  public:
-    enum Type { NUMBER, PERCENTAGE, DIMENSION, HEX };
-  private:
-    ADD_HASHED(Type, type)
-    ADD_HASHED(std::string, value)
-    size_t hash_;
-  public:
-    Textual(ParserState pstate, Type t, std::string val)
-    : Expression(pstate, DELAYED), type_(t), value_(val),
-      hash_(0)
-    { }
-    Textual(const Textual* ptr)
-    : Expression(ptr),
-      type_(ptr->type_),
-      value_(ptr->value_),
-      hash_(ptr->hash_)
-    { }
-
-    virtual bool operator==(const Expression& rhs) const
-    {
-      try
-      {
-        Textual_Ptr_Const e = dynamic_cast<Textual_Ptr_Const>(&rhs);
-        return e && value() == e->value() && type() == e->type();
-      }
-      catch (std::bad_cast&)
-      {
-        return false;
-      }
-      catch (...) { throw; }
-    }
-
-    virtual size_t hash()
-    {
-      if (hash_ == 0) {
-        hash_ = std::hash<std::string>()(value_);
-        hash_combine(hash_, std::hash<int>()(type_));
-      }
-      return hash_;
-    }
-
-    ATTACH_AST_OPERATIONS(Textual)
-    ATTACH_OPERATIONS()
-  };
-
   ////////////////////////////////////////////////
   // Numbers, percentages, dimensions, and colors.
   ////////////////////////////////////////////////
-  class Number : public Value {
-    ADD_HASHED(double, value)
+  class Number : public Value, public Units {
+    HASH_PROPERTY(double, value)
     ADD_PROPERTY(bool, zero)
-    std::vector<std::string> numerator_units_;
-    std::vector<std::string> denominator_units_;
     size_t hash_;
   public:
     Number(ParserState pstate, double val, std::string u = "", bool zero = true);
 
     Number(const Number* ptr)
     : Value(ptr),
+      Units(ptr),
       value_(ptr->value_), zero_(ptr->zero_),
-      numerator_units_(ptr->numerator_units_),
-      denominator_units_(ptr->denominator_units_),
       hash_(ptr->hash_)
     { concrete_type(NUMBER); }
 
     bool zero() { return zero_; }
-    bool is_valid_css_unit() const;
-    std::vector<std::string>& numerator_units()   { return numerator_units_; }
-    std::vector<std::string>& denominator_units() { return denominator_units_; }
-    const std::vector<std::string>& numerator_units() const   { return numerator_units_; }
-    const std::vector<std::string>& denominator_units() const { return denominator_units_; }
-    std::string type() { return "number"; }
+    std::string type() const { return "number"; }
     static std::string type_name() { return "number"; }
-    std::string unit() const;
 
-    bool is_unitless() const;
-    double convert_factor(const Number&) const;
-    bool convert(const std::string& unit = "", bool strict = false);
-    void normalize(const std::string& unit = "", bool strict = false);
-    // useful for making one number compatible with another
-    std::string find_convertible_unit() const;
+    void reduce();
+    void normalize();
 
     virtual size_t hash()
     {
       if (hash_ == 0) {
         hash_ = std::hash<double>()(value_);
-        for (const auto numerator : numerator_units())
+        for (const auto numerator : numerators)
           hash_combine(hash_, std::hash<std::string>()(numerator));
-        for (const auto denominator : denominator_units())
+        for (const auto denominator : denominators)
           hash_combine(hash_, std::hash<std::string>()(denominator));
       }
       return hash_;
     }
 
     virtual bool operator< (const Number& rhs) const;
+    virtual bool operator== (const Number& rhs) const;
     virtual bool operator== (const Expression& rhs) const;
-    virtual bool eq(const Expression& rhs) const;
     ATTACH_AST_OPERATIONS(Number)
     ATTACH_OPERATIONS()
   };
@@ -1633,11 +1630,11 @@ namespace Sass {
   // Colors.
   //////////
   class Color : public Value {
-    ADD_HASHED(double, r)
-    ADD_HASHED(double, g)
-    ADD_HASHED(double, b)
-    ADD_HASHED(double, a)
-    ADD_PROPERTY(std::string, disp)
+    HASH_PROPERTY(double, r)
+    HASH_PROPERTY(double, g)
+    HASH_PROPERTY(double, b)
+    HASH_PROPERTY(double, a)
+    ADD_CONSTREF(std::string, disp)
     size_t hash_;
   public:
     Color(ParserState pstate, double r, double g, double b, double a = 1, const std::string disp = "")
@@ -1653,7 +1650,7 @@ namespace Sass {
       disp_(ptr->disp_),
       hash_(ptr->hash_)
     { concrete_type(COLOR); }
-    std::string type() { return "color"; }
+    std::string type() const { return "color"; }
     static std::string type_name() { return "color"; }
 
     virtual size_t hash()
@@ -1677,7 +1674,7 @@ namespace Sass {
   // Errors from Sass_Values.
   //////////////////////////////
   class Custom_Error : public Value {
-    ADD_PROPERTY(std::string, message)
+    ADD_CONSTREF(std::string, message)
   public:
     Custom_Error(ParserState pstate, std::string msg)
     : Value(pstate), message_(msg)
@@ -1694,7 +1691,7 @@ namespace Sass {
   // Warnings from Sass_Values.
   //////////////////////////////
   class Custom_Warning : public Value {
-    ADD_PROPERTY(std::string, message)
+    ADD_CONSTREF(std::string, message)
   public:
     Custom_Warning(ParserState pstate, std::string msg)
     : Value(pstate), message_(msg)
@@ -1711,7 +1708,7 @@ namespace Sass {
   // Booleans.
   ////////////
   class Boolean : public Value {
-    ADD_HASHED(bool, value)
+    HASH_PROPERTY(bool, value)
     size_t hash_;
   public:
     Boolean(ParserState pstate, bool val)
@@ -1724,7 +1721,7 @@ namespace Sass {
       hash_(ptr->hash_)
     { concrete_type(BOOLEAN); }
     virtual operator bool() { return value_; }
-    std::string type() { return "bool"; }
+    std::string type() const { return "bool"; }
     static std::string type_name() { return "bool"; }
     virtual bool is_false() { return !value_; }
 
@@ -1757,8 +1754,6 @@ namespace Sass {
     static std::string type_name() { return "string"; }
     virtual ~String() = 0;
     virtual void rtrim() = 0;
-    virtual void ltrim() = 0;
-    virtual void trim() = 0;
     virtual bool operator==(const Expression& rhs) const = 0;
     virtual bool operator<(const Expression& rhs) const {
       return this->to_string() < rhs.to_string();
@@ -1773,19 +1768,20 @@ namespace Sass {
   // evaluation phase.
   ///////////////////////////////////////////////////////////////////////
   class String_Schema : public String, public Vectorized<Expression_Obj> {
-    // ADD_PROPERTY(bool, has_interpolants)
+    ADD_PROPERTY(bool, css)
     size_t hash_;
   public:
-    String_Schema(ParserState pstate, size_t size = 0, bool has_interpolants = false)
-    : String(pstate), Vectorized<Expression_Obj>(size), hash_(0)
+    String_Schema(ParserState pstate, size_t size = 0, bool css = true)
+    : String(pstate), Vectorized<Expression_Obj>(size), css_(css), hash_(0)
     { concrete_type(STRING); }
     String_Schema(const String_Schema* ptr)
     : String(ptr),
       Vectorized<Expression_Obj>(*ptr),
+      css_(ptr->css_),
       hash_(ptr->hash_)
     { concrete_type(STRING); }
 
-    std::string type() { return "string"; }
+    std::string type() const { return "string"; }
     static std::string type_name() { return "string"; }
 
     bool is_left_interpolant(void) const;
@@ -1798,8 +1794,6 @@ namespace Sass {
       return false;
     }
     virtual void rtrim();
-    virtual void ltrim();
-    virtual void trim();
 
     virtual size_t hash()
     {
@@ -1825,7 +1819,7 @@ namespace Sass {
   class String_Constant : public String {
     ADD_PROPERTY(char, quote_mark)
     ADD_PROPERTY(bool, can_compress_whitespace)
-    ADD_HASHED(std::string, value)
+    HASH_CONSTREF(std::string, value)
   protected:
     size_t hash_;
   public:
@@ -1836,24 +1830,22 @@ namespace Sass {
       value_(ptr->value_),
       hash_(ptr->hash_)
     { }
-    String_Constant(ParserState pstate, std::string val)
-    : String(pstate), quote_mark_(0), can_compress_whitespace_(false), value_(read_css_string(val)), hash_(0)
+    String_Constant(ParserState pstate, std::string val, bool css = true)
+    : String(pstate), quote_mark_(0), can_compress_whitespace_(false), value_(read_css_string(val, css)), hash_(0)
     { }
-    String_Constant(ParserState pstate, const char* beg)
-    : String(pstate), quote_mark_(0), can_compress_whitespace_(false), value_(read_css_string(std::string(beg))), hash_(0)
+    String_Constant(ParserState pstate, const char* beg, bool css = true)
+    : String(pstate), quote_mark_(0), can_compress_whitespace_(false), value_(read_css_string(std::string(beg), css)), hash_(0)
     { }
-    String_Constant(ParserState pstate, const char* beg, const char* end)
-    : String(pstate), quote_mark_(0), can_compress_whitespace_(false), value_(read_css_string(std::string(beg, end-beg))), hash_(0)
+    String_Constant(ParserState pstate, const char* beg, const char* end, bool css = true)
+    : String(pstate), quote_mark_(0), can_compress_whitespace_(false), value_(read_css_string(std::string(beg, end-beg), css)), hash_(0)
     { }
-    String_Constant(ParserState pstate, const Token& tok)
-    : String(pstate), quote_mark_(0), can_compress_whitespace_(false), value_(read_css_string(std::string(tok.begin, tok.end))), hash_(0)
+    String_Constant(ParserState pstate, const Token& tok, bool css = true)
+    : String(pstate), quote_mark_(0), can_compress_whitespace_(false), value_(read_css_string(std::string(tok.begin, tok.end), css)), hash_(0)
     { }
-    std::string type() { return "string"; }
+    std::string type() const { return "string"; }
     static std::string type_name() { return "string"; }
     virtual bool is_invisible() const;
     virtual void rtrim();
-    virtual void ltrim();
-    virtual void trim();
 
     virtual size_t hash()
     {
@@ -1881,8 +1873,8 @@ namespace Sass {
   public:
     String_Quoted(ParserState pstate, std::string val, char q = 0,
       bool keep_utf8_escapes = false, bool skip_unquoting = false,
-      bool strict_unquoting = true)
-    : String_Constant(pstate, val)
+      bool strict_unquoting = true, bool css = true)
+    : String_Constant(pstate, val, css)
     {
       if (skip_unquoting == false) {
         value_ = unquote(value_, &quote_mark_, keep_utf8_escapes, strict_unquoting);
@@ -2103,7 +2095,7 @@ namespace Sass {
 
       if (s->statement_type() == Statement::DIRECTIVE)
       {
-        if (Directive_Obj dir = SASS_MEMORY_CAST(Directive, s))
+        if (Directive_Obj dir = Cast<Directive>(s))
         {
           std::string keyword(dir->keyword());
           if (keyword.length() > 0) keyword.erase(0, 1);
@@ -2122,7 +2114,7 @@ namespace Sass {
       {
         return expression()->exclude("supports");
       }
-      if (Directive_Obj dir = SASS_MEMORY_CAST(Directive, s))
+      if (Directive_Obj dir = Cast<Directive>(s))
       {
         if (dir->is_keyframes()) return expression()->exclude("keyframes");
       }
@@ -2139,7 +2131,7 @@ namespace Sass {
   public:
     Null(ParserState pstate) : Value(pstate) { concrete_type(NULL_VAL); }
     Null(const Null* ptr) : Value(ptr) { concrete_type(NULL_VAL); }
-    std::string type() { return "null"; }
+    std::string type() const { return "null"; }
     static std::string type_name() { return "null"; }
     bool is_invisible() const { return true; }
     operator bool() { return false; }
@@ -2172,7 +2164,7 @@ namespace Sass {
   // Individual parameter objects for mixins and functions.
   /////////////////////////////////////////////////////////
   class Parameter : public AST_Node {
-    ADD_PROPERTY(std::string, name)
+    ADD_CONSTREF(std::string, name)
     ADD_PROPERTY(Expression_Obj, default_value)
     ADD_PROPERTY(bool, is_rest_parameter)
   public:
@@ -2180,9 +2172,11 @@ namespace Sass {
               std::string n, Expression_Obj def = 0, bool rest = false)
     : AST_Node(pstate), name_(n), default_value_(def), is_rest_parameter_(rest)
     {
-      if (default_value_ && is_rest_parameter_) {
-        error("variable-length parameter may not have a default value", pstate_);
-      }
+      // tried to come up with a spec test for this, but it does no longer
+      // get  past the parser (it error out earlier). A spec test was added!
+      // if (default_value_ && is_rest_parameter_) {
+      //   error("variable-length parameter may not have a default value", pstate_);
+      // }
     }
     Parameter(const Parameter* ptr)
     : AST_Node(ptr),
@@ -2190,9 +2184,11 @@ namespace Sass {
       default_value_(ptr->default_value_),
       is_rest_parameter_(ptr->is_rest_parameter_)
     {
-      if (default_value_ && is_rest_parameter_) {
-        error("variable-length parameter may not have a default value", pstate_);
-      }
+      // tried to come up with a spec test for this, but it does no longer
+      // get  past the parser (it error out earlier). A spec test was added!
+      // if (default_value_ && is_rest_parameter_) {
+      //   error("variable-length parameter may not have a default value", pstate_);
+      // }
     }
     ATTACH_AST_OPERATIONS(Parameter)
     ATTACH_OPERATIONS()
@@ -2210,23 +2206,23 @@ namespace Sass {
     void adjust_after_pushing(Parameter_Obj p)
     {
       if (p->default_value()) {
-        if (has_rest_parameter_) {
-          error("optional parameters may not be combined with variable-length parameters", p->pstate());
+        if (has_rest_parameter()) {
+          coreError("optional parameters may not be combined with variable-length parameters", p->pstate());
         }
-        has_optional_parameters_ = true;
+        has_optional_parameters(true);
       }
       else if (p->is_rest_parameter()) {
-        if (has_rest_parameter_) {
-          error("functions and mixins cannot have more than one variable-length parameter", p->pstate());
+        if (has_rest_parameter()) {
+          coreError("functions and mixins cannot have more than one variable-length parameter", p->pstate());
         }
-        has_rest_parameter_ = true;
+        has_rest_parameter(true);
       }
       else {
-        if (has_rest_parameter_) {
-          error("required parameters must precede variable-length parameters", p->pstate());
+        if (has_rest_parameter()) {
+          coreError("required parameters must precede variable-length parameters", p->pstate());
         }
-        if (has_optional_parameters_) {
-          error("required parameters must precede optional parameters", p->pstate());
+        if (has_optional_parameters()) {
+          coreError("required parameters must precede optional parameters", p->pstate());
         }
       }
     }
@@ -2266,9 +2262,8 @@ namespace Sass {
   protected:
     size_t hash_;
   public:
-    Selector(ParserState pstate, bool r = false, bool h = false)
+    Selector(ParserState pstate)
     : Expression(pstate),
-      // has_reference_(r),
       has_line_feed_(false),
       has_line_break_(false),
       is_optional_(false),
@@ -2286,21 +2281,19 @@ namespace Sass {
     { concrete_type(SELECTOR); }
     virtual ~Selector() = 0;
     virtual size_t hash() = 0;
-    virtual unsigned long specificity() {
-      return 0;
-    }
+    virtual unsigned long specificity() const = 0;
     virtual void set_media_block(Media_Block_Ptr mb) {
       media_block(mb);
     }
-    virtual bool has_parent_ref() {
+    virtual bool has_parent_ref() const {
       return false;
     }
-    virtual bool has_real_parent_ref() {
+    virtual bool has_real_parent_ref() const {
       return false;
     }
     // dispatch to correct handlers
-    virtual bool operator<(const Selector& rhs) const;
-    virtual bool operator==(const Selector& rhs) const;
+    virtual bool operator<(const Selector& rhs) const = 0;
+    virtual bool operator==(const Selector& rhs) const = 0;
     ATTACH_VIRTUAL_AST_OPERATIONS(Selector);
   };
   inline Selector::~Selector() { }
@@ -2309,20 +2302,36 @@ namespace Sass {
   // Interpolated selectors -- the interpolated String will be expanded and
   // re-parsed into a normal selector class.
   /////////////////////////////////////////////////////////////////////////
-  class Selector_Schema : public Selector {
+  class Selector_Schema : public AST_Node {
     ADD_PROPERTY(String_Obj, contents)
-    ADD_PROPERTY(bool, at_root);
+    ADD_PROPERTY(bool, connect_parent);
+    // must not be a reference counted object
+    // otherwise we create circular references
+    ADD_PROPERTY(Media_Block_Ptr, media_block)
+    // store computed hash
+    size_t hash_;
   public:
     Selector_Schema(ParserState pstate, String_Obj c)
-    : Selector(pstate), contents_(c), at_root_(false)
+    : AST_Node(pstate),
+      contents_(c),
+      connect_parent_(true),
+      media_block_(NULL),
+      hash_(0)
     { }
     Selector_Schema(const Selector_Schema* ptr)
-    : Selector(ptr),
+    : AST_Node(ptr),
       contents_(ptr->contents_),
-      at_root_(ptr->at_root_)
+      connect_parent_(ptr->connect_parent_),
+      media_block_(ptr->media_block_),
+      hash_(ptr->hash_)
     { }
-    virtual bool has_parent_ref();
-    virtual bool has_real_parent_ref();
+    virtual bool has_parent_ref() const;
+    virtual bool has_real_parent_ref() const;
+    virtual bool operator<(const Selector& rhs) const;
+    virtual bool operator==(const Selector& rhs) const;
+    // selector schema is not yet a final selector, so we do not
+    // have a specificity for it yet. We need to
+    virtual unsigned long specificity() const { return 0; }
     virtual size_t hash() {
       if (hash_ == 0) {
         hash_combine(hash_, contents_->hash());
@@ -2337,8 +2346,8 @@ namespace Sass {
   // Abstract base class for simple selectors.
   ////////////////////////////////////////////
   class Simple_Selector : public Selector {
-    ADD_PROPERTY(std::string, ns)
-    ADD_PROPERTY(std::string, name)
+    ADD_CONSTREF(std::string, ns)
+    ADD_CONSTREF(std::string, name)
     ADD_PROPERTY(Simple_Type, simple_type)
     ADD_PROPERTY(bool, has_ns)
   public:
@@ -2360,10 +2369,6 @@ namespace Sass {
       name_(ptr->name_),
       has_ns_(ptr->has_ns_)
     { simple_type(SIMPLE); }
-    virtual bool unique() const
-    {
-      return false;
-    }
     virtual std::string ns_name() const
     {
       std::string name("");
@@ -2380,6 +2385,8 @@ namespace Sass {
       }
       return hash_;
     }
+    // namespace compare functions
+    bool is_ns_eq(const Simple_Selector& r) const;
     // namespace query functions
     bool is_universal_ns() const
     {
@@ -2412,11 +2419,10 @@ namespace Sass {
     }
 
     virtual ~Simple_Selector() = 0;
-    virtual Compound_Selector_Ptr unify_with(Compound_Selector_Ptr, Context&);
-    virtual bool has_parent_ref() { return false; };
-    virtual bool has_real_parent_ref() { return false; };
-    virtual bool is_pseudo_element() { return false; }
-    virtual bool is_pseudo_class() { return false; }
+    virtual Compound_Selector_Ptr unify_with(Compound_Selector_Ptr);
+    virtual bool has_parent_ref() const { return false; };
+    virtual bool has_real_parent_ref() const  { return false; };
+    virtual bool is_pseudo_element() const { return false; }
 
     virtual bool is_superselector_of(Compound_Selector_Obj sub) { return false; }
 
@@ -2448,14 +2454,14 @@ namespace Sass {
     Parent_Selector(const Parent_Selector* ptr)
     : Simple_Selector(ptr), real_(ptr->real_)
     { /* has_reference(true); */ }
-    bool is_real_parent_ref() { return real(); };
-    virtual bool has_parent_ref() { return true; };
-    virtual bool has_real_parent_ref() { return is_real_parent_ref(); };
-    virtual unsigned long specificity()
+    bool is_real_parent_ref() const { return real(); };
+    virtual bool has_parent_ref() const { return true; };
+    virtual bool has_real_parent_ref() const { return is_real_parent_ref(); };
+    virtual unsigned long specificity() const
     {
       return 0;
     }
-    std::string type() { return "selector"; }
+    std::string type() const { return "selector"; }
     static std::string type_name() { return "selector"; }
     ATTACH_AST_OPERATIONS(Parent_Selector)
     ATTACH_OPERATIONS()
@@ -2472,7 +2478,7 @@ namespace Sass {
     Placeholder_Selector(const Placeholder_Selector* ptr)
     : Simple_Selector(ptr)
     { }
-    virtual unsigned long specificity()
+    virtual unsigned long specificity() const
     {
       return Constants::Specificity_Base;
     }
@@ -2495,13 +2501,17 @@ namespace Sass {
     Element_Selector(const Element_Selector* ptr)
     : Simple_Selector(ptr)
     { }
-    virtual unsigned long specificity()
+    virtual unsigned long specificity() const
     {
       if (name() == "*") return 0;
       else               return Constants::Specificity_Element;
     }
-    virtual Simple_Selector_Ptr unify_with(Simple_Selector_Ptr, Context&);
-    virtual Compound_Selector_Ptr unify_with(Compound_Selector_Ptr, Context&);
+    virtual Simple_Selector_Ptr unify_with(Simple_Selector_Ptr);
+    virtual Compound_Selector_Ptr unify_with(Compound_Selector_Ptr);
+    virtual bool operator==(const Simple_Selector& rhs) const;
+    virtual bool operator==(const Element_Selector& rhs) const;
+    virtual bool operator<(const Simple_Selector& rhs) const;
+    virtual bool operator<(const Element_Selector& rhs) const;
     ATTACH_AST_OPERATIONS(Element_Selector)
     ATTACH_OPERATIONS()
   };
@@ -2517,15 +2527,11 @@ namespace Sass {
     Class_Selector(const Class_Selector* ptr)
     : Simple_Selector(ptr)
     { }
-    virtual bool unique() const
-    {
-      return false;
-    }
-    virtual unsigned long specificity()
+    virtual unsigned long specificity() const
     {
       return Constants::Specificity_Class;
     }
-    virtual Compound_Selector_Ptr unify_with(Compound_Selector_Ptr, Context&);
+    virtual Compound_Selector_Ptr unify_with(Compound_Selector_Ptr);
     ATTACH_AST_OPERATIONS(Class_Selector)
     ATTACH_OPERATIONS()
   };
@@ -2541,15 +2547,11 @@ namespace Sass {
     Id_Selector(const Id_Selector* ptr)
     : Simple_Selector(ptr)
     { }
-    virtual bool unique() const
-    {
-      return true;
-    }
-    virtual unsigned long specificity()
+    virtual unsigned long specificity() const
     {
       return Constants::Specificity_ID;
     }
-    virtual Compound_Selector_Ptr unify_with(Compound_Selector_Ptr, Context&);
+    virtual Compound_Selector_Ptr unify_with(Compound_Selector_Ptr);
     ATTACH_AST_OPERATIONS(Id_Selector)
     ATTACH_OPERATIONS()
   };
@@ -2558,17 +2560,19 @@ namespace Sass {
   // Attribute selectors -- e.g., [src*=".jpg"], etc.
   ///////////////////////////////////////////////////
   class Attribute_Selector : public Simple_Selector {
-    ADD_PROPERTY(std::string, matcher)
+    ADD_CONSTREF(std::string, matcher)
     // this cannot be changed to obj atm!!!!!!????!!!!!!!
     ADD_PROPERTY(String_Obj, value) // might be interpolated
+    ADD_PROPERTY(char, modifier);
   public:
-    Attribute_Selector(ParserState pstate, std::string n, std::string m, String_Obj v)
-    : Simple_Selector(pstate, n), matcher_(m), value_(v)
+    Attribute_Selector(ParserState pstate, std::string n, std::string m, String_Obj v, char o = 0)
+    : Simple_Selector(pstate, n), matcher_(m), value_(v), modifier_(o)
     { simple_type(ATTR_SEL); }
     Attribute_Selector(const Attribute_Selector* ptr)
     : Simple_Selector(ptr),
       matcher_(ptr->matcher_),
-      value_(ptr->value_)
+      value_(ptr->value_),
+      modifier_(ptr->modifier_)
     { simple_type(ATTR_SEL); }
     virtual size_t hash()
     {
@@ -2579,7 +2583,7 @@ namespace Sass {
       }
       return hash_;
     }
-    virtual unsigned long specificity()
+    virtual unsigned long specificity() const
     {
       return Constants::Specificity_Attr;
     }
@@ -2617,14 +2621,6 @@ namespace Sass {
     : Simple_Selector(ptr), expression_(ptr->expression_)
     { simple_type(PSEUDO_SEL); }
 
-    // A pseudo-class always consists of a "colon" (:) followed by the name
-    // of the pseudo-class and optionally by a value between parentheses.
-    virtual bool is_pseudo_class()
-    {
-      return (name_[0] == ':' && name_[1] != ':')
-             && ! is_pseudo_class_element(name_);
-    }
-
     // A pseudo-element is made of two colons (::) followed by the name.
     // The `::` notation is introduced by the current document in order to
     // establish a discrimination between pseudo-classes and pseudo-elements.
@@ -2633,7 +2629,7 @@ namespace Sass {
     // in CSS levels 1 and 2 (namely, :first-line, :first-letter, :before and
     // :after). This compatibility is not allowed for the new pseudo-elements
     // introduced in this specification.
-    virtual bool is_pseudo_element()
+    virtual bool is_pseudo_element() const
     {
       return (name_[0] == ':' && name_[1] == ':')
              || is_pseudo_class_element(name_);
@@ -2646,7 +2642,7 @@ namespace Sass {
       }
       return hash_;
     }
-    virtual unsigned long specificity()
+    virtual unsigned long specificity() const
     {
       if (is_pseudo_element())
         return Constants::Specificity_Element;
@@ -2656,7 +2652,7 @@ namespace Sass {
     virtual bool operator==(const Pseudo_Selector& rhs) const;
     virtual bool operator<(const Simple_Selector& rhs) const;
     virtual bool operator<(const Pseudo_Selector& rhs) const;
-    virtual Compound_Selector_Ptr unify_with(Compound_Selector_Ptr, Context&);
+    virtual Compound_Selector_Ptr unify_with(Compound_Selector_Ptr);
     ATTACH_AST_OPERATIONS(Pseudo_Selector)
     ATTACH_OPERATIONS()
   };
@@ -2665,9 +2661,9 @@ namespace Sass {
   // Wrapped selector -- pseudo selector that takes a list of selectors as argument(s) e.g., :not(:first-of-type), :-moz-any(ol p.blah, ul, menu, dir)
   /////////////////////////////////////////////////
   class Wrapped_Selector : public Simple_Selector {
-    ADD_PROPERTY(Selector_Obj, selector)
+    ADD_PROPERTY(Selector_List_Obj, selector)
   public:
-    Wrapped_Selector(ParserState pstate, std::string n, Selector_Obj sel)
+    Wrapped_Selector(ParserState pstate, std::string n, Selector_List_Obj sel)
     : Simple_Selector(pstate, n), selector_(sel)
     { simple_type(WRAPPED_SEL); }
     Wrapped_Selector(const Wrapped_Selector* ptr)
@@ -2676,28 +2672,11 @@ namespace Sass {
     virtual bool is_superselector_of(Wrapped_Selector_Obj sub);
     // Selectors inside the negation pseudo-class are counted like any
     // other, but the negation itself does not count as a pseudo-class.
-    virtual size_t hash()
-    {
-      if (hash_ == 0) {
-        hash_combine(hash_, Simple_Selector::hash());
-        if (selector_) hash_combine(hash_, selector_->hash());
-      }
-      return hash_;
-    }
-    virtual bool has_parent_ref() {
-      // if (has_reference()) return true;
-      if (!selector()) return false;
-      return selector()->has_parent_ref();
-    }
-    virtual bool has_real_parent_ref() {
-      // if (has_reference()) return true;
-      if (!selector()) return false;
-      return selector()->has_real_parent_ref();
-    }
-    virtual unsigned long specificity()
-    {
-      return selector_ ? selector_->specificity() : 0;
-    }
+    virtual size_t hash();
+    virtual bool has_parent_ref() const;
+    virtual bool has_real_parent_ref() const;
+    virtual unsigned long specificity() const;
+    virtual bool find ( bool (*f)(AST_Node_Obj) );
     virtual bool operator==(const Simple_Selector& rhs) const;
     virtual bool operator==(const Wrapped_Selector& rhs) const;
     virtual bool operator<(const Simple_Selector& rhs) const;
@@ -2707,18 +2686,13 @@ namespace Sass {
     ATTACH_OPERATIONS()
   };
 
-  struct Complex_Selector_Pointer_Compare {
-    bool operator() (const Complex_Selector_Obj& pLeft, const Complex_Selector_Obj& pRight) const;
-  };
-
   ////////////////////////////////////////////////////////////////////////////
   // Simple selector sequences. Maintains flags indicating whether it contains
   // any parent references or placeholders, to simplify expansion.
   ////////////////////////////////////////////////////////////////////////////
-  typedef std::set<Complex_Selector_Obj, Complex_Selector_Pointer_Compare> SourcesSet;
   class Compound_Selector : public Selector, public Vectorized<Simple_Selector_Obj> {
   private:
-    SourcesSet sources_;
+    ComplexSelectorSet sources_;
     ADD_PROPERTY(bool, extended);
     ADD_PROPERTY(bool, has_parent_reference);
   protected:
@@ -2755,20 +2729,15 @@ namespace Sass {
     }
 
     Complex_Selector_Obj to_complex();
-    Compound_Selector_Ptr unify_with(Compound_Selector_Ptr rhs, Context& ctx);
+    Compound_Selector_Ptr unify_with(Compound_Selector_Ptr rhs);
     // virtual Placeholder_Selector_Ptr find_placeholder();
-    virtual bool has_parent_ref();
-    virtual bool has_real_parent_ref();
-    Simple_Selector_Ptr base()
-    {
-      // Implement non-const in terms of const. Safe to const_cast since this method is non-const
-      return const_cast<Simple_Selector_Ptr>(static_cast<Compound_Selector_Ptr_Const>(this)->base());
-    }
-    Simple_Selector_Ptr_Const base() const {
+    virtual bool has_parent_ref() const;
+    virtual bool has_real_parent_ref() const;
+    Simple_Selector_Ptr base() const {
       if (length() == 0) return 0;
       // ToDo: why is this needed?
-      if (SASS_MEMORY_CAST(Element_Selector, (*this)[0]))
-        return &(*this)[0];
+      if (Cast<Element_Selector>((*this)[0]))
+        return (*this)[0];
       return 0;
     }
     virtual bool is_superselector_of(Compound_Selector_Obj sub, std::string wrapped = "");
@@ -2782,7 +2751,7 @@ namespace Sass {
       }
       return Selector::hash_;
     }
-    virtual unsigned long specificity()
+    virtual unsigned long specificity() const
     {
       int sum = 0;
       for (size_t i = 0, L = length(); i < L; ++i)
@@ -2802,19 +2771,21 @@ namespace Sass {
     bool is_empty_reference()
     {
       return length() == 1 &&
-             SASS_MEMORY_CAST(Parent_Selector, (*this)[0]);
+             Cast<Parent_Selector>((*this)[0]);
     }
-    std::vector<Subset_Map_Key> to_str_vec(); // sometimes need to convert to a flat "by-value" data structure
 
+    virtual bool find ( bool (*f)(AST_Node_Obj) );
+    virtual bool operator<(const Selector& rhs) const;
+    virtual bool operator==(const Selector& rhs) const;
     virtual bool operator<(const Compound_Selector& rhs) const;
     virtual bool operator==(const Compound_Selector& rhs) const;
     inline bool operator!=(const Compound_Selector& rhs) const { return !(*this == rhs); }
 
-    SourcesSet& sources() { return sources_; }
+    ComplexSelectorSet& sources() { return sources_; }
     void clearSources() { sources_.clear(); }
-    void mergeSources(SourcesSet& sources, Context& ctx);
+    void mergeSources(ComplexSelectorSet& sources);
 
-    Compound_Selector_Ptr minus(Compound_Selector_Ptr rhs, Context& ctx);
+    Compound_Selector_Ptr minus(Compound_Selector_Ptr rhs);
     virtual void cloneChildren();
     ATTACH_AST_OPERATIONS(Compound_Selector)
     ATTACH_OPERATIONS()
@@ -2829,10 +2800,10 @@ namespace Sass {
   public:
     enum Combinator { ANCESTOR_OF, PARENT_OF, PRECEDES, ADJACENT_TO, REFERENCE };
   private:
-    ADD_PROPERTY(Combinator, combinator)
-    ADD_PROPERTY(Compound_Selector_Obj, head)
-    ADD_PROPERTY(Complex_Selector_Obj, tail)
-    ADD_PROPERTY(String_Obj, reference);
+    HASH_CONSTREF(Combinator, combinator)
+    HASH_PROPERTY(Compound_Selector_Obj, head)
+    HASH_PROPERTY(Complex_Selector_Obj, tail)
+    HASH_PROPERTY(String_Obj, reference);
   public:
     bool contains_placeholder() {
       if (head() && head()->contains_placeholder()) return true;
@@ -2855,8 +2826,8 @@ namespace Sass {
       head_(ptr->head_), tail_(ptr->tail_),
       reference_(ptr->reference_)
     {};
-    virtual bool has_parent_ref();
-    virtual bool has_real_parent_ref();
+    virtual bool has_parent_ref() const;
+    virtual bool has_real_parent_ref() const;
 
     Complex_Selector_Obj skip_empty_reference()
     {
@@ -2878,10 +2849,7 @@ namespace Sass {
              combinator() == Combinator::ANCESTOR_OF;
     }
 
-    Complex_Selector_Obj context(Context&);
-
-
-    Selector_List_Ptr tails(Context& ctx, Selector_List_Ptr tails);
+    Selector_List_Ptr tails(Selector_List_Ptr tails);
 
     // front returns the first real tail
     // skips over parent and empty ones
@@ -2893,13 +2861,13 @@ namespace Sass {
     Complex_Selector_Obj innermost() { return last(); };
 
     size_t length() const;
-    Selector_List_Ptr resolve_parent_refs(Context& ctx, std::vector<Selector_List_Obj>& pstack, bool implicit_parent = true);
+    Selector_List_Ptr resolve_parent_refs(std::vector<Selector_List_Obj>& pstack, Backtraces& traces, bool implicit_parent = true);
     virtual bool is_superselector_of(Compound_Selector_Obj sub, std::string wrapping = "");
     virtual bool is_superselector_of(Complex_Selector_Obj sub, std::string wrapping = "");
     virtual bool is_superselector_of(Selector_List_Obj sub, std::string wrapping = "");
-    Selector_List_Ptr unify_with(Complex_Selector_Ptr rhs, Context& ctx);
+    Selector_List_Ptr unify_with(Complex_Selector_Ptr rhs);
     Combinator clear_innermost();
-    void append(Context&, Complex_Selector_Obj);
+    void append(Complex_Selector_Obj, Backtraces& traces);
     void set_innermost(Complex_Selector_Obj, Combinator);
     virtual size_t hash()
     {
@@ -2928,55 +2896,58 @@ namespace Sass {
       if (tail_ && tail_->has_placeholder()) return true;
       return false;
     }
+    virtual bool find ( bool (*f)(AST_Node_Obj) );
+    virtual bool operator<(const Selector& rhs) const;
+    virtual bool operator==(const Selector& rhs) const;
     virtual bool operator<(const Complex_Selector& rhs) const;
     virtual bool operator==(const Complex_Selector& rhs) const;
     inline bool operator!=(const Complex_Selector& rhs) const { return !(*this == rhs); }
-    SourcesSet sources()
+    const ComplexSelectorSet sources()
     {
       //s = Set.new
       //seq.map {|sseq_or_op| s.merge sseq_or_op.sources if sseq_or_op.is_a?(SimpleSequence)}
       //s
 
-      SourcesSet srcs;
+      ComplexSelectorSet srcs;
 
       Compound_Selector_Obj pHead = head();
       Complex_Selector_Obj  pTail = tail();
 
       if (pHead) {
-        SourcesSet& headSources = pHead->sources();
+        const ComplexSelectorSet& headSources = pHead->sources();
         srcs.insert(headSources.begin(), headSources.end());
       }
 
       if (pTail) {
-        SourcesSet tailSources = pTail->sources();
+        const ComplexSelectorSet& tailSources = pTail->sources();
         srcs.insert(tailSources.begin(), tailSources.end());
       }
 
       return srcs;
     }
-    void addSources(SourcesSet& sources, Context& ctx) {
+    void addSources(ComplexSelectorSet& sources) {
       // members.map! {|m| m.is_a?(SimpleSequence) ? m.with_more_sources(sources) : m}
       Complex_Selector_Ptr pIter = this;
       while (pIter) {
-        Compound_Selector_Ptr pHead = &pIter->head();
+        Compound_Selector_Ptr pHead = pIter->head();
 
         if (pHead) {
-          pHead->mergeSources(sources, ctx);
+          pHead->mergeSources(sources);
         }
 
-        pIter = &pIter->tail();
+        pIter = pIter->tail();
       }
     }
     void clearSources() {
       Complex_Selector_Ptr pIter = this;
       while (pIter) {
-        Compound_Selector_Ptr pHead = &pIter->head();
+        Compound_Selector_Ptr pHead = pIter->head();
 
         if (pHead) {
           pHead->clearSources();
         }
 
-        pIter = &pIter->tail();
+        pIter = pIter->tail();
       }
     }
 
@@ -2985,36 +2956,40 @@ namespace Sass {
     ATTACH_OPERATIONS()
   };
 
-  typedef std::deque<Complex_Selector_Obj> ComplexSelectorDeque;
-
   ///////////////////////////////////
   // Comma-separated selector groups.
   ///////////////////////////////////
   class Selector_List : public Selector, public Vectorized<Complex_Selector_Obj> {
-    ADD_PROPERTY(std::vector<std::string>, wspace)
+    ADD_PROPERTY(Selector_Schema_Obj, schema)
+    ADD_CONSTREF(std::vector<std::string>, wspace)
   protected:
     void adjust_after_pushing(Complex_Selector_Obj c);
   public:
     Selector_List(ParserState pstate, size_t s = 0)
-    : Selector(pstate), Vectorized<Complex_Selector_Obj>(s), wspace_(0)
+    : Selector(pstate),
+      Vectorized<Complex_Selector_Obj>(s),
+      schema_(NULL),
+      wspace_(0)
     { }
     Selector_List(const Selector_List* ptr)
     : Selector(ptr),
       Vectorized<Complex_Selector_Obj>(*ptr),
+      schema_(ptr->schema_),
       wspace_(ptr->wspace_)
     { }
-    std::string type() { return "list"; }
+    std::string type() const { return "list"; }
     // remove parent selector references
     // basically unwraps parsed selectors
-    virtual bool has_parent_ref();
-    virtual bool has_real_parent_ref();
+    virtual bool has_parent_ref() const;
+    virtual bool has_real_parent_ref() const;
     void remove_parent_selectors();
-    Selector_List_Ptr resolve_parent_refs(Context& ctx, std::vector<Selector_List_Obj>& pstack, bool implicit_parent = true);
+    Selector_List_Ptr resolve_parent_refs(std::vector<Selector_List_Obj>& pstack, Backtraces& traces, bool implicit_parent = true);
     virtual bool is_superselector_of(Compound_Selector_Obj sub, std::string wrapping = "");
     virtual bool is_superselector_of(Complex_Selector_Obj sub, std::string wrapping = "");
     virtual bool is_superselector_of(Selector_List_Obj sub, std::string wrapping = "");
-    Selector_List_Ptr unify_with(Selector_List_Ptr, Context&);
-    void populate_extends(Selector_List_Obj, Context&, Subset_Map&);
+    Selector_List_Ptr unify_with(Selector_List_Ptr);
+    void populate_extends(Selector_List_Obj, Subset_Map&);
+    Selector_List_Obj eval(Eval& eval);
     virtual size_t hash()
     {
       if (Selector::hash_ == 0) {
@@ -3023,10 +2998,10 @@ namespace Sass {
       }
       return Selector::hash_;
     }
-    virtual unsigned long specificity()
+    virtual unsigned long specificity() const
     {
       unsigned long sum = 0;
-      unsigned long specificity = 0;
+      unsigned long specificity;
       for (size_t i = 0, L = length(); i < L; ++i)
       {
         specificity = (*this)[i]->specificity();
@@ -3046,6 +3021,7 @@ namespace Sass {
       }
       return false;
     }
+    virtual bool find ( bool (*f)(AST_Node_Obj) );
     virtual bool operator<(const Selector& rhs) const;
     virtual bool operator==(const Selector& rhs) const;
     virtual bool operator<(const Selector_List& rhs) const;
@@ -3057,24 +3033,6 @@ namespace Sass {
     ATTACH_OPERATIONS()
   };
 
-  template<typename SelectorType>
-  bool selectors_equal(const SelectorType& one, const SelectorType& two, bool simpleSelectorOrderDependent) {
-    // Test for equality among selectors while differentiating between checks that demand the underlying Simple_Selector
-    // ordering to be the same or not. This works because operator< (which doesn't make a whole lot of sense for selectors, but
-    // is required for proper stl collection ordering) is implemented using string comparision. This gives stable sorting
-    // behavior, and can be used to determine if the selectors would have exactly idential output. operator== matches the
-    // ruby sass implementations for eql, which sometimes perform order independent comparisions (like set comparisons of the
-    // members of a SimpleSequence (Compound_Selector)).
-    //
-    // Due to the reliance on operator== and operater< behavior, this templated method is currently only intended for
-    // use with Compound_Selector and Complex_Selector objects.
-    if (simpleSelectorOrderDependent) {
-      return !(one < two) && !(two < one);
-    } else {
-      return one == two;
-    }
-  }
-
   // compare function for sorting and probably other other uses
   struct cmp_complex_selector { inline bool operator() (const Complex_Selector_Obj l, const Complex_Selector_Obj r) { return (*l < *r); } };
   struct cmp_compound_selector { inline bool operator() (const Compound_Selector_Obj l, const Compound_Selector_Obj r) { return (*l < *r); } };