zuora_connect_ui 0.8.2 → 0.8.3

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

@@ -0,0 +1,84 @@
+// sass.hpp must go before all system headers to get the
+// __EXTENSIONS__ fix on Solaris.
+#include "sass.hpp"
+
+#include <iostream>
+#include <typeinfo>
+#include <string>
+
+#include "listize.hpp"
+#include "context.hpp"
+#include "backtrace.hpp"
+#include "error_handling.hpp"
+
+namespace Sass {
+
+  Listize::Listize()
+  {  }
+
+  Expression* Listize::operator()(Selector_List* sel)
+  {
+    List_Obj l = SASS_MEMORY_NEW(List, sel->pstate(), sel->length(), SASS_COMMA);
+    l->from_selector(true);
+    for (size_t i = 0, L = sel->length(); i < L; ++i) {
+      if (!sel->at(i)) continue;
+      l->append(sel->at(i)->perform(this));
+    }
+    if (l->length()) return l.detach();
+    return SASS_MEMORY_NEW(Null, l->pstate());
+  }
+
+  Expression* Listize::operator()(Compound_Selector* sel)
+  {
+    std::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();
+    }
+    return SASS_MEMORY_NEW(String_Quoted, sel->pstate(), str);
+  }
+
+  Expression* Listize::operator()(Complex_Selector* sel)
+  {
+    List_Obj l = SASS_MEMORY_NEW(List, sel->pstate(), 2);
+    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;
+    }
+
+    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/vendor/ruby/2.6.0/gems/sassc-2.2.0/ext/libsass/src/listize.hpp

@@ -0,0 +1,38 @@
+#ifndef SASS_LISTIZE_H
+#define SASS_LISTIZE_H
+
+// sass.hpp must go before all system headers to get the
+// __EXTENSIONS__ fix on Solaris.
+#include "sass.hpp"
+
+#include <vector>
+#include <iostream>
+
+#include "ast.hpp"
+#include "context.hpp"
+#include "operation.hpp"
+#include "environment.hpp"
+
+namespace Sass {
+
+  struct Backtrace;
+
+  class Listize : public Operation_CRTP<Expression*, Listize> {
+
+  public:
+    Listize();
+    ~Listize() { }
+
+    Expression* operator()(Selector_List*);
+    Expression* operator()(Complex_Selector*);
+    Expression* operator()(Compound_Selector*);
+
+    // generic fallback
+    template <typename U>
+    Expression* fallback(U x)
+    { return Cast<Expression>(x); }
+  };
+
+}
+
+#endif

data/vendor/ruby/2.6.0/gems/sassc-2.2.0/ext/libsass/src/mapping.hpp

@@ -0,0 +1,18 @@
+#ifndef SASS_MAPPING_H
+#define SASS_MAPPING_H
+
+#include "position.hpp"
+
+namespace Sass {
+
+  struct Mapping {
+    Position original_position;
+    Position generated_position;
+
+    Mapping(const Position& original_position, const Position& generated_position)
+    : original_position(original_position), generated_position(generated_position) { }
+  };
+
+}
+
+#endif

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

@@ -0,0 +1,33 @@
+#include "../sass.hpp"
+#include <iostream>
+#include <typeinfo>
+
+#include "SharedPtr.hpp"
+#include "../ast_fwd_decl.hpp"
+
+#ifdef DEBUG_SHARED_PTR
+#include "../debugger.hpp"
+#endif
+
+namespace Sass {
+
+  #ifdef DEBUG_SHARED_PTR
+  void SharedObj::dumpMemLeaks() {
+    if (!all.empty()) {
+      std::cerr << "###################################\n";
+      std::cerr << "# REPORTING MISSING DEALLOCATIONS #\n";
+      std::cerr << "###################################\n";
+      for (SharedObj* var : all) {
+        if (AST_Node* ast = dynamic_cast<AST_Node*>(var)) {
+          debug_ast(ast);
+        } else {
+          std::cerr << "LEAKED " << var << "\n";
+        }
+      }
+    }
+  }
+  std::vector<SharedObj*> SharedObj::all;
+  #endif
+
+  bool SharedObj::taint = false;
+}

data/vendor/ruby/2.6.0/gems/sassc-2.2.0/ext/libsass/src/memory/SharedPtr.hpp

