sassc 0.0.10 → 0.0.11

data/ext/libsass/emitter.cpp

@@ -15,7 +15,7 @@ namespace Sass {
     scheduled_linefeed(0),
     scheduled_delimiter(false),
     in_comment(false),
-    in_at_rule(false),
+    in_wrapped(false),
     in_media_block(false),
     in_declaration(false),
     in_declaration_list(false)

data/ext/libsass/emitter.hpp

@@ -38,7 +38,7 @@ namespace Sass {
 
     public:
       bool in_comment;
-      bool in_at_rule;
+      bool in_wrapped;
       bool in_media_block;
       bool in_declaration;
       bool in_declaration_list;

data/ext/libsass/environment.hpp

@@ -5,7 +5,9 @@
 #include <string>
 #include <iostream>
 
+#include "ast_fwd_decl.hpp"
 #include "ast_def_macros.hpp"
+#include "memory_manager.hpp"
 
 namespace Sass {
   using std::string;
@@ -16,56 +18,136 @@ namespace Sass {
   template <typename T>
   class Environment {
     // TODO: test with unordered_map
-    map<string, T> current_frame_;
+    map<string, T> local_frame_;
     ADD_PROPERTY(Environment*, parent);
 
   public:
-    Environment() : current_frame_(map<string, T>()), parent_(0) { }
-
-    map<string, T>& current_frame() { return current_frame_; }
+    Memory_Manager<AST_Node> mem;
+    Environment() : local_frame_(map<string, T>()), parent_(0) { }
 
+    // link parent to create a stack
     void link(Environment& env) { parent_ = &env; }
     void link(Environment* env) { parent_ = env; }
 
-    bool has(const string key) const
+    // this is used to find the global frame
+    // which is the second last on the stack
+    bool is_lexical() const
+    {
+      return !! parent_ && parent_->parent_;
+    }
+
+    // only match the real root scope
+    // there is still a parent around
+    // not sure what it is actually use for
+    // I guess we store functions etc. there
+    bool is_root_scope() const
     {
-      if (current_frame_.count(key))  return true;
-      else if (parent_)               return parent_->has(key);
-      else                            return false;
+      return parent_ && ! parent_->parent_;
+    }
+
+    // scope operates on the current frame
+
+    map<string, T>& local_frame() {
+      return local_frame_;
     }
 
-    bool current_frame_has(const string key) const
-    { return !!current_frame_.count(key); }
+    bool has_local(const string& key) const
+    { return local_frame_.count(key); }
 
-    Environment* grandparent() const
+    T& get_local(const string& key)
+    { return local_frame_[key]; }
+
+    void set_local(const string& key, T val)
+    { local_frame_[key] = val; }
+
+    void del_local(const string& key)
+    { local_frame_.erase(key); }
+
+
+    // global operates on the global frame
+    // which is the second last on the stack
+
+    Environment* global_env()
     {
-      if(parent_ && parent_->parent_) return parent_->parent_;
-      else return 0;
+      Environment* cur = this;
+      while (cur->is_lexical()) {
+        cur = cur->parent_;
+      }
+      return cur;
     }
 
-    bool global_frame_has(const string key) const
+    bool has_global(const string& key)
+    { return global_env()->has(key); }
+
+    T& get_global(const string& key)
+    { return (*global_env())[key]; }
+
+    void set_global(const string& key, T val)
+    { global_env()->local_frame_[key] = val; }
+
+    void del_global(const string& key)
+    { global_env()->local_frame_.erase(key); }
+
+    // see if we have a lexical variable
+    // move down the stack but stop before we
+    // reach the global frame (is not included)
+    bool has_lexical(const string& key) const
     {
-      if(parent_ && !grandparent()) {
-        return has(key);
+      auto cur = this;
+      while (cur->is_lexical()) {
+        if (cur->has_local(key)) return true;
+        cur = cur->parent_;
       }
-      else if(parent_) {
-        return parent_->global_frame_has(key);
+      return false;
+    }
+
+    // see if we have a lexical we could update
+    // either update already existing lexical value
+    // or if flag is set, we create one if no lexical found
+    void set_lexical(const string& key, T val)
+    {
+      auto cur = this;
+      while (cur->is_lexical()) {
+        if (cur->has_local(key)) {
+          cur->set_local(key, val);
+          return;
+        }
+        cur = cur->parent_;
       }
-      else {
-        return false;
+      set_local(key, val);
+    }
+
+    // look on the full stack for key
+    // include all scopes available
+    bool has(const string& key) const
+    {
+      auto cur = this;
+      while (cur) {
+        if (cur->has_local(key)) {
+          return true;
+        }
+        cur = cur->parent_;
       }
+      return false;
     }
 
-    T& operator[](const string key)
+    // use array access for getter and setter functions
+    T& operator[](const string& key)
     {
-      if (current_frame_.count(key))  return current_frame_[key];
-      else if (parent_)               return (*parent_)[key];
-      else                            return current_frame_[key];
+      auto cur = this;
+      while (cur) {
+        if (cur->has_local(key)) {
+          return cur->get_local(key);
+        }
+        cur = cur->parent_;
+      }
+      return get_local(key);
     }
 
+    #ifdef DEBUG
     void print()
     {
-      for (typename map<string, T>::iterator i = current_frame_.begin(); i != current_frame_.end(); ++i) {
+      for (typename map<string, T>::iterator i = local_frame_.begin(); i != local_frame_.end(); ++i) {
         cerr << i->first << endl;
       }
       if (parent_) {
@@ -73,6 +155,8 @@ namespace Sass {
         parent_->print();
       }
     }
+    #endif
+
   };
 }
 

data/ext/libsass/error_handling.cpp

@@ -9,12 +9,12 @@ namespace Sass {
   { }
 
   void error(string msg, ParserState pstate)
-  { throw Sass_Error(Sass_Error::syntax, pstate, msg); }
+  {
+    throw Sass_Error(Sass_Error::syntax, pstate, msg);
+  }
 
   void error(string msg, ParserState pstate, Backtrace* bt)
   {
-    if (!pstate.path.empty() && Prelexer::quoted_string(pstate.path.c_str()))
-      pstate.path = pstate.path.substr(1, pstate.path.size() - 1);
 
     Backtrace top(bt, pstate, "");
     msg += top.to_string();

data/ext/libsass/error_handling.hpp

@@ -14,7 +14,6 @@ namespace Sass {
     enum Type { read, write, syntax, evaluation };
 
     Type type;
-    string path;
     ParserState pstate;
     string message;
 

data/ext/libsass/eval.cpp

@@ -31,12 +31,21 @@ namespace Sass {
     add, sub, mul, div, fmod
   };
 
-  Eval::Eval(Context& ctx, Env* env, Backtrace* bt)
-  : ctx(ctx), env(env), backtrace(bt) { }
+  Eval::Eval(Context& ctx, Contextualize* contextualize, Listize* listize, Env* env, Backtrace* bt)
+  : ctx(ctx), contextualize(contextualize), listize(listize), env(env), backtrace(bt) { }
   Eval::~Eval() { }
 
   Eval* Eval::with(Env* e, Backtrace* bt) // for setting the env before eval'ing an expression
   {
+    contextualize = contextualize->with(0, e, bt);
+    env = e;
+    backtrace = bt;
+    return this;
+  }
+
+  Eval* Eval::with(Selector* c, Env* e, Backtrace* bt, Selector* p, Selector* ex) // for setting the env before eval'ing an expression
+  {
+    contextualize = contextualize->with(c, e, bt, p, ex);
     env = e;
     backtrace = bt;
     return this;
@@ -55,12 +64,59 @@ namespace Sass {
   Expression* Eval::operator()(Assignment* a)
   {
     string var(a->variable());
-    if (env->has(var)) {
-      Expression* v = static_cast<Expression*>((*env)[var]);
-      if (!a->is_guarded() || v->concrete_type() == Expression::NULL_VAL) (*env)[var] = a->value()->perform(this);
+    if (a->is_global()) {
+      if (a->is_default()) {
+        if (env->has_global(var)) {
+          Expression* e = dynamic_cast<Expression*>(env->get_global(var));
+          if (!e || e->concrete_type() == Expression::NULL_VAL) {
+            env->set_global(var, a->value()->perform(this));
+          }
+        }
+        else {
+          env->set_global(var, a->value()->perform(this));
+        }
+      }
+      else {
+        env->set_global(var, a->value()->perform(this));
+      }
+    }
+    else if (a->is_default()) {
+      if (env->has_lexical(var)) {
+        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 (!e || e->concrete_type() == Expression::NULL_VAL) {
+                cur->set_local(var, a->value()->perform(this));
+              }
+            }
+            else {
+              throw runtime_error("Env not in sync");
+            }
+            return 0;
+          }
+          cur = cur->parent();
+        }
+        throw 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 (!e || e->concrete_type() == Expression::NULL_VAL) {
+            env->set_global(var, a->value()->perform(this));
+          }
+        }
+      }
+      else if (env->is_lexical()) {
+        env->set_local(var, a->value()->perform(this));
+      }
+      else {
+        env->set_local(var, a->value()->perform(this));
+      }
     }
     else {
-      env->current_frame()[var] = a->value()->perform(this);
+      env->set_lexical(var, a->value()->perform(this));
     }
     return 0;
   }
@@ -77,6 +133,8 @@ namespace Sass {
     return 0;
   }
 
+  // For does not create a new env scope
+  // But iteration vars are reset afterwards
   Expression* Eval::operator()(For* f)
   {
     string variable(f->variable());
@@ -88,19 +146,30 @@ namespace Sass {
     if (high->concrete_type() != Expression::NUMBER) {
       error("upper bound of `@for` directive must be numeric", high->pstate());
     }
-    double start = static_cast<Number*>(low)->value();
-    double end = static_cast<Number*>(high)->value();
-    Env new_env;
-    new_env[variable] = new (ctx.mem) Number(low->pstate(), start);
-    new_env.link(env);
-    env = &new_env;
+    Number* sass_start = static_cast<Number*>(low);
+    Number* sass_end = static_cast<Number*>(high);
+    // check if units are valid for sequence
+    if (sass_start->unit() != sass_end->unit()) {
+      stringstream msg; msg << "Incompatible units: '"
+        << sass_start->unit() << "' and '"
+        << sass_end->unit() << "'.";
+      error(msg.str(), low->pstate(), backtrace);
+    }
+    double start = sass_start->value();
+    double end = sass_end->value();
+    // only create iterator once in this environment
+    Number* it = new (env->mem) Number(low->pstate(), start, sass_end->unit());
+    AST_Node* old_var = env->has_local(variable) ? env->get_local(variable) : 0;
+    env->set_local(variable, it);
     Block* body = f->block();
     Expression* val = 0;
     if (start < end) {
       if (f->is_inclusive()) ++end;
       for (double i = start;
            i < end;
-           (*env)[variable] = new (ctx.mem) Number(low->pstate(), ++i)) {
+           ++i) {
+        it->value(i);
+        env->set_local(variable, it);
         val = body->perform(this);
         if (val) break;
       }
@@ -108,15 +177,21 @@ namespace Sass {
       if (f->is_inclusive()) --end;
       for (double i = start;
            i > end;
-           (*env)[variable] = new (ctx.mem) Number(low->pstate(), --i)) {
+           --i) {
+        it->value(i);
+        env->set_local(variable, it);
         val = body->perform(this);
         if (val) break;
       }
     }
-    env = new_env.parent();
+    // restore original environment
+    if (!old_var) env->del_local(variable);
+    else env->set_local(variable, old_var);
     return val;
   }
 
+  // Eval does not create a new env scope
+  // But iteration vars are reset afterwards
   Expression* Eval::operator()(Each* e)
   {
     vector<string> variables(e->variables());
@@ -133,10 +208,12 @@ namespace Sass {
     else {
       list = static_cast<List*>(expr);
     }
-    Env new_env;
-    for (size_t i = 0, L = variables.size(); i < L; ++i) new_env[variables[i]] = 0;
-    new_env.link(env);
-    env = &new_env;
+    // remember variables and then reset them
+    vector<AST_Node*> old_vars(variables.size());
+    for (size_t i = 0, L = variables.size(); i < L; ++i) {
+      old_vars[i] = env->has_local(variables[i]) ? env->get_local(variables[i]) : 0;
+      env->set_local(variables[i], 0);
+    }
     Block* body = e->block();
     Expression* val = 0;
 
@@ -148,10 +225,10 @@ namespace Sass {
           List* variable = new (ctx.mem) List(map->pstate(), 2, List::SPACE);
           *variable << key;
           *variable << value;
-          (*env)[variables[0]] = variable;
+          env->set_local(variables[0], variable);
         } else {
-          (*env)[variables[0]] = key;
-          (*env)[variables[1]] = value;
+          env->set_local(variables[0], key);
+          env->set_local(variables[1], value);
         }
 
         val = body->perform(this);
@@ -170,10 +247,10 @@ namespace Sass {
         }
         for (size_t j = 0, K = variables.size(); j < K; ++j) {
           if (j < variable->length()) {
-            (*env)[variables[j]] = (*variable)[j];
+            env->set_local(variables[j], (*variable)[j]);
           }
           else {
-            (*env)[variables[j]] = new (ctx.mem) Null(expr->pstate());
+            env->set_local(variables[j], new (ctx.mem) Null(expr->pstate()));
           }
           val = body->perform(this);
           if (val) break;
@@ -181,7 +258,11 @@ namespace Sass {
         if (val) break;
       }
     }
-    env = new_env.parent();
+    // restore original environment
+    for (size_t j = 0, K = variables.size(); j < K; ++j) {
+      if(!old_vars[j]) env->del_local(variables[j]);
+      else env->set_local(variables[j], old_vars[j]);
+    }
     return val;
   }
 
@@ -212,12 +293,13 @@ namespace Sass {
       Definition* def = static_cast<Definition*>((*env)["@warn[f]"]);
       // Block*          body   = def->block();
       // Native_Function func   = def->native_function();
-      Sass_C_Function c_func = def->c_function();
+      Sass_Function_Entry c_function = def->c_function();
+      Sass_Function_Fn c_func = sass_function_get_function(c_function);
 
       To_C to_c;
       union Sass_Value* c_args = sass_make_list(1, SASS_COMMA);
       sass_list_set_value(c_args, 0, message->perform(&to_c));
-      Sass_Value* c_val = c_func(c_args, def->cookie());
+      Sass_Value* c_val = c_func(c_args, c_function, ctx.c_options);
       sass_delete_value(c_args);
       sass_delete_value(c_val);
       return 0;
@@ -243,12 +325,13 @@ namespace Sass {
       Definition* def = static_cast<Definition*>((*env)["@error[f]"]);
       // Block*          body   = def->block();
       // Native_Function func   = def->native_function();
-      Sass_C_Function c_func = def->c_function();
+      Sass_Function_Entry c_function = def->c_function();
+      Sass_Function_Fn c_func = sass_function_get_function(c_function);
 
       To_C to_c;
       union Sass_Value* c_args = sass_make_list(1, SASS_COMMA);
       sass_list_set_value(c_args, 0, message->perform(&to_c));
-      Sass_Value* c_val = c_func(c_args, def->cookie());
+      Sass_Value* c_val = c_func(c_args, c_function, ctx.c_options);
       sass_delete_value(c_args);
       sass_delete_value(c_val);
       return 0;
@@ -256,10 +339,7 @@ namespace Sass {
     }
 
     string result(unquote(message->perform(&to_string)));
-    Backtrace top(backtrace, e->pstate(), "");
-    cerr << "Error: " << result;
-    cerr << top.to_string(true);
-    cerr << endl << endl;
+    error(result, e->pstate());
     return 0;
   }
 
@@ -274,12 +354,13 @@ namespace Sass {
       Definition* def = static_cast<Definition*>((*env)["@debug[f]"]);
       // Block*          body   = def->block();
       // Native_Function func   = def->native_function();
-      Sass_C_Function c_func = def->c_function();
+      Sass_Function_Entry c_function = def->c_function();
+      Sass_Function_Fn c_func = sass_function_get_function(c_function);
 
       To_C to_c;
       union Sass_Value* c_args = sass_make_list(1, SASS_COMMA);
       sass_list_set_value(c_args, 0, message->perform(&to_c));
-      Sass_Value* c_val = c_func(c_args, def->cookie());
+      Sass_Value* c_val = c_func(c_args, c_function, ctx.c_options);
       sass_delete_value(c_args);
       sass_delete_value(c_val);
       return 0;
@@ -431,7 +512,8 @@ namespace Sass {
 
   Expression* Eval::operator()(Function_Call* c)
   {
-    string full_name(c->name() + "[f]");
+    string name(Util::normalize_underscores(c->name()));
+    string full_name(name + "[f]");
     Arguments* args = c->arguments();
     if (full_name != "if[f]") {
       args = static_cast<Arguments*>(args->perform(this));
@@ -458,7 +540,7 @@ namespace Sass {
     Definition*     def    = static_cast<Definition*>((*env)[full_name]);
     Block*          body   = def->block();
     Native_Function func   = def->native_function();
-    Sass_C_Function c_func = def->c_function();
+    Sass_Function_Entry c_function = def->c_function();
 
     if (full_name != "if[f]") {
       for (size_t i = 0, L = args->length(); i < L; ++i) {
@@ -509,8 +591,9 @@ namespace Sass {
       env = old_env;
     }
     // else if it's a user-defined c function
-    else if (c_func) {
+    else if (c_function) {
 
+      Sass_Function_Fn c_func = sass_function_get_function(c_function);
       if (full_name == "*[f]") {
         String_Constant *str = new (ctx.mem) String_Constant(c->pstate(), c->name());
         Arguments* new_args = new (ctx.mem) Arguments(c->pstate());
@@ -528,14 +611,14 @@ namespace Sass {
       backtrace = &here;
 
       To_C to_c;
-      union Sass_Value* c_args = sass_make_list(env->current_frame().size(), SASS_COMMA);
+      union Sass_Value* c_args = sass_make_list(env->local_frame().size(), SASS_COMMA);
       for(size_t i = 0; i < params[0].length(); i++) {
         string key = params[0][i]->name();
-        AST_Node* node = env->current_frame().at(key);
+        AST_Node* node = env->local_frame().at(key);
         Expression* arg = static_cast<Expression*>(node);
         sass_list_set_value(c_args, i, arg->perform(&to_c));
       }
-      Sass_Value* c_val = c_func(c_args, def->cookie());
+      Sass_Value* c_val = c_func(c_args, c_function, ctx.c_options);
       if (sass_value_get_tag(c_val) == SASS_ERROR) {
         error("error in C function " + c->name() + ": " + sass_error_get_message(c_val), c->pstate(), backtrace);
       } else if (sass_value_get_tag(c_val) == SASS_WARNING) {
@@ -671,7 +754,7 @@ namespace Sass {
       case Textual::DIMENSION:
         result = new (ctx.mem) Number(t->pstate(),
                                       sass_atof(num.c_str()),
-                                      Token(number(text.c_str()), t->pstate()),
+                                      Token(number(text.c_str())),
                                       zero);
         break;
       case Textual::HEX: {
@@ -727,21 +810,15 @@ namespace Sass {
   }
 
   string Eval::interpolation(Expression* s) {
-
     if (String_Quoted* str_quoted = dynamic_cast<String_Quoted*>(s)) {
-
       if (str_quoted->quote_mark()) {
         return string_escape(str_quoted->value());
       } else {
         return evacuate_escapes(str_quoted->value());
       }
-
     } else if (String_Constant* str_constant = dynamic_cast<String_Constant*>(s)) {
-
       return evacuate_escapes(str_constant->value());
-
     } else if (String_Schema* str_schema = dynamic_cast<String_Schema*>(s)) {
-
       string res = "";
       for(auto i : str_schema->elements())
         res += (interpolation(i));
@@ -753,9 +830,7 @@ namespace Sass {
       } else {
         return evacuate_quotes(unq);
       }
-
     } else if (List* list = dynamic_cast<List*>(s)) {
-
       string acc = ""; // ToDo: different output styles
       string sep = list->separator() == List::Separator::COMMA ? "," : " ";
       if (ctx.output_style != COMPRESSED && sep == ",") sep += " ";
@@ -766,30 +841,30 @@ namespace Sass {
         initial = true;
       }
       return evacuate_quotes(acc);
-
     } else if (Variable* var = dynamic_cast<Variable*>(s)) {
-
       string name(var->name());
       if (!env->has(name)) error("Undefined variable: \"" + var->name() + "\".", var->pstate());
       Expression* value = static_cast<Expression*>((*env)[name]);
       return evacuate_quotes(interpolation(value));
-
     } else if (Binary_Expression* var = dynamic_cast<Binary_Expression*>(s)) {
-
-      Expression* ex = operator()(var);
+      Expression* ex = var->perform(this);
       return evacuate_quotes(interpolation(ex));
-
     } else if (Function_Call* var = dynamic_cast<Function_Call*>(s)) {
-
-      Expression* ex = operator()(var);
+      Expression* ex = var->perform(this);
+      return evacuate_quotes(interpolation(ex));
+    } else if (Parent_Selector* var = dynamic_cast<Parent_Selector*>(s)) {
+      Expression* ex = var->perform(this);
+      return evacuate_quotes(interpolation(ex));
+    } else if (Unary_Expression* var = dynamic_cast<Unary_Expression*>(s)) {
+      Expression* ex = var->perform(this);
+      return evacuate_quotes(interpolation(ex));
+    } else if (Selector* var = dynamic_cast<Selector*>(s)) {
+      Expression* ex = var->perform(this);
       return evacuate_quotes(interpolation(ex));
-
     } else {
-
       To_String to_string(&ctx);
       // to_string.in_decl_list = true;
       return evacuate_quotes(s->perform(&to_string));
-
     }
   }
 
@@ -938,6 +1013,15 @@ namespace Sass {
     return 0;
   }
 
+  Expression* Eval::operator()(Parent_Selector* p)
+  {
+    Selector* s = p->perform(contextualize);
+    // access to parent selector may return 0
+    Selector_List* l = static_cast<Selector_List*>(s);
+    if (!s) { l = new (ctx.mem) Selector_List(p->pstate()); }
+    return l->perform(listize);
+  }
+
   inline Expression* Eval::fallback_impl(AST_Node* n)
   {
     return static_cast<Expression*>(n);