zuora_connect_ui 0.8.2 → 0.8.3

data/vendor/ruby/2.6.0/gems/sassc-2.2.0/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 = std::string(our_version).find('.', 0);
+    if (pos != std::string::npos) pos = std::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; }
+    // 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)
+  {
+
+    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 std::string& path)
+  {
+
+    // count plugins
+    size_t loaded = 0;
+
+    #ifdef _WIN32
+
+      try
+      {
+
+        // use wchar (utf16)
+        WIN32_FIND_DATAW data;
+        // trailing slash is guaranteed
+        std::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)
+            std::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/vendor/ruby/2.6.0/gems/sassc-2.2.0/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 std::string& path);
+      // load all plugins from a directory
+      size_t load_plugins(const std::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; }
+
+    private: // private vars
+      std::vector<Sass_Importer_Entry> headers;
+      std::vector<Sass_Importer_Entry> importers;
+      std::vector<Sass_Function_Entry> functions;
+
+  };
+
+}
+
+#endif

data/vendor/ruby/2.6.0/gems/sassc-2.2.0/ext/libsass/src/position.cpp

@@ -0,0 +1,184 @@
+// sass.hpp must go before all system headers to get the
+// __EXTENSIONS__ fix on Solaris.
+#include "sass.hpp"
+
+#include "position.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 std::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 += 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;
+        // skip over 10xxxxxx
+        // is 1st bit not set
+        if ((chr & 128) == 0) {
+          // regular ascii char
+          column += 1;
+        }
+        // is 2nd bit not set
+        else if ((chr & 64) == 0) {
+          // first utf8 byte
+          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) { }
+
+
+  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() { }
+
+  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) { }
+
+  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);
+  }
+
+  /* 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/vendor/ruby/2.6.0/gems/sassc-2.2.0/ext/libsass/src/position.hpp

@@ -0,0 +1,124 @@
+#ifndef SASS_POSITION_H
+#define SASS_POSITION_H
+
+#include <string>
+#include <cstring>
+// #include <iostream>
+
+namespace Sass {
+
+
+  class Offset {
+
+    public: // c-tor
+      Offset(const char chr);
+      Offset(const char* string);
+      Offset(const std::string& text);
+      Offset(const size_t line, const size_t column);
+
+      // return new position, incremented by the given string
+      Offset add(const char* begin, const char* end);
+      Offset inc(const char* begin, const char* end) const;
+
+      // init/create instance from const char substring
+      static Offset init(const char* beg, const char* end);
+
+    public: // overload operators for position
+      void operator+= (const Offset &pos);
+      bool operator== (const Offset &pos) const;
+      bool operator!= (const Offset &pos) const;
+      Offset operator+ (const Offset &off) const;
+      Offset operator- (const Offset &off) const;
+
+    public: // overload output stream operator
+      // friend std::ostream& operator<<(std::ostream& strm, const Offset& off);
+
+    public:
+      Offset off() { return *this; }
+
+    public:
+      size_t line;
+      size_t column;
+
+  };
+
+  class Position : public Offset {
+
+    public: // c-tor
+      Position(const size_t file); // line(0), column(0)
+      Position(const size_t file, const Offset& offset);
+      Position(const size_t line, const size_t column); // file(-1)
+      Position(const size_t file, const size_t line, const size_t column);
+
+    public: // overload operators for position
+      void operator+= (const Offset &off);
+      bool operator== (const Position &pos) const;
+      bool operator!= (const Position &pos) const;
+      const Position operator+ (const Offset &off) const;
+      const Offset operator- (const Offset &off) const;
+      // return new position, incremented by the given string
+      Position add(const char* begin, const char* end);
+      Position inc(const char* begin, const char* end) const;
+
+    public: // overload output stream operator
+      // friend std::ostream& operator<<(std::ostream& strm, const Position& pos);
+
+    public:
+      size_t file;
+
+  };
+
+  // Token type for representing lexed chunks of text
+  class Token {
+  public:
+    const char* prefix;
+    const char* begin;
+    const char* end;
+
+    Token()
+    : prefix(0), begin(0), end(0) { }
+    Token(const char* b, const char* e)
+    : prefix(b), begin(b), end(e) { }
+    Token(const char* str)
+    : prefix(str), begin(str), end(str + strlen(str)) { }
+    Token(const char* p, const char* b, const char* e)
+    : 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");
+      return str.erase(str.find_last_not_of(whitespaces)+1);
+    }
+
+    operator bool()        { return begin && end && begin >= end; }
+    operator std::string() { return to_string(); }
+
+    bool operator==(Token t)  { return to_string() == t.to_string(); }
+  };
+
+  class ParserState : public Position {
+
+    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: // down casts
+      Offset off() { return *this; }
+      Position pos() { return *this; }
+      ParserState pstate() { return *this; }
+
+    public:
+      const char* path;
+      const char* src;
+      Offset offset;
+      Token token;
+
+  };
+
+}
+
+#endif