sassc4 2.4.0

data/ext/libsass/src/ast2c.cpp

@@ -0,0 +1,80 @@
+// sass.hpp must go before all system headers to get the
+// __EXTENSIONS__ fix on Solaris.
+#include "sass.hpp"
+
+#include "ast2c.hpp"
+#include "ast.hpp"
+
+namespace Sass {
+
+  union Sass_Value* AST2C::operator()(Boolean* b)
+  { return sass_make_boolean(b->value()); }
+
+  union Sass_Value* AST2C::operator()(Number* n)
+  { return sass_make_number(n->value(), n->unit().c_str()); }
+
+  union Sass_Value* AST2C::operator()(Custom_Warning* w)
+  { return sass_make_warning(w->message().c_str()); }
+
+  union Sass_Value* AST2C::operator()(Custom_Error* e)
+  { return sass_make_error(e->message().c_str()); }
+
+  union Sass_Value* AST2C::operator()(Color_RGBA* c)
+  { return sass_make_color(c->r(), c->g(), c->b(), c->a()); }
+
+  union Sass_Value* AST2C::operator()(Color_HSLA* c)
+  {
+    Color_RGBA_Obj rgba = c->copyAsRGBA();
+    return operator()(rgba.ptr());
+  }
+
+  union Sass_Value* AST2C::operator()(String_Constant* s)
+  {
+    if (s->quote_mark()) {
+      return sass_make_qstring(s->value().c_str());
+    } else {
+      return sass_make_string(s->value().c_str());
+    }
+  }
+
+  union Sass_Value* AST2C::operator()(String_Quoted* s)
+  { return sass_make_qstring(s->value().c_str()); }
+
+  union Sass_Value* AST2C::operator()(List* l)
+  {
+    union Sass_Value* v = sass_make_list(l->length(), l->separator(), l->is_bracketed());
+    for (size_t i = 0, L = l->length(); i < L; ++i) {
+      sass_list_set_value(v, i, (*l)[i]->perform(this));
+    }
+    return v;
+  }
+
+  union Sass_Value* AST2C::operator()(Map* m)
+  {
+    union Sass_Value* v = sass_make_map(m->length());
+    int i = 0;
+    for (auto key : m->keys()) {
+      sass_map_set_key(v, i, key->perform(this));
+      sass_map_set_value(v, i, m->at(key)->perform(this));
+      i++;
+    }
+    return v;
+  }
+
+  union Sass_Value* AST2C::operator()(Arguments* a)
+  {
+    union Sass_Value* v = sass_make_list(a->length(), SASS_COMMA, false);
+    for (size_t i = 0, L = a->length(); i < L; ++i) {
+      sass_list_set_value(v, i, (*a)[i]->perform(this));
+    }
+    return v;
+  }
+
+  union Sass_Value* AST2C::operator()(Argument* a)
+  { return a->value()->perform(this); }
+
+  // not strictly necessary because of the fallback
+  union Sass_Value* AST2C::operator()(Null* n)
+  { return sass_make_null(); }
+
+};

data/ext/libsass/src/ast2c.hpp

@@ -0,0 +1,39 @@
+#ifndef SASS_AST2C_H
+#define SASS_AST2C_H
+
+#include "ast_fwd_decl.hpp"
+#include "operation.hpp"
+#include "sass/values.h"
+
+namespace Sass {
+
+  class AST2C : public Operation_CRTP<union Sass_Value*, AST2C> {
+
+  public:
+
+    AST2C() { }
+    ~AST2C() { }
+
+    union Sass_Value* operator()(Boolean*);
+    union Sass_Value* operator()(Number*);
+    union Sass_Value* operator()(Color_RGBA*);
+    union Sass_Value* operator()(Color_HSLA*);
+    union Sass_Value* operator()(String_Constant*);
+    union Sass_Value* operator()(String_Quoted*);
+    union Sass_Value* operator()(Custom_Warning*);
+    union Sass_Value* operator()(Custom_Error*);
+    union Sass_Value* operator()(List*);
+    union Sass_Value* operator()(Map*);
+    union Sass_Value* operator()(Null*);
+    union Sass_Value* operator()(Arguments*);
+    union Sass_Value* operator()(Argument*);
+
+    // return sass error if type is not supported
+    union Sass_Value* fallback(AST_Node* x)
+    { return sass_make_error("unknown type for C-API"); }
+
+  };
+
+}
+
+#endif

