sassc 2.2.1 → 2.4.0

data/ext/libsass/src/lexer.cpp

@@ -2,11 +2,11 @@
 // __EXTENSIONS__ fix on Solaris.
 #include "sass.hpp"
 
-#include <cctype>
 #include <iostream>
 #include <iomanip>
 #include "lexer.hpp"
 #include "constants.hpp"
+#include "util_string.hpp"
 
 
 namespace Sass {
@@ -28,77 +28,14 @@ namespace Sass {
     const char* kwd_minus(const char* src) { return exactly<'-'>(src); };
     const char* kwd_slash(const char* src) { return exactly<'/'>(src); };
 
-    //####################################
-    // implement some function that do exist in the standard
-    // but those are locale aware which brought some trouble
-    // this even seems to improve performance by quite a bit
-    //####################################
-
-    bool is_alpha(const char& chr)
-    {
-      return unsigned(chr - 'A') <= 'Z' - 'A' ||
-             unsigned(chr - 'a') <= 'z' - 'a';
-    }
-
-    bool is_space(const char& chr)
-    {
-      // adapted the technique from is_alpha
-      return chr == ' ' || unsigned(chr - '\t') <= '\r' - '\t';
-    }
-
-    bool is_digit(const char& chr)
-    {
-      // adapted the technique from is_alpha
-      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
-      return unsigned(chr - '0') <= '9' - '0' ||
-             unsigned(chr - 'a') <= 'f' - 'a' ||
-             unsigned(chr - 'A') <= 'F' - 'A';
-    }
-
-    bool is_punct(const char& chr)
-    {
-      // locale independent
-      return chr == '.';
-    }
-
-    bool is_alnum(const char& chr)
-    {
-      return is_alpha(chr) || is_digit(chr);
-    }
-
-    // check if char is outside ascii range
-    bool is_unicode(const char& chr)
-    {
-      // check for unicode range
-      return unsigned(chr) > 127;
-    }
-
-    // check if char is outside ascii range
-    // but with specific ranges (copied from Ruby Sass)
-    bool is_nonascii(const char& chr)
-    {
-      unsigned int cmp = unsigned(chr);
-      return (
-        (cmp >= 128 && cmp <= 15572911) ||
-        (cmp >= 15630464 && cmp <= 15712189) ||
-        (cmp >= 4036001920)
-      );
+    bool is_number(char chr) {
+      return Util::ascii_isdigit(static_cast<unsigned char>(chr)) ||
+        chr == '-' || chr == '+';
     }
 
     // check if char is within a reduced ascii range
     // valid in a uri (copied from Ruby Sass)
-    bool is_uri_character(const char& chr)
+    bool is_uri_character(char chr)
     {
       unsigned int cmp = unsigned(chr);
       return (cmp > 41 && cmp < 127) ||
@@ -107,17 +44,19 @@ namespace Sass {
 
     // check if char is within a reduced ascii range
     // valid for escaping (copied from Ruby Sass)
-    bool is_escapable_character(const char& chr)
+    bool is_escapable_character(char chr)
     {
       unsigned int cmp = unsigned(chr);
       return cmp > 31 && cmp < 127;
     }
 
     // Match word character (look ahead)
-    bool is_character(const char& chr)
+    bool is_character(char chr)
     {
       // valid alpha, numeric or unicode char (plus hyphen)
-      return is_alnum(chr) || is_unicode(chr) || chr == '-';
+      return Util::ascii_isalnum(static_cast<unsigned char>(chr)) ||
+        !Util::ascii_isascii(static_cast<unsigned char>(chr)) ||
+        chr == '-';
     }
 
     //####################################
@@ -125,16 +64,13 @@ namespace Sass {
     //####################################
 
     // create matchers that advance the position
-    const char* space(const char* src) { return is_space(*src) ? src + 1 : 0; }
-    const char* alpha(const char* src) { return is_alpha(*src) ? src + 1 : 0; }
-    const char* unicode(const char* src) { return is_unicode(*src) ? src + 1 : 0; }
-    const char* nonascii(const char* src) { return is_nonascii(*src) ? src + 1 : 0; }
-    const char* digit(const char* src) { return is_digit(*src) ? src + 1 : 0; }
-    const char* xdigit(const char* src) { return is_xdigit(*src) ? src + 1 : 0; }
-    const char* alnum(const char* src) { return is_alnum(*src) ? src + 1 : 0; }
-    const char* punct(const char* src) { return is_punct(*src) ? src + 1 : 0; }
-    const char* hyphen(const char* src) { return *src && *src == '-' ? src + 1 : 0; }
-    const char* character(const char* src) { return is_character(*src) ? src + 1 : 0; }
+    const char* space(const char* src) { return Util::ascii_isspace(static_cast<unsigned char>(*src)) ? src + 1 : nullptr; }
+    const char* alpha(const char* src) { return Util::ascii_isalpha(static_cast<unsigned char>(*src)) ? src + 1 : nullptr; }
+    const char* nonascii(const char* src) { return Util::ascii_isascii(static_cast<unsigned char>(*src)) ? nullptr : src + 1; }
+    const char* digit(const char* src) { return Util::ascii_isdigit(static_cast<unsigned char>(*src)) ? src + 1 : nullptr; }
+    const char* xdigit(const char* src) { return Util::ascii_isxdigit(static_cast<unsigned char>(*src)) ? src + 1 : nullptr; }
+    const char* alnum(const char* src) { return Util::ascii_isalnum(static_cast<unsigned char>(*src)) ? src + 1 : nullptr; }
+    const char* hyphen(const char* src) { return *src == '-' ? src + 1 : 0; }
     const char* uri_character(const char* src) { return is_uri_character(*src) ? src + 1 : 0; }
     const char* escapable_character(const char* src) { return is_escapable_character(*src) ? src + 1 : 0; }
 
@@ -157,7 +93,9 @@ namespace Sass {
     const char* re_linebreak(const char* src)
     {
       // end of file or unix linefeed return here
-      if (*src == 0 || *src == '\n' || *src == '\f') return src + 1;
+      if (*src == 0) return src;
+      // end of file or unix linefeed return here
+      if (*src == '\n' || *src == '\f') return src + 1;
       // a carriage return may optionally be followed by a linefeed
       if (*src == '\r') return *(src + 1) == '\n' ? src + 2 : src + 1;
       // no linefeed

data/ext/libsass/src/lexer.hpp

@@ -24,19 +24,11 @@ namespace Sass {
     // BASIC CLASS MATCHERS
     //####################################
 
-    // These are locale independant
-    bool is_space(const char& src);
-    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);
-    bool is_nonascii(const char& src);
-    bool is_character(const char& src);
-    bool is_uri_character(const char& src);
-    bool escapable_character(const char& src);
+    // Matches ASCII digits, +, and -.
+    bool is_number(char src);
+
+    bool is_uri_character(char src);
+    bool escapable_character(char src);
 
     // Match a single ctype predicate.
     const char* space(const char* src);
@@ -44,11 +36,8 @@ namespace Sass {
     const char* digit(const char* src);
     const char* xdigit(const char* src);
     const char* alnum(const char* src);
-    const char* punct(const char* src);
     const char* hyphen(const char* src);
-    const char* unicode(const char* src);
     const char* nonascii(const char* src);
-    const char* character(const char* src);
     const char* uri_character(const char* src);
     const char* escapable_character(const char* src);
 

data/ext/libsass/src/listize.cpp

@@ -16,7 +16,13 @@ namespace Sass {
   Listize::Listize()
   {  }
 
-  Expression* Listize::operator()(Selector_List* sel)
+  Expression* Listize::perform(AST_Node* node)
+  {
+    Listize listize;
+    return node->perform(&listize);
+  }
+
+  Expression* Listize::operator()(SelectorList* sel)
   {
     List_Obj l = SASS_MEMORY_NEW(List, sel->pstate(), sel->length(), SASS_COMMA);
     l->from_selector(true);
@@ -28,9 +34,9 @@ namespace Sass {
     return SASS_MEMORY_NEW(Null, l->pstate());
   }
 
-  Expression* Listize::operator()(Compound_Selector* sel)
+  Expression* Listize::operator()(CompoundSelector* sel)
   {
-    std::string str;
+    sass::string str;
     for (size_t i = 0, L = sel->length(); i < L; ++i) {
       Expression* e = (*sel)[i]->perform(this);
       if (e) str += e->to_string();
@@ -38,45 +44,25 @@ namespace Sass {
     return SASS_MEMORY_NEW(String_Quoted, sel->pstate(), str);
   }
 
-  Expression* Listize::operator()(Complex_Selector* sel)
+  Expression* Listize::operator()(ComplexSelector* sel)
   {
-    List_Obj l = SASS_MEMORY_NEW(List, sel->pstate(), 2);
+    List_Obj l = SASS_MEMORY_NEW(List, sel->pstate());
+    // ToDo: investigate what this does
+    // Note: seems reated to parent ref
     l->from_selector(true);
-    Compound_Selector_Obj head = sel->head();
-    if (head && !head->is_empty_reference())
-    {
-      Expression* hh = head->perform(this);
-      if (hh) l->append(hh);
-    }
 
-    std::string reference = ! sel->reference() ? ""
-      : sel->reference()->to_string();
-    switch(sel->combinator())
-    {
-      case Complex_Selector::PARENT_OF:
-        l->append(SASS_MEMORY_NEW(String_Quoted, sel->pstate(), ">"));
-      break;
-      case Complex_Selector::ADJACENT_TO:
-        l->append(SASS_MEMORY_NEW(String_Quoted, sel->pstate(), "+"));
-      break;
-      case Complex_Selector::REFERENCE:
-        l->append(SASS_MEMORY_NEW(String_Quoted, sel->pstate(), "/" + reference + "/"));
-      break;
-      case Complex_Selector::PRECEDES:
-        l->append(SASS_MEMORY_NEW(String_Quoted, sel->pstate(), "~"));
-      break;
-      case Complex_Selector::ANCESTOR_OF:
-      break;
-      default: break;
+    for (auto component : sel->elements()) {
+      if (CompoundSelectorObj compound = Cast<CompoundSelector>(component)) {
+        if (!compound->empty()) {
+          ExpressionObj hh = compound->perform(this);
+          if (hh) l->append(hh);
+        }
+      }
+      else if (component) {
+        l->append(SASS_MEMORY_NEW(String_Quoted, component->pstate(), component->to_string()));
+      }
     }
 
-    Complex_Selector_Obj tail = sel->tail();
-    if (tail)
-    {
-      Expression_Obj tt = tail->perform(this);
-      if (List* ls = Cast<List>(tt))
-      { l->concat(ls); }
-    }
     if (l->length() == 0) return 0;
     return l.detach();
   }

data/ext/libsass/src/listize.hpp

@@ -5,13 +5,8 @@
 // __EXTENSIONS__ fix on Solaris.
 #include "sass.hpp"
 
-#include <vector>
-#include <iostream>
-
-#include "ast.hpp"
-#include "context.hpp"
+#include "ast_fwd_decl.hpp"
 #include "operation.hpp"
-#include "environment.hpp"
 
 namespace Sass {
 
@@ -19,13 +14,17 @@ namespace Sass {
 
   class Listize : public Operation_CRTP<Expression*, Listize> {
 
+  public:
+
+    static Expression* perform(AST_Node* node);
+
   public:
     Listize();
     ~Listize() { }
 
-    Expression* operator()(Selector_List*);
-    Expression* operator()(Complex_Selector*);
-    Expression* operator()(Compound_Selector*);
+    Expression* operator()(SelectorList*);
+    Expression* operator()(ComplexSelector*);
+    Expression* operator()(CompoundSelector*);
 
     // generic fallback
     template <typename U>

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/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