sassc 2.0.0 → 2.4.0

data/ext/libsass/src/permutate.hpp

@@ -0,0 +1,164 @@
+#ifndef SASS_PATHS_H
+#define SASS_PATHS_H
+
+#include <vector>
+
+namespace Sass {
+
+  // Returns a list of all possible paths through the given lists.
+  //
+  // For example, given `[[1, 2], [3, 4], [5, 6]]`, this returns:
+  //
+  // ```
+  // [[1, 3, 5],
+  //  [2, 3, 5],
+  //  [1, 4, 5],
+  //  [2, 4, 5],
+  //  [1, 3, 6],
+  //  [2, 3, 6],
+  //  [1, 4, 6],
+  //  [2, 4, 6]]
+  // ```
+  // 
+  // Note: called `paths` in dart-sass
+  template <class T>
+  sass::vector<sass::vector<T>> permutate(
+    const sass::vector<sass::vector<T>>& in)
+  {
+
+    size_t L = in.size(), n = 0;
+
+    if (L == 0) return {};
+    // Exit early if any entry is empty
+    for (size_t i = 0; i < L; i += 1) {
+      if (in[i].size() == 0) return {};
+    }
+
+    size_t* state = new size_t[L + 1];
+    sass::vector<sass::vector<T>> out;
+
+    // First initialize all states for every permutation group
+    for (size_t i = 0; i < L; i += 1) {
+      state[i] = in[i].size() - 1;
+    }
+    while (true) {
+      sass::vector<T> perm;
+      // Create one permutation for state
+      for (size_t i = 0; i < L; i += 1) {
+        perm.push_back(in.at(i).at(in[i].size() - state[i] - 1));
+      }
+      // Current group finished
+      if (state[n] == 0) {
+        // Find position of next decrement
+        while (n < L && state[++n] == 0) {}
+
+        if (n == L) {
+          out.push_back(perm);
+          break;
+        }
+
+        state[n] -= 1;
+
+        for (size_t p = 0; p < n; p += 1) {
+          state[p] = in[p].size() - 1;
+        }
+
+        // Restart from front
+        n = 0;
+
+      }
+      else {
+        state[n] -= 1;
+      }
+      out.push_back(perm);
+    }
+
+    delete[] state;
+    return out;
+  }
+  // EO permutate
+
+  // ToDo: this variant is used in resolveParentSelectors
+  // Returns a list of all possible paths through the given lists.
+  //
+  // For example, given `[[1, 2], [3, 4], [5, 6]]`, this returns:
+  //
+  // ```
+  // [[1, 3, 5],
+  //  [1, 3, 6],
+  //  [1, 4, 5],
+  //  [1, 4, 6],
+  //  [2, 3, 5],
+  //  [2, 3, 6],
+  //  [2, 4, 5],
+  //  [2, 4, 6]]
+  // ```
+  // 
+  template <class T>
+  sass::vector<sass::vector<T>>
+    permutateAlt(const sass::vector<sass::vector<T>>& in) {
+
+    size_t L = in.size();
+    size_t n = in.size() - 1;
+
+    if (L == 0) return {};
+    // Exit early if any entry is empty
+    for (size_t i = 0; i < L; i += 1) {
+      if (in[i].size() == 0) return {};
+    }
+
+    size_t* state = new size_t[L];
+    sass::vector<sass::vector<T>> out;
+
+    // First initialize all states for every permutation group
+    for (size_t i = 0; i < L; i += 1) {
+      state[i] = in[i].size() - 1;
+    }
+
+    while (true) {
+      /*
+      // std::cerr << "PERM: ";
+      for (size_t p = 0; p < L; p++)
+      { // std::cerr << state[p] << " "; }
+      // std::cerr << "\n";
+      */
+      sass::vector<T> perm;
+      // Create one permutation for state
+      for (size_t i = 0; i < L; i += 1) {
+        perm.push_back(in.at(i).at(in[i].size() - state[i] - 1));
+      }
+      // Current group finished
+      if (state[n] == 0) {
+        // Find position of next decrement
+        while (n > 0 && state[--n] == 0) {}
+
+        // Check for end condition
+        if (state[n] != 0) {
+          // Decrease next on the left side
+          state[n] -= 1;
+          // Reset all counters to the right
+          for (size_t p = n + 1; p < L; p += 1) {
+            state[p] = in[p].size() - 1;
+          }
+          // Restart from end
+          n = L - 1;
+        }
+        else {
+          out.push_back(perm);
+          break;
+        }
+      }
+      else {
+        state[n] -= 1;
+      }
+      out.push_back(perm);
+    }
+
+    delete[] state;
+    return out;
+  }
+  // EO permutateAlt
+
+}
+
+#endif

