sassc 1.7.1 → 1.8.0.pre1

data/ext/libsass/src/memory_manager.cpp

@@ -0,0 +1,76 @@
+#include "ast.hpp"
+#include "memory_manager.hpp"
+
+namespace Sass {
+
+  Memory_Manager::Memory_Manager(size_t size)
+  : nodes(std::vector<Memory_Object*>())
+  {
+    size_t init = size;
+    if (init < 8) init = 8;
+    // reserve some space
+    nodes.reserve(init);
+  }
+
+  Memory_Manager::~Memory_Manager()
+  {
+    // release memory for all controlled nodes
+    // avoid calling erase for every single node
+    for (size_t i = 0, S = nodes.size(); i < S; ++i) {
+      deallocate(nodes[i]);
+    }
+    // just in case
+    nodes.clear();
+  }
+
+  Memory_Object* Memory_Manager::add(Memory_Object* np)
+  {
+    // object has been initialized
+    // it can be "deleted" from now on
+    np->refcount = 1;
+    return np;
+  }
+
+  bool Memory_Manager::has(Memory_Object* np)
+  {
+    // check if the pointer is controlled under our pool
+    return find(nodes.begin(), nodes.end(), np) != nodes.end();
+  }
+
+  Memory_Object* Memory_Manager::allocate(size_t size)
+  {
+    // allocate requested memory
+    void* heap = malloc(size);
+    // init internal refcount status to zero
+    (static_cast<Memory_Object*>(heap))->refcount = 0;
+    // add the memory under our management
+    nodes.push_back(static_cast<Memory_Object*>(heap));
+    // cast object to its initial type
+    return static_cast<Memory_Object*>(heap);
+  }
+
+  void Memory_Manager::deallocate(Memory_Object* np)
+  {
+    // only call destructor if initialized
+    if (np->refcount) np->~Memory_Object();
+    // always free the memory
+    free(np);
+  }
+
+  void Memory_Manager::remove(Memory_Object* np)
+  {
+    // remove node from pool (no longer active)
+    nodes.erase(find(nodes.begin(), nodes.end(), np));
+    // you are now in control of the memory
+  }
+
+  void Memory_Manager::destroy(Memory_Object* np)
+  {
+    // remove from pool
+    remove(np);
+    // release memory
+    deallocate(np);
+  }
+
+}
+

data/ext/libsass/src/memory_manager.hpp

@@ -0,0 +1,48 @@
+#ifndef SASS_MEMORY_MANAGER_H
+#define SASS_MEMORY_MANAGER_H
+
+#include <vector>
+
+namespace Sass {
+
+  class Memory_Object {
+  friend class Memory_Manager;
+    long refcount;
+  public:
+    Memory_Object() { refcount = 0; };
+    virtual ~Memory_Object() {};
+  };
+
+  /////////////////////////////////////////////////////////////////////////////
+  // A class for tracking allocations of AST_Node objects. The intended usage
+  // is something like: Some_Node* n = new (mem_mgr) Some_Node(...);
+  // Then, at the end of the program, the memory manager will delete all of the
+  // allocated nodes that have been passed to it.
+  // In the future, this class may implement a custom allocator.
+  /////////////////////////////////////////////////////////////////////////////
+  class Memory_Manager {
+    std::vector<Memory_Object*> nodes;
+
+  public:
+    Memory_Manager(size_t size = 0);
+    ~Memory_Manager();
+
+    bool has(Memory_Object* np);
+    Memory_Object* allocate(size_t size);
+    void deallocate(Memory_Object* np);
+    void remove(Memory_Object* np);
+    void destroy(Memory_Object* np);
+    Memory_Object* add(Memory_Object* np);
+
+  };
+}
+
+///////////////////////////////////////////////////////////////////////////////
+// Use macros for the allocation task, since overloading operator `new`
+// has been proven to be flaky under certain compilers (see comment below).
+///////////////////////////////////////////////////////////////////////////////
+
+#define SASS_MEMORY_NEW(mgr, Class, ...)                                                 \
+  (static_cast<Class*>(mgr.add(new (mgr.allocate(sizeof(Class))) Class(__VA_ARGS__))))   \
+
+#endif

data/ext/libsass/{node.cpp → src/node.cpp}

@@ -1,3 +1,5 @@
+#include <vector>
+
 #include "node.hpp"
 #include "to_string.hpp"
 #include "context.hpp"
