sassc4 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

@@ -0,0 +1,188 @@
+// 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>
+#else
+#include <sys/types.h>
+#include <dirent.h>
+#include <errno.h>
+#include <dlfcn.h>
+#endif
+
+namespace Sass {
+
+  Plugins::Plugins(void) { }
+  Plugins::~Plugins(void)
+  {
+    for (auto function : functions) {
+      sass_delete_function(function);
+    }
+    for (auto importer : importers) {
+      sass_delete_importer(importer);
+    }
+    for (auto header : headers) {
+      sass_delete_importer(header);
+    }
+  }
+
+  // check if plugin is compatible with this version
+  // plugins may be linked static against libsass
+  // we try to be compatible between major versions
+  inline bool compatibility(const char* their_version)
+  {
+// const char* their_version = "3.1.2";
+    // first check if anyone has an unknown version
+    const char* our_version = libsass_version();
+    if (!strcmp(their_version, "[na]")) return false;
+    if (!strcmp(our_version, "[na]")) return false;
+
+    // find the position of the second dot
+    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 == 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 sass::string& path)
+  {
+
+    typedef const char* (*__plugin_version__)(void);
+    typedef Sass_Function_List (*__plugin_load_fns__)(void);
+    typedef Sass_Importer_List (*__plugin_load_imps__)(void);
+
+    if (LOAD_LIB(plugin, path))
+    {
+      // try to load initial function to query libsass version suppor
+      if (LOAD_LIB_FN(__plugin_version__, plugin_version, "libsass_get_version"))
+      {
+        // get the libsass version of the plugin
+        if (!compatibility(plugin_version())) return false;
+        // try to get import address for "libsass_load_functions"
+        if (LOAD_LIB_FN(__plugin_load_fns__, plugin_load_functions, "libsass_load_functions"))
+        {
+          Sass_Function_List fns = plugin_load_functions(), _p = fns;
+          while (fns && *fns) { functions.push_back(*fns); ++ fns; }
+          sass_free_memory(_p); // only delete the container, items not yet
+        }
+        // try to get import address for "libsass_load_importers"
+        if (LOAD_LIB_FN(__plugin_load_imps__, plugin_load_importers, "libsass_load_importers"))
+        {
+          Sass_Importer_List imps = plugin_load_importers(), _p = imps;
+          while (imps && *imps) { importers.push_back(*imps); ++ imps; }
+          sass_free_memory(_p); // only delete the container, items not yet
+        }
+        // try to get import address for "libsass_load_headers"
+        if (LOAD_LIB_FN(__plugin_load_imps__, plugin_load_headers, "libsass_load_headers"))
+        {
+          Sass_Importer_List imps = plugin_load_headers(), _p = imps;
+          while (imps && *imps) { headers.push_back(*imps); ++ imps; }
+          sass_free_memory(_p); // only delete the container, items not yet
+        }
+        // success
+        return true;
+      }
+      else
+      {
+        // print debug message to stderr (should not happen)
+        std::cerr << "failed loading 'libsass_support' in <" << path << ">" << std::endl;
+        if (const char* dlsym_error = dlerror()) std::cerr << dlsym_error << std::endl;
+        CLOSE_LIB(plugin);
+      }
+    }
+    else
+    {
+      // print debug message to stderr (should not happen)
+      std::cerr << "failed loading plugin <" << path << ">" << std::endl;
+      if (const char* dlopen_error = dlerror()) std::cerr << dlopen_error << std::endl;
+    }
+
+    return false;
+
+  }
+
+  size_t Plugins::load_plugins(const sass::string& path)
+  {
+
+    // count plugins
+    size_t loaded = 0;
+
+    #ifdef _WIN32
+
+      try
+      {
+
+        // use wchar (utf16)
+        WIN32_FIND_DATAW data;
+        // trailing slash is guaranteed
+        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);
+        // check if system called returned a result
+        // ToDo: maybe we should print a debug message
+        if (hFile == INVALID_HANDLE_VALUE) return -1;
+
+        // read directory
+        while (true)
+        {
+          try
+          {
+            // the system will report the filenames with wide chars (utf16)
+            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
+            if (load_plugin(path + entry)) ++ loaded;
+            // check if there should be more entries
+            if (GetLastError() == ERROR_NO_MORE_FILES) break;
+            // load next entry (check for return type)
+            if (!FindNextFileW(hFile, &data)) break;
+          }
+          catch (...)
+          {
+            // report the error to the console (should not happen)
+            // seems like we got strange data from the system call?
+            std::cerr << "filename in plugin path has invalid utf8?" << std::endl;
+          }
+        }
+      }
+      catch (utf8::invalid_utf8&)
+      {
+        // report the error to the console (should not happen)
+        // implementors should make sure to provide valid utf8
+        std::cerr << "plugin path contains invalid utf8" << std::endl;
+      }
+
+    #else
+
+      DIR *dp;
+      struct dirent *dirp;
+      if((dp  = opendir(path.c_str())) == NULL) return -1;
+      while ((dirp = readdir(dp)) != NULL) {
+        #if __APPLE__
+          if (!ends_with(dirp->d_name, ".dylib")) continue;
+        #else
+          if (!ends_with(dirp->d_name, ".so")) continue;
+        #endif
+        if (load_plugin(path + dirp->d_name)) ++ loaded;
+      }
+      closedir(dp);
+
+    #endif
+    return loaded;
+
+  }
+
+}

