sassc 1.11.1 → 1.11.2

data/ext/libsass/src/inspect.hpp

@@ -13,7 +13,7 @@ namespace Sass {
     // import all the class-specific methods and override as desired
     using Operation_CRTP<void, Inspect>::operator();
 
-    void fallback_impl(AST_Node* n);
+    void fallback_impl(AST_Node_Ptr n);
 
   public:
 
@@ -21,79 +21,79 @@ namespace Sass {
     virtual ~Inspect();
 
     // statements
-    virtual void operator()(Block*);
-    virtual void operator()(Ruleset*);
-    virtual void operator()(Bubble*);
-    virtual void operator()(Supports_Block*);
-    virtual void operator()(Media_Block*);
-    virtual void operator()(At_Root_Block*);
-    virtual void operator()(Directive*);
-    virtual void operator()(Keyframe_Rule*);
-    virtual void operator()(Declaration*);
-    virtual void operator()(Assignment*);
-    virtual void operator()(Import*);
-    virtual void operator()(Import_Stub*);
-    virtual void operator()(Warning*);
-    virtual void operator()(Error*);
-    virtual void operator()(Debug*);
-    virtual void operator()(Comment*);
-    virtual void operator()(If*);
-    virtual void operator()(For*);
-    virtual void operator()(Each*);
-    virtual void operator()(While*);
-    virtual void operator()(Return*);
-    virtual void operator()(Extension*);
-    virtual void operator()(Definition*);
-    virtual void operator()(Mixin_Call*);
-    virtual void operator()(Content*);
+    virtual void operator()(Block_Ptr);
+    virtual void operator()(Ruleset_Ptr);
+    virtual void operator()(Bubble_Ptr);
+    virtual void operator()(Supports_Block_Ptr);
+    virtual void operator()(Media_Block_Ptr);
+    virtual void operator()(At_Root_Block_Ptr);
+    virtual void operator()(Directive_Ptr);
+    virtual void operator()(Keyframe_Rule_Ptr);
+    virtual void operator()(Declaration_Ptr);
+    virtual void operator()(Assignment_Ptr);
+    virtual void operator()(Import_Ptr);
+    virtual void operator()(Import_Stub_Ptr);
+    virtual void operator()(Warning_Ptr);
+    virtual void operator()(Error_Ptr);
+    virtual void operator()(Debug_Ptr);
+    virtual void operator()(Comment_Ptr);
+    virtual void operator()(If_Ptr);
+    virtual void operator()(For_Ptr);
+    virtual void operator()(Each_Ptr);
+    virtual void operator()(While_Ptr);
+    virtual void operator()(Return_Ptr);
+    virtual void operator()(Extension_Ptr);
+    virtual void operator()(Definition_Ptr);
+    virtual void operator()(Mixin_Call_Ptr);
+    virtual void operator()(Content_Ptr);
     // expressions
-    virtual void operator()(Map*);
-    virtual void operator()(List*);
-    virtual void operator()(Binary_Expression*);
-    virtual void operator()(Unary_Expression*);
-    virtual void operator()(Function_Call*);
-    virtual void operator()(Function_Call_Schema*);
-    // virtual void operator()(Custom_Warning*);
-    // virtual void operator()(Custom_Error*);
-    virtual void operator()(Variable*);
-    virtual void operator()(Textual*);
-    virtual void operator()(Number*);
-    virtual void operator()(Color*);
-    virtual void operator()(Boolean*);
-    virtual void operator()(String_Schema*);
-    virtual void operator()(String_Constant*);
-    virtual void operator()(String_Quoted*);
-    virtual void operator()(Custom_Error*);
-    virtual void operator()(Custom_Warning*);
-    virtual void operator()(Supports_Operator*);
-    virtual void operator()(Supports_Negation*);
-    virtual void operator()(Supports_Declaration*);
-    virtual void operator()(Supports_Interpolation*);
-    virtual void operator()(Media_Query*);
-    virtual void operator()(Media_Query_Expression*);
-    virtual void operator()(At_Root_Query*);
-    virtual void operator()(Null*);
-    virtual void operator()(Parent_Selector* p);
+    virtual void operator()(Map_Ptr);
+    virtual void operator()(List_Ptr);
+    virtual void operator()(Binary_Expression_Ptr);
+    virtual void operator()(Unary_Expression_Ptr);
+    virtual void operator()(Function_Call_Ptr);
+    virtual void operator()(Function_Call_Schema_Ptr);
+    // virtual void operator()(Custom_Warning_Ptr);
+    // virtual void operator()(Custom_Error_Ptr);
+    virtual void operator()(Variable_Ptr);
+    virtual void operator()(Textual_Ptr);
+    virtual void operator()(Number_Ptr);
+    virtual void operator()(Color_Ptr);
+    virtual void operator()(Boolean_Ptr);
+    virtual void operator()(String_Schema_Ptr);
+    virtual void operator()(String_Constant_Ptr);
+    virtual void operator()(String_Quoted_Ptr);
+    virtual void operator()(Custom_Error_Ptr);
+    virtual void operator()(Custom_Warning_Ptr);
+    virtual void operator()(Supports_Operator_Ptr);
+    virtual void operator()(Supports_Negation_Ptr);
+    virtual void operator()(Supports_Declaration_Ptr);
+    virtual void operator()(Supports_Interpolation_Ptr);
+    virtual void operator()(Media_Query_Ptr);
+    virtual void operator()(Media_Query_Expression_Ptr);
+    virtual void operator()(At_Root_Query_Ptr);
+    virtual void operator()(Null_Ptr);
+    virtual void operator()(Parent_Selector_Ptr p);
     // parameters and arguments
-    virtual void operator()(Parameter*);
-    virtual void operator()(Parameters*);
-    virtual void operator()(Argument*);
-    virtual void operator()(Arguments*);
+    virtual void operator()(Parameter_Ptr);
+    virtual void operator()(Parameters_Ptr);
+    virtual void operator()(Argument_Ptr);
+    virtual void operator()(Arguments_Ptr);
     // selectors
-    virtual void operator()(Selector_Schema*);
-    virtual void operator()(Placeholder_Selector*);
-    virtual void operator()(Element_Selector*);
-    virtual void operator()(Class_Selector*);
-    virtual void operator()(Id_Selector*);
-    virtual void operator()(Attribute_Selector*);
-    virtual void operator()(Pseudo_Selector*);
-    virtual void operator()(Wrapped_Selector*);
-    virtual void operator()(SimpleSequence_Selector*);
-    virtual void operator()(Sequence_Selector*);
-    virtual void operator()(CommaSequence_Selector*);
+    virtual void operator()(Selector_Schema_Ptr);
+    virtual void operator()(Placeholder_Selector_Ptr);
+    virtual void operator()(Element_Selector_Ptr);
+    virtual void operator()(Class_Selector_Ptr);
+    virtual void operator()(Id_Selector_Ptr);
+    virtual void operator()(Attribute_Selector_Ptr);
+    virtual void operator()(Pseudo_Selector_Ptr);
+    virtual void operator()(Wrapped_Selector_Ptr);
+    virtual void operator()(Compound_Selector_Ptr);
+    virtual void operator()(Complex_Selector_Ptr);
+    virtual void operator()(Selector_List_Ptr);
 
     // template <typename U>
-    // void fallback(U x) { fallback_impl(reinterpret_cast<AST_Node*>(x)); }
+    // void fallback(U x) { fallback_impl(reinterpret_cast<AST_Node_Ptr>(x)); }
   };
 
 }