@@ -19,18 +21,20 @@ namespace Sass {
     pStripped->tail(NULL);
     pStripped->combinator(Complex_Selector::ANCESTOR_OF);
 
-    return Node(SELECTOR, Complex_Selector::ANCESTOR_OF, pStripped, null /*pCollection*/);
+    Node n(SELECTOR, Complex_Selector::ANCESTOR_OF, pStripped, null /*pCollection*/);
+    if (pSelector) n.got_line_feed = pSelector->has_line_feed();
+    return n;
   }
 
 
   Node Node::createCollection() {
-    NodeDequePtr pEmptyCollection = make_shared<NodeDeque>();
+    NodeDequePtr pEmptyCollection = std::make_shared<NodeDeque>();
     return Node(COLLECTION, Complex_Selector::ANCESTOR_OF, NULL /*pSelector*/, pEmptyCollection);
   }
 
 
   Node Node::createCollection(const NodeDeque& values) {
-    NodeDequePtr pShallowCopiedCollection = make_shared<NodeDeque>(values);
+    NodeDequePtr pShallowCopiedCollection = std::make_shared<NodeDeque>(values);
     return Node(COLLECTION, Complex_Selector::ANCESTOR_OF, NULL /*pSelector*/, pShallowCopiedCollection);
   }
 