data/ext/libsass/src/plugins.cpp

@@ -1,7 +1,11 @@
+// sass.hpp must go before all system headers to get the
+// __EXTENSIONS__ fix on Solaris.
 #include "sass.hpp"
+
 #include <iostream>
 #include "output.hpp"
 #include "plugins.hpp"
+#include "util.hpp"
 
 #ifdef _WIN32
 #include <windows.h>
@@ -40,18 +44,18 @@ namespace Sass {
     if (!strcmp(our_version, "[na]")) return false;
 
     // find the position of the second dot
-    size_t pos = std::string(our_version).find('.', 0);
-    if (pos != std::string::npos) pos = std::string(our_version).find('.', pos + 1);
+    size_t pos = sass::string(our_version).find('.', 0);
+    if (pos != sass::string::npos) pos = sass::string(our_version).find('.', pos + 1);
 
     // if we do not have two dots we fallback to compare complete string
-    if (pos == std::string::npos) { return strcmp(their_version, our_version) ? 0 : 1; }
+    if (pos == sass::string::npos) { return strcmp(their_version, our_version) ? 0 : 1; }
     // otherwise only compare up to the second dot (major versions)
     else { return strncmp(their_version, our_version, pos) ? 0 : 1; }
 
   }
 
   // load one specific plugin