@@ -0,0 +1,286 @@
+#ifndef SASS_MEMORY_SHARED_PTR_H
+#define SASS_MEMORY_SHARED_PTR_H
+
+#include "sass/base.h"
+
+#include <cstddef>
+#include <iostream>
+#include <string>
+#include <type_traits>
+#include <vector>
+
+namespace Sass {
+
+  class SharedPtr;
+
+  ///////////////////////////////////////////////////////////////////////////////
+  // Use macros for the allocation task, since overloading operator `new`
+  // has been proven to be flaky under certain compilers (see comment below).
+  ///////////////////////////////////////////////////////////////////////////////
+
+  #ifdef DEBUG_SHARED_PTR
+
+    #define SASS_MEMORY_NEW(Class, ...) \
+      ((Class*)(new Class(__VA_ARGS__))->trace(__FILE__, __LINE__)) \
+
+    #define SASS_MEMORY_COPY(obj) \
+      ((obj)->copy(__FILE__, __LINE__)) \
+
+    #define SASS_MEMORY_CLONE(obj) \
+      ((obj)->clone(__FILE__, __LINE__)) \
+
+  #else
+
+    #define SASS_MEMORY_NEW(Class, ...) \
+      new Class(__VA_ARGS__) \
+
+    #define SASS_MEMORY_COPY(obj) \
+      ((obj)->copy()) \
+
+    #define SASS_MEMORY_CLONE(obj) \
+      ((obj)->clone()) \
+
+  #endif
+
+  class SharedObj {
+   public:
+    SharedObj() : refcount(0), detached(false) {
+      #ifdef DEBUG_SHARED_PTR
+      if (taint) all.push_back(this);
+      #endif
+    }
+    virtual ~SharedObj() {
+      #ifdef DEBUG_SHARED_PTR
+      all.clear();
+      #endif
+    }
+
+    #ifdef DEBUG_SHARED_PTR
+    static void dumpMemLeaks();
+    SharedObj* trace(std::string file, size_t line) {
+      this->file = file;
+      this->line = line;
+      return this;
+    }
+    std::string getDbgFile() { return file; }
+    size_t getDbgLine() { return line; }
+    void setDbg(bool dbg) { this->dbg = dbg; }
+    size_t getRefCount() const { return refcount; }
+    #endif
+
+    static void setTaint(bool val) { taint = val; }
+
+    virtual const std::string to_string() const = 0;
+   protected:
+    friend class SharedPtr;
+    friend class Memory_Manager;
+    size_t refcount;
+    bool detached;
+    static bool taint;
+    #ifdef DEBUG_SHARED_PTR
+    std::string file;
+    size_t line;
+    bool dbg = false;
+    static std::vector<SharedObj*> all;
+    #endif
+  };
+
+  class SharedPtr {
+   public:
+    SharedPtr() : node(nullptr) {}
+    SharedPtr(SharedObj* ptr) : node(ptr) {
+      incRefCount();
+    }
+    SharedPtr(const SharedPtr& obj) : SharedPtr(obj.node) {}
+    ~SharedPtr() {
+      decRefCount();
+    }
+
+    SharedPtr& operator=(SharedObj* other_node) {
+      if (node != other_node) {
+        decRefCount();
+        node = other_node;
+        incRefCount();
+      } else if (node != nullptr) {
+        node->detached = false;
+      }
+      return *this;
+    }
+
+    SharedPtr& operator=(const SharedPtr& obj) {
+      return *this = obj.node;
+    }
+
+    // Prevents all SharedPtrs from freeing this node until it is assigned to another SharedPtr.
+    SharedObj* detach() {
+      if (node != nullptr) node->detached = true;
+      return node;
+    }
+
+    SharedObj* obj() const { return node; }
+    SharedObj* operator->() const { return node; }
+    bool isNull() const { return node == nullptr; }
+    operator bool() const { return node != nullptr; }
+
+   protected:
+    SharedObj* node;
+    void decRefCount() {
+      if (node == nullptr) return;
+      --node->refcount;
+      #ifdef DEBUG_SHARED_PTR
+      if (node->dbg) std::cerr << "- " << node << " X " << node->refcount << " (" << this << ") " << "\n";
+      #endif
+      if (node->refcount == 0 && !node->detached) {
+        #ifdef DEBUG_SHARED_PTR
+        if (node->dbg) std::cerr << "DELETE NODE " << node << "\n";
+        #endif
+        delete node;
+      }
+    }
+    void incRefCount() {
+      if (node == nullptr) return;
+      node->detached = false;
+      ++node->refcount;
+      #ifdef DEBUG_SHARED_PTR
+      if (node->dbg) std::cerr << "+ " << node << " X " << node->refcount << " (" << this << ") " << "\n";
+      #endif
+    }
+  };
+
+  template <class T>
+  class SharedImpl : private SharedPtr {
+   public:
+    SharedImpl() : SharedPtr(nullptr) {}
+
+    template <class U>
+    SharedImpl(U* node) :
+      SharedPtr(static_cast<T*>(node)) {}
+
+    template <class U>
+    SharedImpl(const SharedImpl<U>& impl) :
+      SharedImpl(impl.ptr()) {}
+
+    template <class U>
+    SharedImpl<T>& operator=(U *rhs) {
+      return static_cast<SharedImpl<T>&>(
+        SharedPtr::operator=(static_cast<T*>(rhs)));
+    }
+
+    template <class U>
+    SharedImpl<T>& operator=(const SharedImpl<U>& rhs) {
+      return static_cast<SharedImpl<T>&>(
+        SharedPtr::operator=(static_cast<const SharedImpl<T>&>(rhs)));
+    }
+
+    operator const std::string() const {
+      if (node) return node->to_string();
+      return "[nullptr]";
+    }
+
+    using SharedPtr::isNull;
+    using SharedPtr::operator bool;
+    operator T*() const { return static_cast<T*>(this->obj()); }
+    operator T&() const { return *static_cast<T*>(this->obj()); }
+    T& operator* () const { return *static_cast<T*>(this->obj()); };
+    T* operator-> () const { return static_cast<T*>(this->obj()); };
+    T* ptr () const { return static_cast<T*>(this->obj()); };
+    T* detach() { return static_cast<T*>(SharedPtr::detach()); }
+  };
+
+  // Comparison operators, based on:
+  // https://en.cppreference.com/w/cpp/memory/unique_ptr/operator_cmp
+
+  template<class T1, class T2>
+  bool operator==(const SharedImpl<T1>& x, const SharedImpl<T2>& y) {
+    return x.ptr() == y.ptr();
+  }
+
+  template<class T1, class T2>
+  bool operator!=(const SharedImpl<T1>& x, const SharedImpl<T2>& y) {
+    return x.ptr() != y.ptr();
+  }
+
+  template<class T1, class T2>
+  bool operator<(const SharedImpl<T1>& x, const SharedImpl<T2>& y) {
+    using CT = typename std::common_type<T1*, T2*>::type;
+    return std::less<CT>()(x.get(), y.get());
+  }
+
+  template<class T1, class T2>
+  bool operator<=(const SharedImpl<T1>& x, const SharedImpl<T2>& y) {
+    return !(y < x);
+  }
+
+  template<class T1, class T2>
+  bool operator>(const SharedImpl<T1>& x, const SharedImpl<T2>& y) {
+    return y < x;
+  }
+
+  template<class T1, class T2>
+  bool operator>=(const SharedImpl<T1>& x, const SharedImpl<T2>& y) {
+    return !(x < y);
+  }
+
+  template <class T>
+  bool operator==(const SharedImpl<T>& x, std::nullptr_t) noexcept {
+    return x.isNull();
+  }
+
+  template <class T>
+  bool operator==(std::nullptr_t, const SharedImpl<T>& x) noexcept {
+    return x.isNull();
+  }
+
+  template <class T>
+  bool operator!=(const SharedImpl<T>& x, std::nullptr_t) noexcept {
+    return !x.isNull();
+  }
+
+  template <class T>
+  bool operator!=(std::nullptr_t, const SharedImpl<T>& x) noexcept {
+    return !x.isNull();
+  }
+
+  template <class T>
+  bool operator<(const SharedImpl<T>& x, std::nullptr_t) {
+    return std::less<T*>()(x.get(), nullptr);
+  }
+
+  template <class T>
+  bool operator<(std::nullptr_t, const SharedImpl<T>& y) {
+    return std::less<T*>()(nullptr, y.get());
+  }
+
+  template <class T>
+  bool operator<=(const SharedImpl<T>& x, std::nullptr_t) {
+    return !(nullptr < x);
+  }
+
+  template <class T>
+  bool operator<=(std::nullptr_t, const SharedImpl<T>& y) {
+    return !(y < nullptr);
+  }
+
+  template <class T>
+  bool operator>(const SharedImpl<T>& x, std::nullptr_t) {
+    return nullptr < x;
+  }
+
+  template <class T>
+  bool operator>(std::nullptr_t, const SharedImpl<T>& y) {
+    return y < nullptr;
+  }
+
+  template <class T>
+  bool operator>=(const SharedImpl<T>& x, std::nullptr_t) {
+    return !(x < nullptr);
+  }
+
+  template <class T>
+  bool operator>=(std::nullptr_t, const SharedImpl<T>& y) {
+    return !(nullptr < y);
+  }
+
+}  // namespace Sass
+
+#endif