sassc 1.0.0 → 1.1.0

data/ext/libsass/bind.cpp

@@ -28,14 +28,22 @@ namespace Sass {
     size_t ip = 0, LP = ps->length();
     size_t ia = 0, LA = as->length();
     while (ia < LA) {
+      Argument* a = (*as)[ia];
       if (ip >= LP) {
+        // skip empty rest arguments
+        if (a->is_rest_argument()) {
+          if (List* l = dynamic_cast<List*>(a->value())) {
+            if (l->length() == 0) {
+              ++ ia; continue;
+            }
+          }
+        }
         stringstream msg;
         msg << callee << " only takes " << LP << " arguments; "
             << "given " << LA;
         error(msg.str(), as->pstate());
       }
       Parameter* p = (*ps)[ip];
-      Argument*  a = (*as)[ia];
 
       // If the current parameter is the rest parameter, process and break the loop
       if (p->is_rest_parameter()) {
@@ -48,6 +56,20 @@ namespace Sass {
           else {
             env->local_frame()[p->name()] = a->value();
           }
+        } else if (a->is_keyword_argument()) {
+
+          // expand keyword arguments into their parameters
+          List* arglist = new (ctx.mem) List(p->pstate(), 0, List::COMMA, true);
+          env->local_frame()[p->name()] = arglist;
+          Map* argmap = static_cast<Map*>(a->value());
+          for (auto key : argmap->keys()) {
+            string name = unquote(static_cast<String_Constant*>(key)->value());
+            (*arglist) << new (ctx.mem) Argument(key->pstate(),
+                                                 argmap->at(key),
+                                                 name,
+                                                 false);
+          }
+
         } else {
 
           // copy all remaining arguments into the rest parameter, preserving names

data/ext/libsass/constants.cpp

@@ -3,6 +3,8 @@
 namespace Sass {
   namespace Constants {
 
+    extern const unsigned long MaxCallStack = 1024;
+
     // https://github.com/sass/libsass/issues/592
     // https://developer.mozilla.org/en-US/docs/Web/CSS/Specificity
     // https://github.com/sass/sass/issues/1495#issuecomment-61189114
@@ -138,7 +140,7 @@ namespace Sass {
     extern const char arglist_name[]    = "arglist";
 
     // constants for uri parsing (RFC 3986 Appendix A.)
-    extern const char uri_chars[]  = ":;/?!$%&#@[]{}'\"*+-.,_=";
+    extern const char uri_chars[]  = ":;/?!$%&#@|[]{}'`^\"*+-.,_=~";
 
     // some specific constant character classes
     // they must be static to be useable by lexer

data/ext/libsass/constants.hpp

@@ -4,6 +4,9 @@
 namespace Sass {
   namespace Constants {
 
+    // The maximum call stack that can be created
+    extern const unsigned long MaxCallStack;
+
     // https://developer.mozilla.org/en-US/docs/Web/CSS/Specificity
     // The following list of selectors is by increasing specificity:
     extern const unsigned long Specificity_Star;

data/ext/libsass/context.cpp

@@ -512,7 +512,6 @@ namespace Sass {
     register_function(ctx, index_sig, index, env);
     register_function(ctx, join_sig, join, env);
     register_function(ctx, append_sig, append, env);
-    register_function(ctx, compact_sig, compact, env);
     register_function(ctx, zip_sig, zip, env);
     register_function(ctx, list_separator_sig, list_separator, env);
     // Map Functions

data/ext/libsass/debugger.hpp

@@ -290,6 +290,7 @@ inline void debug_ast(AST_Node* node, string ind = "", Env* env = 0)
     cerr << ind << "Import " << block;
     cerr << " (" << pstate_source_position(node) << ")";
     cerr << " " << block->tabs() << endl;
+    debug_ast(block->media_queries(), ind + " @ ");
     // vector<string>         files_;
     for (auto imp : block->urls()) debug_ast(imp, "@ ", env);
   } else if (dynamic_cast<Assignment*>(node)) {
@@ -342,7 +343,13 @@ inline void debug_ast(AST_Node* node, string ind = "", Env* env = 0)
     Definition* block = dynamic_cast<Definition*>(node);
     cerr << ind << "Definition " << block;
     cerr << " (" << pstate_source_position(node) << ")";
+    cerr << " [name: " << block->name() << "] ";
+    cerr << " [type: " << (block->type() == Sass::Definition::Type::MIXIN ? "Mixin " : "Function ") << "] ";
+    // this seems to lead to segfaults some times?
+    // cerr << " [signature: " << block->signature() << "] ";
+    cerr << " [native: " << block->native_function() << "] ";
     cerr << " " << block->tabs() << endl;
+    debug_ast(block->parameters(), ind + " params: ", env);
     if (block->block()) for(auto i : block->block()->elements()) { debug_ast(i, ind + " ", env); }
   } else if (dynamic_cast<Mixin_Call*>(node)) {
     Mixin_Call* block = dynamic_cast<Mixin_Call*>(node);
@@ -368,9 +375,14 @@ inline void debug_ast(AST_Node* node, string ind = "", Env* env = 0)
     else if (expression->type() == Textual::PERCENTAGE) cerr << " [PERCENTAGE]";
     else if (expression->type() == Textual::DIMENSION) cerr << " [DIMENSION]";
     else if (expression->type() == Textual::HEX) cerr << " [HEX]";
-    cerr << expression << " [" << expression->value() << "]" << endl;
+    cerr << expression << " [" << expression->value() << "]";
+    if (expression->is_delayed()) cerr << " [delayed]";
+    cerr << endl;
   } else if (dynamic_cast<Variable*>(node)) {
     Variable* expression = dynamic_cast<Variable*>(node);
+    cerr << ind << "Variable " << expression << " [" << expression->name() << "]";
+    if (expression->is_delayed()) cerr << " [delayed]";
+    cerr << endl;
     cerr << ind << "Variable " << expression;
     cerr << " (" << pstate_source_position(node) << ")";
     cerr << " [" << expression->name() << "]" << endl;
@@ -378,6 +390,9 @@ inline void debug_ast(AST_Node* node, string ind = "", Env* env = 0)
     if (env && env->has(name)) debug_ast(static_cast<Expression*>((*env)[name]), ind + " -> ", env);
   } else if (dynamic_cast<Function_Call_Schema*>(node)) {
     Function_Call_Schema* expression = dynamic_cast<Function_Call_Schema*>(node);
+    cerr << ind << "Function_Call_Schema " << expression << "]";
+    if (expression->is_delayed()) cerr << " [delayed]";
+    cerr << endl;
     cerr << ind << "Function_Call_Schema " << expression;
     cerr << " (" << pstate_source_position(node) << ")";
     cerr << "" << endl;
@@ -385,30 +400,65 @@ inline void debug_ast(AST_Node* node, string ind = "", Env* env = 0)
     debug_ast(expression->arguments(), ind + " args: ", env);
   } else if (dynamic_cast<Function_Call*>(node)) {
     Function_Call* expression = dynamic_cast<Function_Call*>(node);
+    cerr << ind << "Function_Call " << expression << " [" << expression->name() << "]";
+    if (expression->is_delayed()) cerr << " [delayed]";
+    cerr << endl;
     cerr << ind << "Function_Call " << expression;
     cerr << " (" << pstate_source_position(node) << ")";
     cerr << " [" << expression->name() << "]" << endl;
     debug_ast(expression->arguments(), ind + " args: ", env);
   } else if (dynamic_cast<Arguments*>(node)) {
     Arguments* expression = dynamic_cast<Arguments*>(node);
+    cerr << ind << "Arguments " << expression << "]";
+    if (expression->is_delayed()) cerr << " [delayed]";
+    cerr << endl;
     cerr << ind << "Arguments " << expression;
     cerr << " (" << pstate_source_position(node) << ")";
     cerr << endl;
     for(auto i : expression->elements()) { debug_ast(i, ind + " ", env); }
   } else if (dynamic_cast<Argument*>(node)) {
     Argument* expression = dynamic_cast<Argument*>(node);
+    cerr << ind << "Argument " << expression << " [" << expression->value() << "]";
+    if (expression->is_delayed()) cerr << " [delayed]";
+    if (expression->is_rest_argument()) cerr << " [is_rest_argument]";
+    if (expression->is_keyword_argument()) cerr << " [is_keyword_argument]";
+    cerr << endl;
     cerr << ind << "Argument " << expression;
     cerr << " (" << pstate_source_position(node) << ")";
-    cerr << " [" << expression->value() << "]" << endl;
+    cerr << " [" << expression->value() << "]";
+    cerr << " [name: " << expression->name() << "] ";
+    cerr << " [rest: " << expression->is_rest_argument() << "] ";
+    cerr << " [keyword: " << expression->is_keyword_argument() << "] " << endl;
     debug_ast(expression->value(), ind + " value: ", env);
+  } else if (dynamic_cast<Parameters*>(node)) {
+    Parameters* expression = dynamic_cast<Parameters*>(node);
+    cerr << ind << "Parameters " << expression;
+    cerr << " (" << pstate_source_position(node) << ")";
+    cerr << " [has_optional: " << expression->has_optional_parameters() << "] ";
+    cerr << " [has_rest: " << expression->has_rest_parameter() << "] ";
+    cerr << endl;
+    for(auto i : expression->elements()) { debug_ast(i, ind + " ", env); }
+  } else if (dynamic_cast<Parameter*>(node)) {
+    Parameter* expression = dynamic_cast<Parameter*>(node);
+    cerr << ind << "Parameter " << expression;
+    cerr << " (" << pstate_source_position(node) << ")";
+    cerr << " [name: " << expression->name() << "] ";
+    cerr << " [default: " << expression->default_value() << "] ";
+    cerr << " [rest: " << expression->is_rest_parameter() << "] " << endl;
   } else if (dynamic_cast<Unary_Expression*>(node)) {
     Unary_Expression* expression = dynamic_cast<Unary_Expression*>(node);
+    cerr << ind << "Unary_Expression " << expression << " [" << expression->type_name() << "]";
+    if (expression->is_delayed()) cerr << " [delayed]";
+    cerr << endl;
     cerr << ind << "Unary_Expression " << expression;
     cerr << " (" << pstate_source_position(node) << ")";
     cerr << " [" << expression->type() << "]" << endl;
     debug_ast(expression->operand(), ind + " operand: ", env);
   } else if (dynamic_cast<Binary_Expression*>(node)) {
     Binary_Expression* expression = dynamic_cast<Binary_Expression*>(node);
+    cerr << ind << "Binary_Expression " << expression << " [" << expression->type_name() << "]";
+    if (expression->is_delayed()) cerr << " [delayed]";
+    cerr << endl;
     cerr << ind << "Binary_Expression " << expression;
     cerr << " (" << pstate_source_position(node) << ")";
     cerr << " [" << expression->type() << "]" << endl;
@@ -426,7 +476,11 @@ inline void debug_ast(AST_Node* node, string ind = "", Env* env = 0)
     cerr << " (" << expression->length() << ") " <<
       (expression->separator() == Sass::List::Separator::COMMA ? "Comma " : "Space ") <<
       " [delayed: " << expression->is_delayed() << "] " <<
+      " [interpolant: " << expression->is_interpolant() << "]";
+    if (expression->is_arglist()) cerr << " [is_arglist]";
+    cerr << endl;
       " [interpolant: " << expression->is_interpolant() << "] " <<
+      " [arglist: " << expression->is_arglist() << "] " <<
       endl;
     for(auto i : expression->elements()) { debug_ast(i, ind + " ", env); }
   } else if (dynamic_cast<Content*>(node)) {
@@ -436,21 +490,36 @@ inline void debug_ast(AST_Node* node, string ind = "", Env* env = 0)
     cerr << " [Statement]" << endl;
   } else if (dynamic_cast<Boolean*>(node)) {
     Boolean* expression = dynamic_cast<Boolean*>(node);
+    cerr << ind << "Boolean " << expression << " [" << expression->value() << "]";
+    if (expression->is_delayed()) cerr << " [delayed]";
+    cerr << endl;
     cerr << ind << "Boolean " << expression;
     cerr << " (" << pstate_source_position(node) << ")";
     cerr << " [" << expression->value() << "]" << endl;
   } else if (dynamic_cast<Color*>(node)) {
     Color* expression = dynamic_cast<Color*>(node);
+    cerr << ind << "Color " << expression << " [" << expression->r() << ":"  << expression->g() << ":" << expression->b() << "@" << expression->a() << "]";
+    if (expression->is_delayed()) cerr << " [delayed]";
+    cerr << endl;
     cerr << ind << "Color " << expression;
     cerr << " (" << pstate_source_position(node) << ")";
     cerr << " [" << expression->r() << ":"  << expression->g() << ":" << expression->b() << "@" << expression->a() << "]" << endl;
   } else if (dynamic_cast<Number*>(node)) {
     Number* expression = dynamic_cast<Number*>(node);
+    cerr << ind << "Number " << expression << " [" << expression->value() << expression->unit() << "]";
+    if (expression->is_delayed()) cerr << " [delayed]";
+    cerr << endl;
     cerr << ind << "Number " << expression;
     cerr << " (" << pstate_source_position(node) << ")";
     cerr << " [" << expression->value() << expression->unit() << "]" << endl;
   } else if (dynamic_cast<String_Quoted*>(node)) {
     String_Quoted* expression = dynamic_cast<String_Quoted*>(node);
+    cerr << ind << "String_Quoted : " << expression << " [";
+    cerr << prettyprint(expression->value()) << "]";
+    if (expression->is_delayed()) cerr << " [delayed]";
+    if (expression->sass_fix_1291()) cerr << " [sass_fix_1291]";
+    if (expression->quote_mark()) cerr << " [quote_mark]";
+    cerr << " <" << prettyprint(expression->pstate().token.ws_before()) << ">" << endl;
     cerr << ind << "String_Quoted : " << expression;
     cerr << " (" << pstate_source_position(node) << ")";
     cerr << " [" << prettyprint(expression->value()) << "]" <<
@@ -461,13 +530,23 @@ inline void debug_ast(AST_Node* node, string ind = "", Env* env = 0)
   } else if (dynamic_cast<String_Constant*>(node)) {
     String_Constant* expression = dynamic_cast<String_Constant*>(node);
     cerr << ind << "String_Constant : " << expression;
+    cerr << " [" << prettyprint(expression->value()) << "]";
+    if (expression->is_delayed()) cerr << " [delayed]";
+    if (expression->sass_fix_1291()) cerr << " [sass_fix_1291]";
+    cerr " <" << prettyprint(expression->pstate().token.ws_before()) << ">" << endl;
+    cerr << ind << "String_Constant : " << expression;
     cerr << " (" << pstate_source_position(node) << ")";
     cerr << " [" << prettyprint(expression->value()) << "]" <<
       (expression->is_delayed() ? " {delayed}" : "") <<
       (expression->sass_fix_1291() ? " {sass_fix_1291}" : "") <<
+      (expression->quote_mark() != 0 ? " {qm:" + string(1, expression->quote_mark()) + "}" : "") <<
       " <" << prettyprint(expression->pstate().token.ws_before()) << ">" << endl;
   } else if (dynamic_cast<String_Schema*>(node)) {
     String_Schema* expression = dynamic_cast<String_Schema*>(node);
+    cerr << ind << "String_Schema " << expression << " [" << expression->concrete_type() << "]";
+    if (expression->is_delayed()) cerr << " [delayed]";
+    if (expression->has_interpolants()) cerr << " [has_interpolants]";
+    cerr " <" << prettyprint(expression->pstate().token.ws_before()) << ">" << endl;
     cerr << ind << "String_Schema " << expression;
     cerr << " (" << pstate_source_position(node) << ")";
     cerr << " " << expression->concrete_type() <<
@@ -476,6 +555,9 @@ inline void debug_ast(AST_Node* node, string ind = "", Env* env = 0)
     for(auto i : expression->elements()) { debug_ast(i, ind + " ", env); }
   } else if (dynamic_cast<String*>(node)) {
     String* expression = dynamic_cast<String*>(node);
+    cerr << ind << "String " << expression << expression->concrete_type();
+    if (expression->sass_fix_1291()) cerr << " [sass_fix_1291]";
+    cerr " <" << prettyprint(expression->pstate().token.ws_before()) << ">" << endl;
     cerr << ind << "String " << expression;
     cerr << " (" << pstate_source_position(node) << ")";
     cerr << expression->concrete_type() <<

data/ext/libsass/error_handling.cpp

@@ -8,18 +8,28 @@ namespace Sass {
   : type(type), pstate(pstate), message(message)
   { }
 
-  void error(string msg, ParserState pstate)
+  void warn(string msg, ParserState pstate)
   {
-    throw Sass_Error(Sass_Error::syntax, pstate, msg);
+    cerr << "Warning: " << msg<< endl;
   }
 
-  void error(string msg, ParserState pstate, Backtrace* bt)
+  void warn(string msg, ParserState pstate, Backtrace* bt)
   {
-
     Backtrace top(bt, pstate, "");
     msg += top.to_string();
+    warn(msg, pstate);
+  }
 
+  void error(string msg, ParserState pstate)
+  {
     throw Sass_Error(Sass_Error::syntax, pstate, msg);
   }
 
+  void error(string msg, ParserState pstate, Backtrace* bt)
+  {
+    Backtrace top(bt, pstate, "");
+    msg += "\n" + top.to_string();
+    error(msg, pstate);
+  }
+
 }

data/ext/libsass/error_handling.hpp

@@ -21,6 +21,9 @@ namespace Sass {
 
   };
 
+  void warn(string msg, ParserState pstate);
+  void warn(string msg, ParserState pstate, Backtrace* bt);
+
   void error(string msg, ParserState pstate);
   void error(string msg, ParserState pstate, Backtrace* bt);
 

data/ext/libsass/eval.cpp

@@ -435,8 +435,23 @@ namespace Sass {
     }
     // not a logical connective, so go ahead and eval the rhs
     Expression* rhs = b->right()->perform(this);
-    rhs->is_delayed(false);
-    while (typeid(*rhs) == typeid(Binary_Expression)) rhs = rhs->perform(this);
+    // maybe fully evaluate structure
+    if (op_type == Binary_Expression::EQ ||
+        op_type == Binary_Expression::NEQ ||
+        op_type == Binary_Expression::GT ||
+        op_type == Binary_Expression::GTE ||
+        op_type == Binary_Expression::LT ||
+        op_type == Binary_Expression::LTE)
+    {
+      rhs->is_expanded(false);
+      rhs->set_delayed(false);
+      rhs = rhs->perform(this);
+    }
+    else
+    {
+      rhs->is_delayed(false);
+      rhs = rhs->perform(this);
+    }
 
     // see if it's a relational expression
     switch(op_type) {
@@ -512,6 +527,9 @@ namespace Sass {
 
   Expression* Eval::operator()(Function_Call* c)
   {
+    if (backtrace->parent != NULL && backtrace->depth() > Constants::MaxCallStack) {
+        error("Stack depth exceeded max of " + to_string(Constants::MaxCallStack), c->pstate(), backtrace);
+    }
     string name(Util::normalize_underscores(c->name()));
     string full_name(name + "[f]");
     Arguments* args = c->arguments();
@@ -700,7 +718,11 @@ namespace Sass {
       if (auto str = dynamic_cast<String_Quoted*>(value)) {
         value = new (ctx.mem) String_Quoted(*str);
       } else if (auto str = dynamic_cast<String_Constant*>(value)) {
-        value = new (ctx.mem) String_Constant(*str);
+        if (str->quote_mark()) {
+          value = new (ctx.mem) String_Quoted(str->pstate(), str->perform(&to_string));
+        } else {
+          value = new (ctx.mem) String_Constant(str->pstate(), unquote(str->value()));
+        }
       }
     }
     else if (value->concrete_type() == Expression::LIST) {
@@ -785,6 +807,7 @@ namespace Sass {
 
   Expression* Eval::operator()(Number* n)
   {
+    n->normalize();
     // behave according to as ruby sass (add leading zero)
     return new (ctx.mem) Number(n->pstate(),
                                 n->value(),
@@ -812,12 +835,18 @@ 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());
+        if (str_quoted->quote_mark() == '*' || str_quoted->is_delayed()) {
+          return interpolation(new (ctx.mem) String_Constant(*str_quoted));
+        } else {
+          return string_escape(quote(str_quoted->value(), str_quoted->quote_mark()));
+        }
       } else {
         return evacuate_escapes(str_quoted->value());
       }
     } else if (String_Constant* str_constant = dynamic_cast<String_Constant*>(s)) {
-      return evacuate_escapes(str_constant->value());
+      string str = str_constant->value();
+      if (!str_constant->quote_mark()) str = unquote(str);
+      return evacuate_escapes(str);
     } else if (String_Schema* str_schema = dynamic_cast<String_Schema*>(s)) {
       string res = "";
       for(auto i : str_schema->elements())
@@ -872,6 +901,9 @@ namespace Sass {
   {
     string acc;
     for (size_t i = 0, L = s->length(); i < L; ++i) {
+      if (String_Quoted* str_quoted = dynamic_cast<String_Quoted*>((*s)[i])) {
+        if (!str_quoted->is_delayed()) str_quoted->value(string_eval_escapes(str_quoted->value()));
+      }
       acc += interpolation((*s)[i]);
     }
     String_Quoted* str = new (ctx.mem) String_Quoted(s->pstate(), acc);
@@ -1042,13 +1074,8 @@ namespace Sass {
       } break;
 
       case Expression::NUMBER: {
-        Number* l = static_cast<Number*>(lhs);
-        Number* r = static_cast<Number*>(rhs);
-        Number tmp_r(*r);
-        tmp_r.normalize(l->find_convertible_unit());
-        return l->unit() == tmp_r.unit() && l->value() == tmp_r.value()
-               ? true
-               : false;
+        return *static_cast<Number*>(lhs) ==
+               *static_cast<Number*>(rhs);
       } break;
 
       case Expression::COLOR: {
@@ -1139,8 +1166,8 @@ namespace Sass {
       v->denominator_units() = r->denominator_units();
     }
 
-    v->value(ops[op](lv, tmp.value()));
     if (op == Binary_Expression::MUL) {
+      v->value(ops[op](lv, rv));
       for (size_t i = 0, S = r->numerator_units().size(); i < S; ++i) {
         v->numerator_units().push_back(r->numerator_units()[i]);
       }
@@ -1149,14 +1176,17 @@ namespace Sass {
       }
     }
     else if (op == Binary_Expression::DIV) {
+      v->value(ops[op](lv, rv));
       for (size_t i = 0, S = r->numerator_units().size(); i < S; ++i) {
         v->denominator_units().push_back(r->numerator_units()[i]);
       }
       for (size_t i = 0, S = r->denominator_units().size(); i < S; ++i) {
         v->numerator_units().push_back(r->denominator_units()[i]);
       }
+    } else {
+      v->value(ops[op](lv, tmp.value()));
     }
-    v->normalize();
+    // v->normalize();
     return v;
   }