sassc 2.0.0 → 2.4.0

data/ext/libsass/src/listize.hpp

@@ -1,32 +1,35 @@
 #ifndef SASS_LISTIZE_H
 #define SASS_LISTIZE_H
 
-#include <vector>
-#include <iostream>
+// sass.hpp must go before all system headers to get the
+// __EXTENSIONS__ fix on Solaris.
+#include "sass.hpp"
 
-#include "ast.hpp"
-#include "context.hpp"
+#include "ast_fwd_decl.hpp"
 #include "operation.hpp"
-#include "environment.hpp"
 
 namespace Sass {
 
   struct Backtrace;
 
-  class Listize : public Operation_CRTP<Expression_Ptr, Listize> {
+  class Listize : public Operation_CRTP<Expression*, Listize> {
 
-    Expression_Ptr fallback_impl(AST_Node_Ptr n);
+  public:
+
+    static Expression* perform(AST_Node* node);
 
   public:
     Listize();
     ~Listize() { }
 
-    Expression_Ptr operator()(Selector_List_Ptr);
-    Expression_Ptr operator()(Complex_Selector_Ptr);
-    Expression_Ptr operator()(Compound_Selector_Ptr);
+    Expression* operator()(SelectorList*);
+    Expression* operator()(ComplexSelector*);
+    Expression* operator()(CompoundSelector*);
 
+    // generic fallback
     template <typename U>
-    Expression_Ptr fallback(U x) { return fallback_impl(x); }
+    Expression* fallback(U x)
+    { return Cast<Expression>(x); }
   };
 
 }

data/ext/libsass/src/mapping.hpp

@@ -2,6 +2,7 @@
 #define SASS_MAPPING_H
 
 #include "position.hpp"
+#include "backtrace.hpp"
 
 namespace Sass {
 

data/ext/libsass/src/memory.hpp

@@ -0,0 +1,12 @@
+#ifndef SASS_MEMORY_H
+#define SASS_MEMORY_H
+
+#include "settings.hpp"
+
+// Include memory headers
+#include "memory/config.hpp"
+#include "memory/allocator.hpp"
+#include "memory/shared_ptr.hpp"
+#include "memory/memory_pool.hpp"
+
+#endif

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

@@ -0,0 +1,48 @@
+#include "../sass.hpp"
+#include "allocator.hpp"
+#include "memory_pool.hpp"
+
+#if defined (_MSC_VER) // Visual studio
+#define thread_local __declspec( thread )
+#elif defined (__GCC__) // GCC
+#define thread_local __thread
+#endif
+
+namespace Sass {
+
+#ifdef SASS_CUSTOM_ALLOCATOR
+
+  // Only use PODs for thread_local
+  // Objects get unpredictable init order
+  static thread_local MemoryPool* pool;
+  static thread_local size_t allocations;
+
+  void* allocateMem(size_t size)
+  {
+    if (pool == nullptr) {
+      pool = new MemoryPool();
+    }
+    allocations++;
+    return pool->allocate(size);
+  }
+
+  void deallocateMem(void* ptr, size_t size)
+  {
+
+    // It seems thread_local variable might be discharged!?
+    // But the destructors of e.g. static strings is still
+    // called, although their memory was discharged too.
+    // Fine with me as long as address sanitizer is happy.
+    if (pool == nullptr || allocations == 0) { return; }
+
+    pool->deallocate(ptr);
+    if (--allocations == 0) {
+      delete pool;
+      pool = nullptr;
+    }
+
+  }
+
+#endif
+
+}

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

@@ -0,0 +1,138 @@
+#ifndef SASS_ALLOCATOR_H
+#define SASS_ALLOCATOR_H
+
+#include "config.hpp"
+#include "../settings.hpp"
+#include "../MurmurHash2.hpp"
+
+#include <vector>
+#include <limits>
+#include <iostream>
+#include <algorithm>
+#include <functional>
+
+namespace Sass {
+
+#ifndef SASS_CUSTOM_ALLOCATOR
+
+  template <typename T> using Allocator = std::allocator<T>;
+
+#else
+
+  void* allocateMem(size_t size);
+
+  void deallocateMem(void* ptr, size_t size = 1);
+
+  template<typename T>
+  class Allocator
+  {
+  public:
+
+    // Allocator traits
+    typedef T                 type;            
+    typedef type              value_type;      
+    typedef value_type*       pointer;         
+    typedef value_type const* const_pointer;   
+    typedef value_type&       reference;       
+    typedef value_type const& const_reference; 
+    typedef std::size_t       size_type;       
+    typedef std::ptrdiff_t    difference_type; 
+
+    template<typename U>
+    struct rebind
+    {
+      typedef Allocator<U> other;
+    };
+
+    // Constructor
+    Allocator(void) {}
+
+    // Copy Constructor
+    template<typename U>
+    Allocator(Allocator<U> const&)
+    {}
+
+    // allocate but don't initialize count of elements of type T
+    pointer allocate(size_type count, const_pointer /* hint */ = 0)
+    {
+      return (pointer)(Sass::allocateMem(count * sizeof(T)));
+    }
+
+    // deallocate storage ptr of deleted elements
+    void deallocate(pointer ptr, size_type count)
+    {
+      Sass::deallocateMem(ptr, count);
+    }
+
+    // return maximum number of elements that can be allocated
+    size_type max_size() const throw()
+    {
+      return std::numeric_limits<size_type>::max() / sizeof(T);
+    }
+
+    // Address of object
+    type* address(type& obj) const { return &obj; }
+    type const* address(type const& obj) const { return &obj; }
+
+    // Construct object
+    void construct(type* ptr, type const& ref) const
+    {
+      // In-place copy construct
+      new(ptr) type(ref);
+    }
+
+    // Destroy object
+    void destroy(type* ptr) const
+    {
+      // Call destructor
+      ptr->~type();
+    }
+
+  };
+
+  template<typename T, typename U>
+    bool operator==(Allocator<T> const& left,
+      Allocator<U> const& right)
+  {
+    return true;
+  }
+
+  template<typename T, typename U>
+    bool operator!=(Allocator<T> const& left,
+      Allocator<U> const& right)
+  {
+    return !(left == right);
+  }
+
+#endif
+
+  namespace sass {
+    template <typename T> using vector = std::vector<T, Sass::Allocator<T>>;
+    using string = std::basic_string<char, std::char_traits<char>, Sass::Allocator<char>>;
+    using sstream = std::basic_stringstream<char, std::char_traits<char>, Sass::Allocator<char>>;
+    using ostream = std::basic_ostringstream<char, std::char_traits<char>, Sass::Allocator<char>>;
+    using istream = std::basic_istringstream<char, std::char_traits<char>, Sass::Allocator<char>>;
+  }
+
+}
+
+#ifdef SASS_CUSTOM_ALLOCATOR
+
+namespace std {
+  // Only GCC seems to need this specialization!?
+  template <> struct hash<Sass::sass::string> {
+  public:
+    inline size_t operator()(
+      const Sass::sass::string& name) const
+    {
+      return MurmurHash2(
+        (void*)name.c_str(),
+        (int)name.size(),
+        0x73617373);
+    }
+  };
+}
+
+#endif
+
+#endif

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

@@ -0,0 +1,20 @@
+#ifndef SASS_MEMORY_CONFIG_H
+#define SASS_MEMORY_CONFIG_H
+
+// Define memory alignment requirements
+#define SASS_MEM_ALIGN sizeof(unsigned int)
+
+// Minimal alignment for memory fragments. Must be a multiple
+// of `SASS_MEM_ALIGN` and should not be too big (maybe 1 or 2)
+#define SassAllocatorHeadSize sizeof(unsigned int)
+
+// The number of bytes we use for our book-keeping before every
+// memory fragment. Needed to know to which bucket we belongs on
+// deallocations, or if it should go directly to the `free` call.
+#define SassAllocatorBookSize sizeof(unsigned int)
+
+// Bytes reserve for book-keeping on the arenas
+// Currently unused and for later optimization
+#define SassAllocatorArenaHeadSize 0
+
+#endif

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

@@ -0,0 +1,186 @@
+#ifndef SASS_MEMORY_POOL_H
+#define SASS_MEMORY_POOL_H
+
+#include <stdlib.h>
+#include <iostream>
+#include <algorithm>
+#include <climits>
+#include <vector>
+
+namespace Sass {
+
+  // SIMPLE MEMORY-POOL ALLOCATOR WITH FREE-LIST ON TOP
+
+  // This is a memory pool allocator with a free list on top.
+  // We only allocate memory arenas from the system in specific
+  // sizes (`SassAllocatorArenaSize`). Users claim memory slices
+  // of certain sizes from the pool. If the allocation is too big
+  // to fit into our buckets, we use regular malloc/free instead.
+
+  // When the systems starts, we allocate the first arena and then
+  // start to give out addresses to memory slices. During that
+  // we steadily increase `offset` until the current arena is full.
+  // Once that happens we allocate a new arena and continue.
+  // https://en.wikipedia.org/wiki/Memory_pool
+
+  // Fragments that get deallocated are not really freed, we put
+  // them on our free-list. For every bucket we have a pointer to
+  // the first item for reuse. That item itself holds a pointer to
+  // the previously free item (regular free-list implementation).
+  // https://en.wikipedia.org/wiki/Free_list
+
+  // On allocation calls we first check if there is any suitable
+  // item on the free-list. If there is we pop it from the stack
+  // and return it to the caller. Otherwise we have to take out
+  // a new slice from the current `arena` and increase `offset`.
+
+  // Note that this is not thread safe. This is on purpose as we
+  // want to use the memory pool in a thread local usage. In order
+  // to get this thread safe you need to only allocate one pool
+  // per thread. This can be achieved by using thread local PODs.
+  // Simply create a pool on the first allocation and dispose
+  // it once all allocations have been returned. E.g. by using:
+  // static thread_local size_t allocations;
+  // static thread_local MemoryPool* pool;
+
+  class MemoryPool {
+
+    // Current arena we fill up
+    char* arena;
+
+    // Position into the arena
+    size_t offset = std::string::npos;
+
+    // A list of full arenas
+    std::vector<void*> arenas;
+
+    // One pointer for every bucket (zero init)
+    #ifdef _MSC_VER
+    #pragma warning (suppress:4351)
+    #endif
+    void* freeList[SassAllocatorBuckets]{};
+
+    // Increase the address until it sits on a
+    // memory aligned address (maybe use `aligned`).
+    inline static size_t alignMemAddr(size_t addr) {
+      return (addr + SASS_MEM_ALIGN - 1) & ~(SASS_MEM_ALIGN - 1);
+    }
+
+  public:
+
+    // Default ctor
+    MemoryPool() :
+      // Wait for first allocation
+      arena(nullptr),
+      // Set to maximum value in order to
+      // make an allocation on the first run
+      offset(std::string::npos)
+    {
+    }
+
+    // Destructor
+    ~MemoryPool() {
+      // Delete full arenas
+      for (auto area : arenas) {
+        free(area);
+      }
+      // Delete current arena
+      free(arena);
+
+    }
+
+    // Allocate a slice of the memory pool
+    void* allocate(size_t size)
+    {
+
+      // Increase size so its memory is aligned
+      size = alignMemAddr(
+        // Make sure we have enough space for us to
+        // create the pointer to the free list later
+        std::max(sizeof(void*), size)
+        // and the size needed for our book-keeping
+        + SassAllocatorBookSize);
+
+      // Size must be multiple of alignment
+      // So we can derive bucket index from it
+      size_t bucket = size / SASS_MEM_ALIGN;
+
+      // Everything bigger is allocated via malloc
+      // Malloc is optimized for exactly this case
+      if (bucket >= SassAllocatorBuckets) {
+        char* buffer = (char*)malloc(size);
+        if (buffer == nullptr) {
+          throw std::bad_alloc();
+        }
+        // Mark it for deallocation via free
+        ((unsigned int*)buffer)[0] = UINT_MAX;
+        // Return pointer after our book-keeping space
+        return (void*)(buffer + SassAllocatorBookSize);
+      }
+      // Use custom allocator
+      else {
+        // Get item from free list
+        void*& free = freeList[bucket];
+        // Do we have a free item?
+        if (free != nullptr) {
+          // Copy pointer to return
+          void* ptr = free;
+          // Update free list pointer
+          free = ((void**)ptr)[0];
+          // Return popped item
+          return ptr;
+        }
+      }
+
+      // Make sure we have enough space in the arena
+      if (!arena || offset > SassAllocatorArenaSize - size) {
+        if (arena) arenas.emplace_back(arena);
+        arena = (char*)malloc(SassAllocatorArenaSize);
+        if (arena == nullptr) throw std::bad_alloc();
+        offset = SassAllocatorArenaHeadSize;
+      }
+
+      // Get pointer into the arena
+      char* buffer = arena + offset;
+      // Consume object size
+      offset += size;
+
+      // Set the bucket index for this slice
+      ((unsigned int*)buffer)[0] = (unsigned int)bucket;
+
+      // Return pointer after our book-keeping space
+      return (void*)(buffer + SassAllocatorBookSize);
+
+    }
+    // EO allocate
+
+    void deallocate(void* ptr)
+    {
+
+      // Rewind buffer from pointer
+      char* buffer = (char*)ptr -
+        SassAllocatorBookSize;
+
+      // Get the bucket index stored in the header
+      unsigned int bucket = ((unsigned int*)buffer)[0];
+
+      // Check allocation method
+      if (bucket != UINT_MAX) {
+        // Let memory point to previous item in free list
+        ((void**)ptr)[0] = freeList[bucket];
+        // Free list now points to our memory
+        freeList[bucket] = (void*)ptr;
+      }
+      else {
+        // Release memory
+        free(buffer);
+      }
+
+    }
+    // EO deallocate
+
+  };
+
+}
+
+#endif