sassc 1.11.4 → 1.12.0

data/ext/libsass/src/bind.hpp

@@ -6,7 +6,6 @@
 #include "ast_fwd_decl.hpp"
 
 namespace Sass {
-  typedef Environment<AST_Node_Obj> Env;
 
   void bind(std::string type, std::string name, Parameters_Obj, Arguments_Obj, Context*, Env*, Eval*);
 }

data/ext/libsass/src/cencode.c

@@ -46,6 +46,9 @@ 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
+				__attribute__ ((fallthrough));
+			#endif
 	case step_B:
 			if (plainchar == plaintextend)
 			{
@@ -57,6 +60,9 @@ 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
+				__attribute__ ((fallthrough));
+			#endif
 	case step_C:
 			if (plainchar == plaintextend)
 			{

data/ext/libsass/src/check_nesting.cpp

@@ -7,15 +7,20 @@ namespace Sass {
 
   CheckNesting::CheckNesting()
   : parents(std::vector<Statement_Ptr>()),
-    parent(0),
-    current_mixin_definition(0)
+    traces(std::vector<Backtrace>()),
+    parent(0), current_mixin_definition(0)
   { }
 
+  void error(AST_Node_Ptr node, Backtraces traces, std::string msg) {
+    traces.push_back(Backtrace(node->pstate()));
+    throw Exception::InvalidSass(node->pstate(), traces, msg);
+  }
+
   Statement_Ptr CheckNesting::visit_children(Statement_Ptr parent)
   {
     Statement_Ptr old_parent = this->parent;
 
-    if (At_Root_Block_Ptr root = SASS_MEMORY_CAST_PTR(At_Root_Block, parent)) {
+    if (At_Root_Block_Ptr root = Cast<At_Root_Block>(parent)) {
       std::vector<Statement_Ptr> old_parents = this->parents;
       std::vector<Statement_Ptr> new_parents;
 
@@ -39,8 +44,14 @@ namespace Sass {
         }
       }
 
-      At_Root_Block_Ptr ar = SASS_MEMORY_CAST_PTR(At_Root_Block, parent);
-      Statement_Ptr ret = this->visit_children(&ar->block());
+      At_Root_Block_Ptr ar = Cast<At_Root_Block>(parent);
+      Block_Ptr ret = ar->block();
+
+      if (ret != NULL) {
+        for (auto n : ret->elements()) {
+          n->perform(this);
+        }
+      }
 
       this->parent = old_parent;
       this->parents = old_parents;
@@ -54,11 +65,17 @@ namespace Sass {
 
     this->parents.push_back(parent);
 
-    Block_Ptr b = SASS_MEMORY_CAST_PTR(Block, parent);
+    Block_Ptr b = Cast<Block>(parent);
+
+    if (Trace_Ptr trace = Cast<Trace>(parent)) {
+      if (trace->type() == 'i') {
+        this->traces.push_back(Backtrace(trace->pstate()));
+      }
+    }
 
     if (!b) {
-      if (Has_Block_Ptr bb = SASS_MEMORY_CAST(Has_Block, *parent)) {
-        b = &bb->block();
+      if (Has_Block_Ptr bb = Cast<Has_Block>(parent)) {
+        b = bb->block();
       }
     }
 
@@ -67,9 +84,16 @@ namespace Sass {
         n->perform(this);
       }
     }
+
     this->parent = old_parent;
     this->parents.pop_back();
 
+    if (Trace_Ptr trace = Cast<Trace>(parent)) {
+      if (trace->type() == 'i') {
+        this->traces.pop_back();
+      }
+    }
+
     return b;
   }
 
@@ -97,10 +121,21 @@ namespace Sass {
     return n;
   }
 
+  Statement_Ptr CheckNesting::operator()(If_Ptr i)
+  {
+    this->visit_children(i);
+
+    if (Block_Ptr b = Cast<Block>(i->alternative())) {
+      for (auto n : b->elements()) n->perform(this);
+    }
+
+    return i;
+  }
+
   Statement_Ptr CheckNesting::fallback_impl(Statement_Ptr s)
   {
-    Block_Ptr b1 = SASS_MEMORY_CAST_PTR(Block, s);
-    Has_Block_Ptr b2 = SASS_MEMORY_CAST_PTR(Has_Block, s);
+    Block_Ptr b1 = Cast<Block>(s);
+    Has_Block_Ptr b2 = Cast<Has_Block>(s);
     return b1 || b2 ? visit_children(s) : s;
   }
 
@@ -108,91 +143,82 @@ namespace Sass {
   {
     if (!this->parent) return true;
 
-    if (SASS_MEMORY_CAST_PTR(Content, node))
-    { this->invalid_content_parent(this->parent); }
+    if (Cast<Content>(node))
+    { this->invalid_content_parent(this->parent, node); }
 
     if (is_charset(node))
-    { this->invalid_charset_parent(this->parent); }
+    { this->invalid_charset_parent(this->parent, node); }
 
-    if (SASS_MEMORY_CAST_PTR(Extension, node))
-    { this->invalid_extend_parent(this->parent); }
+    if (Cast<Extension>(node))
+    { this->invalid_extend_parent(this->parent, node); }
 
-    // if (SASS_MEMORY_CAST(Import, node))
+    // if (Cast<Import>(node))
     // { this->invalid_import_parent(this->parent); }
 
     if (this->is_mixin(node))
-    { this->invalid_mixin_definition_parent(this->parent); }
+    { this->invalid_mixin_definition_parent(this->parent, node); }
 
     if (this->is_function(node))
-    { this->invalid_function_parent(this->parent); }
+    { this->invalid_function_parent(this->parent, node); }
 
     if (this->is_function(this->parent))
     { this->invalid_function_child(node); }
 
-    if (SASS_MEMORY_CAST_PTR(Declaration, node))
-    { this->invalid_prop_parent(this->parent); }
+    if (Declaration_Ptr d = Cast<Declaration>(node))
+    {
+      this->invalid_prop_parent(this->parent, node);
+      this->invalid_value_child(d->value());
+    }
 
-    if (SASS_MEMORY_CAST_PTR(Declaration, this->parent))
+    if (Cast<Declaration>(this->parent))
     { this->invalid_prop_child(node); }
 
-    if (SASS_MEMORY_CAST_PTR(Return, node))
-    { this->invalid_return_parent(this->parent); }
+    if (Cast<Return>(node))
+    { this->invalid_return_parent(this->parent, node); }
 
     return true;
   }
 
-  void CheckNesting::invalid_content_parent(Statement_Ptr parent)
+  void CheckNesting::invalid_content_parent(Statement_Ptr parent, AST_Node_Ptr node)
   {
     if (!this->current_mixin_definition) {
-      throw Exception::InvalidSass(
-        parent->pstate(),
-        "@content may only be used within a mixin."
-      );
+      error(node, traces, "@content may only be used within a mixin.");
     }
   }
 
-  void CheckNesting::invalid_charset_parent(Statement_Ptr parent)
+  void CheckNesting::invalid_charset_parent(Statement_Ptr parent, AST_Node_Ptr node)
   {
     if (!(
         is_root_node(parent)
     )) {
-      throw Exception::InvalidSass(
-        parent->pstate(),
-        "@charset may only be used at the root of a document."
-      );
+      error(node, traces, "@charset may only be used at the root of a document.");
     }
   }
 
-  void CheckNesting::invalid_extend_parent(Statement_Ptr parent)
+  void CheckNesting::invalid_extend_parent(Statement_Ptr parent, AST_Node_Ptr node)
   {
     if (!(
-        SASS_MEMORY_CAST_PTR(Ruleset, parent) ||
-        SASS_MEMORY_CAST_PTR(Mixin_Call, parent) ||
+        Cast<Ruleset>(parent) ||
+        Cast<Mixin_Call>(parent) ||
         is_mixin(parent)
     )) {
-      throw Exception::InvalidSass(
-        parent->pstate(),
-        "Extend directives may only be used within rules."
-      );
+      error(node, traces, "Extend directives may only be used within rules.");
     }
   }
 
-  // void CheckNesting::invalid_import_parent(Statement_Ptr parent)
+  // void CheckNesting::invalid_import_parent(Statement_Ptr parent, AST_Node_Ptr node)
   // {
   //   for (auto pp : this->parents) {
   //     if (
-  //         SASS_MEMORY_CAST(Each, pp) ||
-  //         SASS_MEMORY_CAST(For, pp) ||
-  //         SASS_MEMORY_CAST(If, pp) ||
-  //         SASS_MEMORY_CAST(While, pp) ||
-  //         SASS_MEMORY_CAST(Trace, pp) ||
-  //         SASS_MEMORY_CAST(Mixin_Call, pp) ||
+  //         Cast<Each>(pp) ||
+  //         Cast<For>(pp) ||
+  //         Cast<If>(pp) ||
+  //         Cast<While>(pp) ||
+  //         Cast<Trace>(pp) ||
+  //         Cast<Mixin_Call>(pp) ||
   //         is_mixin(pp)
   //     ) {
-  //       throw Exception::InvalidSass(
-  //         parent->pstate(),
-  //         "Import directives may not be defined within control directives or other mixins."
-  //       );
+  //       error(node, traces, "Import directives may not be defined within control directives or other mixins.");
   //     }
   //   }
 
@@ -201,49 +227,40 @@ namespace Sass {
   //   }
 
   //   if (false/*n.css_import?*/) {
-  //     throw Exception::InvalidSass(
-  //       parent->pstate(),
-  //       "CSS import directives may only be used at the root of a document."
-  //     );
+  //     error(node, traces, "CSS import directives may only be used at the root of a document.");
   //   }
   // }
 
-  void CheckNesting::invalid_mixin_definition_parent(Statement_Ptr parent)
+  void CheckNesting::invalid_mixin_definition_parent(Statement_Ptr parent, AST_Node_Ptr node)
   {
     for (Statement_Ptr pp : this->parents) {
       if (
-          SASS_MEMORY_CAST_PTR(Each, pp) ||
-          SASS_MEMORY_CAST_PTR(For, pp) ||
-          SASS_MEMORY_CAST_PTR(If, pp) ||
-          SASS_MEMORY_CAST_PTR(While, pp) ||
-          SASS_MEMORY_CAST_PTR(Trace, pp) ||
-          SASS_MEMORY_CAST_PTR(Mixin_Call, pp) ||
+          Cast<Each>(pp) ||
+          Cast<For>(pp) ||
+          Cast<If>(pp) ||
+          Cast<While>(pp) ||
+          Cast<Trace>(pp) ||
+          Cast<Mixin_Call>(pp) ||
           is_mixin(pp)
       ) {
-        throw Exception::InvalidSass(
-          parent->pstate(),
-          "Mixins may not be defined within control directives or other mixins."
-        );
+        error(node, traces, "Mixins may not be defined within control directives or other mixins.");
       }
     }
   }
 
-  void CheckNesting::invalid_function_parent(Statement_Ptr parent)
+  void CheckNesting::invalid_function_parent(Statement_Ptr parent, AST_Node_Ptr node)
   {
     for (Statement_Ptr pp : this->parents) {
       if (
-          SASS_MEMORY_CAST_PTR(Each, pp) ||
-          SASS_MEMORY_CAST_PTR(For, pp) ||
-          SASS_MEMORY_CAST_PTR(If, pp) ||
-          SASS_MEMORY_CAST_PTR(While, pp) ||
-          SASS_MEMORY_CAST_PTR(Trace, pp) ||
-          SASS_MEMORY_CAST_PTR(Mixin_Call, pp) ||
+          Cast<Each>(pp) ||
+          Cast<For>(pp) ||
+          Cast<If>(pp) ||
+          Cast<While>(pp) ||
+          Cast<Trace>(pp) ||
+          Cast<Mixin_Call>(pp) ||
           is_mixin(pp)
       ) {
-        throw Exception::InvalidSass(
-          parent->pstate(),
-          "Functions may not be defined within control directives or other mixins."
-        );
+        error(node, traces, "Functions may not be defined within control directives or other mixins.");
       }
     }
   }
@@ -251,70 +268,75 @@ namespace Sass {
   void CheckNesting::invalid_function_child(Statement_Ptr child)
   {
     if (!(
-        SASS_MEMORY_CAST_PTR(Each, child) ||
-        SASS_MEMORY_CAST_PTR(For, child) ||
-        SASS_MEMORY_CAST_PTR(If, child) ||
-        SASS_MEMORY_CAST_PTR(While, child) ||
-        SASS_MEMORY_CAST_PTR(Trace, child) ||
-        SASS_MEMORY_CAST_PTR(Comment, child) ||
-        SASS_MEMORY_CAST_PTR(Debug, child) ||
-        SASS_MEMORY_CAST_PTR(Return, child) ||
-        SASS_MEMORY_CAST_PTR(Variable, child) ||
+        Cast<Each>(child) ||
+        Cast<For>(child) ||
+        Cast<If>(child) ||
+        Cast<While>(child) ||
+        Cast<Trace>(child) ||
+        Cast<Comment>(child) ||
+        Cast<Debug>(child) ||
+        Cast<Return>(child) ||
+        Cast<Variable>(child) ||
         // Ruby Sass doesn't distinguish variables and assignments
-        SASS_MEMORY_CAST_PTR(Assignment, child) ||
-        SASS_MEMORY_CAST_PTR(Warning, child) ||
-        SASS_MEMORY_CAST_PTR(Error, child)
+        Cast<Assignment>(child) ||
+        Cast<Warning>(child) ||
+        Cast<Error>(child)
     )) {
-      throw Exception::InvalidSass(
-        child->pstate(),
-        "Functions can only contain variable declarations and control directives."
-      );
+      error(child, traces, "Functions can only contain variable declarations and control directives.");
     }
   }
 
   void CheckNesting::invalid_prop_child(Statement_Ptr child)
   {
     if (!(
-        SASS_MEMORY_CAST_PTR(Each, child) ||
-        SASS_MEMORY_CAST_PTR(For, child) ||
-        SASS_MEMORY_CAST_PTR(If, child) ||
-        SASS_MEMORY_CAST_PTR(While, child) ||
-        SASS_MEMORY_CAST_PTR(Trace, child) ||
-        SASS_MEMORY_CAST_PTR(Comment, child) ||
-        SASS_MEMORY_CAST_PTR(Declaration, child) ||
-        SASS_MEMORY_CAST_PTR(Mixin_Call, child)
+        Cast<Each>(child) ||
+        Cast<For>(child) ||
+        Cast<If>(child) ||
+        Cast<While>(child) ||
+        Cast<Trace>(child) ||
+        Cast<Comment>(child) ||
+        Cast<Declaration>(child) ||
+        Cast<Mixin_Call>(child)
     )) {
-      throw Exception::InvalidSass(
-        child->pstate(),
-        "Illegal nesting: Only properties may be nested beneath properties."
-      );
+      error(child, traces, "Illegal nesting: Only properties may be nested beneath properties.");
     }
   }
 
-  void CheckNesting::invalid_prop_parent(Statement_Ptr parent)
+  void CheckNesting::invalid_prop_parent(Statement_Ptr parent, AST_Node_Ptr node)
   {
     if (!(
         is_mixin(parent) ||
         is_directive_node(parent) ||
-        SASS_MEMORY_CAST_PTR(Ruleset, parent) ||
-        SASS_MEMORY_CAST_PTR(Keyframe_Rule, parent) ||
-        SASS_MEMORY_CAST_PTR(Declaration, parent) ||
-        SASS_MEMORY_CAST_PTR(Mixin_Call, parent)
+        Cast<Ruleset>(parent) ||
+        Cast<Keyframe_Rule>(parent) ||
+        Cast<Declaration>(parent) ||
+        Cast<Mixin_Call>(parent)
     )) {
-      throw Exception::InvalidSass(
-        parent->pstate(),
-        "Properties are only allowed within rules, directives, mixin includes, or other properties."
-      );
+      error(node, traces, "Properties are only allowed within rules, directives, mixin includes, or other properties.");
     }
   }
 
-  void CheckNesting::invalid_return_parent(Statement_Ptr parent)
+  void CheckNesting::invalid_value_child(AST_Node_Ptr d)
+  {
+    if (Map_Ptr m = Cast<Map>(d)) {
+      traces.push_back(Backtrace(m->pstate()));
+      throw Exception::InvalidValue(traces, *m);
+    }
+    if (Number_Ptr n = Cast<Number>(d)) {
+      if (!n->is_valid_css_unit()) {
+        traces.push_back(Backtrace(n->pstate()));
+        throw Exception::InvalidValue(traces, *n);
+      }
+    }
+
+    // error(dbg + " isn't a valid CSS value.", m->pstate(),);
+
+  }
+
+  void CheckNesting::invalid_return_parent(Statement_Ptr parent, AST_Node_Ptr node)
   {
     if (!this->is_function(parent)) {
-      throw Exception::InvalidSass(
-        parent->pstate(),
-        "@return may only be used within a function."
-      );
+      error(node, traces, "@return may only be used within a function.");
     }
   }
 
@@ -326,51 +348,51 @@ namespace Sass {
                              !is_root_node(grandparent) &&
                              !is_at_root_node(grandparent);
 
-    return SASS_MEMORY_CAST_PTR(Import, parent) ||
-           SASS_MEMORY_CAST_PTR(Each, parent) ||
-           SASS_MEMORY_CAST_PTR(For, parent) ||
-           SASS_MEMORY_CAST_PTR(If, parent) ||
-           SASS_MEMORY_CAST_PTR(While, parent) ||
-           SASS_MEMORY_CAST_PTR(Trace, parent) ||
+    return Cast<Import>(parent) ||
+           Cast<Each>(parent) ||
+           Cast<For>(parent) ||
+           Cast<If>(parent) ||
+           Cast<While>(parent) ||
+           Cast<Trace>(parent) ||
            valid_bubble_node;
   }
 
   bool CheckNesting::is_charset(Statement_Ptr n)
   {
-    Directive_Ptr d = SASS_MEMORY_CAST_PTR(Directive, n);
+    Directive_Ptr d = Cast<Directive>(n);
     return d && d->keyword() == "charset";
   }
 
   bool CheckNesting::is_mixin(Statement_Ptr n)
   {
-    Definition_Ptr def = SASS_MEMORY_CAST_PTR(Definition, n);
+    Definition_Ptr def = Cast<Definition>(n);
     return def && def->type() == Definition::MIXIN;
   }
 
   bool CheckNesting::is_function(Statement_Ptr n)
   {
-    Definition_Ptr def = SASS_MEMORY_CAST_PTR(Definition, n);
+    Definition_Ptr def = Cast<Definition>(n);
     return def && def->type() == Definition::FUNCTION;
   }
 
   bool CheckNesting::is_root_node(Statement_Ptr n)
   {
-    if (SASS_MEMORY_CAST_PTR(Ruleset, n)) return false;
+    if (Cast<Ruleset>(n)) return false;
 
-    Block_Ptr b = SASS_MEMORY_CAST_PTR(Block, n);
+    Block_Ptr b = Cast<Block>(n);
     return b && b->is_root();
   }
 
   bool CheckNesting::is_at_root_node(Statement_Ptr n)
   {
-    return SASS_MEMORY_CAST_PTR(At_Root_Block, n) != NULL;
+    return Cast<At_Root_Block>(n) != NULL;
   }
 
   bool CheckNesting::is_directive_node(Statement_Ptr n)
   {
-    return SASS_MEMORY_CAST_PTR(Directive, n) ||
-           SASS_MEMORY_CAST_PTR(Import, n) ||
-           SASS_MEMORY_CAST_PTR(Media_Block, n) ||
-           SASS_MEMORY_CAST_PTR(Supports_Block, n);
+    return Cast<Directive>(n) ||
+           Cast<Import>(n) ||
+           Cast<Media_Block>(n) ||
+           Cast<Supports_Block>(n);
   }
 }