sassc 2.2.1 → 2.4.0

data/ext/libsass/src/bind.cpp

@@ -11,11 +11,11 @@
 
 namespace Sass {
 
-  void bind(std::string type, std::string name, Parameters_Obj ps, Arguments_Obj as, Env* env, Eval* eval, Backtraces& traces)
+  void bind(sass::string type, sass::string name, Parameters_Obj ps, Arguments_Obj as, Env* env, Eval* eval, Backtraces& traces)
   {
-    std::string callee(type + " " + name);
+    sass::string callee(type + " " + name);
 
-    std::map<std::string, Parameter_Obj> param_map;
+    std::map<sass::string, Parameter_Obj> param_map;
     List_Obj varargs = SASS_MEMORY_NEW(List, as->pstate());
     varargs->is_arglist(true); // enable keyword size handling
 
@@ -52,7 +52,7 @@ namespace Sass {
             }
           }
         }
-        std::stringstream msg;
+        sass::ostream msg;
         msg << "wrong number of arguments (" << LA << " for " << LP << ")";
         msg << " for `" << name << "'";
         return error(msg.str(), as->pstate(), traces);
@@ -73,7 +73,7 @@ namespace Sass {
                                               rest->separator(),
                                               true);
               // wrap each item from list as an argument
-              for (Expression_Obj item : rest->elements()) {
+              for (ExpressionObj item : rest->elements()) {
                 if (Argument_Obj arg = Cast<Argument>(item)) {
                   arglist->append(SASS_MEMORY_COPY(arg)); // copy
                 } else {
@@ -100,7 +100,7 @@ namespace Sass {
           Map_Obj argmap = Cast<Map>(a->value());
           for (auto key : argmap->keys()) {
             if (String_Constant_Obj str = Cast<String_Constant>(key)) {
-              std::string param = unquote(str->value());
+              sass::string param = unquote(str->value());
               arglist->append(SASS_MEMORY_NEW(Argument,
                                               key->pstate(),
                                               argmap->at(key),
@@ -130,7 +130,7 @@ namespace Sass {
             // skip any list completely if empty
             if (ls && ls->empty() && a->is_rest_argument()) continue;
 
-            Expression_Obj value = a->value();
+            ExpressionObj value = a->value();
             if (Argument_Obj arg = Cast<Argument>(value)) {
               arglist->append(arg);
             }
@@ -141,7 +141,7 @@ namespace Sass {
                 arglist->separator(rest->separator());
 
                 for (size_t i = 0, L = rest->length(); i < L; ++i) {
-                  Expression_Obj obj = rest->value_at_index(i);
+                  ExpressionObj obj = rest->value_at_index(i);
                   arglist->append(SASS_MEMORY_NEW(Argument,
                                                 obj->pstate(),
                                                 obj,
@@ -168,7 +168,7 @@ namespace Sass {
         }
         // consumed parameter
         ++ip;
-        // no more paramaters
+        // no more parameters
         break;
       }
 
@@ -177,7 +177,7 @@ namespace Sass {
         // normal param and rest arg
         List_Obj arglist = Cast<List>(a->value());
         if (!arglist) {
-          if (Expression_Obj arg = Cast<Expression>(a->value())) {
+          if (ExpressionObj arg = Cast<Expression>(a->value())) {
             arglist = SASS_MEMORY_NEW(List, a->pstate(), 1);
             arglist->append(arg);
           }
@@ -189,7 +189,7 @@ namespace Sass {
         } else {
           if (arglist->length() > LP - ip && !ps->has_rest_parameter()) {
             size_t arg_count = (arglist->length() + LA - 1);
-            std::stringstream msg;
+            sass::ostream msg;
             msg << callee << " takes " << LP;
             msg << (LP == 1 ? " argument" : " arguments");
             msg << " but " << arg_count;
@@ -202,7 +202,7 @@ namespace Sass {
           }
         }
         // otherwise move one of the rest args into the param, converting to argument if necessary
-        Expression_Obj obj = arglist->at(0);
+        ExpressionObj obj = arglist->at(0);
         if (!(a = Cast<Argument>(obj))) {
           Expression* a_to_convert = obj;
           a = SASS_MEMORY_NEW(Argument,
@@ -226,10 +226,10 @@ namespace Sass {
             traces.push_back(Backtrace(key->pstate()));
             throw Exception::InvalidVarKwdType(key->pstate(), traces, key->inspect(), a);
           }
-          std::string param = "$" + unquote(val->value());
+          sass::string param = "$" + unquote(val->value());
 
           if (!param_map.count(param)) {
-            std::stringstream msg;
+            sass::ostream msg;
             msg << callee << " has no parameter named " << param;
             error(msg.str(), a->pstate(), traces);
           }
@@ -243,7 +243,7 @@ namespace Sass {
 
       if (a->name().empty()) {
         if (env->has_local(p->name())) {
-          std::stringstream msg;
+          sass::ostream msg;
           msg << "parameter " << p->name()
           << " provided more than once in call to " << callee;
           error(msg.str(), a->pstate(), traces);
@@ -258,21 +258,21 @@ namespace Sass {
           if (ps->has_rest_parameter()) {
             varargs->append(a);
           } else {
-            std::stringstream msg;
+            sass::ostream msg;
             msg << callee << " has no parameter named " << a->name();
             error(msg.str(), a->pstate(), traces);
           }
         }
         if (param_map[a->name()]) {
           if (param_map[a->name()]->is_rest_parameter()) {
-            std::stringstream msg;
+            sass::ostream msg;
             msg << "argument " << a->name() << " of " << callee
                 << "cannot be used as named argument";
             error(msg.str(), a->pstate(), traces);
           }
         }
         if (env->has_local(a->name())) {
-          std::stringstream msg;
+          sass::ostream msg;
           msg << "parameter " << p->name()
               << "provided more than once in call to " << callee;
           error(msg.str(), a->pstate(), traces);

data/ext/libsass/src/bind.hpp

@@ -8,7 +8,7 @@
 
 namespace Sass {
 
-  void bind(std::string type, std::string name, Parameters_Obj, Arguments_Obj, Env*, Eval*, Backtraces& traces);
+  void bind(sass::string type, sass::string name, Parameters_Obj, Arguments_Obj, Env*, Eval*, Backtraces& traces);
 
 }
 

data/ext/libsass/src/c2ast.cpp

@@ -8,7 +8,7 @@
 
 namespace Sass {
 
-  Value* c2ast(union Sass_Value* v, Backtraces traces, ParserState pstate)
+  Value* c2ast(union Sass_Value* v, Backtraces traces, SourceSpan pstate)
   {
     using std::strlen;
     using std::strcpy;
@@ -51,10 +51,10 @@ namespace Sass {
         e = SASS_MEMORY_NEW(Null, pstate);
       } break;
       case SASS_ERROR: {
-        error("Error in C function: " + std::string(sass_error_get_message(v)), pstate, traces);
+        error("Error in C function: " + sass::string(sass_error_get_message(v)), pstate, traces);
       } break;
       case SASS_WARNING: {
-        error("Warning in C function: " + std::string(sass_warning_get_message(v)), pstate, traces);
+        error("Warning in C function: " + sass::string(sass_warning_get_message(v)), pstate, traces);
       } break;
       default: break;
     }

data/ext/libsass/src/c2ast.hpp

@@ -7,7 +7,7 @@
 
 namespace Sass {
 
-  Value* c2ast(union Sass_Value* v, Backtraces traces, ParserState pstate);
+  Value* c2ast(union Sass_Value* v, Backtraces traces, SourceSpan pstate);
 
 }
 

data/ext/libsass/src/cencode.c

@@ -46,9 +46,8 @@ int base64_encode_block(const char* plaintext_in, int length_in, char* code_out,
 			result = (fragment & 0x0fc) >> 2;
 			*codechar++ = base64_encode_value(result);
 			result = (fragment & 0x003) << 4;
-			#ifndef _MSC_VER
-				/* fall through */
-			#endif
+			/* fall through */
+
 	case step_B:
 			if (plainchar == plaintextend)
 			{
@@ -60,9 +59,8 @@ int base64_encode_block(const char* plaintext_in, int length_in, char* code_out,
 			result |= (fragment & 0x0f0) >> 4;
 			*codechar++ = base64_encode_value(result);
 			result = (fragment & 0x00f) << 2;
-			#ifndef _MSC_VER
-				/* fall through */
-			#endif
+			/* fall through */
+
 	case step_C:
 			if (plainchar == plaintextend)
 			{

data/ext/libsass/src/check_nesting.cpp

@@ -1,20 +1,18 @@
 // sass.hpp must go before all system headers to get the
 // __EXTENSIONS__ fix on Solaris.
 #include "sass.hpp"
-
-#include <vector>
-
+#include "ast.hpp"
 #include "check_nesting.hpp"
 
 namespace Sass {
 
   CheckNesting::CheckNesting()
-  : parents(std::vector<Statement*>()),
-    traces(std::vector<Backtrace>()),
+  : parents(sass::vector<Statement*>()),
+    traces(sass::vector<Backtrace>()),
     parent(0), current_mixin_definition(0)
   { }
 
-  void error(AST_Node* node, Backtraces traces, std::string msg) {
+  void error(AST_Node* node, Backtraces traces, sass::string msg) {
     traces.push_back(Backtrace(node->pstate()));
     throw Exception::InvalidSass(node->pstate(), traces, msg);
   }
@@ -23,9 +21,9 @@ namespace Sass {
   {
     Statement* old_parent = this->parent;
 
-    if (At_Root_Block* root = Cast<At_Root_Block>(parent)) {
-      std::vector<Statement*> old_parents = this->parents;
-      std::vector<Statement*> new_parents;
+    if (AtRootRule* root = Cast<AtRootRule>(parent)) {
+      sass::vector<Statement*> old_parents = this->parents;
+      sass::vector<Statement*> new_parents;
 
       for (size_t i = 0, L = this->parents.size(); i < L; i++) {
         Statement* p = this->parents.at(i);
@@ -47,7 +45,7 @@ namespace Sass {
         }
       }
 
-      At_Root_Block* ar = Cast<At_Root_Block>(parent);
+      AtRootRule* ar = Cast<AtRootRule>(parent);
       Block* ret = ar->block();
 
       if (ret != NULL) {
@@ -77,7 +75,7 @@ namespace Sass {
     }
 
     if (!b) {
-      if (Has_Block* bb = Cast<Has_Block>(parent)) {
+      if (ParentStatement* bb = Cast<ParentStatement>(parent)) {
         b = bb->block();
       }
     }
@@ -145,7 +143,7 @@ namespace Sass {
     if (is_charset(node))
     { this->invalid_charset_parent(this->parent, node); }
 
-    if (Cast<Extension>(node))
+    if (Cast<ExtendRule>(node))
     { this->invalid_extend_parent(this->parent, node); }
 
     // if (Cast<Import>(node))
@@ -194,7 +192,7 @@ namespace Sass {
   void CheckNesting::invalid_extend_parent(Statement* parent, AST_Node* node)
   {
     if (!(
-        Cast<Ruleset>(parent) ||
+        Cast<StyleRule>(parent) ||
         Cast<Mixin_Call>(parent) ||
         is_mixin(parent)
     )) {
@@ -206,10 +204,10 @@ namespace Sass {
   // {
   //   for (auto pp : this->parents) {
   //     if (
-  //         Cast<Each>(pp) ||
-  //         Cast<For>(pp) ||
+  //         Cast<EachRule>(pp) ||
+  //         Cast<ForRule>(pp) ||
   //         Cast<If>(pp) ||
-  //         Cast<While>(pp) ||
+  //         Cast<WhileRule>(pp) ||
   //         Cast<Trace>(pp) ||
   //         Cast<Mixin_Call>(pp) ||
   //         is_mixin(pp)
@@ -231,10 +229,10 @@ namespace Sass {
   {
     for (Statement* pp : this->parents) {
       if (
-          Cast<Each>(pp) ||
-          Cast<For>(pp) ||
+          Cast<EachRule>(pp) ||
+          Cast<ForRule>(pp) ||
           Cast<If>(pp) ||
-          Cast<While>(pp) ||
+          Cast<WhileRule>(pp) ||
           Cast<Trace>(pp) ||
           Cast<Mixin_Call>(pp) ||
           is_mixin(pp)
@@ -248,10 +246,10 @@ namespace Sass {
   {
     for (Statement* pp : this->parents) {
       if (
-          Cast<Each>(pp) ||
-          Cast<For>(pp) ||
+          Cast<EachRule>(pp) ||
+          Cast<ForRule>(pp) ||
           Cast<If>(pp) ||
-          Cast<While>(pp) ||
+          Cast<WhileRule>(pp) ||
           Cast<Trace>(pp) ||
           Cast<Mixin_Call>(pp) ||
           is_mixin(pp)
@@ -264,19 +262,19 @@ namespace Sass {
   void CheckNesting::invalid_function_child(Statement* child)
   {
     if (!(
-        Cast<Each>(child) ||
-        Cast<For>(child) ||
+        Cast<EachRule>(child) ||
+        Cast<ForRule>(child) ||
         Cast<If>(child) ||
-        Cast<While>(child) ||
+        Cast<WhileRule>(child) ||
         Cast<Trace>(child) ||
         Cast<Comment>(child) ||
-        Cast<Debug>(child) ||
+        Cast<DebugRule>(child) ||
         Cast<Return>(child) ||
         Cast<Variable>(child) ||
         // Ruby Sass doesn't distinguish variables and assignments
         Cast<Assignment>(child) ||
-        Cast<Warning>(child) ||
-        Cast<Error>(child)
+        Cast<WarningRule>(child) ||
+        Cast<ErrorRule>(child)
     )) {
       error(child, traces, "Functions can only contain variable declarations and control directives.");
     }
@@ -285,10 +283,10 @@ namespace Sass {
   void CheckNesting::invalid_prop_child(Statement* child)
   {
     if (!(
-        Cast<Each>(child) ||
-        Cast<For>(child) ||
+        Cast<EachRule>(child) ||
+        Cast<ForRule>(child) ||
         Cast<If>(child) ||
-        Cast<While>(child) ||
+        Cast<WhileRule>(child) ||
         Cast<Trace>(child) ||
         Cast<Comment>(child) ||
         Cast<Declaration>(child) ||
@@ -303,7 +301,7 @@ namespace Sass {
     if (!(
         is_mixin(parent) ||
         is_directive_node(parent) ||
-        Cast<Ruleset>(parent) ||
+        Cast<StyleRule>(parent) ||
         Cast<Keyframe_Rule>(parent) ||
         Cast<Declaration>(parent) ||
         Cast<Mixin_Call>(parent)
@@ -345,17 +343,17 @@ namespace Sass {
                              !is_at_root_node(grandparent);
 
     return Cast<Import>(parent) ||
-           Cast<Each>(parent) ||
-           Cast<For>(parent) ||
+           Cast<EachRule>(parent) ||
+           Cast<ForRule>(parent) ||
            Cast<If>(parent) ||
-           Cast<While>(parent) ||
+           Cast<WhileRule>(parent) ||
            Cast<Trace>(parent) ||
            valid_bubble_node;
   }
 
   bool CheckNesting::is_charset(Statement* n)
   {
-    Directive* d = Cast<Directive>(n);
+    AtRule* d = Cast<AtRule>(n);
     return d && d->keyword() == "charset";
   }
 
@@ -373,7 +371,7 @@ namespace Sass {
 
   bool CheckNesting::is_root_node(Statement* n)
   {
-    if (Cast<Ruleset>(n)) return false;
+    if (Cast<StyleRule>(n)) return false;
 
     Block* b = Cast<Block>(n);
     return b && b->is_root();
@@ -381,14 +379,15 @@ namespace Sass {
 
   bool CheckNesting::is_at_root_node(Statement* n)
   {
-    return Cast<At_Root_Block>(n) != NULL;
+    return Cast<AtRootRule>(n) != NULL;
   }
 
   bool CheckNesting::is_directive_node(Statement* n)
   {
-    return Cast<Directive>(n) ||
+    return Cast<AtRule>(n) ||
            Cast<Import>(n) ||
-           Cast<Media_Block>(n) ||
-           Cast<Supports_Block>(n);
+      Cast<MediaRule>(n) ||
+      Cast<CssMediaRule>(n) ||
+      Cast<SupportsRule>(n);
   }
 }

data/ext/libsass/src/check_nesting.hpp

@@ -1,14 +1,18 @@
 #ifndef SASS_CHECK_NESTING_H
 #define SASS_CHECK_NESTING_H
 
+// sass.hpp must go before all system headers to get the
+// __EXTENSIONS__ fix on Solaris.
+#include "sass.hpp"
 #include "ast.hpp"
 #include "operation.hpp"
+#include <vector>
 
 namespace Sass {
 
   class CheckNesting : public Operation_CRTP<Statement*, CheckNesting> {
 
-    std::vector<Statement*>  parents;
+    sass::vector<Statement*>  parents;
     Backtraces                  traces;
     Statement*               parent;
     Definition*              current_mixin_definition;
@@ -29,7 +33,7 @@ namespace Sass {
       Statement* s = Cast<Statement>(x);
       if (s && this->should_visit(s)) {
         Block* b1 = Cast<Block>(s);
-        Has_Block* b2 = Cast<Has_Block>(s);
+        ParentStatement* b2 = Cast<ParentStatement>(s);
         if (b1 || b2) return visit_children(s);
       }
       return s;

data/ext/libsass/src/color_maps.cpp

@@ -4,6 +4,7 @@
 
 #include "ast.hpp"
 #include "color_maps.hpp"
+#include "util_string.hpp"
 
 namespace Sass {
 
@@ -161,7 +162,7 @@ namespace Sass {
   }
 
   namespace Colors {
-    const ParserState color_table("[COLOR TABLE]");
+    const SourceSpan color_table("[COLOR TABLE]");
     const Color_RGBA aliceblue(color_table, 240, 248, 255, 1);
     const Color_RGBA antiquewhite(color_table, 250, 235, 215, 1);
     const Color_RGBA cyan(color_table, 0, 255, 255, 1);
@@ -313,7 +314,7 @@ namespace Sass {
     const Color_RGBA transparent(color_table, 0, 0, 0, 0);
   }
 
-  const std::map<const int, const char*> colors_to_names {
+  static const auto* const colors_to_names = new std::unordered_map<int, const char*> {
     { 240 * 0x10000 + 248 * 0x100 + 255, ColorNames::aliceblue },
     { 250 * 0x10000 + 235 * 0x100 + 215, ColorNames::antiquewhite },
     {   0 * 0x10000 + 255 * 0x100 + 255, ColorNames::cyan },
@@ -455,7 +456,7 @@ namespace Sass {
     { 102 * 0x10000 +  51 * 0x100 + 153, ColorNames::rebeccapurple }
   };
 
-  const std::map<const char*, const Color_RGBA*, map_cmp_str> names_to_colors
+  static const auto *const names_to_colors = new std::unordered_map<sass::string, const Color_RGBA*>
   {
     { ColorNames::aliceblue, &Colors::aliceblue },
     { ColorNames::antiquewhite, &Colors::antiquewhite },
@@ -610,29 +611,29 @@ namespace Sass {
 
   const Color_RGBA* name_to_color(const char* key)
   {
-    return name_to_color(std::string(key));
+    return name_to_color(sass::string(key));
   }
 
-  const Color_RGBA* name_to_color(const std::string& key)
+  const Color_RGBA* name_to_color(const sass::string& key)
   {
     // case insensitive lookup.  See #2462
-    std::string lower{key};
-    std::transform(lower.begin(), lower.end(), lower.begin(), ::tolower);
+    sass::string lower = key;
+    Util::ascii_str_tolower(&lower);
 
-    auto p = names_to_colors.find(lower.c_str());
-    if (p != names_to_colors.end()) {
+    auto p = names_to_colors->find(lower);
+    if (p != names_to_colors->end()) {
       return p->second;
     }
-    return 0;
+    return nullptr;
   }
 
   const char* color_to_name(const int key)
   {
-    auto p = colors_to_names.find(key);
-    if (p != colors_to_names.end()) {
+    auto p = colors_to_names->find(key);
+    if (p != colors_to_names->end()) {
       return p->second;
     }
-    return 0;
+    return nullptr;
   }
 
   const char* color_to_name(const double key)

data/ext/libsass/src/color_maps.hpp

@@ -7,14 +7,6 @@
 
 namespace Sass {
 
-  struct map_cmp_str
-  {
-    bool operator()(char const *a, char const *b) const
-    {
-      return std::strcmp(a, b) < 0;
-    }
-  };
-
   namespace ColorNames
   {
     extern const char aliceblue[];
@@ -321,7 +313,7 @@ namespace Sass {
   }
 
   const Color_RGBA* name_to_color(const char*);
-  const Color_RGBA* name_to_color(const std::string&);
+  const Color_RGBA* name_to_color(const sass::string&);
   const char* color_to_name(const int);
   const char* color_to_name(const Color_RGBA&);
   const char* color_to_name(const double);

data/ext/libsass/src/constants.cpp

@@ -45,6 +45,7 @@ namespace Sass {
     extern const char for_kwd[]           = "@for";
     extern const char from_kwd[]          = "from";
     extern const char to_kwd[]            = "to";
+    extern const char of_kwd[]            = "of";
     extern const char through_kwd[]       = "through";
     extern const char each_kwd[]          = "@each";
     extern const char in_kwd[]            = "in";
@@ -161,6 +162,10 @@ namespace Sass {
     extern const char uri_chars[]  = ":;/?!%&#@|[]{}'`^\"*+-.,_=~";
     extern const char real_uri_chars[]  = "#%&";
 
+    extern const char selector_combinator_child[] = ">";
+    extern const char selector_combinator_general[] = "~";
+    extern const char selector_combinator_adjacent[] = "+";
+
     // some specific constant character classes
     // they must be static to be useable by lexer
     extern const char static_ops[]      = "*/%";

data/ext/libsass/src/constants.hpp

@@ -43,6 +43,7 @@ namespace Sass {
     extern const char for_kwd[];
     extern const char from_kwd[];
     extern const char to_kwd[];
+    extern const char of_kwd[];
     extern const char through_kwd[];
     extern const char each_kwd[];
     extern const char in_kwd[];
@@ -161,6 +162,11 @@ namespace Sass {
     extern const char uri_chars[];
     extern const char real_uri_chars[];
 
+    // constants for selector combinators
+    extern const char selector_combinator_child[];
+    extern const char selector_combinator_general[];
+    extern const char selector_combinator_adjacent[];
+
     // some specific constant character classes
     // they must be static to be useable by lexer
     extern const char static_ops[];