-  bool Plugins::load_plugin (const std::string& path)
+  bool Plugins::load_plugin (const sass::string& path)
   {
 
     typedef const char* (*__plugin_version__)(void);
@@ -108,7 +112,7 @@ namespace Sass {
 
   }
 
-  size_t Plugins::load_plugins(const std::string& path)
+  size_t Plugins::load_plugins(const sass::string& path)
   {
 
     // count plugins
@@ -122,7 +126,7 @@ namespace Sass {
         // use wchar (utf16)
         WIN32_FIND_DATAW data;
         // trailing slash is guaranteed
-        std::string globsrch(path + "*.dll");
+        sass::string globsrch(path + "*.dll");
         // convert to wide chars (utf16) for system call
         std::wstring wglobsrch(UTF_8::convert_to_utf16(globsrch));
         HANDLE hFile = FindFirstFileW(wglobsrch.c_str(), &data);
@@ -136,7 +140,7 @@ namespace Sass {
           try
           {
             // the system will report the filenames with wide chars (utf16)
-            std::string entry = UTF_8::convert_from_utf16(data.cFileName);
+            sass::string entry = UTF_8::convert_from_utf16(data.cFileName);
             // check if file ending matches exactly
             if (!ends_with(entry, ".dll")) continue;
             // load the plugin and increase counter
@@ -154,7 +158,7 @@ namespace Sass {
           }
         }
       }
-      catch (utf8::invalid_utf8)
+      catch (utf8::invalid_utf8&)
       {
         // report the error to the console (should not happen)
         // implementors should make sure to provide valid utf8

data/ext/libsass/src/plugins.hpp

@@ -36,19 +36,19 @@ namespace Sass {
 
     public: // methods
       // load one specific plugin
-      bool load_plugin(const std::string& path);
+      bool load_plugin(const sass::string& path);
       // load all plugins from a directory
-      size_t load_plugins(const std::string& path);
+      size_t load_plugins(const sass::string& path);
 
     public: // public accessors
-      const std::vector<Sass_Importer_Entry> get_headers(void) { return headers; }
-      const std::vector<Sass_Importer_Entry> get_importers(void) { return importers; }
-      const std::vector<Sass_Function_Entry> get_functions(void) { return functions; }
+      const sass::vector<Sass_Importer_Entry> get_headers(void) { return headers; }
+      const sass::vector<Sass_Importer_Entry> get_importers(void) { return importers; }
+      const sass::vector<Sass_Function_Entry> get_functions(void) { return functions; }
 
     private: // private vars
-      std::vector<Sass_Importer_Entry> headers;
-      std::vector<Sass_Importer_Entry> importers;
-      std::vector<Sass_Function_Entry> functions;
+      sass::vector<Sass_Importer_Entry> headers;
+      sass::vector<Sass_Importer_Entry> importers;
+      sass::vector<Sass_Function_Entry> functions;
 
   };
 

data/ext/libsass/src/position.cpp

@@ -1,5 +1,9 @@
+// sass.hpp must go before all system headers to get the
+// __EXTENSIONS__ fix on Solaris.
 #include "sass.hpp"
+
 #include "position.hpp"
+#include "source.hpp"
 
 namespace Sass {
 
@@ -15,7 +19,7 @@ namespace Sass {
     *this = inc(string, string + strlen(string));
   }
 
-  Offset::Offset(const std::string& text)
+  Offset::Offset(const sass::string& text)
   : line(0), column(0)
   {
     *this = inc(text.c_str(), text.c_str() + text.size());
@@ -53,7 +57,7 @@ namespace Sass {
         // skip over 10xxxxxx
         // is 1st bit not set
         if ((chr & 128) == 0) {
-          // regular ascii char
+          // regular ASCII char
           column += 1;
         }
         // is 2nd bit not set
@@ -114,14 +118,11 @@ namespace Sass {
   : Offset(line, column), file(file) { }
 
 
-  ParserState::ParserState(const char* path, const char* src, const size_t file)
-  : Position(file, 0, 0), path(path), src(src), offset(0, 0), token() { }
-
-  ParserState::ParserState(const char* path, const char* src, const Position& position, Offset offset)
-  : Position(position), path(path), src(src), offset(offset), token() { }
+  SourceSpan::SourceSpan(const char* path)
+  : source(SASS_MEMORY_NEW(SynthFile, path)), position(0, 0), offset(0, 0) { }
 
-  ParserState::ParserState(const char* path, const char* src, const Token& token, const Position& position, Offset offset)
-  : Position(position), path(path), src(src), offset(offset), token(token) { }
+  SourceSpan::SourceSpan(SourceDataObj source, const Offset& position, const Offset& offset)
+    : source(source), position(position), offset(offset) { }
 
   Position Position::add(const char* begin, const char* end)
   {
@@ -161,21 +162,4 @@ namespace Sass {
     return Offset(line - off.line, off.line == line ? column - off.column : column);
   }
 
-  /* not used anymore - remove?
-  std::ostream& operator<<(std::ostream& strm, const Offset& off)
-  {
-    if (off.line == string::npos) strm << "-1:"; else strm << off.line << ":";
-    if (off.column == string::npos) strm << "-1"; else strm << off.column;
-    return strm;
-  } */
-
-  /* not used anymore - remove?
-  std::ostream& operator<<(std::ostream& strm, const Position& pos)
-  {
-    if (pos.file != string::npos) strm << pos.file << ":";
-    if (pos.line == string::npos) strm << "-1:"; else strm << pos.line << ":";
-    if (pos.column == string::npos) strm << "-1"; else strm << pos.column;
-    return strm;
-  } */
-
 }

data/ext/libsass/src/position.hpp

@@ -3,7 +3,8 @@
 
 #include <string>
 #include <cstring>
-// #include <iostream>
+#include "source_data.hpp"
+#include "ast_fwd_decl.hpp"
 
 namespace Sass {
 
@@ -13,7 +14,7 @@ namespace Sass {
     public: // c-tor
       Offset(const char chr);
       Offset(const char* string);
-      Offset(const std::string& text);
+      Offset(const sass::string& text);
       Offset(const size_t line, const size_t column);
 
       // return new position, incremented by the given string
@@ -85,37 +86,59 @@ namespace Sass {
     : prefix(p), begin(b), end(e) { }
 
     size_t length()    const { return end - begin; }
-    std::string ws_before() const { return std::string(prefix, begin); }
-    const std::string to_string() const { return std::string(begin, end); }
-    std::string time_wspace() const {
-      std::string str(to_string());
-      std::string whitespaces(" \t\f\v\n\r");
+    sass::string ws_before() const { return sass::string(prefix, begin); }
+    sass::string to_string() const { return sass::string(begin, end); }
+    sass::string time_wspace() const {
+      sass::string str(to_string());
+      sass::string whitespaces(" \t\f\v\n\r");
       return str.erase(str.find_last_not_of(whitespaces)+1);
     }
 
     operator bool()        { return begin && end && begin >= end; }
-    operator std::string() { return to_string(); }
+    operator sass::string() { return to_string(); }
 
     bool operator==(Token t)  { return to_string() == t.to_string(); }
   };
 
-  class ParserState : public Position {
+  class SourceSpan {
 
-    public: // c-tor
-      ParserState(const char* path, const char* src = 0, const size_t file = std::string::npos);
-      ParserState(const char* path, const char* src, const Position& position, Offset offset = Offset(0, 0));
-      ParserState(const char* path, const char* src, const Token& token, const Position& position, Offset offset = Offset(0, 0));
+    public:
 
-    public: // down casts
-      Offset off() { return *this; }
-      Position pos() { return *this; }
-      ParserState pstate() { return *this; }
+      SourceSpan(const char* path);
 
-    public:
-      const char* path;
-      const char* src;
+      SourceSpan(SourceDataObj source,
+        const Offset& position = Offset(0, 0),
+        const Offset& offset = Offset(0, 0));
+
+      const char* getPath() const {
+        return source->getPath();
+      }
+
+      const char* getRawData() const {
+        return source->getRawData();
+      }
+
+      Offset getPosition() const {
+        return position;
+      }
+
+      size_t getLine() const {
+        return position.line + 1;
+      }
+
+      size_t getColumn() const {
+        return position.column + 1;
+      }
+
+      size_t getSrcId() const {
+        return source == nullptr
+          ? std::string::npos
+          : source->getSrcId();
+      }
+
+      SourceDataObj source;
+      Offset position;
       Offset offset;
-      Token token;
 
   };
 

data/ext/libsass/src/prelexer.cpp

@@ -1,8 +1,11 @@
+// sass.hpp must go before all system headers to get the
+// __EXTENSIONS__ fix on Solaris.
 #include "sass.hpp"
-#include <cctype>
+
 #include <iostream>
 #include <iomanip>
 #include "util.hpp"
+#include "util_string.hpp"
 #include "position.hpp"
 #include "prelexer.hpp"
 #include "constants.hpp"
@@ -260,7 +263,7 @@ namespace Sass {
       >(src);
     }
 
-    // Match a line comment (/.*?(?=\n|\r\n?|\Z)/.
+    // Match a line comment (/.*?(?=\n|\r\n?|\f|\Z)/.
     const char* line_comment(const char* src)
     {
       return sequence<
@@ -333,7 +336,7 @@ namespace Sass {
       return alternatives<
                unicode_seq,
                alpha,
-               unicode,
+               nonascii,
                exactly<'-'>,
                exactly<'_'>,
                NONASCII,
@@ -348,7 +351,7 @@ namespace Sass {
       return alternatives<
                unicode_seq,
                alnum,
-               unicode,
+               nonascii,
                exactly<'-'>,
                exactly<'_'>,
                NONASCII,
@@ -382,7 +385,7 @@ namespace Sass {
     {
       return alternatives <
                alpha,
-               unicode,
+               nonascii,
                escape_seq,
                exactly<'_'>
              >(src);
@@ -392,7 +395,7 @@ namespace Sass {
     {
       return alternatives <
                alnum,
-               unicode,
+               nonascii,
                escape_seq,
                exactly<'_'>
              >(src);
@@ -1260,6 +1263,9 @@ namespace Sass {
     const char* kwd_lte(const char* src) {
       return exactly<lte>(src);
     }
+    const char* kwd_using(const char* src) {
+      return keyword<using_kwd>(src);
+    }
 
     // match specific IE syntax
     const char* ie_progid(const char* src) {
@@ -1394,7 +1400,7 @@ namespace Sass {
     }*/
 
     const char* H(const char* src) {
-      return std::isxdigit(*src) ? src+1 : 0;
+      return Util::ascii_isxdigit(static_cast<unsigned char>(*src)) ? src+1 : 0;
     }
 
     const char* W(const char* src) {
@@ -1606,7 +1612,7 @@ namespace Sass {
       >(src);
     }
 
-    extern const char css_variable_url_top_level_negates[] = "()[]{}\"'#/;!";
+    extern const char css_variable_url_top_level_negates[] = "()[]{}\"'#/;";
     const char* css_variable_top_level_value(const char* src) {
       return sequence<
         alternatives<