data/ext/libsass/src/listize.cpp

@@ -10,78 +10,76 @@
 
 namespace Sass {
 
-  Listize::Listize(Memory_Manager& mem)
-  : mem(mem)
+  Listize::Listize()
   {  }
 
-  Expression* Listize::operator()(CommaSequence_Selector* sel)
+  Expression_Ptr Listize::operator()(Selector_List_Ptr sel)
   {
-    List* l = SASS_MEMORY_NEW(mem, List, sel->pstate(), sel->length(), SASS_COMMA);
+    List_Obj l = SASS_MEMORY_NEW(List, sel->pstate(), sel->length(), SASS_COMMA);
     l->from_selector(true);
     for (size_t i = 0, L = sel->length(); i < L; ++i) {
-      if (!(*sel)[i]) continue;
-      *l << (*sel)[i]->perform(this);
+      if (!sel->at(i)) continue;
+      l->append(sel->at(i)->perform(this));
     }
-    if (l->length()) return l;
-    return SASS_MEMORY_NEW(mem, Null, l->pstate());
+    if (l->length()) return l.detach();
+    return SASS_MEMORY_NEW(Null, l->pstate());
   }
 
-  Expression* Listize::operator()(SimpleSequence_Selector* sel)
+  Expression_Ptr Listize::operator()(Compound_Selector_Ptr sel)
   {
     std::string str;
     for (size_t i = 0, L = sel->length(); i < L; ++i) {
-      Expression* e = (*sel)[i]->perform(this);
+      Expression_Ptr e = (*sel)[i]->perform(this);
       if (e) str += e->to_string();
     }
-    return SASS_MEMORY_NEW(mem, String_Quoted, sel->pstate(), str);
+    return SASS_MEMORY_NEW(String_Quoted, sel->pstate(), str);
   }
 
-  Expression* Listize::operator()(Sequence_Selector* sel)
+  Expression_Ptr Listize::operator()(Complex_Selector_Ptr sel)
   {
-    List* l = SASS_MEMORY_NEW(mem, List, sel->pstate(), 2);
+    List_Obj l = SASS_MEMORY_NEW(List, sel->pstate(), 2);
     l->from_selector(true);
-    SimpleSequence_Selector* head = sel->head();
+    Compound_Selector_Obj head = sel->head();
     if (head && !head->is_empty_reference())
     {
-      Expression* hh = head->perform(this);
-      if (hh) *l << hh;
+      Expression_Ptr hh = head->perform(this);
+      if (hh) l->append(hh);
     }
 
     std::string reference = ! sel->reference() ? ""
       : sel->reference()->to_string();
     switch(sel->combinator())
     {
-      case Sequence_Selector::PARENT_OF:
-        *l << SASS_MEMORY_NEW(mem, String_Quoted, sel->pstate(), ">");
+      case Complex_Selector::PARENT_OF:
+        l->append(SASS_MEMORY_NEW(String_Quoted, sel->pstate(), ">"));
       break;
-      case Sequence_Selector::ADJACENT_TO:
-        *l << SASS_MEMORY_NEW(mem, String_Quoted, sel->pstate(), "+");
+      case Complex_Selector::ADJACENT_TO:
+        l->append(SASS_MEMORY_NEW(String_Quoted, sel->pstate(), "+"));
       break;
-      case Sequence_Selector::REFERENCE:
-        *l << SASS_MEMORY_NEW(mem, String_Quoted, sel->pstate(), "/" + reference + "/");
+      case Complex_Selector::REFERENCE:
+        l->append(SASS_MEMORY_NEW(String_Quoted, sel->pstate(), "/" + reference + "/"));
       break;
-      case Sequence_Selector::PRECEDES:
-        *l << SASS_MEMORY_NEW(mem, String_Quoted, sel->pstate(), "~");
+      case Complex_Selector::PRECEDES:
+        l->append(SASS_MEMORY_NEW(String_Quoted, sel->pstate(), "~"));
       break;
-      case Sequence_Selector::ANCESTOR_OF:
+      case Complex_Selector::ANCESTOR_OF:
       break;
     }
 
-    Sequence_Selector* tail = sel->tail();
+    Complex_Selector_Obj tail = sel->tail();
     if (tail)
     {
-      Expression* tt = tail->perform(this);
-      if (tt && tt->concrete_type() == Expression::LIST)
-      { *l += static_cast<List*>(tt); }
-      else if (tt) *l << static_cast<List*>(tt);
+      Expression_Obj tt = tail->perform(this);
+      if (List_Ptr ls = SASS_MEMORY_CAST(List, tt))
+      { l->concat(ls); }
     }
     if (l->length() == 0) return 0;
-    return l;
+    return l.detach();
   }
 
-  Expression* Listize::fallback_impl(AST_Node* n)
+  Expression_Ptr Listize::fallback_impl(AST_Node_Ptr n)
   {
-    return dynamic_cast<Expression*>(n);
+    return dynamic_cast<Expression_Ptr>(n);
   }
 
 }

