Refactor contextualize into eval [WIP]

Makefile

@@ -117,8 +117,6 @@ SOURCES = \
 	bind.cpp \
 	constants.cpp \
 	context.cpp \
-	contextualize.cpp \
-	contextualize_eval.cpp \
 	cssize.cpp \
 	listize.cpp \
 	error_handling.cpp \

Makefile.am

@@ -46,8 +46,6 @@ libsass_la_SOURCES = \
 	bind.cpp bind.hpp \
 	constants.cpp constants.hpp \
 	context.cpp context.hpp \
-	contextualize.cpp contextualize.hpp \
-	contextualize_eval.cpp contextualize_eval.hpp \
 	error_handling.cpp error_handling.hpp \
 	eval.cpp eval.hpp \
 	expand.cpp expand.hpp \

ast.cpp

@@ -507,7 +507,6 @@ namespace Sass {
   void Selector_List::adjust_after_pushing(Complex_Selector* c)
   {
     if (c->has_reference())   has_reference(true);
-    if (c->has_placeholder()) has_placeholder(true);
 
 #ifdef DEBUG
     To_String to_string;
@@ -559,45 +558,6 @@ namespace Sass {
     return false;
   }
 
-  /* not used anymore - remove?
-  Selector_Placeholder* Selector_List::find_placeholder()
-  {
-    if (has_placeholder()) {
-      for (size_t i = 0, L = length(); i < L; ++i) {
-        if ((*this)[i]->has_placeholder()) return (*this)[i]->find_placeholder();
-      }
-    }
-    return 0;
-  }*/
-
-  /* not used anymore - remove?
-  Selector_Placeholder* Complex_Selector::find_placeholder()
-  {
-    if (has_placeholder()) {
-      if (head() && head()->has_placeholder()) return head()->find_placeholder();
-      else if (tail() && tail()->has_placeholder()) return tail()->find_placeholder();
-    }
-    return 0;
-  }*/
-
-  /* not used anymore - remove?
-  Selector_Placeholder* Compound_Selector::find_placeholder()
-  {
-    if (has_placeholder()) {
-      for (size_t i = 0, L = length(); i < L; ++i) {
-        if ((*this)[i]->has_placeholder()) return (*this)[i]->find_placeholder();
-      }
-      // return this;
-    }
-    return 0;
-  }*/
-
-  /* not used anymore - remove?
-  Selector_Placeholder* Selector_Placeholder::find_placeholder()
-  {
-    return this;
-  }*/
-
   vector<string> Compound_Selector::to_str_vec()
   {
     To_String to_string;
@@ -681,17 +641,17 @@ namespace Sass {
 
   string Number::unit() const
   {
-    stringstream u;
+    string u;
     for (size_t i = 0, S = numerator_units_.size(); i < S; ++i) {
-      if (i) u << '*';
-      u << numerator_units_[i];
+      if (i) u += '*';
+      u += numerator_units_[i];
     }
-    if (!denominator_units_.empty()) u << '/';
+    if (!denominator_units_.empty()) u += '/';
     for (size_t i = 0, S = denominator_units_.size(); i < S; ++i) {
-      if (i) u << '*';
-      u << denominator_units_[i];
+      if (i) u += '*';
+      u += denominator_units_[i];
     }
-    return u.str();
+    return u;
   }
 
   bool Number::is_unitless()
@@ -882,17 +842,11 @@ namespace Sass {
 
   bool Number::operator== (Expression* rhs) const
   {
-    try
-    {
-      Number l(pstate_, value_, unit());
-      Number& r = dynamic_cast<Number&>(*rhs);
-      l.normalize(find_convertible_unit());
-      r.normalize(find_convertible_unit());
-      return l.unit() == r.unit() &&
-             l.value() == r.value();
+    if (Number* r = static_cast<Number*>(rhs)) {
+      return (value() == r->value()) &&
+             (numerator_units_ == r->numerator_units_) &&
+             (denominator_units_ == r->denominator_units_);
     }
-    catch (std::bad_cast&) {}
-    catch (...) { throw; }
     return false;
   }
 

ast.hpp

@@ -648,15 +648,15 @@ namespace Sass {
     ADD_PROPERTY(Native_Function, native_function);
     ADD_PROPERTY(Sass_Function_Entry, c_function);
     ADD_PROPERTY(void*, cookie);
-    ADD_PROPERTY(Context*, ctx);
+    // ADD_PROPERTY(Context*, ctx);
     ADD_PROPERTY(bool, is_overload_stub);
     ADD_PROPERTY(Signature, signature);
   public:
     Definition(ParserState pstate,
                string n,
                Parameters* params,
                Block* b,
-               Context* ctx,
+               // Context* ctx,
                Type t)
     : Has_Block(pstate, b),
       name_(n),
@@ -666,7 +666,7 @@ namespace Sass {
       native_function_(0),
       c_function_(0),
       cookie_(0),
-      ctx_(ctx),
+      // ctx_(ctx),
       is_overload_stub_(false),
       signature_(0)
     { }
@@ -675,7 +675,7 @@ namespace Sass {
                string n,
                Parameters* params,
                Native_Function func_ptr,
-               Context* ctx,
+               // Context* ctx,
                bool overload_stub = false)
     : Has_Block(pstate, 0),
       name_(n),
@@ -685,7 +685,7 @@ namespace Sass {
       native_function_(func_ptr),
       c_function_(0),
       cookie_(0),
-      ctx_(ctx),
+      // ctx_(ctx),
       is_overload_stub_(overload_stub),
       signature_(sig)
     { }
@@ -694,7 +694,7 @@ namespace Sass {
                string n,
                Parameters* params,
                Sass_Function_Entry c_func,
-               Context* ctx,
+               // Context* ctx,
                bool whatever,
                bool whatever2)
     : Has_Block(pstate, 0),
@@ -705,7 +705,7 @@ namespace Sass {
       native_function_(0),
       c_function_(c_func),
       cookie_(sass_function_get_cookie(c_func)),
-      ctx_(ctx),
+      // ctx_(ctx),
       is_overload_stub_(false),
       signature_(sig)
     { }
@@ -1666,26 +1666,10 @@ namespace Sass {
   //////////////////////////////////////////////////////////////////////////////////////////
   inline Expression* List::value_at_index(size_t i) { return is_arglist_ ? ((Argument*)(*this)[i])->value() : (*this)[i]; }
 
-  ////////////
-  // The Parent Selector Expression.
-  ////////////
-  class Parent_Selector : public Expression {
-    ADD_PROPERTY(Selector*, selector);
-  public:
-    Parent_Selector(ParserState pstate, Selector* r = 0)
-    : Expression(pstate), selector_(r)
-    { concrete_type(SELECTOR); }
-    virtual Selector* selector() { return selector_; }
-    string type() { return "selector"; }
-    static string type_name() { return "selector"; }
-
-    ATTACH_OPERATIONS();
-  };
-
   /////////////////////////////////////////
   // Abstract base class for CSS selectors.
   /////////////////////////////////////////
-  class Selector : public AST_Node {
+  class Selector : public Expression {
     ADD_PROPERTY(bool, has_reference);
     ADD_PROPERTY(bool, has_placeholder);
     // line break before list separator
@@ -1699,14 +1683,14 @@ namespace Sass {
     ADD_PROPERTY(Media_Block*, media_block);
   public:
     Selector(ParserState pstate, bool r = false, bool h = false)
-    : AST_Node(pstate),
+    : Expression(pstate),
       has_reference_(r),
       has_placeholder_(h),
       has_line_feed_(false),
       has_line_break_(false),
       is_optional_(false),
       media_block_(0)
-    { }
+    { concrete_type(SELECTOR); }
     virtual ~Selector() = 0;
     // virtual Selector_Placeholder* find_placeholder();
     virtual unsigned long specificity() {
@@ -1748,20 +1732,26 @@ namespace Sass {
   };
   inline Simple_Selector::~Simple_Selector() { }
 
-  /////////////////////////////////////
-  // Parent references (i.e., the "&").
-  /////////////////////////////////////
-  class Selector_Reference : public Simple_Selector {
-    ADD_PROPERTY(Selector*, selector);
+
+  //////////////////////////////////
+  // The Parent Selector Expression.
+  //////////////////////////////////
+  class Parent_Selector : public Simple_Selector {
+    // ADD_PROPERTY(Selector*, selector);
   public:
-    Selector_Reference(ParserState pstate, Selector* r = 0)
-    : Simple_Selector(pstate), selector_(r)
+    Parent_Selector(ParserState pstate, Selector* r = 0)
+    : Simple_Selector(pstate)// , selector_(r)
     { has_reference(true); }
     virtual unsigned long specificity()
     {
-      if (!selector()) return 0;
-      return selector()->specificity();
+      return 0;
+      // if (!selector()) return 0;
+      // return selector()->specificity();
     }
+    // virtual Selector* selector() { return selector_; }
+    string type() { return "selector"; }
+    static string type_name() { return "selector"; }
+
     ATTACH_OPERATIONS();
   };
 
@@ -1956,8 +1946,7 @@ namespace Sass {
     bool is_empty_reference()
     {
       return length() == 1 &&
-             typeid(*(*this)[0]) == typeid(Selector_Reference) &&
-             !static_cast<Selector_Reference*>((*this)[0])->selector();
+             typeid(*(*this)[0]) == typeid(Parent_Selector);
     }
     vector<string> to_str_vec(); // sometimes need to convert to a flat "by-value" data structure
 

ast_def_macros.hpp

@@ -1,6 +1,30 @@
 #ifndef SASS_AST_DEF_MACROS_H
 #define SASS_AST_DEF_MACROS_H
 
+template <class T>
+class LocalOption {
+  private:
+    T* var; // pointer to original variable
+    T orig; // copy of the original option
+  public:
+    LocalOption(T& var)
+    {
+      this->var = &var;
+      this->orig = var;
+    }
+    LocalOption(T& var, T orig)
+    {
+      this->var = &var;
+      this->orig = var;
+      *(this->var) = orig;
+    }
+    ~LocalOption() {
+      *(this->var) = this->orig;
+    }
+};
+
+#define LOCAL_FLAG(name,opt) LocalOption<bool> flag_##name(name, opt)
+
 #define ATTACH_OPERATIONS()\
 virtual void perform(Operation<void>* op) { (*op)(this); }\
 virtual AST_Node* perform(Operation<AST_Node*>* op) { return (*op)(this); }\

ast_fwd_decl.hpp

@@ -1,9 +1,9 @@
 #ifndef SASS_AST_FWD_DECL_H
 #define SASS_AST_FWD_DECL_H
 
+
 /////////////////////////////////////////////
 // Forward declarations for the AST visitors.
-/////////////////////////////////////////////
 namespace Sass {
 
   enum Output_Style { NESTED, EXPANDED, COMPACT, COMPRESSED, FORMATTED };
@@ -69,7 +69,6 @@ namespace Sass {
   // selectors
   class Selector;
   class Selector_Schema;
-  class Selector_Reference;
   class Selector_Placeholder;
   class Type_Selector;
   class Selector_Qualifier;

bind.cpp

@@ -12,6 +12,8 @@ namespace Sass {
 
   void bind(string callee, Parameters* ps, Arguments* as, Context& ctx, Env* env, Eval* eval)
   {
+
+    // Context& ctx = eval->context();
     map<string, Parameter*> param_map;
 
     // Set up a map to ensure named arguments refer to actual parameters. Also
@@ -227,15 +229,7 @@ namespace Sass {
                                                                       true);
         }
         else if (leftover->default_value()) {
-          // make sure to eval the default value in the env that we've been populating
-          Env* old_env = eval->env;
-          Backtrace* old_bt = eval->backtrace;
-          Contextualize* old_context = eval->contextualize;
-          Expression* dv = leftover->default_value()->perform(eval->with(env, eval->backtrace));
-          eval->env = old_env;
-          eval->backtrace = old_bt;
-          eval->contextualize = old_context;
-          // dv->perform(&to_string);
+          Expression* dv = leftover->default_value()->perform(eval);
           env->local_frame()[leftover->name()] = dv;
         }
         else {