data/ext/libsass/src/plugins.hpp

@@ -0,0 +1,57 @@
+#ifndef SASS_PLUGINS_H
+#define SASS_PLUGINS_H
+
+#include <string>
+#include <vector>
+#include "utf8_string.hpp"
+#include "sass/functions.h"
+
+#ifdef _WIN32
+
+  #define LOAD_LIB(var, path) HMODULE var = LoadLibraryW(UTF_8::convert_to_utf16(path).c_str())
+  #define LOAD_LIB_WCHR(var, path_wide_str) HMODULE var = LoadLibraryW(path_wide_str.c_str())
+  #define LOAD_LIB_FN(type, var, name) type var = (type) GetProcAddress(plugin, name)
+  #define CLOSE_LIB(var) FreeLibrary(var)
+
+  #ifndef dlerror
+  #define dlerror() 0
+  #endif
+
+#else
+
+  #define LOAD_LIB(var, path) void* var = dlopen(path.c_str(), RTLD_LAZY)
+  #define LOAD_LIB_FN(type, var, name) type var = (type) dlsym(plugin, name)
+  #define CLOSE_LIB(var) dlclose(var)
+
+#endif
+
+namespace Sass {
+
+
+  class Plugins {
+
+    public: // c-tor
+      Plugins(void);
+      ~Plugins(void);
+
+    public: // methods
+      // load one specific plugin
+      bool load_plugin(const sass::string& path);
+      // load all plugins from a directory
+      size_t load_plugins(const sass::string& path);
+
+    public: // public accessors
+      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
+      sass::vector<Sass_Importer_Entry> headers;
+      sass::vector<Sass_Importer_Entry> importers;
+      sass::vector<Sass_Function_Entry> functions;
+
+  };
+
+}
+
+#endif

data/ext/libsass/src/position.cpp