data/ext/libsass/src/listize.hpp

@@ -11,25 +11,23 @@
 
 namespace Sass {
 
-  typedef Environment<AST_Node*> Env;
+  typedef Environment<AST_Node_Obj> Env;
   struct Backtrace;
 
-  class Listize : public Operation_CRTP<Expression*, Listize> {
+  class Listize : public Operation_CRTP<Expression_Ptr, Listize> {
 
-    Memory_Manager& mem;
-
-    Expression* fallback_impl(AST_Node* n);
+    Expression_Ptr fallback_impl(AST_Node_Ptr n);
 
   public:
-    Listize(Memory_Manager&);
+    Listize();
     ~Listize() { }
 
-    Expression* operator()(CommaSequence_Selector*);
-    Expression* operator()(Sequence_Selector*);
-    Expression* operator()(SimpleSequence_Selector*);
+    Expression_Ptr operator()(Selector_List_Ptr);
+    Expression_Ptr operator()(Complex_Selector_Ptr);
+    Expression_Ptr operator()(Compound_Selector_Ptr);
 
     template <typename U>
-    Expression* fallback(U x) { return fallback_impl(x); }
+    Expression_Ptr fallback(U x) { return fallback_impl(x); }
   };
 
 }

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

@@ -0,0 +1,116 @@
+#include "../sass.hpp"
+#include <iostream>
+#include <typeinfo>
+
+#include "SharedPtr.hpp"
+#include "../ast_fwd_decl.hpp"
+
+#ifdef DEBUG_SHARED_PTR
+#include "../debugger.hpp"
+#endif
+
+namespace Sass {
+
+  #ifdef DEBUG_SHARED_PTR
+  void SharedObj::dumpMemLeaks() {
+    if (!all.empty()) {
+      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)) {
+          debug_ast(ast);
+        } else {
+          std::cerr << "LEAKED " << var << "\n";
+        }
+      }
+    }
+  }
+  std::vector<SharedObj*> SharedObj::all;
+  #endif
+
+  bool SharedObj::taint = false;
+
+  SharedObj::SharedObj()
+  : detached(false)
+    #ifdef DEBUG_SHARED_PTR
+    , 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
+    };
+
+
+
+  void SharedPtr::decRefCount() {
+    if (node) {
+      -- node->refcounter;
+      #ifdef DEBUG_SHARED_PTR
+        if (node->dbg)  std::cerr << "- " << node << " X " << node->refcounter << " (" << this << ") " << "\n";
+      #endif
+      if (node->refcounter == 0) {
+        #ifdef DEBUG_SHARED_PTR
+          AST_Node_Ptr ptr = SASS_MEMORY_CAST_PTR(AST_Node, node);
+          if (node->dbg) std::cerr << "DELETE NODE " << node << "\n";
+        #endif
+        if (!node->detached) {
+          delete(node);
+        }
+      }
+    }
+  }
+
+  void SharedPtr::incRefCount() {
+    if (node) {
+      ++ node->refcounter;
+      node->detached = false;
+      #ifdef DEBUG_SHARED_PTR
+        if (node->dbg) {
+          std::cerr << "+ " << node << " X " << node->refcounter << " (" << this << ") " << "\n";
+        }
+      #endif
+    }
+  }
+
+  SharedPtr::~SharedPtr() {
+    decRefCount();
+  }
+
+
+  // the create constructor
+  SharedPtr::SharedPtr(SharedObj* ptr)
+  : node(ptr) {
+    incRefCount();
+  }
+  // copy assignment operator
+  SharedPtr& SharedPtr::operator=(const SharedPtr& rhs) {
+    void* cur_ptr = (void*) node;
+    void* rhs_ptr = (void*) rhs.node;
+    if (cur_ptr == rhs_ptr) {
+      return *this;
+    }
+    decRefCount();
+    node = rhs.node;
+    incRefCount();
+    return *this;
+  }
+
+  // the copy constructor
+  SharedPtr::SharedPtr(const SharedPtr& obj)
+  : node(obj.node) {
+    incRefCount();
+  }
+
+}

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

