sassc 2.0.1 → 2.1.0.pre1

data/ext/libsass/src/backtrace.cpp

@@ -24,6 +24,8 @@ namespace Sass {
         ss << indent;
         ss << "on line ";
         ss << trace.pstate.line + 1;
+        ss << ":";
+        ss << trace.pstate.column + 1;
         ss << " of " << rel_path;
         // ss << trace.caller;
         first = false;
@@ -33,6 +35,8 @@ namespace Sass {
         ss << indent;
         ss << "from line ";
         ss << trace.pstate.line + 1;
+        ss << ":";
+        ss << trace.pstate.column + 1;
         ss << " of " << rel_path;
       }
 

data/ext/libsass/src/base64vlq.cpp

@@ -1,4 +1,7 @@
+// sass.hpp must go before all system headers to get the
+// __EXTENSIONS__ fix on Solaris.
 #include "sass.hpp"
+
 #include "base64vlq.hpp"
 
 namespace Sass {

data/ext/libsass/src/bind.cpp

@@ -1,6 +1,7 @@
 #include "sass.hpp"
 #include "bind.hpp"
 #include "ast.hpp"
+#include "backtrace.hpp"
 #include "context.hpp"
 #include "expand.hpp"
 #include "eval.hpp"
@@ -10,7 +11,7 @@
 
 namespace Sass {
 
-  void bind(std::string type, std::string name, Parameters_Obj ps, Arguments_Obj as, Context* ctx, Env* env, Eval* eval)
+  void bind(std::string type, std::string name, Parameters_Obj ps, Arguments_Obj as, Env* env, Eval* eval, Backtraces& traces)
   {
     std::string callee(type + " " + name);
 
@@ -54,7 +55,7 @@ namespace Sass {
         std::stringstream msg;
         msg << "wrong number of arguments (" << LA << " for " << LP << ")";
         msg << " for `" << name << "'";
-        return error(msg.str(), as->pstate(), eval->exp.traces);
+        return error(msg.str(), as->pstate(), traces);
       }
       Parameter_Obj p = ps->at(ip);
 
@@ -66,7 +67,7 @@ namespace Sass {
           // We should always get a list for rest arguments
           if (List_Obj rest = Cast<List>(a->value())) {
               // create a new list object for wrapped items
-              List_Ptr arglist = SASS_MEMORY_NEW(List,
+              List* arglist = SASS_MEMORY_NEW(List,
                                               p->pstate(),
                                               0,
                                               rest->separator(),
@@ -94,7 +95,7 @@ namespace Sass {
         } else if (a->is_keyword_argument()) {
 
           // expand keyword arguments into their parameters
-          List_Ptr arglist = SASS_MEMORY_NEW(List, p->pstate(), 0, SASS_COMMA, true);
+          List* arglist = SASS_MEMORY_NEW(List, p->pstate(), 0, SASS_COMMA, true);
           env->local_frame()[p->name()] = arglist;
           Map_Obj argmap = Cast<Map>(a->value());
           for (auto key : argmap->keys()) {
@@ -107,8 +108,8 @@ namespace Sass {
                                               false,
                                               false));
             } else {
-              eval->exp.traces.push_back(Backtrace(key->pstate()));
-              throw Exception::InvalidVarKwdType(key->pstate(), eval->exp.traces, key->inspect(), a);
+              traces.push_back(Backtrace(key->pstate()));
+              throw Exception::InvalidVarKwdType(key->pstate(), traces, key->inspect(), a);
             }
           }
 
@@ -203,7 +204,7 @@ namespace Sass {
         // otherwise move one of the rest args into the param, converting to argument if necessary
         Expression_Obj obj = arglist->at(0);
         if (!(a = Cast<Argument>(obj))) {
-          Expression_Ptr a_to_convert = obj;
+          Expression* a_to_convert = obj;
           a = SASS_MEMORY_NEW(Argument,
                               a_to_convert->pstate(),
                               a_to_convert,
@@ -220,17 +221,17 @@ namespace Sass {
         Map_Obj argmap = Cast<Map>(a->value());
 
         for (auto key : argmap->keys()) {
-          String_Constant_Ptr val = Cast<String_Constant>(key);
+          String_Constant* val = Cast<String_Constant>(key);
           if (val == NULL) {
-            eval->exp.traces.push_back(Backtrace(key->pstate()));
-            throw Exception::InvalidVarKwdType(key->pstate(), eval->exp.traces, key->inspect(), a);
+            traces.push_back(Backtrace(key->pstate()));
+            throw Exception::InvalidVarKwdType(key->pstate(), traces, key->inspect(), a);
           }
           std::string param = "$" + unquote(val->value());
 
           if (!param_map.count(param)) {
             std::stringstream msg;
             msg << callee << " has no parameter named " << param;
-            error(msg.str(), a->pstate(), eval->exp.traces);
+            error(msg.str(), a->pstate(), traces);
           }
           env->local_frame()[param] = argmap->at(key);
         }
@@ -245,7 +246,7 @@ namespace Sass {
           std::stringstream msg;
           msg << "parameter " << p->name()
           << " provided more than once in call to " << callee;
-          error(msg.str(), a->pstate(), eval->exp.traces);
+          error(msg.str(), a->pstate(), traces);
         }
         // ordinal arg -- bind it to the next param
         env->local_frame()[p->name()] = a->value();
@@ -259,7 +260,7 @@ namespace Sass {
           } else {
             std::stringstream msg;
             msg << callee << " has no parameter named " << a->name();
-            error(msg.str(), a->pstate(), eval->exp.traces);
+            error(msg.str(), a->pstate(), traces);
           }
         }
         if (param_map[a->name()]) {
@@ -267,14 +268,14 @@ namespace Sass {
             std::stringstream msg;
             msg << "argument " << a->name() << " of " << callee
                 << "cannot be used as named argument";
-            error(msg.str(), a->pstate(), eval->exp.traces);
+            error(msg.str(), a->pstate(), traces);
           }
         }
         if (env->has_local(a->name())) {
           std::stringstream msg;
           msg << "parameter " << p->name()
               << "provided more than once in call to " << callee;
-          error(msg.str(), a->pstate(), eval->exp.traces);
+          error(msg.str(), a->pstate(), traces);
         }
         env->local_frame()[a->name()] = a->value();
       }
@@ -294,12 +295,12 @@ namespace Sass {
           env->local_frame()[leftover->name()] = varargs;
         }
         else if (leftover->default_value()) {
-          Expression_Ptr dv = leftover->default_value()->perform(eval);
+          Expression* dv = leftover->default_value()->perform(eval);
           env->local_frame()[leftover->name()] = dv;
         }
         else {
           // param is unbound and has no default value -- error
-          throw Exception::MissingArgument(as->pstate(), eval->exp.traces, name, leftover->name(), type);
+          throw Exception::MissingArgument(as->pstate(), traces, name, leftover->name(), type);
         }
       }
     }

data/ext/libsass/src/bind.hpp

@@ -2,12 +2,14 @@
 #define SASS_BIND_H
 
 #include <string>
+#include "backtrace.hpp"
 #include "environment.hpp"
 #include "ast_fwd_decl.hpp"
 
 namespace Sass {
 
-  void bind(std::string type, std::string name, Parameters_Obj, Arguments_Obj, Context*, Env*, Eval*);
+  void bind(std::string type, std::string name, Parameters_Obj, Arguments_Obj, Env*, Eval*, Backtraces& traces);
+
 }
 
 #endif

data/ext/libsass/src/c2ast.cpp

@@ -0,0 +1,64 @@
+#include "ast.hpp"
+#include "units.hpp"
+#include "position.hpp"
+#include "backtrace.hpp"
+#include "sass/values.h"
+#include "ast_fwd_decl.hpp"
+#include "error_handling.hpp"
+
+namespace Sass {
+
+  Value* c2ast(union Sass_Value* v, Backtraces traces, ParserState pstate)
+  {
+    using std::strlen;
+    using std::strcpy;
+    Value* e = NULL;
+    switch (sass_value_get_tag(v)) {
+      case SASS_BOOLEAN: {
+        e = SASS_MEMORY_NEW(Boolean, pstate, !!sass_boolean_get_value(v));
+      } break;
+      case SASS_NUMBER: {
+        e = SASS_MEMORY_NEW(Number, pstate, sass_number_get_value(v), sass_number_get_unit(v));
+      } break;
+      case SASS_COLOR: {
+        e = SASS_MEMORY_NEW(Color_RGBA, pstate, sass_color_get_r(v), sass_color_get_g(v), sass_color_get_b(v), sass_color_get_a(v));
+      } break;
+      case SASS_STRING: {
+        if (sass_string_is_quoted(v))
+          e = SASS_MEMORY_NEW(String_Quoted, pstate, sass_string_get_value(v));
+        else {
+          e = SASS_MEMORY_NEW(String_Constant, pstate, sass_string_get_value(v));
+        }
+      } break;
+      case SASS_LIST: {
+        List* l = SASS_MEMORY_NEW(List, pstate, sass_list_get_length(v), sass_list_get_separator(v));
+        for (size_t i = 0, L = sass_list_get_length(v); i < L; ++i) {
+          l->append(c2ast(sass_list_get_value(v, i), traces, pstate));
+        }
+        l->is_bracketed(sass_list_get_is_bracketed(v));
+        e = l;
+      } break;
+      case SASS_MAP: {
+        Map* m = SASS_MEMORY_NEW(Map, pstate);
+        for (size_t i = 0, L = sass_map_get_length(v); i < L; ++i) {
+          *m << std::make_pair(
+            c2ast(sass_map_get_key(v, i), traces, pstate),
+            c2ast(sass_map_get_value(v, i), traces, pstate));
+        }
+        e = m;
+      } break;
+      case SASS_NULL: {
+        e = SASS_MEMORY_NEW(Null, pstate);
+      } break;
+      case SASS_ERROR: {
+        error("Error in C function: " + std::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);
+      } break;
+      default: break;
+    }
+    return e;
+  }
+
+}

data/ext/libsass/src/c2ast.hpp

@@ -0,0 +1,14 @@
+#ifndef SASS_C2AST_H
+#define SASS_C2AST_H
+
+#include "position.hpp"
+#include "backtrace.hpp"
+#include "ast_fwd_decl.hpp"
+
+namespace Sass {
+
+  Value* c2ast(union Sass_Value* v, Backtraces traces, ParserState pstate);
+
+}
+
+#endif

data/ext/libsass/src/cencode.c

@@ -47,7 +47,7 @@ int base64_encode_block(const char* plaintext_in, int length_in, char* code_out,
 			*codechar++ = base64_encode_value(result);
 			result = (fragment & 0x003) << 4;
 			#ifndef _MSC_VER
-				__attribute__ ((fallthrough));
+				/* fall through */
 			#endif
 	case step_B:
 			if (plainchar == plaintextend)
@@ -61,7 +61,7 @@ int base64_encode_block(const char* plaintext_in, int length_in, char* code_out,
 			*codechar++ = base64_encode_value(result);
 			result = (fragment & 0x00f) << 2;
 			#ifndef _MSC_VER
-				__attribute__ ((fallthrough));
+				/* fall through */
 			#endif
 	case step_C:
 			if (plainchar == plaintextend)

data/ext/libsass/src/check_nesting.cpp

@@ -1,4 +1,7 @@
+// sass.hpp must go before all system headers to get the
+// __EXTENSIONS__ fix on Solaris.
 #include "sass.hpp"
+
 #include <vector>
 
 #include "check_nesting.hpp"
@@ -6,26 +9,26 @@
 namespace Sass {
 
   CheckNesting::CheckNesting()
-  : parents(std::vector<Statement_Ptr>()),
+  : parents(std::vector<Statement*>()),
     traces(std::vector<Backtrace>()),
     parent(0), current_mixin_definition(0)
   { }
 
-  void error(AST_Node_Ptr node, Backtraces traces, std::string msg) {
+  void error(AST_Node* 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* CheckNesting::visit_children(Statement* parent)
   {
-    Statement_Ptr old_parent = this->parent;
+    Statement* old_parent = this->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;
+    if (At_Root_Block* root = Cast<At_Root_Block>(parent)) {
+      std::vector<Statement*> old_parents = this->parents;
+      std::vector<Statement*> new_parents;
 
       for (size_t i = 0, L = this->parents.size(); i < L; i++) {
-        Statement_Ptr p = this->parents.at(i);
+        Statement* p = this->parents.at(i);
         if (!root->exclude_node(p)) {
           new_parents.push_back(p);
         }
@@ -33,8 +36,8 @@ namespace Sass {
       this->parents = new_parents;
 
       for (size_t i = this->parents.size(); i > 0; i--) {
-        Statement_Ptr p = 0;
-        Statement_Ptr gp = 0;
+        Statement* p = 0;
+        Statement* gp = 0;
         if (i > 0) p = this->parents.at(i - 1);
         if (i > 1) gp = this->parents.at(i - 2);
 
@@ -44,8 +47,8 @@ namespace Sass {
         }
       }
 
-      At_Root_Block_Ptr ar = Cast<At_Root_Block>(parent);
-      Block_Ptr ret = ar->block();
+      At_Root_Block* ar = Cast<At_Root_Block>(parent);
+      Block* ret = ar->block();
 
       if (ret != NULL) {
         for (auto n : ret->elements()) {
@@ -65,16 +68,16 @@ namespace Sass {
 
     this->parents.push_back(parent);
 
-    Block_Ptr b = Cast<Block>(parent);
+    Block* b = Cast<Block>(parent);
 
-    if (Trace_Ptr trace = Cast<Trace>(parent)) {
+    if (Trace* trace = Cast<Trace>(parent)) {
       if (trace->type() == 'i') {
         this->traces.push_back(Backtrace(trace->pstate()));
       }
     }
 
     if (!b) {
-      if (Has_Block_Ptr bb = Cast<Has_Block>(parent)) {
+      if (Has_Block* bb = Cast<Has_Block>(parent)) {
         b = bb->block();
       }
     }
@@ -88,7 +91,7 @@ namespace Sass {
     this->parent = old_parent;
     this->parents.pop_back();
 
-    if (Trace_Ptr trace = Cast<Trace>(parent)) {
+    if (Trace* trace = Cast<Trace>(parent)) {
       if (trace->type() == 'i') {
         this->traces.pop_back();
       }
@@ -98,12 +101,12 @@ namespace Sass {
   }
 
 
-  Statement_Ptr CheckNesting::operator()(Block_Ptr b)
+  Statement* CheckNesting::operator()(Block* b)
   {
     return this->visit_children(b);
   }
 
-  Statement_Ptr CheckNesting::operator()(Definition_Ptr n)
+  Statement* CheckNesting::operator()(Definition* n)
   {
     if (!this->should_visit(n)) return NULL;
     if (!is_mixin(n)) {
@@ -111,7 +114,7 @@ namespace Sass {
       return n;
     }
 
-    Definition_Ptr old_mixin_definition = this->current_mixin_definition;
+    Definition* old_mixin_definition = this->current_mixin_definition;
     this->current_mixin_definition = n;
 
     visit_children(n);
@@ -121,25 +124,18 @@ namespace Sass {
     return n;
   }
 
-  Statement_Ptr CheckNesting::operator()(If_Ptr i)
+  Statement* CheckNesting::operator()(If* i)
   {
     this->visit_children(i);
 
-    if (Block_Ptr b = Cast<Block>(i->alternative())) {
+    if (Block* 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 = Cast<Block>(s);
-    Has_Block_Ptr b2 = Cast<Has_Block>(s);
-    return b1 || b2 ? visit_children(s) : s;
-  }
-
-  bool CheckNesting::should_visit(Statement_Ptr node)
+  bool CheckNesting::should_visit(Statement* node)
   {
     if (!this->parent) return true;
 
@@ -164,7 +160,7 @@ namespace Sass {
     if (this->is_function(this->parent))
     { this->invalid_function_child(node); }
 
-    if (Declaration_Ptr d = Cast<Declaration>(node))
+    if (Declaration* d = Cast<Declaration>(node))
     {
       this->invalid_prop_parent(this->parent, node);
       this->invalid_value_child(d->value());
@@ -179,14 +175,14 @@ namespace Sass {
     return true;
   }
 
-  void CheckNesting::invalid_content_parent(Statement_Ptr parent, AST_Node_Ptr node)
+  void CheckNesting::invalid_content_parent(Statement* parent, AST_Node* node)
   {
     if (!this->current_mixin_definition) {
       error(node, traces, "@content may only be used within a mixin.");
     }
   }
 
-  void CheckNesting::invalid_charset_parent(Statement_Ptr parent, AST_Node_Ptr node)
+  void CheckNesting::invalid_charset_parent(Statement* parent, AST_Node* node)
   {
     if (!(
         is_root_node(parent)
@@ -195,7 +191,7 @@ namespace Sass {
     }
   }
 
-  void CheckNesting::invalid_extend_parent(Statement_Ptr parent, AST_Node_Ptr node)
+  void CheckNesting::invalid_extend_parent(Statement* parent, AST_Node* node)
   {
     if (!(
         Cast<Ruleset>(parent) ||
@@ -206,7 +202,7 @@ namespace Sass {
     }
   }
 
-  // void CheckNesting::invalid_import_parent(Statement_Ptr parent, AST_Node_Ptr node)
+  // void CheckNesting::invalid_import_parent(Statement* parent, AST_Node* node)
   // {
   //   for (auto pp : this->parents) {
   //     if (
@@ -231,9 +227,9 @@ namespace Sass {
   //   }
   // }
 
-  void CheckNesting::invalid_mixin_definition_parent(Statement_Ptr parent, AST_Node_Ptr node)
+  void CheckNesting::invalid_mixin_definition_parent(Statement* parent, AST_Node* node)
   {
-    for (Statement_Ptr pp : this->parents) {
+    for (Statement* pp : this->parents) {
       if (
           Cast<Each>(pp) ||
           Cast<For>(pp) ||
@@ -248,9 +244,9 @@ namespace Sass {
     }
   }
 
-  void CheckNesting::invalid_function_parent(Statement_Ptr parent, AST_Node_Ptr node)
+  void CheckNesting::invalid_function_parent(Statement* parent, AST_Node* node)
   {
-    for (Statement_Ptr pp : this->parents) {
+    for (Statement* pp : this->parents) {
       if (
           Cast<Each>(pp) ||
           Cast<For>(pp) ||
@@ -265,7 +261,7 @@ namespace Sass {
     }
   }
 
-  void CheckNesting::invalid_function_child(Statement_Ptr child)
+  void CheckNesting::invalid_function_child(Statement* child)
   {
     if (!(
         Cast<Each>(child) ||
@@ -286,7 +282,7 @@ namespace Sass {
     }
   }
 
-  void CheckNesting::invalid_prop_child(Statement_Ptr child)
+  void CheckNesting::invalid_prop_child(Statement* child)
   {
     if (!(
         Cast<Each>(child) ||
@@ -302,7 +298,7 @@ namespace Sass {
     }
   }
 
-  void CheckNesting::invalid_prop_parent(Statement_Ptr parent, AST_Node_Ptr node)
+  void CheckNesting::invalid_prop_parent(Statement* parent, AST_Node* node)
   {
     if (!(
         is_mixin(parent) ||
@@ -316,13 +312,13 @@ namespace Sass {
     }
   }
 
-  void CheckNesting::invalid_value_child(AST_Node_Ptr d)
+  void CheckNesting::invalid_value_child(AST_Node* d)
   {
-    if (Map_Ptr m = Cast<Map>(d)) {
+    if (Map* m = Cast<Map>(d)) {
       traces.push_back(Backtrace(m->pstate()));
       throw Exception::InvalidValue(traces, *m);
     }
-    if (Number_Ptr n = Cast<Number>(d)) {
+    if (Number* n = Cast<Number>(d)) {
       if (!n->is_valid_css_unit()) {
         traces.push_back(Backtrace(n->pstate()));
         throw Exception::InvalidValue(traces, *n);
@@ -333,14 +329,14 @@ namespace Sass {
 
   }
 
-  void CheckNesting::invalid_return_parent(Statement_Ptr parent, AST_Node_Ptr node)
+  void CheckNesting::invalid_return_parent(Statement* parent, AST_Node* node)
   {
     if (!this->is_function(parent)) {
       error(node, traces, "@return may only be used within a function.");
     }
   }
 
-  bool CheckNesting::is_transparent_parent(Statement_Ptr parent, Statement_Ptr grandparent)
+  bool CheckNesting::is_transparent_parent(Statement* parent, Statement* grandparent)
   {
     bool parent_bubbles = parent && parent->bubbles();
 
@@ -357,38 +353,38 @@ namespace Sass {
            valid_bubble_node;
   }
 
-  bool CheckNesting::is_charset(Statement_Ptr n)
+  bool CheckNesting::is_charset(Statement* n)
   {
-    Directive_Ptr d = Cast<Directive>(n);
+    Directive* d = Cast<Directive>(n);
     return d && d->keyword() == "charset";
   }
 
-  bool CheckNesting::is_mixin(Statement_Ptr n)
+  bool CheckNesting::is_mixin(Statement* n)
   {
-    Definition_Ptr def = Cast<Definition>(n);
+    Definition* def = Cast<Definition>(n);
     return def && def->type() == Definition::MIXIN;
   }
 
-  bool CheckNesting::is_function(Statement_Ptr n)
+  bool CheckNesting::is_function(Statement* n)
   {
-    Definition_Ptr def = Cast<Definition>(n);
+    Definition* def = Cast<Definition>(n);
     return def && def->type() == Definition::FUNCTION;
   }
 
-  bool CheckNesting::is_root_node(Statement_Ptr n)
+  bool CheckNesting::is_root_node(Statement* n)
   {
     if (Cast<Ruleset>(n)) return false;
 
-    Block_Ptr b = Cast<Block>(n);
+    Block* b = Cast<Block>(n);
     return b && b->is_root();
   }
 
-  bool CheckNesting::is_at_root_node(Statement_Ptr n)
+  bool CheckNesting::is_at_root_node(Statement* n)
   {
     return Cast<At_Root_Block>(n) != NULL;
   }
 
-  bool CheckNesting::is_directive_node(Statement_Ptr n)
+  bool CheckNesting::is_directive_node(Statement* n)
   {
     return Cast<Directive>(n) ||
            Cast<Import>(n) ||