@@ -0,0 +1,163 @@
+// 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 {
+
+
+  Offset::Offset(const char chr)
+  : line(chr == '\n' ? 1 : 0),
+    column(chr == '\n' ? 0 : 1)
+  {}
+
+  Offset::Offset(const char* string)
+  : line(0), column(0)
+  {
+    *this = inc(string, string + strlen(string));
+  }
+
+  Offset::Offset(const sass::string& text)
+  : line(0), column(0)
+  {
+    *this = inc(text.c_str(), text.c_str() + text.size());
+  }
+
+  Offset::Offset(const size_t line, const size_t column)
+  : line(line), column(column) { }
+
+  // init/create instance from const char substring
+  Offset Offset::init(const char* beg, const char* end)
+  {
+    Offset offset(0, 0);
+    if (end == 0) {
+      end = beg + strlen(beg);
+    }
+    offset.add(beg, end);
+    return offset;
+  }
+
+  // increase offset by given string (mostly called by lexer)
+  // increase line counter and count columns on the last line
+  Offset Offset::add(const char* begin, const char* end)
+  {
+    if (end == 0) return *this;
+    while (begin < end && *begin) {
+      if (*begin == '\n') {
+        ++ line;
+        // start new line
+        column = 0;
+      } else {
+        // do not count any utf8 continuation bytes
+        // https://stackoverflow.com/a/9356203/1550314
+        // https://en.wikipedia.org/wiki/UTF-8#Description
+        unsigned char chr = *begin;
+        // Ignore all `10xxxxxx` chars
+        // '0xxxxxxx' are ASCII chars
+        // '11xxxxxx' are utf8 starts
+        // 64 => initial utf8 byte
+        // 128 => regular ASCII char
+        if ((chr & 192) != 128) {
+          // regular ASCII char
+          column += 1;
+        }
+      }
+      ++ begin;
+    }
+    return *this;
+  }
+
+  // increase offset by given string (mostly called by lexer)
+  // increase line counter and count columns on the last line
+  Offset Offset::inc(const char* begin, const char* end) const
+  {
+    Offset offset(line, column);
+    offset.add(begin, end);
+    return offset;
+  }
+
+  bool Offset::operator== (const Offset &pos) const
+  {
+    return line == pos.line && column == pos.column;
+  }
+
+  bool Offset::operator!= (const Offset &pos) const
+  {
+    return line != pos.line || column != pos.column;
+  }
+
+  void Offset::operator+= (const Offset &off)
+  {
+    *this = Offset(line + off.line, off.line > 0 ? off.column : column + off.column);
+  }
+
+  Offset Offset::operator+ (const Offset &off) const
+  {
+    return Offset(line + off.line, off.line > 0 ? off.column : column + off.column);
+  }
+
+  Offset Offset::operator- (const Offset &off) const
+  {
+    return Offset(line - off.line, off.line == line ? column - off.column : column);
+  }
+
+  Position::Position(const size_t file)
+  : Offset(0, 0), file(file) { }
+
+  Position::Position(const size_t file, const Offset& offset)
+  : Offset(offset), file(file) { }
+
+  Position::Position(const size_t line, const size_t column)
+  : Offset(line, column), file(-1) { }
+
+  Position::Position(const size_t file, const size_t line, const size_t column)
+  : Offset(line, column), file(file) { }
+
+
+  SourceSpan::SourceSpan(const char* path)
+  : source(SASS_MEMORY_NEW(SynthFile, path)), position(0, 0), offset(0, 0) { }
+
+  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)
+  {
+    Offset::add(begin, end);
+    return *this;
+  }
+
+  Position Position::inc(const char* begin, const char* end) const
+  {
+    Offset offset(line, column);
+    offset = offset.inc(begin, end);
+    return Position(file, offset);
+  }
+
+  bool Position::operator== (const Position &pos) const
+  {
+    return file == pos.file && line == pos.line && column == pos.column;
+  }
+
+  bool Position::operator!= (const Position &pos) const
+  {
+    return file == pos.file || line != pos.line || column != pos.column;
+  }
+
+  void Position::operator+= (const Offset &off)
+  {
+    *this = Position(file, line + off.line, off.line > 0 ? off.column : column + off.column);
+  }
+
+  const Position Position::operator+ (const Offset &off) const
+  {
+    return Position(file, line + off.line, off.line > 0 ? off.column : column + off.column);
+  }
+
+  const Offset Position::operator- (const Offset &off) const
+  {
+    return Offset(line - off.line, off.line == line ? column - off.column : column);
+  }
+
+}