@@ -0,0 +1,202 @@
+#ifndef SASS_MEMORY_SHARED_PTR_H
+#define SASS_MEMORY_SHARED_PTR_H
+
+#include "sass/base.h"
+
+#include <vector>
+
+namespace Sass {
+
+  class SharedPtr;
+
+  ///////////////////////////////////////////////////////////////////////////////
+  // Use macros for the allocation task, since overloading operator `new`
+  // has been proven to be flaky under certain compilers (see comment below).
+  ///////////////////////////////////////////////////////////////////////////////
+
+  #ifdef DEBUG_SHARED_PTR
+
+    #define SASS_MEMORY_NEW(Class, ...) \
+      static_cast<Class##_Ptr>((new Class(__VA_ARGS__))->trace(__FILE__, __LINE__)) \
+
+    #define SASS_MEMORY_COPY(obj) \
+      ((obj)->copy(__FILE__, __LINE__)) \
+
+    #define SASS_MEMORY_CLONE(obj) \
+      ((obj)->clone(__FILE__, __LINE__)) \
+
+  #else
+
+    #define SASS_MEMORY_NEW(Class, ...) \
+      new Class(__VA_ARGS__) \
+
+    #define SASS_MEMORY_COPY(obj) \
+      ((obj)->copy()) \
+
+    #define SASS_MEMORY_CLONE(obj) \
+      ((obj)->clone()) \
+
+  #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;
+  friend class Memory_Manager;
+    #ifdef DEBUG_SHARED_PTR
+      static std::vector<SharedObj*> all;
+      std::string file;
+      size_t line;
+    #endif
+    static bool taint;
+    long refcounter;
+    // long refcount;
+    bool detached;
+    #ifdef DEBUG_SHARED_PTR
+      bool dbg;
+    #endif
+  public:
+    #ifdef DEBUG_SHARED_PTR
+      static void dumpMemLeaks();
+      SharedObj* trace(std::string file, size_t line) {
+        this->file = file;
+        this->line = line;
+        return this;
+      }
+    #endif
+    SharedObj();
+    #ifdef DEBUG_SHARED_PTR
+      std::string getDbgFile() {
+        return file;
+      }
+      size_t getDbgLine() {
+        return line;
+      }
+      void setDbg(bool dbg) {
+        this->dbg = dbg;
+      }
+    #endif
+    static void setTaint(bool val) {
+      taint = val;
+    }
+    virtual ~SharedObj();
+    long getRefCount() {
+      return refcounter;
+    }
+  };
+
+
+  class SharedPtr {
+  private:
+    SharedObj* node;
+  private:
+    void decRefCount();
+    void incRefCount();
+  public:
+    // the empty constructor
+    SharedPtr()
+    : 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();
+  public:
+    SharedObj* obj () {
+      return node;
+    };
+    SharedObj* obj () const {
+      return node;
+    };
+    SharedObj* operator-> () {
+      return node;
+    };
+    bool isNull () {
+      return node == NULL;
+    };
+    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 >
+  class SharedImpl : private SharedPtr {
+  public:
+    SharedImpl()
+    : SharedPtr(NULL) {};
+    SharedImpl(T* node)
+    : SharedPtr(node) {};
+    SharedImpl(T&& node)
+    : SharedPtr(node) {};
+    SharedImpl(const T& node)
+    : SharedPtr(node) {};
+    ~SharedImpl() {};
+  public:
+    T* operator& () {
+      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* operator-> () {
+      return static_cast<T*>(this->obj());
+    };
+    T* operator-> () const {
+      return static_cast<T*>(this->obj());
+    };
+    T* ptr () {
+      return static_cast<T*>(this->obj());
+    };
+    T* detach() {
+      if (this->obj() == NULL) return NULL;
+      return static_cast<T*>(SharedPtr::detach());
+    }
+    bool isNull() {
+      return this->obj() == NULL;
+    }
+    operator bool() {
+      return this->obj() != NULL;
+    };
+    operator bool() const {
+      return this->obj() != NULL;
+    };
+  };
+
+}
+
+#endif