sassc 2.0.0 → 2.4.0

data/ext/libsass/src/prelexer.hpp

@@ -25,6 +25,7 @@ namespace Sass {
     const char* kwd_gte(const char* src);
     const char* kwd_lt(const char* src);
     const char* kwd_lte(const char* src);
+    const char* kwd_using(const char* src);
 
     // Match standard control chars
     const char* kwd_at(const char* src);
@@ -64,16 +65,15 @@ namespace Sass {
       size_t level = 0;
       bool in_squote = false;
       bool in_dquote = false;
-      // bool in_braces = false;
-
-      while (*src) {
-
-        // check for abort condition
-        if (end && src >= end) break;
+      bool in_backslash_escape = false;
 
+      while ((end == nullptr || src < end) && *src != '\0') {
         // has escaped sequence?
-        if (*src == '\\') {
-          ++ src; // skip this (and next)
+        if (in_backslash_escape) {
+          in_backslash_escape = false;
+        }
+        else if (*src == '\\') {
+          in_backslash_escape = true;
         }
         else if (*src == '"') {
           in_dquote = ! in_dquote;
@@ -119,7 +119,7 @@ namespace Sass {
     // first start/opener must be consumed already!
     template<prelexer start, prelexer stop>
     const char* skip_over_scopes(const char* src) {
-      return skip_over_scopes<start, stop>(src, 0);
+      return skip_over_scopes<start, stop>(src, nullptr);
     }
 
     // Match a sequence of characters delimited by the supplied chars.

data/ext/libsass/src/remove_placeholders.cpp

@@ -1,84 +1,86 @@
+// sass.hpp must go before all system headers to get the
+// __EXTENSIONS__ fix on Solaris.
 #include "sass.hpp"
+#include "ast.hpp"
+
 #include "remove_placeholders.hpp"
-#include "context.hpp"
-#include "inspect.hpp"
-#include <iostream>
 
 namespace Sass {
 
     Remove_Placeholders::Remove_Placeholders()
     { }
 
-    void Remove_Placeholders::operator()(Block_Ptr b) {
-        for (size_t i = 0, L = b->length(); i < L; ++i) {
-            Statement_Ptr st = b->at(i);
-            st->perform(this);
-        }
+    void Remove_Placeholders::operator()(Block* b) {
+      for (size_t i = 0, L = b->length(); i < L; ++i) {
+        if (b->get(i)) b->get(i)->perform(this);
+      }
     }
 
-    Selector_List_Ptr Remove_Placeholders::remove_placeholders(Selector_List_Ptr sl)
+    void Remove_Placeholders::remove_placeholders(SimpleSelector* simple)
     {
-      Selector_List_Ptr new_sl = SASS_MEMORY_NEW(Selector_List, sl->pstate());
-
-      for (size_t i = 0, L = sl->length(); i < L; ++i) {
-          if (!sl->at(i)->contains_placeholder()) {
-              new_sl->append(sl->at(i));
-          }
+      if (PseudoSelector * pseudo = simple->getPseudoSelector()) {
+        if (pseudo->selector()) remove_placeholders(pseudo->selector());
       }
-
-      return new_sl;
-
     }
 
+    void Remove_Placeholders::remove_placeholders(CompoundSelector* compound)
+    {
+      for (size_t i = 0, L = compound->length(); i < L; ++i) {
+        if (compound->get(i)) remove_placeholders(compound->get(i));
+      }
+      listEraseItemIf(compound->elements(), listIsEmpty<SimpleSelector>);
+    }
 
-    void Remove_Placeholders::operator()(Ruleset_Ptr r) {
-        // Create a new selector group without placeholders
-        Selector_List_Obj sl = Cast<Selector_List>(r->selector());
-
-        if (sl) {
-          // Set the new placeholder selector list
-          r->selector(remove_placeholders(sl));
-          // Remove placeholders in wrapped selectors
-          for (Complex_Selector_Obj cs : sl->elements()) {
-            while (cs) {
-              if (cs->head()) {
-                for (Simple_Selector_Obj& ss : cs->head()->elements()) {
-                  if (Wrapped_Selector_Ptr ws = Cast<Wrapped_Selector>(ss)) {
-                    if (Selector_List_Ptr wsl = Cast<Selector_List>(ws->selector())) {
-                      Selector_List_Ptr clean = remove_placeholders(wsl);
-                      // also clean superflous parent selectors
-                      // probably not really the correct place
-                      clean->remove_parent_selectors();
-                      ws->selector(clean);
-                    }
-                  }
-                }
-              }
-              cs = cs->tail();
-            }
+    void Remove_Placeholders::remove_placeholders(ComplexSelector* complex)
+    {
+      if (complex->has_placeholder()) {
+        complex->clear(); // remove all
+      }
+      else {
+        for (size_t i = 0, L = complex->length(); i < L; ++i) {
+          if (CompoundSelector * compound = complex->get(i)->getCompound()) {
+            if (compound) remove_placeholders(compound);
           }
         }
+        listEraseItemIf(complex->elements(), listIsEmpty<SelectorComponent>);
+      }
+    }
 
-        // Iterate into child blocks
-        Block_Obj b = r->block();
+    SelectorList* Remove_Placeholders::remove_placeholders(SelectorList* sl)
+    {
+      for (size_t i = 0, L = sl->length(); i < L; ++i) {
+        if (sl->get(i)) remove_placeholders(sl->get(i));
+      }
+      listEraseItemIf(sl->elements(), listIsEmpty<ComplexSelector>);
+      return sl;
+    }
 
-        for (size_t i = 0, L = b->length(); i < L; ++i) {
-            if (b->at(i)) {
-                Statement_Obj st = b->at(i);
-                st->perform(this);
-            }
-        }
+    void Remove_Placeholders::operator()(CssMediaRule* rule)
+    {
+      if (rule->block()) operator()(rule->block());
     }
 
-    void Remove_Placeholders::operator()(Media_Block_Ptr m) {
-        operator()(m->block());
+    void Remove_Placeholders::operator()(StyleRule* r)
+    {
+      if (SelectorListObj sl = r->selector()) {
+        // Set the new placeholder selector list
+        r->selector((remove_placeholders(sl)));
+      }
+      // Iterate into child blocks
+      Block_Obj b = r->block();
+      for (size_t i = 0, L = b->length(); i < L; ++i) {
+        if (b->get(i)) { b->get(i)->perform(this); }
+      }
     }
-    void Remove_Placeholders::operator()(Supports_Block_Ptr m) {
-        operator()(m->block());
+
+    void Remove_Placeholders::operator()(SupportsRule* m)
+    {
+      if (m->block()) operator()(m->block());
     }
 
-    void Remove_Placeholders::operator()(Directive_Ptr a) {
-        if (a->block()) a->block()->perform(this);
+    void Remove_Placeholders::operator()(AtRule* a)
+    {
+      if (a->block()) a->block()->perform(this);
     }
 
 }

data/ext/libsass/src/remove_placeholders.hpp

@@ -1,34 +1,36 @@
 #ifndef SASS_REMOVE_PLACEHOLDERS_H
 #define SASS_REMOVE_PLACEHOLDERS_H
 
-#pragma once
-
-#include "ast.hpp"
+#include "ast_fwd_decl.hpp"
 #include "operation.hpp"
 
 namespace Sass {
 
+  class Remove_Placeholders : public Operation_CRTP<void, Remove_Placeholders> {
+
+  public:
 
-    class Remove_Placeholders : public Operation_CRTP<void, Remove_Placeholders> {
+    SelectorList* remove_placeholders(SelectorList*);
+    void remove_placeholders(SimpleSelector* simple);
+    void remove_placeholders(CompoundSelector* complex);
+    void remove_placeholders(ComplexSelector* complex);
 
-        void fallback_impl(AST_Node_Ptr n) {}
 
-    public:
-      Selector_List_Ptr remove_placeholders(Selector_List_Ptr);
+  public:
+    Remove_Placeholders();
+    ~Remove_Placeholders() { }
 
-    public:
-        Remove_Placeholders();
-        ~Remove_Placeholders() { }
+    void operator()(Block*);
+    void operator()(StyleRule*);
+    void operator()(CssMediaRule*);
+    void operator()(SupportsRule*);
+    void operator()(AtRule*);
 
-        void operator()(Block_Ptr);
-        void operator()(Ruleset_Ptr);
-        void operator()(Media_Block_Ptr);
-        void operator()(Supports_Block_Ptr);
-        void operator()(Directive_Ptr);
+    // ignore missed types
+    template <typename U>
+    void fallback(U x) {}
 
-        template <typename U>
-        void fallback(U x) { return fallback_impl(x); }
-    };
+  };
 
 }
 

data/ext/libsass/src/sass.cpp

@@ -1,4 +1,7 @@
+// sass.hpp must go before all system headers to get the
+// __EXTENSIONS__ fix on Solaris.
 #include "sass.hpp"
+
 #include <cstdlib>
 #include <cstring>
 #include <vector>
@@ -7,15 +10,16 @@
 #include "sass.h"
 #include "file.hpp"
 #include "util.hpp"
+#include "context.hpp"
 #include "sass_context.hpp"
 #include "sass_functions.hpp"
 
 namespace Sass {
 
   // helper to convert string list to vector
-  std::vector<std::string> list2vec(struct string_list* cur)
+  sass::vector<sass::string> list2vec(struct string_list* cur)
   {
-    std::vector<std::string> list;
+    sass::vector<sass::string> list;
     while (cur) {
       list.push_back(cur->string);
       cur = cur->next;
@@ -33,13 +37,16 @@ extern "C" {
   void* ADDCALL sass_alloc_memory(size_t size)
   {
     void* ptr = malloc(size);
-    if (ptr == NULL)
-      out_of_memory();
+    if (ptr == NULL) {
+      std::cerr << "Out of memory.\n";
+      exit(EXIT_FAILURE);
+    }
     return ptr;
   }
 
   char* ADDCALL sass_copy_c_string(const char* str)
   {
+    if (str == nullptr) return nullptr;
     size_t len = strlen(str) + 1;
     char* cpy = (char*) sass_alloc_memory(len);
     std::memcpy(cpy, str, len);
@@ -55,14 +62,14 @@ extern "C" {
   // caller must free the returned memory
   char* ADDCALL sass_string_quote (const char *str, const char quote_mark)
   {
-    std::string quoted = quote(str, quote_mark);
+    sass::string quoted = quote(str, quote_mark);
     return sass_copy_c_string(quoted.c_str());
   }
 
   // caller must free the returned memory
   char* ADDCALL sass_string_unquote (const char *str)
   {
-    std::string unquoted = unquote(str);
+    sass::string unquoted = unquote(str);
     return sass_copy_c_string(unquoted.c_str());
   }
 
@@ -70,13 +77,13 @@ extern "C" {
   {
     // get the last import entry to get current base directory
     Sass_Import_Entry import = sass_compiler_get_last_import(compiler);
-    const std::vector<std::string>& incs = compiler->cpp_ctx->include_paths;
+    const sass::vector<sass::string>& incs = compiler->cpp_ctx->include_paths;
     // create the vector with paths to lookup
-    std::vector<std::string> paths(1 + incs.size());
+    sass::vector<sass::string> paths(1 + incs.size());
     paths.push_back(File::dir_name(import->abs_path));
     paths.insert( paths.end(), incs.begin(), incs.end() );
     // now resolve the file path relative to lookup paths
-    std::string resolved(File::find_include(file, paths));
+    sass::string resolved(File::find_include(file, paths));
     return sass_copy_c_string(resolved.c_str());
   }
 
@@ -84,13 +91,13 @@ extern "C" {
   {
     // get the last import entry to get current base directory
     Sass_Import_Entry import = sass_compiler_get_last_import(compiler);
-    const std::vector<std::string>& incs = compiler->cpp_ctx->include_paths;
+    const sass::vector<sass::string>& incs = compiler->cpp_ctx->include_paths;
     // create the vector with paths to lookup
-    std::vector<std::string> paths(1 + incs.size());
+    sass::vector<sass::string> paths(1 + incs.size());
     paths.push_back(File::dir_name(import->abs_path));
     paths.insert( paths.end(), incs.begin(), incs.end() );
     // now resolve the file path relative to lookup paths
-    std::string resolved(File::find_file(file, paths));
+    sass::string resolved(File::find_file(file, paths));
     return sass_copy_c_string(resolved.c_str());
   }
 
@@ -99,8 +106,8 @@ extern "C" {
   // this has the original resolve logic for sass include
   char* ADDCALL sass_find_include (const char* file, struct Sass_Options* opt)
   {
-    std::vector<std::string> vec(list2vec(opt->include_paths));
-    std::string resolved(File::find_include(file, vec));
+    sass::vector<sass::string> vec(list2vec(opt->include_paths));
+    sass::string resolved(File::find_include(file, vec));
     return sass_copy_c_string(resolved.c_str());
   }
 
@@ -108,8 +115,8 @@ extern "C" {
   // Incs array has to be null terminated!
   char* ADDCALL sass_find_file (const char* file, struct Sass_Options* opt)
   {
-    std::vector<std::string> vec(list2vec(opt->include_paths));
-    std::string resolved(File::find_file(file, vec));
+    sass::vector<sass::string> vec(list2vec(opt->include_paths));
+    sass::string resolved(File::find_file(file, vec));
     return sass_copy_c_string(resolved.c_str());
   }
 
@@ -130,7 +137,7 @@ extern "C" {
 namespace Sass {
 
   // helper to aid dreaded MSVC debug mode
-  char* sass_copy_string(std::string str)
+  char* sass_copy_string(sass::string str)
   {
     // In MSVC the following can lead to segfault:
     // sass_copy_c_string(stream.str().c_str());
@@ -146,4 +153,4 @@ namespace Sass {
     return sass_copy_c_string(str.c_str());
   }
 
-}
+}

data/ext/libsass/src/sass.hpp

@@ -11,14 +11,20 @@
 #pragma warning(disable : 4005)
 #endif
 
-// aplies to MSVC and MinGW
+// applies to MSVC and MinGW
 #ifdef _WIN32
 // we do not want the ERROR macro
-# define NOGDI
+# ifndef NOGDI
+#  define NOGDI
+# endif
 // we do not want the min/max macro
-# define NOMINMAX
+# ifndef NOMINMAX
+#  define NOMINMAX
+# endif
 // we do not want the IN/OUT macro
-# define _NO_W32_PSEUDO_MODIFIERS
+# ifndef _NO_W32_PSEUDO_MODIFIERS
+#  define _NO_W32_PSEUDO_MODIFIERS
+# endif
 #endif
 
 
@@ -42,13 +48,17 @@
 #endif
 
 
-// include C-API header
+// Include C-API header
 #include "sass/base.h"
 
+// Include allocator
+#include "memory.hpp"
+
 // For C++ helper
 #include <string>
+#include <vector>
 
-// output behaviours
+// output behavior
 namespace Sass {
 
   // create some C++ aliases for the most used options
@@ -59,14 +69,15 @@ namespace Sass {
   // only used internal to trigger ruby inspect behavior
   const static Sass_Output_Style INSPECT = SASS_STYLE_INSPECT;
   const static Sass_Output_Style TO_SASS = SASS_STYLE_TO_SASS;
+  const static Sass_Output_Style TO_CSS = SASS_STYLE_TO_CSS;
 
   // helper to aid dreaded MSVC debug mode
   // see implementation for more details
-  char* sass_copy_string(std::string str);
+  char* sass_copy_string(sass::string str);
 
 }
 
-// input behaviours
+// input behaviors
 enum Sass_Input_Style {
   SASS_CONTEXT_NULL,
   SASS_CONTEXT_FILE,
@@ -90,13 +101,10 @@ struct Sass_Inspect_Options {
   // Precision for fractional numbers
   int precision;
 
-  // Do not compress colors in selectors
-  bool in_selector;
-
   // initialization list (constructor with defaults)
   Sass_Inspect_Options(Sass_Output_Style style = Sass::NESTED,
-                       int precision = 5, bool in_selector = false)
-  : output_style(style), precision(precision), in_selector(in_selector)
+                       int precision = 10)
+  : output_style(style), precision(precision)
   { }
 
 };
@@ -125,7 +133,7 @@ struct Sass_Output_Options : Sass_Inspect_Options {
 
   // initialization list (constructor with defaults)
   Sass_Output_Options(Sass_Output_Style style = Sass::NESTED,
-                      int precision = 5,
+                      int precision = 10,
                       const char* indent = "  ",
                       const char* linefeed = "\n",
                       bool source_comments = false)