data/ext/libsass/src/ast_def_macros.hpp

@@ -0,0 +1,140 @@
+#ifndef SASS_AST_DEF_MACROS_H
+#define SASS_AST_DEF_MACROS_H
+
+// Helper class to switch a flag and revert once we go out of scope
+template <class T>
+class LocalOption {
+  private:
+    T* var; // pointer to original variable
+    T orig; // copy of the original option
+  public:
+    LocalOption(T& var)
+    {
+      this->var = &var;
+      this->orig = var;
+    }
+    LocalOption(T& var, T orig)
+    {
+      this->var = &var;
+      this->orig = var;
+      *(this->var) = orig;
+    }
+    void reset()
+    {
+      *(this->var) = this->orig;
+    }
+    ~LocalOption() {
+      *(this->var) = this->orig;
+    }
+};
+
+#define LOCAL_FLAG(name,opt) LocalOption<bool> flag_##name(name, opt)
+#define LOCAL_COUNT(name,opt) LocalOption<size_t> cnt_##name(name, opt)
+
+#define NESTING_GUARD(name) \
+  LocalOption<size_t> cnt_##name(name, name + 1); \
+  if (name > MAX_NESTING) throw Exception::NestingLimitError(pstate, traces); \
+
+#define ADD_PROPERTY(type, name)\
+protected:\
+  type name##_;\
+public:\
+  type name() const        { return name##_; }\
+  type name(type name##__) { return name##_ = name##__; }\
+private:
+
+#define HASH_PROPERTY(type, name)\
+protected:\
+  type name##_;\
+public:\
+  type name() const        { return name##_; }\
+  type name(type name##__) { hash_ = 0; return name##_ = name##__; }\
+private:
+
+#define ADD_CONSTREF(type, name) \
+protected: \
+  type name##_; \
+public: \
+  const type& name() const { return name##_; } \
+  void name(type name##__) { name##_ = name##__; } \
+private:
+
+#define HASH_CONSTREF(type, name) \
+protected: \
+  type name##_; \
+public: \
+  const type& name() const { return name##_; } \
+  void name(type name##__) { hash_ = 0; name##_ = name##__; } \
+private:
+
+#ifdef DEBUG_SHARED_PTR
+
+#define ATTACH_ABSTRACT_AST_OPERATIONS(klass) \
+  virtual klass* copy(sass::string, size_t) const = 0; \
+  virtual klass* clone(sass::string, size_t) const = 0; \
+
+#define ATTACH_VIRTUAL_AST_OPERATIONS(klass) \
+  klass(const klass* ptr); \
+  virtual klass* copy(sass::string, size_t) const override = 0; \
+  virtual klass* clone(sass::string, size_t) const override = 0; \
+
+#define ATTACH_AST_OPERATIONS(klass) \
+  klass(const klass* ptr); \
+  virtual klass* copy(sass::string, size_t) const override; \
+  virtual klass* clone(sass::string, size_t) const override; \
+
+#else
+
+#define ATTACH_ABSTRACT_AST_OPERATIONS(klass) \
+  virtual klass* copy() const = 0; \
+  virtual klass* clone() const = 0; \
+
+#define ATTACH_VIRTUAL_AST_OPERATIONS(klass) \
+  klass(const klass* ptr); \
+  virtual klass* copy() const override = 0; \
+  virtual klass* clone() const override = 0; \
+
+#define ATTACH_AST_OPERATIONS(klass) \
+  klass(const klass* ptr); \
+  virtual klass* copy() const override; \
+  virtual klass* clone() const override; \
+
+#endif
+
+#define ATTACH_VIRTUAL_CMP_OPERATIONS(klass) \
+  virtual bool operator==(const klass& rhs) const = 0; \
+  virtual bool operator!=(const klass& rhs) const { return !(*this == rhs); }; \
+
+#define ATTACH_CMP_OPERATIONS(klass) \
+  virtual bool operator==(const klass& rhs) const; \
+  virtual bool operator!=(const klass& rhs) const { return !(*this == rhs); }; \
+
+#ifdef DEBUG_SHARED_PTR
+
+  #define IMPLEMENT_AST_OPERATORS(klass) \
+    klass* klass::copy(sass::string file, size_t line) const { \
+      klass* cpy = SASS_MEMORY_NEW(klass, this); \
+      cpy->trace(file, line); \
+      return cpy; \
+    } \
+    klass* klass::clone(sass::string file, size_t line) const { \
+      klass* cpy = copy(file, line); \
+      cpy->cloneChildren(); \
+      return cpy; \
+    } \
+
+#else
+
+  #define IMPLEMENT_AST_OPERATORS(klass) \
+    klass* klass::copy() const { \
+      return SASS_MEMORY_NEW(klass, this); \
+    } \
+    klass* klass::clone() const { \
+      klass* cpy = copy(); \
+      cpy->cloneChildren(); \
+      return cpy; \
+    } \
+
+#endif
+
+#endif

data/ext/libsass/src/ast_fwd_decl.cpp

@@ -0,0 +1,31 @@
+#include "ast.hpp"
+
+namespace Sass {
+
+  #define IMPLEMENT_BASE_CAST(T) \
+  template<> \
+  T* Cast(AST_Node* ptr) { \
+    return dynamic_cast<T*>(ptr); \
+  }; \
+  \
+  template<> \
+  const T* Cast(const AST_Node* ptr) { \
+    return dynamic_cast<const T*>(ptr); \
+  }; \
+
+  IMPLEMENT_BASE_CAST(AST_Node)
+  IMPLEMENT_BASE_CAST(Expression)
+  IMPLEMENT_BASE_CAST(Statement)
+  IMPLEMENT_BASE_CAST(ParentStatement)
+  IMPLEMENT_BASE_CAST(PreValue)
+  IMPLEMENT_BASE_CAST(Value)
+  IMPLEMENT_BASE_CAST(Color)
+  IMPLEMENT_BASE_CAST(List)
+  IMPLEMENT_BASE_CAST(String)
+  IMPLEMENT_BASE_CAST(String_Constant)
+  IMPLEMENT_BASE_CAST(SupportsCondition)
+  IMPLEMENT_BASE_CAST(Selector)
+  IMPLEMENT_BASE_CAST(SelectorComponent)
+  IMPLEMENT_BASE_CAST(SimpleSelector)
+
+}

data/ext/libsass/src/ast_fwd_decl.hpp

@@ -0,0 +1,274 @@
+#ifndef SASS_AST_FWD_DECL_H
+#define SASS_AST_FWD_DECL_H
+
+// sass.hpp must go before all system headers to get the
+// __EXTENSIONS__ fix on Solaris.
+#include "sass.hpp"
+#include "memory.hpp"
+#include "sass/functions.h"
+
+/////////////////////////////////////////////
+// Forward declarations for the AST visitors.
+/////////////////////////////////////////////
+namespace Sass {
+
+  class SourceData;
+  class SourceFile;
+  class SynthFile;
+  class ItplFile;
+
+  class AST_Node;
+
+  class ParentStatement;
+
+  class SimpleSelector;
+
+  class Parent_Reference;
+
+  class PreValue;
+  class Block;
+  class Expression;
+  class Statement;
+  class Value;
+  class Declaration;
+  class StyleRule;
+  class Bubble;
+  class Trace;
+
+  class MediaRule;
+  class CssMediaRule;
+  class CssMediaQuery;
+
+  class SupportsRule;
+  class AtRule;
+
+  class Keyframe_Rule;
+  class AtRootRule;
+  class Assignment;
+
+  class Import;
+  class Import_Stub;
+  class WarningRule;
+
+  class ErrorRule;
+  class DebugRule;
+  class Comment;
+
+  class If;
+  class ForRule;
+  class EachRule;
+  class WhileRule;
+  class Return;
+  class Content;
+  class ExtendRule;
+  class Definition;
+
+  class List;
+  class Map;
+  class Function;
+
+  class Mixin_Call;
+  class Binary_Expression;
+  class Unary_Expression;
+  class Function_Call;
+  class Custom_Warning;
+  class Custom_Error;
+
+  class Variable;
+  class Number;
+  class Color;
+  class Color_RGBA;
+  class Color_HSLA;
+  class Boolean;
+  class String;
+  class Null;
+
+  class String_Schema;
+  class String_Constant;
+  class String_Quoted;
+
+  class Media_Query;
+  class Media_Query_Expression;
+  class SupportsCondition;
+  class SupportsOperation;
+  class SupportsNegation;
+  class SupportsDeclaration;
+  class Supports_Interpolation;
+  
+  class At_Root_Query;
+  class Parameter;
+  class Parameters;
+  class Argument;
+  class Arguments;
+  class Selector;
+
+
+  class Selector_Schema;
+  class PlaceholderSelector;
+  class TypeSelector;
+  class ClassSelector;
+  class IDSelector;
+  class AttributeSelector;
+
+  class PseudoSelector;
+  
+  class SelectorComponent;
+  class SelectorCombinator;
+  class CompoundSelector;
+  class ComplexSelector;
+  class SelectorList;
+
+  // common classes
+  class Context;
+  class Expand;
+  class Eval;
+
+  class Extension;
+
+  // declare classes that are instances of memory nodes
+  // Note: also add a mapping without underscore
+  // ToDo: move to camelCase vars in the future
+  #define IMPL_MEM_OBJ(type) \
+    typedef SharedImpl<type> type##Obj; \
+    typedef SharedImpl<type> type##_Obj; \
+
+  IMPL_MEM_OBJ(SourceData);
+  IMPL_MEM_OBJ(SourceFile);
+  IMPL_MEM_OBJ(SynthFile);
+  IMPL_MEM_OBJ(ItplFile);
+
+  IMPL_MEM_OBJ(AST_Node);
+  IMPL_MEM_OBJ(Statement);
+  IMPL_MEM_OBJ(Block);
+  IMPL_MEM_OBJ(StyleRule);
+  IMPL_MEM_OBJ(Bubble);
+  IMPL_MEM_OBJ(Trace);
+  IMPL_MEM_OBJ(MediaRule);
+  IMPL_MEM_OBJ(CssMediaRule);
+  IMPL_MEM_OBJ(CssMediaQuery);
+  IMPL_MEM_OBJ(SupportsRule);
+  IMPL_MEM_OBJ(AtRule);
+  IMPL_MEM_OBJ(Keyframe_Rule);
+  IMPL_MEM_OBJ(AtRootRule);
+  IMPL_MEM_OBJ(Declaration);
+  IMPL_MEM_OBJ(Assignment);
+  IMPL_MEM_OBJ(Import);
+  IMPL_MEM_OBJ(Import_Stub);
+  IMPL_MEM_OBJ(WarningRule);
+  IMPL_MEM_OBJ(ErrorRule);
+  IMPL_MEM_OBJ(DebugRule);
+  IMPL_MEM_OBJ(Comment);
+  IMPL_MEM_OBJ(PreValue);
+  IMPL_MEM_OBJ(ParentStatement);
+  IMPL_MEM_OBJ(If);
+  IMPL_MEM_OBJ(ForRule);
+  IMPL_MEM_OBJ(EachRule);
+  IMPL_MEM_OBJ(WhileRule);
+  IMPL_MEM_OBJ(Return);
+  IMPL_MEM_OBJ(Content);
+  IMPL_MEM_OBJ(ExtendRule);
+  IMPL_MEM_OBJ(Definition);
+  IMPL_MEM_OBJ(Mixin_Call);
+  IMPL_MEM_OBJ(Value);
+  IMPL_MEM_OBJ(Expression);
+  IMPL_MEM_OBJ(List);
+  IMPL_MEM_OBJ(Map);
+  IMPL_MEM_OBJ(Function);
+  IMPL_MEM_OBJ(Binary_Expression);
+  IMPL_MEM_OBJ(Unary_Expression);
+  IMPL_MEM_OBJ(Function_Call);
+  IMPL_MEM_OBJ(Custom_Warning);
+  IMPL_MEM_OBJ(Custom_Error);
+  IMPL_MEM_OBJ(Variable);
+  IMPL_MEM_OBJ(Number);
+  IMPL_MEM_OBJ(Color);
+  IMPL_MEM_OBJ(Color_RGBA);
+  IMPL_MEM_OBJ(Color_HSLA);
+  IMPL_MEM_OBJ(Boolean);
+  IMPL_MEM_OBJ(String_Schema);
+  IMPL_MEM_OBJ(String);
+  IMPL_MEM_OBJ(String_Constant);
+  IMPL_MEM_OBJ(String_Quoted);
+  IMPL_MEM_OBJ(Media_Query);
+  IMPL_MEM_OBJ(Media_Query_Expression);
+  IMPL_MEM_OBJ(SupportsCondition);
+  IMPL_MEM_OBJ(SupportsOperation);
+  IMPL_MEM_OBJ(SupportsNegation);
+  IMPL_MEM_OBJ(SupportsDeclaration);
+  IMPL_MEM_OBJ(Supports_Interpolation);
+  IMPL_MEM_OBJ(At_Root_Query);
+  IMPL_MEM_OBJ(Null);
+  IMPL_MEM_OBJ(Parent_Reference);
+  IMPL_MEM_OBJ(Parameter);
+  IMPL_MEM_OBJ(Parameters);
+  IMPL_MEM_OBJ(Argument);
+  IMPL_MEM_OBJ(Arguments);
+  IMPL_MEM_OBJ(Selector);
+  IMPL_MEM_OBJ(Selector_Schema);
+  IMPL_MEM_OBJ(SimpleSelector);
+  IMPL_MEM_OBJ(PlaceholderSelector);
+  IMPL_MEM_OBJ(TypeSelector);
+  IMPL_MEM_OBJ(ClassSelector);
+  IMPL_MEM_OBJ(IDSelector);
+  IMPL_MEM_OBJ(AttributeSelector);
+  IMPL_MEM_OBJ(PseudoSelector);
+
+  IMPL_MEM_OBJ(SelectorComponent);
+  IMPL_MEM_OBJ(SelectorCombinator);
+  IMPL_MEM_OBJ(CompoundSelector);
+  IMPL_MEM_OBJ(ComplexSelector);
+  IMPL_MEM_OBJ(SelectorList);
+
+  // ###########################################################################
+  // some often used typedefs
+  // ###########################################################################
+
+  typedef sass::vector<Block*> BlockStack;
+  typedef sass::vector<Sass_Callee> CalleeStack;
+  typedef sass::vector<AST_Node_Obj> CallStack;
+  typedef sass::vector<CssMediaRuleObj> MediaStack;
+  typedef sass::vector<SelectorListObj> SelectorStack;
+  typedef sass::vector<Sass_Import_Entry> ImporterStack;
+
+  // only to switch implementations for testing
+  #define environment_map std::map
+
+  // ###########################################################################
+  // explicit type conversion functions
+  // ###########################################################################
+
+  template<class T>
+  T* Cast(AST_Node* ptr);
+
+  template<class T>
+  const T* Cast(const AST_Node* ptr);
+
+  // sometimes you know the class you want to cast to is final
+  // in this case a simple typeid check is faster and safe to use
+
+  #define DECLARE_BASE_CAST(T) \
+  template<> T* Cast(AST_Node* ptr); \
+  template<> const T* Cast(const AST_Node* ptr); \
+
+  // ###########################################################################
+  // implement specialization for final classes
+  // ###########################################################################
+
+  DECLARE_BASE_CAST(AST_Node)
+  DECLARE_BASE_CAST(Expression)
+  DECLARE_BASE_CAST(Statement)
+  DECLARE_BASE_CAST(ParentStatement)
+  DECLARE_BASE_CAST(PreValue)
+  DECLARE_BASE_CAST(Value)
+  DECLARE_BASE_CAST(List)
+  DECLARE_BASE_CAST(Color)
+  DECLARE_BASE_CAST(String)
+  DECLARE_BASE_CAST(String_Constant)
+  DECLARE_BASE_CAST(SupportsCondition)
+  DECLARE_BASE_CAST(Selector)
+  DECLARE_BASE_CAST(SimpleSelector)
+  DECLARE_BASE_CAST(SelectorComponent)
+
+}
+
+#endif