@@ -43,11 +47,11 @@ namespace Sass {
 
   Node::Node(const TYPE& type, Complex_Selector::Combinator combinator, Complex_Selector* pSelector, NodeDequePtr& pCollection)
   : got_line_feed(false), mType(type), mCombinator(combinator), mpSelector(pSelector), mpCollection(pCollection)
-  { /* if (pSelector) got_line_feed = pSelector->has_line_feed(); */ }
+  { if (pSelector) got_line_feed = pSelector->has_line_feed(); }
 
 
   Node Node::clone(Context& ctx) const {
-    NodeDequePtr pNewCollection = make_shared<NodeDeque>();
+    NodeDequePtr pNewCollection = std::make_shared<NodeDeque>();
     if (mpCollection) {
       for (NodeDeque::iterator iter = mpCollection->begin(), iterEnd = mpCollection->end(); iter != iterEnd; iter++) {
         Node& toClone = *iter;
@@ -55,7 +59,9 @@ namespace Sass {
       }
     }
 
-    return Node(mType, mCombinator, mpSelector ? mpSelector->clone(ctx) : NULL, pNewCollection);
+    Node n(mType, mCombinator, mpSelector ? mpSelector->clone(ctx) : NULL, pNewCollection);
+    n.got_line_feed = got_line_feed;
+    return n;
   }
 
 
@@ -129,7 +135,7 @@ namespace Sass {
   }
 
 #ifdef DEBUG
-  ostream& operator<<(ostream& os, const Node& node) {
+  std::ostream& operator<<(std::ostream& os, const Node& node) {
 
     if (node.isCombinator()) {
 
@@ -138,6 +144,7 @@ namespace Sass {
         case Complex_Selector::PARENT_OF:   os << "\">\""; break;
         case Complex_Selector::PRECEDES:    os << "\"~\""; break;
         case Complex_Selector::ADJACENT_TO: os << "\"+\""; break;
+        case Complex_Selector::REFERENCE: os    << "\"/\""; break;
       }
 
     } else if (node.isNil()) {
@@ -151,14 +158,14 @@ namespace Sass {
 
     } else if (node.isCollection()) {
 
-			os << "[";
+      os << "[";
 
       for (NodeDeque::iterator iter = node.collection()->begin(), iterBegin = node.collection()->begin(), iterEnd = node.collection()->end(); iter != iterEnd; iter++) {
         if (iter != iterBegin) {
           os << ", ";
         }
 
-				os << (*iter);
+        os << (*iter);
       }
 
       os << "]";
@@ -175,18 +182,39 @@ namespace Sass {
     if (pToConvert == NULL) {
       return Node::createNil();
     }
-
     Node node = Node::createCollection();
+    node.got_line_feed = pToConvert->has_line_feed();
+    bool has_lf = pToConvert->has_line_feed();
+
+    // unwrap the selector from parent ref
+    if (pToConvert->head() && pToConvert->head()->has_parent_ref()) {
+      Complex_Selector* tail = pToConvert->tail();
+      if (tail) tail->has_line_feed(pToConvert->has_line_feed());
+      pToConvert = tail;
+    }
 
     while (pToConvert) {
 
+      bool empty_parent_ref = pToConvert->head() && pToConvert->head()->is_empty_reference();
+
+      if (pToConvert->head() == NULL || empty_parent_ref) {
+      }
+
       // the first Complex_Selector may contain a dummy head pointer, skip it.
-      if (pToConvert->head() != NULL && !pToConvert->head()->is_empty_reference()) {
+      if (pToConvert->head() != NULL && !empty_parent_ref) {
         node.collection()->push_back(Node::createSelector(pToConvert, ctx));
+        if (has_lf) node.collection()->back().got_line_feed = has_lf;
+        has_lf = false;
       }
 
       if (pToConvert->combinator() != Complex_Selector::ANCESTOR_OF) {
         node.collection()->push_back(Node::createCombinator(pToConvert->combinator()));
+        if (has_lf) node.collection()->back().got_line_feed = has_lf;
+        has_lf = false;
+      }
+
+      if (pToConvert && empty_parent_ref && pToConvert->tail()) {
+        // pToConvert->tail()->has_line_feed(pToConvert->has_line_feed());
       }
 
       pToConvert = pToConvert->tail();
@@ -209,26 +237,33 @@ namespace Sass {
 
     NodeDeque& childNodes = *toConvert.collection();
 
-    string noPath("");
+    std::string noPath("");
     Position noPosition(-1, -1, -1);
-    Complex_Selector* pFirst = new (ctx.mem) Complex_Selector(ParserState("[NODE]"), Complex_Selector::ANCESTOR_OF, NULL, NULL);
+    Complex_Selector* pFirst = SASS_MEMORY_NEW(ctx.mem, Complex_Selector, ParserState("[NODE]"), Complex_Selector::ANCESTOR_OF, NULL, NULL);
+
     Complex_Selector* pCurrent = pFirst;
 
+    if (toConvert.isSelector()) pFirst->has_line_feed(toConvert.got_line_feed);
+    if (toConvert.isCombinator()) pFirst->has_line_feed(toConvert.got_line_feed);
+
     for (NodeDeque::iterator childIter = childNodes.begin(), childIterEnd = childNodes.end(); childIter != childIterEnd; childIter++) {
 
       Node& child = *childIter;
 
       if (child.isSelector()) {
         pCurrent->tail(child.selector()->clone(ctx));   // JMA - need to clone the selector, because they can end up getting shared across Node collections, and can result in an infinite loop during the call to parentSuperselector()
+        // if (child.got_line_feed) pCurrent->has_line_feed(child.got_line_feed);
         pCurrent = pCurrent->tail();
       } else if (child.isCombinator()) {
         pCurrent->combinator(child.combinator());
+        if (child.got_line_feed) pCurrent->has_line_feed(child.got_line_feed);
 
         // if the next node is also a combinator, create another Complex_Selector to hold it so it doesn't replace the current combinator
         if (childIter+1 != childIterEnd) {
           Node& nextNode = *(childIter+1);
           if (nextNode.isCombinator()) {
-            pCurrent->tail(new (ctx.mem) Complex_Selector(ParserState("[NODE]"), Complex_Selector::ANCESTOR_OF, NULL, NULL));
+            pCurrent->tail(SASS_MEMORY_NEW(ctx.mem, 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();
           }
         }
@@ -238,14 +273,50 @@ namespace Sass {
     }
 
     // Put the dummy Compound_Selector in the first position, for consistency with the rest of libsass
-    Compound_Selector* fakeHead = new (ctx.mem) Compound_Selector(ParserState("[NODE]"), 1);
-    Selector_Reference* selectorRef = new (ctx.mem) Selector_Reference(ParserState("[NODE]"), NULL);
+    Compound_Selector* fakeHead = SASS_MEMORY_NEW(ctx.mem, Compound_Selector, ParserState("[NODE]"), 1);
+    Parent_Selector* selectorRef = SASS_MEMORY_NEW(ctx.mem, Parent_Selector, ParserState("[NODE]"));
     fakeHead->elements().push_back(selectorRef);
+    if (toConvert.got_line_feed) pFirst->has_line_feed(toConvert.got_line_feed);
+    // pFirst->has_line_feed(pFirst->has_line_feed() || pFirst->tail()->has_line_feed() || toConvert.got_line_feed);
     pFirst->head(fakeHead);
-    pFirst->has_line_feed(pFirst->has_line_feed() || pFirst->tail()->has_line_feed() || toConvert.got_line_feed);
-
     return pFirst;
   }
 
+  // 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) {
+
+    std::vector<Node*> res;
+    std::vector<Complex_Selector*> known;
+
+    NodeDeque::reverse_iterator seqsesIter = seqses.collection()->rbegin(),
+                                seqsesIterEnd = seqses.collection()->rend();
+
+    for (; seqsesIter != seqsesIterEnd; ++seqsesIter)
+    {
+      Node& seqs1 = *seqsesIter;
+      if( seqs1.isSelector() ) {
+        Complex_Selector* sel = seqs1.selector();
+        std::vector<Complex_Selector*>::iterator it;
+        bool found = false;
+        for (it = known.begin(); it != known.end(); ++it) {
+          if (**it == *sel) { found = true; break; }
+        }
+        if( !found ) {
+          known.push_back(seqs1.selector());
+          res.push_back(&seqs1);
+        }
+      } else {
+        res.push_back(&seqs1);
+      }
+    }
+
+    Node result = Node::createCollection();
 
+    for (size_t i = res.size() - 1; i != std::string::npos; --i) {
+      result.collection()->push_back(*res[i]);
+    }
+
+    return result;
+  }
 }

data/ext/libsass/{node.hpp → src/node.hpp}

@@ -2,7 +2,6 @@
 #define SASS_NODE_H
 
 #include <deque>
-#include <iostream>
 #include <memory>
 
 #include "ast.hpp"
@@ -11,7 +10,6 @@
 namespace Sass {
 
 
-  using namespace std;
 
 
   class Context;
@@ -33,8 +31,8 @@ namespace Sass {
    */
 
   class Node;
-  typedef deque<Node> NodeDeque;
-  typedef shared_ptr<NodeDeque> NodeDequePtr;
+  typedef std::deque<Node> NodeDeque;
+  typedef std::shared_ptr<NodeDeque> NodeDequePtr;
 
   class Node {
   public:
@@ -45,7 +43,7 @@ namespace Sass {
       NIL
     };
 
-		TYPE type() const { return mType; }
+    TYPE type() const { return mType; }
     bool isCombinator() const { return mType == COMBINATOR; }
     bool isSelector() const { return mType == SELECTOR; }
     bool isCollection() const { return mType == COLLECTION; }
@@ -69,6 +67,7 @@ namespace Sass {
     static Node createCollection(const NodeDeque& values);
 
     static Node createNil();
+    static Node naiveTrim(Node& seqses, Context& ctx);
 
     Node clone(Context& ctx) const;
 
@@ -109,7 +108,7 @@ namespace Sass {
   };
 
 #ifdef DEBUG
-  ostream& operator<<(ostream& os, const Node& node);
+  std::ostream& operator<<(std::ostream& os, const Node& node);
 #endif
   Node complexSelectorToNode(Complex_Selector* pToConvert, Context& ctx);
   Complex_Selector* nodeToComplexSelector(const Node& toConvert, Context& ctx);

data/ext/libsass/{operation.hpp → src/operation.hpp}

@@ -1,13 +1,9 @@
 #ifndef SASS_OPERATION_H
 #define SASS_OPERATION_H
 
-#include <iostream>
-#include <typeinfo>
-
 #include "ast_fwd_decl.hpp"
 
 namespace Sass {
-  using namespace std;
 
   template<typename T>
   class Operation {
@@ -19,7 +15,7 @@ namespace Sass {
     virtual T operator()(Ruleset* x)                = 0;
     virtual T operator()(Propset* x)                = 0;
     virtual T operator()(Bubble* x)                 = 0;
-    virtual T operator()(Feature_Block* x)          = 0;
+    virtual T operator()(Supports_Block* x)          = 0;
     virtual T operator()(Media_Block* x)            = 0;
     virtual T operator()(At_Root_Block* x)          = 0;
     virtual T operator()(At_Rule* x)                = 0;
@@ -48,15 +44,21 @@ namespace Sass {
     virtual T operator()(Unary_Expression* x)       = 0;
     virtual T operator()(Function_Call* x)          = 0;
     virtual T operator()(Function_Call_Schema* x)   = 0;
+    virtual T operator()(Custom_Warning* x)         = 0;
+    virtual T operator()(Custom_Error* x)           = 0;
     virtual T operator()(Variable* x)               = 0;
     virtual T operator()(Textual* x)                = 0;
     virtual T operator()(Number* x)                 = 0;
     virtual T operator()(Color* x)                  = 0;
     virtual T operator()(Boolean* x)                = 0;
     virtual T operator()(String_Schema* x)          = 0;
+    virtual T operator()(String_Quoted* x)          = 0;
     virtual T operator()(String_Constant* x)        = 0;
-    virtual T operator()(Feature_Query* x)          = 0;
-    virtual T operator()(Feature_Query_Condition* x)= 0;
+    virtual T operator()(Supports_Condition* x)     = 0;
+    virtual T operator()(Supports_Operator* x)      = 0;
+    virtual T operator()(Supports_Negation* x)      = 0;
+    virtual T operator()(Supports_Declaration* x)   = 0;
+    virtual T operator()(Supports_Interpolation* x) = 0;
     virtual T operator()(Media_Query* x)            = 0;
     virtual T operator()(Media_Query_Expression* x) = 0;
     virtual T operator()(At_Root_Expression* x)     = 0;
@@ -69,7 +71,6 @@ namespace Sass {
     virtual T operator()(Arguments* x)              = 0;
     // selectors
     virtual T operator()(Selector_Schema* x)        = 0;
-    virtual T operator()(Selector_Reference* x)     = 0;
     virtual T operator()(Selector_Placeholder* x)   = 0;
     virtual T operator()(Type_Selector* x)          = 0;
     virtual T operator()(Selector_Qualifier* x)     = 0;
@@ -94,7 +95,7 @@ namespace Sass {
     virtual T operator()(Ruleset* x)                { return static_cast<D*>(this)->fallback(x); }
     virtual T operator()(Propset* x)                { return static_cast<D*>(this)->fallback(x); }
     virtual T operator()(Bubble* x)                 { return static_cast<D*>(this)->fallback(x); }
-    virtual T operator()(Feature_Block* x)          { return static_cast<D*>(this)->fallback(x); }
+    virtual T operator()(Supports_Block* x)          { return static_cast<D*>(this)->fallback(x); }
     virtual T operator()(Media_Block* x)            { return static_cast<D*>(this)->fallback(x); }
     virtual T operator()(At_Root_Block* x)          { return static_cast<D*>(this)->fallback(x); }
     virtual T operator()(At_Rule* x)                { return static_cast<D*>(this)->fallback(x); }
@@ -123,6 +124,8 @@ namespace Sass {
     virtual T operator()(Unary_Expression* x)       { return static_cast<D*>(this)->fallback(x); }
     virtual T operator()(Function_Call* x)          { return static_cast<D*>(this)->fallback(x); }
     virtual T operator()(Function_Call_Schema* x)   { return static_cast<D*>(this)->fallback(x); }
+    virtual T operator()(Custom_Warning* x)         { return static_cast<D*>(this)->fallback(x); }
+    virtual T operator()(Custom_Error* x)           { return static_cast<D*>(this)->fallback(x); }
     virtual T operator()(Variable* x)               { return static_cast<D*>(this)->fallback(x); }
     virtual T operator()(Textual* x)                { return static_cast<D*>(this)->fallback(x); }
     virtual T operator()(Number* x)                 { return static_cast<D*>(this)->fallback(x); }
@@ -130,8 +133,12 @@ namespace Sass {
     virtual T operator()(Boolean* x)                { return static_cast<D*>(this)->fallback(x); }
     virtual T operator()(String_Schema* x)          { return static_cast<D*>(this)->fallback(x); }
     virtual T operator()(String_Constant* x)        { return static_cast<D*>(this)->fallback(x); }
-    virtual T operator()(Feature_Query* x)          { return static_cast<D*>(this)->fallback(x); }
-    virtual T operator()(Feature_Query_Condition* x){ return static_cast<D*>(this)->fallback(x); }
+    virtual T operator()(String_Quoted* x)          { return static_cast<D*>(this)->fallback(x); }
+    virtual T operator()(Supports_Condition* x)     { return static_cast<D*>(this)->fallback(x); }
+    virtual T operator()(Supports_Operator* x)      { return static_cast<D*>(this)->fallback(x); }
+    virtual T operator()(Supports_Negation* x)      { return static_cast<D*>(this)->fallback(x); }
+    virtual T operator()(Supports_Declaration* x)   { return static_cast<D*>(this)->fallback(x); }
+    virtual T operator()(Supports_Interpolation* x) { return static_cast<D*>(this)->fallback(x); }
     virtual T operator()(Media_Query* x)            { return static_cast<D*>(this)->fallback(x); }
     virtual T operator()(Media_Query_Expression* x) { return static_cast<D*>(this)->fallback(x); }
     virtual T operator()(At_Root_Expression* x)     { return static_cast<D*>(this)->fallback(x); }
@@ -144,7 +151,6 @@ namespace Sass {
     virtual T operator()(Arguments* x)              { return static_cast<D*>(this)->fallback(x); }
     // selectors
     virtual T operator()(Selector_Schema* x)        { return static_cast<D*>(this)->fallback(x); }
-    virtual T operator()(Selector_Reference* x)     { return static_cast<D*>(this)->fallback(x); }
     virtual T operator()(Selector_Placeholder* x)   { return static_cast<D*>(this)->fallback(x); }
     virtual T operator()(Type_Selector* x)          { return static_cast<D*>(this)->fallback(x); }
     virtual T operator()(Selector_Qualifier* x)     { return static_cast<D*>(this)->fallback(x); }