sassc 1.11.4 → 1.12.0

data/ext/libsass/src/lexer.cpp

@@ -1,6 +1,5 @@
 #include "sass.hpp"
 #include <cctype>
-#include <cstddef>
 #include <iostream>
 #include <iomanip>
 #include "lexer.hpp"
@@ -50,6 +49,12 @@ namespace Sass {
       return unsigned(chr - '0') <= '9' - '0';
     }
 
+    bool is_number(const char& chr)
+    {
+      // adapted the technique from is_alpha
+      return is_digit(chr) || chr == '-' || chr == '+';
+    }
+
     bool is_xdigit(const char& chr)
     {
       // adapted the technique from is_alpha
@@ -80,10 +85,11 @@ namespace Sass {
     // but with specific ranges (copied from Ruby Sass)
     bool is_nonascii(const char& chr)
     {
+      unsigned int cmp = unsigned(chr);
       return (
-        (unsigned(chr) >= 128 && unsigned(chr) <= 15572911) ||
-        (unsigned(chr) >= 15630464 && unsigned(chr) <= 15712189) ||
-        (unsigned(chr) >= 4036001920)
+        (cmp >= 128 && cmp <= 15572911) ||
+        (cmp >= 15630464 && cmp <= 15712189) ||
+        (cmp >= 4036001920)
       );
     }
 
@@ -91,15 +97,17 @@ namespace Sass {
     // valid in a uri (copied from Ruby Sass)
     bool is_uri_character(const char& chr)
     {
-      return (unsigned(chr) > 41 && unsigned(chr) < 127) ||
-             unsigned(chr) == ':' || unsigned(chr) == '/';
+      unsigned int cmp = unsigned(chr);
+      return (cmp > 41 && cmp < 127) ||
+             cmp == ':' || cmp == '/';
     }
 
     // check if char is within a reduced ascii range
     // valid for escaping (copied from Ruby Sass)
     bool is_escapable_character(const char& chr)
     {
-      return unsigned(chr) > 31 && unsigned(chr) < 127;
+      unsigned int cmp = unsigned(chr);
+      return cmp > 31 && cmp < 127;
     }
 
     // Match word character (look ahead)

data/ext/libsass/src/lexer.hpp

@@ -29,6 +29,7 @@ namespace Sass {
     bool is_alpha(const char& src);
     bool is_punct(const char& src);
     bool is_digit(const char& src);
+    bool is_number(const char& src);
     bool is_alnum(const char& src);
     bool is_xdigit(const char& src);
     bool is_unicode(const char& src);
@@ -96,9 +97,9 @@ namespace Sass {
     // Regex equivalent: /(?:literal)/
     template <const char* str>
     const char* exactly(const char* src) {
-      if (str == 0) return 0;
+      if (str == NULL) return 0;
       const char* pre = str;
-      if (src == 0) return 0;
+      if (src == NULL) return 0;
       // there is a small chance that the search string
       // is longer than the rest of the string to look at
       while (*pre && *src == *pre) {
@@ -109,14 +110,22 @@ namespace Sass {
     }
 
 
+    // Match a single character literal.
+    // Regex equivalent: /(?:x)/i
+    // only define lower case alpha chars
+    template <char chr>
+    const char* insensitive(const char* src) {
+      return *src == chr || *src+32 == chr ? src + 1 : 0;
+    }
+
     // Match the full string literal.
     // Regex equivalent: /(?:literal)/i
     // only define lower case alpha chars
     template <const char* str>
     const char* insensitive(const char* src) {
-      if (str == 0) return 0;
+      if (str == NULL) return 0;
       const char* pre = str;
-      if (src == 0) return 0;
+      if (src == NULL) return 0;
       // there is a small chance that the search string
       // is longer than the rest of the string to look at
       while (*pre && (*src == *pre || *src+32 == *pre)) {

data/ext/libsass/src/listize.cpp

@@ -64,13 +64,14 @@ namespace Sass {
       break;
       case Complex_Selector::ANCESTOR_OF:
       break;
+      default: break;
     }
 
     Complex_Selector_Obj tail = sel->tail();
     if (tail)
     {
       Expression_Obj tt = tail->perform(this);
-      if (List_Ptr ls = SASS_MEMORY_CAST(List, tt))
+      if (List_Ptr ls = Cast<List>(tt))
       { l->concat(ls); }
     }
     if (l->length() == 0) return 0;
@@ -79,7 +80,7 @@ namespace Sass {
 
   Expression_Ptr Listize::fallback_impl(AST_Node_Ptr n)
   {
-    return dynamic_cast<Expression_Ptr>(n);
+    return Cast<Expression>(n);
   }
 
 }

data/ext/libsass/src/listize.hpp

@@ -11,7 +11,6 @@
 
 namespace Sass {
 
-  typedef Environment<AST_Node_Obj> Env;
   struct Backtrace;
 
   class Listize : public Operation_CRTP<Expression_Ptr, Listize> {

data/ext/libsass/src/memory/SharedPtr.cpp

@@ -17,8 +17,8 @@ namespace Sass {
       std::cerr << "###################################\n";
       std::cerr << "# REPORTING MISSING DEALLOCATIONS #\n";
       std::cerr << "###################################\n";
-      for (auto var : all) {
-        if (AST_Node_Ptr ast = SASS_MEMORY_CAST_PTR(AST_Node, var)) {
+      for (SharedObj* var : all) {
+        if (AST_Node_Ptr ast = dynamic_cast<AST_Node*>(var)) {
           debug_ast(ast);
         } else {
           std::cerr << "LEAKED " << var << "\n";
@@ -37,22 +37,20 @@ namespace Sass {
     , dbg(false)
     #endif
   {
-      refcounter = 0;
-      #ifdef DEBUG_SHARED_PTR
-        if (taint) all.push_back(this);
-      #endif
-    };
-
-    SharedObj::~SharedObj() {
-      #ifdef DEBUG_SHARED_PTR
-          if (dbg) std::cerr << "Destruct " << this << "\n";
-          if(!all.empty()) { // check needed for MSVC (no clue why?)
-            all.erase(std::remove(all.begin(), all.end(), this), all.end());
-          }
-      #endif
-    };
-
+    refcounter = 0;
+    #ifdef DEBUG_SHARED_PTR
+      if (taint) all.push_back(this);
+    #endif
+  };
 
+  SharedObj::~SharedObj() {
+    #ifdef DEBUG_SHARED_PTR
+      if (dbg) std::cerr << "Destruct " << this << "\n";
+      if(!all.empty()) { // check needed for MSVC (no clue why?)
+        all.erase(std::remove(all.begin(), all.end(), this), all.end());
+      }
+    #endif
+  };
 
   void SharedPtr::decRefCount() {
     if (node) {
@@ -62,7 +60,7 @@ namespace Sass {
       #endif
       if (node->refcounter == 0) {
         #ifdef DEBUG_SHARED_PTR
-          AST_Node_Ptr ptr = SASS_MEMORY_CAST_PTR(AST_Node, node);
+          // AST_Node_Ptr ast = dynamic_cast<AST_Node*>(node);
           if (node->dbg) std::cerr << "DELETE NODE " << node << "\n";
         #endif
         if (!node->detached) {

data/ext/libsass/src/memory/SharedPtr.hpp

@@ -17,7 +17,7 @@ namespace Sass {
   #ifdef DEBUG_SHARED_PTR
 
     #define SASS_MEMORY_NEW(Class, ...) \
-      static_cast<Class##_Ptr>((new Class(__VA_ARGS__))->trace(__FILE__, __LINE__)) \
+      ((Class*)(new Class(__VA_ARGS__))->trace(__FILE__, __LINE__)) \
 
     #define SASS_MEMORY_COPY(obj) \
       ((obj)->copy(__FILE__, __LINE__)) \
@@ -38,12 +38,6 @@ namespace Sass {
 
   #endif
 
-  #define SASS_MEMORY_CAST(Class, obj) \
-    (dynamic_cast<Class##_Ptr>(&obj)) \
-
-  #define SASS_MEMORY_CAST_PTR(Class, ptr) \
-    (dynamic_cast<Class##_Ptr>(ptr)) \
-
   class SharedObj {
   protected:
   friend class SharedPtr;
@@ -92,9 +86,9 @@ namespace Sass {
 
 
   class SharedPtr {
-  private:
+  protected:
     SharedObj* node;
-  private:
+  protected:
     void decRefCount();
     void incRefCount();
   public:
@@ -103,24 +97,21 @@ namespace Sass {
     : node(NULL) {};
     // the create constructor
     SharedPtr(SharedObj* ptr);
-    // copy assignment operator
-    SharedPtr& operator=(const SharedPtr& rhs);
-    // move assignment operator
-    /* SharedPtr& operator=(SharedPtr&& rhs); */
     // the copy constructor
     SharedPtr(const SharedPtr& obj);
     // the move constructor
-    /* SharedPtr(SharedPtr&& obj); */
-    // destructor
-    ~SharedPtr();
+    SharedPtr(SharedPtr&& obj);
+    // copy assignment operator
+    SharedPtr& operator=(const SharedPtr& obj);
+    // move assignment operator
+    SharedPtr& operator=(SharedPtr&& obj);
+    // pure virtual destructor
+    virtual ~SharedPtr() = 0;
   public:
-    SharedObj* obj () {
-      return node;
-    };
     SharedObj* obj () const {
       return node;
     };
-    SharedObj* operator-> () {
+    SharedObj* operator-> () const {
       return node;
     };
     bool isNull () {
@@ -129,68 +120,81 @@ namespace Sass {
     bool isNull () const {
       return node == NULL;
     };
-    SharedObj* detach() {
-      node->detached = true;
-      return node;
-    };
     SharedObj* detach() const {
       if (node) {
         node->detached = true;
       }
       return node;
     };
-    operator bool() {
-      return node != NULL;
-    };
     operator bool() const {
       return node != NULL;
     };
 
   };
 
-  template < typename T >
+  template < class T >
   class SharedImpl : private SharedPtr {
   public:
     SharedImpl()
     : SharedPtr(NULL) {};
     SharedImpl(T* node)
     : SharedPtr(node) {};
+    template < class U >
+    SharedImpl(SharedImpl<U> obj)
+    : SharedPtr(static_cast<T*>(obj.ptr())) {}
     SharedImpl(T&& node)
     : SharedPtr(node) {};
     SharedImpl(const T& node)
     : SharedPtr(node) {};
+    // the copy constructor
+    SharedImpl(const SharedImpl<T>& impl)
+    : SharedPtr(impl.node) {};
+    // the move constructor
+    SharedImpl(SharedImpl<T>&& impl)
+    : SharedPtr(impl.node) {};
+    // copy assignment operator
+    SharedImpl<T>& operator=(const SharedImpl<T>& rhs) {
+      if (node) decRefCount();
+      node = rhs.node;
+      incRefCount();
+      return *this;
+    }
+    // move assignment operator
+    SharedImpl<T>& operator=(SharedImpl<T>&& rhs) {
+      // don't move our self
+      if (this != &rhs) {
+        if (node) decRefCount();
+        node = std::move(rhs.node);
+        rhs.node = NULL;
+      }
+      return *this;
+    }
     ~SharedImpl() {};
   public:
-    T* operator& () {
-      return static_cast<T*>(this->obj());
-    };
-    T* operator& () const {
+    operator T*() const {
       return static_cast<T*>(this->obj());
-    };
-    T& operator* () {
+    }
+    operator T&() const {
       return *static_cast<T*>(this->obj());
-    };
+    }
     T& operator* () const {
       return *static_cast<T*>(this->obj());
     };
-    T* operator-> () {
-      return static_cast<T*>(this->obj());
-    };
     T* operator-> () const {
       return static_cast<T*>(this->obj());
     };
-    T* ptr () {
+    T* ptr () const {
       return static_cast<T*>(this->obj());
     };
-    T* detach() {
+    T* detach() const {
       if (this->obj() == NULL) return NULL;
       return static_cast<T*>(SharedPtr::detach());
     }
-    bool isNull() {
+    bool isNull() const {
       return this->obj() == NULL;
     }
-    operator bool() {
-      return this->obj() != NULL;
+    bool operator<(const T& rhs) const {
+      return *this->ptr() < rhs;
     };
     operator bool() const {
       return this->obj() != NULL;

data/ext/libsass/src/node.cpp

@@ -14,15 +14,15 @@ namespace Sass {
   }
 
 
-  Node Node::createSelector(Complex_Selector_Ptr pSelector, Context& ctx) {
+  Node Node::createSelector(const Complex_Selector& pSelector) {
     NodeDequePtr null;
 
-    Complex_Selector_Ptr pStripped = SASS_MEMORY_COPY(pSelector);
+    Complex_Selector_Ptr pStripped = SASS_MEMORY_COPY(&pSelector);
     pStripped->tail(NULL);
     pStripped->combinator(Complex_Selector::ANCESTOR_OF);
 
     Node n(SELECTOR, Complex_Selector::ANCESTOR_OF, pStripped, null /*pCollection*/);
-    if (pSelector) n.got_line_feed = pSelector->has_line_feed();
+    n.got_line_feed = pSelector.has_line_feed();
     return n;
   }
 
@@ -50,12 +50,12 @@ namespace Sass {
   { if (pSelector) got_line_feed = pSelector->has_line_feed(); }
 
 
-  Node Node::klone(Context& ctx) const {
+  Node Node::klone() const {
     NodeDequePtr pNewCollection = std::make_shared<NodeDeque>();
     if (mpCollection) {
       for (NodeDeque::iterator iter = mpCollection->begin(), iterEnd = mpCollection->end(); iter != iterEnd; iter++) {
         Node& toClone = *iter;
-        pNewCollection->push_back(toClone.klone(ctx));
+        pNewCollection->push_back(toClone.klone());
       }
     }
 
@@ -65,13 +65,13 @@ namespace Sass {
   }
 
 
-  bool Node::contains(const Node& potentialChild, bool simpleSelectorOrderDependent) const {
-  	bool found = false;
+  bool Node::contains(const Node& potentialChild) const {
+    bool found = false;
 
     for (NodeDeque::iterator iter = mpCollection->begin(), iterEnd = mpCollection->end(); iter != iterEnd; iter++) {
       Node& toTest = *iter;
 
-      if (nodesEqual(toTest, potentialChild, simpleSelectorOrderDependent)) {
+      if (toTest == potentialChild) {
         found = true;
         break;
       }
@@ -82,37 +82,32 @@ namespace Sass {
 
 
   bool Node::operator==(const Node& rhs) const {
-  	return nodesEqual(*this, rhs, true /*simpleSelectorOrderDependent*/);
-  }
-
-
-  bool nodesEqual(const Node& lhs, const Node& rhs, bool simpleSelectorOrderDependent) {
-    if (lhs.type() != rhs.type()) {
+    if (this->type() != rhs.type()) {
       return false;
     }
 
-    if (lhs.isCombinator()) {
+    if (this->isCombinator()) {
 
-    	return lhs.combinator() == rhs.combinator();
+      return this->combinator() == rhs.combinator();
 
-    } else if (lhs.isNil()) {
+    } else if (this->isNil()) {
 
       return true; // no state to check
 
-    } else if (lhs.isSelector()){
+    } else if (this->isSelector()){
 
-      return selectors_equal(*&lhs.selector(), *&rhs.selector(), simpleSelectorOrderDependent);
+      return *this->selector() == *rhs.selector();
 
-    } else if (lhs.isCollection()) {
+    } else if (this->isCollection()) {
 
-      if (lhs.collection()->size() != rhs.collection()->size()) {
+      if (this->collection()->size() != rhs.collection()->size()) {
         return false;
       }
 
-      for (NodeDeque::iterator lhsIter = lhs.collection()->begin(), lhsIterEnd = lhs.collection()->end(),
+      for (NodeDeque::iterator lhsIter = this->collection()->begin(), lhsIterEnd = this->collection()->end(),
            rhsIter = rhs.collection()->begin(); lhsIter != lhsIterEnd; lhsIter++, rhsIter++) {
 
-        if (!nodesEqual(*lhsIter, *rhsIter, simpleSelectorOrderDependent)) {
+        if (*lhsIter != *rhsIter) {
           return false;
         }
 
@@ -128,10 +123,10 @@ namespace Sass {
 
 
   void Node::plus(Node& rhs) {
-  	if (!this->isCollection() || !rhs.isCollection()) {
-    	throw "Both the current node and rhs must be collections.";
+    if (!this->isCollection() || !rhs.isCollection()) {
+      throw "Both the current node and rhs must be collections.";
     }
-  	this->collection()->insert(this->collection()->end(), rhs.collection()->begin(), rhs.collection()->end());
+    this->collection()->insert(this->collection()->end(), rhs.collection()->begin(), rhs.collection()->end());
   }
 
 #ifdef DEBUG
@@ -177,7 +172,7 @@ namespace Sass {
 #endif
 
 
-  Node complexSelectorToNode(Complex_Selector_Ptr pToConvert, Context& ctx) {
+  Node complexSelectorToNode(Complex_Selector_Ptr pToConvert) {
     if (pToConvert == NULL) {
       return Node::createNil();
     }
@@ -189,20 +184,22 @@ namespace Sass {
     if (pToConvert->head() && pToConvert->head()->has_parent_ref()) {
       Complex_Selector_Obj tail = pToConvert->tail();
       if (tail) tail->has_line_feed(pToConvert->has_line_feed());
-      pToConvert = &tail;
+      pToConvert = tail;
     }
 
     while (pToConvert) {
 
       bool empty_parent_ref = pToConvert->head() && pToConvert->head()->is_empty_reference();
 
-      if (pToConvert->head() || empty_parent_ref) {
-      }
-
       // the first Complex_Selector may contain a dummy head pointer, skip it.
       if (pToConvert->head() && !empty_parent_ref) {
-        node.collection()->push_back(Node::createSelector(pToConvert, ctx));
+        node.collection()->push_back(Node::createSelector(*pToConvert));
         if (has_lf) node.collection()->back().got_line_feed = has_lf;
+        if (pToConvert->head() || empty_parent_ref) {
+          if (pToConvert->tail()) {
+            pToConvert->tail()->has_line_feed(pToConvert->has_line_feed());
+          }
+        }
         has_lf = false;
       }
 
@@ -216,14 +213,14 @@ namespace Sass {
         // pToConvert->tail()->has_line_feed(pToConvert->has_line_feed());
       }
 
-      pToConvert = &pToConvert->tail();
+      pToConvert = pToConvert->tail();
     }
 
     return node;
   }
 
 
-  Complex_Selector_Ptr nodeToComplexSelector(const Node& toConvert, Context& ctx) {
+  Complex_Selector_Ptr nodeToComplexSelector(const Node& toConvert) {
     if (toConvert.isNil()) {
       return NULL;
     }
@@ -237,7 +234,6 @@ namespace Sass {
     NodeDeque& childNodes = *toConvert.collection();
 
     std::string noPath("");
-    Position noPosition(-1, -1, -1);
     Complex_Selector_Obj pFirst = SASS_MEMORY_NEW(Complex_Selector, ParserState("[NODE]"), Complex_Selector::ANCESTOR_OF, NULL, NULL);
 
     Complex_Selector_Obj pCurrent = pFirst;
@@ -254,7 +250,7 @@ namespace Sass {
         // collections, and can result in an infinite loop during the call to parentSuperselector()
         pCurrent->tail(SASS_MEMORY_COPY(child.selector()));
         // if (child.got_line_feed) pCurrent->has_line_feed(child.got_line_feed);
-        pCurrent = &pCurrent->tail();
+        pCurrent = pCurrent->tail();
       } else if (child.isCombinator()) {
         pCurrent->combinator(child.combinator());
         if (child.got_line_feed) pCurrent->has_line_feed(child.got_line_feed);
@@ -265,7 +261,7 @@ namespace Sass {
           if (nextNode.isCombinator()) {
             pCurrent->tail(SASS_MEMORY_NEW(Complex_Selector, ParserState("[NODE]"), Complex_Selector::ANCESTOR_OF, NULL, NULL));
             if (nextNode.got_line_feed) pCurrent->tail()->has_line_feed(nextNode.got_line_feed);
-            pCurrent = &pCurrent->tail();
+            pCurrent = pCurrent->tail();
           }
         }
       } else {
@@ -285,7 +281,7 @@ namespace Sass {
 
   // A very naive trim function, which removes duplicates in a node
   // This is only used in Complex_Selector::unify_with for now, may need modifications to fit other needs
-  Node Node::naiveTrim(Node& seqses, Context& ctx) {
+  Node Node::naiveTrim(Node& seqses) {
 
     std::vector<Node*> res;
     std::vector<Complex_Selector_Obj> known;