sassc 1.11.4 → 1.12.0

data/ext/libsass/src/ast_def_macros.hpp

@@ -19,12 +19,21 @@ class LocalOption {
       this->orig = var;
       *(this->var) = orig;
     }
+    void reset()
+    {
+      *(this->var) = this->orig;
+    }
     ~LocalOption() {
       *(this->var) = this->orig;
     }
 };
 
 #define LOCAL_FLAG(name,opt) LocalOption<bool> flag_##name(name, opt)
+#define LOCAL_COUNT(name,opt) LocalOption<size_t> cnt_##name(name, opt)
+
+#define NESTING_GUARD(name) \
+  LocalOption<size_t> cnt_##name(name, name + 1); \
+  if (name > MAX_NESTING) throw Exception::NestingLimitError(pstate, traces); \
 
 #define ATTACH_OPERATIONS()\
 virtual void perform(Operation<void>* op) { (*op)(this); }\
@@ -44,7 +53,7 @@ public:\
   type name(type name##__) { return name##_ = name##__; }\
 private:
 
-#define ADD_HASHED(type, name)\
+#define HASH_PROPERTY(type, name)\
 protected:\
   type name##_;\
 public:\
@@ -52,4 +61,20 @@ public:\
   type name(type name##__) { hash_ = 0; return name##_ = name##__; }\
 private:
 
+#define ADD_CONSTREF(type, name) \
+protected: \
+  type name##_; \
+public: \
+  const type& name() const { return name##_; } \
+  void name(type name##__) { name##_ = name##__; } \
+private:
+
+#define HASH_CONSTREF(type, name) \
+protected: \
+  type name##_; \
+public: \
+  const type& name() const { return name##_; } \
+  void name(type name##__) { hash_ = 0; name##_ = name##__; } \
+private:
+
 #endif

data/ext/libsass/src/ast_fwd_decl.cpp

@@ -0,0 +1,29 @@
+#include "ast.hpp"
+
+namespace Sass {
+
+  #define IMPLEMENT_BASE_CAST(T) \
+  template<> \
+  T* Cast(AST_Node* ptr) { \
+    return dynamic_cast<T*>(ptr); \
+  }; \
+  \
+  template<> \
+  const T* Cast(const AST_Node* ptr) { \
+    return dynamic_cast<const T*>(ptr); \
+  }; \
+
+  IMPLEMENT_BASE_CAST(AST_Node)
+  IMPLEMENT_BASE_CAST(Expression)
+  IMPLEMENT_BASE_CAST(Statement)
+  IMPLEMENT_BASE_CAST(Has_Block)
+  IMPLEMENT_BASE_CAST(PreValue)
+  IMPLEMENT_BASE_CAST(Value)
+  IMPLEMENT_BASE_CAST(List)
+  IMPLEMENT_BASE_CAST(String)
+  IMPLEMENT_BASE_CAST(String_Constant)
+  IMPLEMENT_BASE_CAST(Supports_Condition)
+  IMPLEMENT_BASE_CAST(Selector)
+  IMPLEMENT_BASE_CAST(Simple_Selector)
+
+}

data/ext/libsass/src/ast_fwd_decl.hpp

@@ -1,12 +1,17 @@
 #ifndef SASS_AST_FWD_DECL_H
 #define SASS_AST_FWD_DECL_H
 
+#include <map>
+#include <set>
+#include <deque>
 #include <vector>
+#include <typeinfo>
 #include <iostream>
 #include <algorithm>
 #include <unordered_map>
 #include <unordered_set>
 #include "memory/SharedPtr.hpp"
+#include "sass/functions.h"
 
 /////////////////////////////////////////////
 // Forward declarations for the AST visitors.
@@ -128,6 +133,9 @@ namespace Sass {
   class Map;
   typedef Map* Map_Ptr;
   typedef Map const* Map_Ptr_Const;
+  class Function;
+  typedef Function* Function_Ptr;
+  typedef Function const* Function_Ptr_Const;
 
   class Mixin_Call;
   typedef Mixin_Call* Mixin_Call_Ptr;
@@ -154,9 +162,6 @@ namespace Sass {
   class Variable;
   typedef Variable* Variable_Ptr;
   typedef Variable const* Variable_Ptr_Const;
-  class Textual;
-  typedef Textual* Textual_Ptr;
-  typedef Textual const* Textual_Ptr_Const;
   class Number;
   typedef Number* Number_Ptr;
   typedef Number const* Number_Ptr_Const;
@@ -310,6 +315,7 @@ namespace Sass {
   IMPL_MEM_OBJ(Expression);
   IMPL_MEM_OBJ(List);
   IMPL_MEM_OBJ(Map);
+  IMPL_MEM_OBJ(Function);
   IMPL_MEM_OBJ(Binary_Expression);
   IMPL_MEM_OBJ(Unary_Expression);
   IMPL_MEM_OBJ(Function_Call);
@@ -317,7 +323,6 @@ namespace Sass {
   IMPL_MEM_OBJ(Custom_Warning);
   IMPL_MEM_OBJ(Custom_Error);
   IMPL_MEM_OBJ(Variable);
-  IMPL_MEM_OBJ(Textual);
   IMPL_MEM_OBJ(Number);
   IMPL_MEM_OBJ(Color);
   IMPL_MEM_OBJ(Boolean);
@@ -353,37 +358,105 @@ namespace Sass {
   IMPL_MEM_OBJ(Complex_Selector);
   IMPL_MEM_OBJ(Selector_List);
 
+  // ###########################################################################
+  // Implement compare, order and hashing operations for AST Nodes
+  // ###########################################################################
 
-  struct HashExpression {
-    size_t operator() (Expression_Obj ex) const;
+  struct HashNodes {
+    template <class T>
+    size_t operator() (const T& ex) const {
+      return ex.isNull() ? 0 : ex->hash();
+    }
   };
-  struct CompareExpression {
-    bool operator()(const Expression_Obj& lhs, const Expression_Obj& rhs) const;
+  struct OrderNodes {
+    template <class T>
+    bool operator() (const T& lhs, const T& rhs) const {
+      return !lhs.isNull() && !rhs.isNull() && *lhs < *rhs;
+    }
   };
-
-  struct HashSimpleSelector {
-    size_t operator() (Simple_Selector_Obj ex) const;
+  struct CompareNodes {
+    template <class T>
+    bool operator() (const T& lhs, const T& rhs) const {
+      // code around sass logic issue. 1px == 1 is true
+      // but both items are still different keys in maps
+      if (dynamic_cast<Number*>(lhs.ptr()))
+        if (dynamic_cast<Number*>(rhs.ptr()))
+          return lhs->hash() == rhs->hash();
+      return !lhs.isNull() && !rhs.isNull() && *lhs == *rhs;
+    }
   };
 
-  struct CompareSimpleSelector {
-    bool operator()(Simple_Selector_Obj lhs, Simple_Selector_Obj rhs) const;
-  };
+  // ###########################################################################
+  // some often used typedefs
+  // ###########################################################################
 
   typedef std::unordered_map<
     Expression_Obj, // key
     Expression_Obj, // value
-    HashExpression, // hasher
-    CompareExpression // compare
+    HashNodes, // hasher
+    CompareNodes // compare
   > ExpressionMap;
   typedef std::unordered_set<
     Expression_Obj, // value
-    HashExpression, // hasher
-    CompareExpression // compare
+    HashNodes, // hasher
+    CompareNodes // compare
   > ExpressionSet;
 
-  typedef std::string Subset_Map_Key;
-  typedef std::vector<size_t> Subset_Map_Arr;
-  typedef std::pair<Complex_Selector_Obj, Compound_Selector_Obj> Subset_Map_Val;
+  typedef std::string SubSetMapKey;
+  typedef std::vector<std::string> SubSetMapKeys;
+
+  typedef std::pair<Complex_Selector_Obj, Compound_Selector_Obj> SubSetMapPair;
+  typedef std::pair<Compound_Selector_Obj, Complex_Selector_Obj> SubSetMapLookup;
+  typedef std::vector<SubSetMapPair> SubSetMapPairs;
+  typedef std::vector<SubSetMapLookup> SubSetMapLookups;
+
+  typedef std::pair<Complex_Selector_Obj, SubSetMapPairs> SubSetMapResult;
+  typedef std::vector<SubSetMapResult> SubSetMapResults;
+
+  typedef std::deque<Complex_Selector_Obj> ComplexSelectorDeque;
+  typedef std::set<Simple_Selector_Obj, OrderNodes> SimpleSelectorSet;
+  typedef std::set<Complex_Selector_Obj, OrderNodes> ComplexSelectorSet;
+  typedef std::set<Compound_Selector_Obj, OrderNodes> CompoundSelectorSet;
+  typedef std::unordered_set<Simple_Selector_Obj, HashNodes, CompareNodes> SimpleSelectorDict;
+
+  typedef std::vector<Sass_Import_Entry>* ImporterStack;
+
+  // only to switch implementations for testing
+  #define environment_map std::map
+
+  // ###########################################################################
+  // explicit type conversion functions
+  // ###########################################################################
+
+  template<class T>
+  T* Cast(AST_Node* ptr);
+
+  template<class T>
+  const T* Cast(const AST_Node* ptr);
+
+  // sometimes you know the class you want to cast to is final
+  // in this case a simple typeid check is faster and safe to use
+
+  #define DECLARE_BASE_CAST(T) \
+  template<> T* Cast(AST_Node* ptr); \
+  template<> const T* Cast(const AST_Node* ptr); \
+
+  // ###########################################################################
+  // implement specialization for final classes
+  // ###########################################################################
+
+  DECLARE_BASE_CAST(AST_Node)
+  DECLARE_BASE_CAST(Expression)
+  DECLARE_BASE_CAST(Statement)
+  DECLARE_BASE_CAST(Has_Block)
+  DECLARE_BASE_CAST(PreValue)
+  DECLARE_BASE_CAST(Value)
+  DECLARE_BASE_CAST(List)
+  DECLARE_BASE_CAST(String)
+  DECLARE_BASE_CAST(String_Constant)
+  DECLARE_BASE_CAST(Supports_Condition)
+  DECLARE_BASE_CAST(Selector)
+  DECLARE_BASE_CAST(Simple_Selector)
 
 }
 

data/ext/libsass/src/b64/encode.h

@@ -24,7 +24,9 @@ namespace base64
 
 		encoder(int buffersize_in = BUFFERSIZE)
 		: _buffersize(buffersize_in)
-		{}
+		{
+			base64_init_encodestate(&_state);
+		}
 
 		int encode(char value_in)
 		{

data/ext/libsass/src/backtrace.cpp

@@ -0,0 +1,46 @@
+#include "backtrace.hpp"
+
+namespace Sass {
+
+  const std::string traces_to_string(Backtraces traces, std::string indent) {
+
+    std::stringstream ss;
+    std::string cwd(File::get_cwd());
+
+    bool first = true;
+    size_t i_beg = traces.size() - 1;
+    size_t i_end = std::string::npos;
+    for (size_t i = i_beg; i != i_end; i --) {
+
+      const Backtrace& trace = traces[i];
+
+      // make path relative to the current directory
+      std::string rel_path(File::abs2rel(trace.pstate.path, cwd, cwd));
+
+      // skip functions on error cases (unsure why ruby sass does this)
+      // if (trace.caller.substr(0, 6) == ", in f") continue;
+
+      if (first) {
+        ss << indent;
+        ss << "on line ";
+        ss << trace.pstate.line + 1;
+        ss << " of " << rel_path;
+        // ss << trace.caller;
+        first = false;
+      } else {
+        ss << trace.caller;
+        ss << std::endl;
+        ss << indent;
+        ss << "from line ";
+        ss << trace.pstate.line + 1;
+        ss << " of " << rel_path;
+      }
+
+    }
+
+    ss << std::endl;
+    return ss.str();
+
+  }
+
+};

data/ext/libsass/src/backtrace.hpp

@@ -1,75 +1,28 @@
 #ifndef SASS_BACKTRACE_H
 #define SASS_BACKTRACE_H
 
+#include <vector>
 #include <sstream>
-
 #include "file.hpp"
 #include "position.hpp"
 
 namespace Sass {
 
-
   struct Backtrace {
 
-    Backtrace*  parent;
     ParserState pstate;
-    std::string      caller;
+    std::string caller;
 
-    Backtrace(Backtrace* prn, ParserState pstate, std::string c)
-    : parent(prn),
-      pstate(pstate),
+    Backtrace(ParserState pstate, std::string c = "")
+    : pstate(pstate),
       caller(c)
     { }
 
-    std::string to_string(bool warning = false)
-    {
-      size_t i = -1;
-      std::stringstream ss;
-      std::string cwd(Sass::File::get_cwd());
-      Backtrace* this_point = this;
-
-      if (!warning) ss << std::endl << "Backtrace:";
-      // the first tracepoint (which is parent-less) is an empty placeholder
-      while (this_point->parent) {
-
-        // make path relative to the current directory
-        std::string rel_path(Sass::File::abs2rel(this_point->pstate.path, cwd, cwd));
-
-        if (warning) {
-          ss << std::endl
-             << "\t"
-             << (++i == 0 ? "on" : "from")
-             << " line "
-             << this_point->pstate.line + 1
-             << " of "
-             << rel_path;
-        } else {
-          ss << std::endl
-             << "\t"
-             << rel_path
-             << ":"
-             << this_point->pstate.line + 1
-             << this_point->parent->caller;
-        }
-
-        this_point = this_point->parent;
-      }
-
-      return ss.str();
-    }
+  };
 
-    size_t depth()
-    {
-      size_t d = 0;
-      Backtrace* p = parent;
-      while (p) {
-        ++d;
-        p = p->parent;
-      }
-      return d-1;
-    }
+  typedef std::vector<Backtrace> Backtraces;
 
-  };
+  const std::string traces_to_string(Backtraces traces, std::string indent = "\t");
 
 }
 

data/ext/libsass/src/bind.cpp

@@ -2,6 +2,7 @@
 #include "bind.hpp"
 #include "ast.hpp"
 #include "context.hpp"
+#include "expand.hpp"
 #include "eval.hpp"
 #include <map>
 #include <iostream>
@@ -14,9 +15,11 @@ namespace Sass {
     std::string callee(type + " " + name);
 
     std::map<std::string, Parameter_Obj> param_map;
+    List_Obj varargs = SASS_MEMORY_NEW(List, as->pstate());
+    varargs->is_arglist(true); // enable keyword size handling
 
     for (size_t i = 0, L = as->length(); i < L; ++i) {
-      if (auto str = SASS_MEMORY_CAST(String_Quoted, (*as)[i]->value())) {
+      if (auto str = Cast<String_Quoted>((*as)[i]->value())) {
         // force optional quotes (only if needed)
         if (str->quote_mark()) {
           str->quote_mark('*');
@@ -42,7 +45,7 @@ namespace Sass {
       if (ip >= LP) {
         // skip empty rest arguments
         if (a->is_rest_argument()) {
-          if (List_Obj l = SASS_MEMORY_CAST(List, a->value())) {
+          if (List_Obj l = Cast<List>(a->value())) {
             if (l->length() == 0) {
               ++ ia; continue;
             }
@@ -51,7 +54,7 @@ namespace Sass {
         std::stringstream msg;
         msg << "wrong number of arguments (" << LA << " for " << LP << ")";
         msg << " for `" << name << "'";
-        return error(msg.str(), as->pstate());
+        return error(msg.str(), as->pstate(), eval->exp.traces);
       }
       Parameter_Obj p = ps->at(ip);
 
@@ -61,7 +64,7 @@ namespace Sass {
         if (a->is_rest_argument()) {
 
           // We should always get a list for rest arguments
-          if (List_Obj rest = SASS_MEMORY_CAST(List, a->value())) {
+          if (List_Obj rest = Cast<List>(a->value())) {
               // create a new list object for wrapped items
               List_Ptr arglist = SASS_MEMORY_NEW(List,
                                               p->pstate(),
@@ -70,12 +73,12 @@ namespace Sass {
                                               true);
               // wrap each item from list as an argument
               for (Expression_Obj item : rest->elements()) {
-                if (Argument_Obj arg = SASS_MEMORY_CAST(Argument, item)) {
+                if (Argument_Obj arg = Cast<Argument>(item)) {
                   arglist->append(SASS_MEMORY_COPY(arg)); // copy
                 } else {
                   arglist->append(SASS_MEMORY_NEW(Argument,
                                                   item->pstate(),
-                                                  &item,
+                                                  item,
                                                   "",
                                                   false,
                                                   false));
@@ -93,15 +96,20 @@ namespace Sass {
           // expand keyword arguments into their parameters
           List_Ptr arglist = SASS_MEMORY_NEW(List, p->pstate(), 0, SASS_COMMA, true);
           env->local_frame()[p->name()] = arglist;
-          Map_Obj argmap = SASS_MEMORY_CAST(Map, a->value());
+          Map_Obj argmap = Cast<Map>(a->value());
           for (auto key : argmap->keys()) {
-            std::string name = unquote(SASS_MEMORY_CAST(String_Constant, key)->value());
-            arglist->append(SASS_MEMORY_NEW(Argument,
-                                            key->pstate(),
-                                            argmap->at(key),
-                                            "$" + name,
-                                            false,
-                                            false));
+            if (String_Constant_Obj str = Cast<String_Constant>(key)) {
+              std::string param = unquote(str->value());
+              arglist->append(SASS_MEMORY_NEW(Argument,
+                                              key->pstate(),
+                                              argmap->at(key),
+                                              "$" + param,
+                                              false,
+                                              false));
+            } else {
+              eval->exp.traces.push_back(Backtrace(key->pstate()));
+              throw Exception::InvalidVarKwdType(key->pstate(), eval->exp.traces, key->inspect(), a);
+            }
           }
 
         } else {
@@ -117,25 +125,25 @@ namespace Sass {
             // get and post inc
             a = (*as)[ia++];
             // maybe we have another list as argument
-            List_Obj ls = SASS_MEMORY_CAST(List, a->value());
+            List_Obj ls = Cast<List>(a->value());
             // skip any list completely if empty
             if (ls && ls->empty() && a->is_rest_argument()) continue;
 
             Expression_Obj value = a->value();
-            if (Argument_Obj arg = SASS_MEMORY_CAST(Argument, value)) {
-              arglist->append(&arg);
+            if (Argument_Obj arg = Cast<Argument>(value)) {
+              arglist->append(arg);
             }
             // check if we have rest argument
             else if (a->is_rest_argument()) {
               // preserve the list separator from rest args
-              if (List_Obj rest = SASS_MEMORY_CAST(List, a->value())) {
+              if (List_Obj rest = Cast<List>(a->value())) {
                 arglist->separator(rest->separator());
 
-                for (size_t i = 0, L = rest->size(); i < L; ++i) {
-                  Expression_Obj obj = rest->at(i);
+                for (size_t i = 0, L = rest->length(); i < L; ++i) {
+                  Expression_Obj obj = rest->value_at_index(i);
                   arglist->append(SASS_MEMORY_NEW(Argument,
                                                 obj->pstate(),
-                                                &obj,
+                                                obj,
                                                 "",
                                                 false,
                                                 false));
@@ -155,7 +163,7 @@ namespace Sass {
             }
           }
           // assign new arglist to environment
-          env->local_frame()[p->name()] = &arglist;
+          env->local_frame()[p->name()] = arglist;
         }
         // consumed parameter
         ++ip;
@@ -166,9 +174,16 @@ namespace Sass {
       // If the current argument is the rest argument, extract a value for processing
       else if (a->is_rest_argument()) {
         // normal param and rest arg
-        List_Obj arglist = SASS_MEMORY_CAST(List, a->value());
+        List_Obj arglist = Cast<List>(a->value());
+        if (!arglist) {
+          if (Expression_Obj arg = Cast<Expression>(a->value())) {
+            arglist = SASS_MEMORY_NEW(List, a->pstate(), 1);
+            arglist->append(arg);
+          }
+        }
+
         // empty rest arg - treat all args as default values
-        if (!arglist->length()) {
+        if (!arglist || !arglist->length()) {
           break;
         } else {
           if (arglist->length() > LP - ip && !ps->has_rest_parameter()) {
@@ -187,8 +202,8 @@ 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 = SASS_MEMORY_CAST(Argument, obj))) {
-          Expression_Ptr a_to_convert = &obj;
+        if (!(a = Cast<Argument>(obj))) {
+          Expression_Ptr a_to_convert = obj;
           a = SASS_MEMORY_NEW(Argument,
                               a_to_convert->pstate(),
                               a_to_convert,
@@ -202,17 +217,22 @@ namespace Sass {
         }
 
       } else if (a->is_keyword_argument()) {
-        Map_Obj argmap = SASS_MEMORY_CAST(Map, a->value());
+        Map_Obj argmap = Cast<Map>(a->value());
 
         for (auto key : argmap->keys()) {
-          std::string name = "$" + unquote(SASS_MEMORY_CAST(String_Constant, key)->value());
+          String_Constant_Ptr 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);
+          }
+          std::string param = "$" + unquote(val->value());
 
-          if (!param_map.count(name)) {
+          if (!param_map.count(param)) {
             std::stringstream msg;
-            msg << callee << " has no parameter named " << name;
-            error(msg.str(), a->pstate());
+            msg << callee << " has no parameter named " << param;
+            error(msg.str(), a->pstate(), eval->exp.traces);
           }
-          env->local_frame()[name] = &argmap->at(&key);
+          env->local_frame()[param] = argmap->at(key);
         }
         ++ia;
         continue;
@@ -225,32 +245,38 @@ namespace Sass {
           std::stringstream msg;
           msg << "parameter " << p->name()
           << " provided more than once in call to " << callee;
-          error(msg.str(), a->pstate());
+          error(msg.str(), a->pstate(), eval->exp.traces);
         }
         // ordinal arg -- bind it to the next param
-        env->local_frame()[p->name()] = &a->value();
+        env->local_frame()[p->name()] = a->value();
         ++ip;
       }
       else {
         // named arg -- bind it to the appropriately named param
         if (!param_map.count(a->name())) {
-          std::stringstream msg;
-          msg << callee << " has no parameter named " << a->name();
-          error(msg.str(), a->pstate());
+          if (ps->has_rest_parameter()) {
+            varargs->append(a);
+          } else {
+            std::stringstream msg;
+            msg << callee << " has no parameter named " << a->name();
+            error(msg.str(), a->pstate(), eval->exp.traces);
+          }
         }
-        if (param_map[a->name()]->is_rest_parameter()) {
-          std::stringstream msg;
-          msg << "argument " << a->name() << " of " << callee
-              << "cannot be used as named argument";
-          error(msg.str(), a->pstate());
+        if (param_map[a->name()]) {
+          if (param_map[a->name()]->is_rest_parameter()) {
+            std::stringstream msg;
+            msg << "argument " << a->name() << " of " << callee
+                << "cannot be used as named argument";
+            error(msg.str(), a->pstate(), eval->exp.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());
+          error(msg.str(), a->pstate(), eval->exp.traces);
         }
-        env->local_frame()[a->name()] = &a->value();
+        env->local_frame()[a->name()] = a->value();
       }
     }
     // EO while ia
@@ -265,11 +291,7 @@ namespace Sass {
       // cerr << "********" << endl;
       if (!env->has_local(leftover->name())) {
         if (leftover->is_rest_parameter()) {
-          env->local_frame()[leftover->name()] = SASS_MEMORY_NEW(List,
-                                                                   leftover->pstate(),
-                                                                   0,
-                                                                   SASS_COMMA,
-                                                                   true);
+          env->local_frame()[leftover->name()] = varargs;
         }
         else if (leftover->default_value()) {
           Expression_Ptr dv = leftover->default_value()->perform(eval);
@@ -277,7 +299,7 @@ namespace Sass {
         }
         else {
           // param is unbound and has no default value -- error
-          throw Exception::MissingArgument(as->pstate(), name, leftover->name(), type);
+          throw Exception::MissingArgument(as->pstate(), eval->exp.traces, name, leftover->name(), type);
         }
       }
     }