sassc 2.2.1 → 2.4.0

data/ext/libsass/src/ast_def_macros.hpp

@@ -70,18 +70,18 @@ private:
 #ifdef DEBUG_SHARED_PTR
 
 #define ATTACH_ABSTRACT_AST_OPERATIONS(klass) \
-  virtual klass* copy(std::string, size_t) const = 0; \
-  virtual klass* clone(std::string, size_t) const = 0; \
+  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(std::string, size_t) const override = 0; \
-  virtual klass* clone(std::string, size_t) const override = 0; \
+  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(std::string, size_t) const override; \
-  virtual klass* clone(std::string, size_t) const override; \
+  virtual klass* copy(sass::string, size_t) const override; \
+  virtual klass* clone(sass::string, size_t) const override; \
 
 #else
 
@@ -101,15 +101,23 @@ private:
 
 #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(std::string file, size_t line) const { \
-      klass* cpy = new klass(this); \
+    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(std::string file, size_t line) const { \
+    klass* klass::clone(sass::string file, size_t line) const { \
       klass* cpy = copy(file, line); \
       cpy->cloneChildren(); \
       return cpy; \
@@ -119,7 +127,7 @@ private:
 
   #define IMPLEMENT_AST_OPERATORS(klass) \
     klass* klass::copy() const { \
-      return new klass(this); \
+      return SASS_MEMORY_NEW(klass, this); \
     } \
     klass* klass::clone() const { \
       klass* cpy = copy(); \

data/ext/libsass/src/ast_fwd_decl.cpp

@@ -16,15 +16,16 @@ namespace Sass {
   IMPLEMENT_BASE_CAST(AST_Node)
   IMPLEMENT_BASE_CAST(Expression)
   IMPLEMENT_BASE_CAST(Statement)
-  IMPLEMENT_BASE_CAST(Has_Block)
+  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(Supports_Condition)
+  IMPLEMENT_BASE_CAST(SupportsCondition)
   IMPLEMENT_BASE_CAST(Selector)
-  IMPLEMENT_BASE_CAST(Simple_Selector)
+  IMPLEMENT_BASE_CAST(SelectorComponent)
+  IMPLEMENT_BASE_CAST(SimpleSelector)
 
 }

data/ext/libsass/src/ast_fwd_decl.hpp

@@ -1,16 +1,10 @@
 #ifndef SASS_AST_FWD_DECL_H
 #define SASS_AST_FWD_DECL_H
 
-#include <map>
-#include <set>
-#include <deque>
-#include <vector>
-#include <typeinfo>
-#include <iostream>
-#include <algorithm>
-#include <unordered_map>
-#include <unordered_set>
-#include "memory/SharedPtr.hpp"
+// 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"
 
 /////////////////////////////////////////////
@@ -18,11 +12,16 @@
 /////////////////////////////////////////////
 namespace Sass {
 
+  class SourceData;
+  class SourceFile;
+  class SynthFile;
+  class ItplFile;
+
   class AST_Node;
 
-  class Has_Block;
+  class ParentStatement;
 
-  class Simple_Selector;
+  class SimpleSelector;
 
   class Parent_Reference;
 
@@ -32,34 +31,36 @@ namespace Sass {
   class Statement;
   class Value;
   class Declaration;
-  class Ruleset;
+  class StyleRule;
   class Bubble;
   class Trace;
 
-  class Media_Block;
-  class Supports_Block;
-  class Directive;
+  class MediaRule;
+  class CssMediaRule;
+  class CssMediaQuery;
 
+  class SupportsRule;
+  class AtRule;
 
   class Keyframe_Rule;
-  class At_Root_Block;
+  class AtRootRule;
   class Assignment;
 
   class Import;
   class Import_Stub;
-  class Warning;
+  class WarningRule;
 
-  class Error;
-  class Debug;
+  class ErrorRule;
+  class DebugRule;
   class Comment;
 
   class If;
-  class For;
-  class Each;
-  class While;
+  class ForRule;
+  class EachRule;
+  class WhileRule;
   class Return;
   class Content;
-  class Extension;
+  class ExtendRule;
   class Definition;
 
   class List;
@@ -80,6 +81,7 @@ namespace Sass {
   class Color_HSLA;
   class Boolean;
   class String;
+  class Null;
 
   class String_Schema;
   class String_Constant;
@@ -87,17 +89,13 @@ namespace Sass {
 
   class Media_Query;
   class Media_Query_Expression;
-  class Supports_Condition;
-  class Supports_Operator;
-  class Supports_Negation;
-  class Supports_Declaration;
+  class SupportsCondition;
+  class SupportsOperation;
+  class SupportsNegation;
+  class SupportsDeclaration;
   class Supports_Interpolation;
-
-
-  class Null;
-
+  
   class At_Root_Query;
-  class Parent_Selector;
   class Parameter;
   class Parameters;
   class Argument;
@@ -106,56 +104,69 @@ namespace Sass {
 
 
   class Selector_Schema;
-  class Placeholder_Selector;
-  class Type_Selector;
-  class Class_Selector;
-  class Id_Selector;
-  class Attribute_Selector;
-
-  class Pseudo_Selector;
-  class Wrapped_Selector;
-  class Compound_Selector;
-  class Complex_Selector;
-  class Selector_List;
-
+  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
-  // #define IMPL_MEM_OBJ(type) using type##_Obj = SharedImpl<type>
-  #define IMPL_MEM_OBJ(type) typedef SharedImpl<type> type##_Obj
+  // 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(Ruleset);
+  IMPL_MEM_OBJ(StyleRule);
   IMPL_MEM_OBJ(Bubble);
   IMPL_MEM_OBJ(Trace);
-  IMPL_MEM_OBJ(Media_Block);
-  IMPL_MEM_OBJ(Supports_Block);
-  IMPL_MEM_OBJ(Directive);
+  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(At_Root_Block);
+  IMPL_MEM_OBJ(AtRootRule);
   IMPL_MEM_OBJ(Declaration);
   IMPL_MEM_OBJ(Assignment);
   IMPL_MEM_OBJ(Import);
   IMPL_MEM_OBJ(Import_Stub);
-  IMPL_MEM_OBJ(Warning);
-  IMPL_MEM_OBJ(Error);
-  IMPL_MEM_OBJ(Debug);
+  IMPL_MEM_OBJ(WarningRule);
+  IMPL_MEM_OBJ(ErrorRule);
+  IMPL_MEM_OBJ(DebugRule);
   IMPL_MEM_OBJ(Comment);
   IMPL_MEM_OBJ(PreValue);
-  IMPL_MEM_OBJ(Has_Block);
+  IMPL_MEM_OBJ(ParentStatement);
   IMPL_MEM_OBJ(If);
-  IMPL_MEM_OBJ(For);
-  IMPL_MEM_OBJ(Each);
-  IMPL_MEM_OBJ(While);
+  IMPL_MEM_OBJ(ForRule);
+  IMPL_MEM_OBJ(EachRule);
+  IMPL_MEM_OBJ(WhileRule);
   IMPL_MEM_OBJ(Return);
   IMPL_MEM_OBJ(Content);
-  IMPL_MEM_OBJ(Extension);
+  IMPL_MEM_OBJ(ExtendRule);
   IMPL_MEM_OBJ(Definition);
   IMPL_MEM_OBJ(Mixin_Call);
   IMPL_MEM_OBJ(Value);
@@ -180,14 +191,13 @@ namespace Sass {
   IMPL_MEM_OBJ(String_Quoted);
   IMPL_MEM_OBJ(Media_Query);
   IMPL_MEM_OBJ(Media_Query_Expression);
-  IMPL_MEM_OBJ(Supports_Condition);
-  IMPL_MEM_OBJ(Supports_Operator);
-  IMPL_MEM_OBJ(Supports_Negation);
-  IMPL_MEM_OBJ(Supports_Declaration);
+  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_Selector);
   IMPL_MEM_OBJ(Parent_Reference);
   IMPL_MEM_OBJ(Parameter);
   IMPL_MEM_OBJ(Parameters);
@@ -195,108 +205,30 @@ namespace Sass {
   IMPL_MEM_OBJ(Arguments);
   IMPL_MEM_OBJ(Selector);
   IMPL_MEM_OBJ(Selector_Schema);
-  IMPL_MEM_OBJ(Simple_Selector);
-  IMPL_MEM_OBJ(Placeholder_Selector);
-  IMPL_MEM_OBJ(Type_Selector);
-  IMPL_MEM_OBJ(Class_Selector);
-  IMPL_MEM_OBJ(Id_Selector);
-  IMPL_MEM_OBJ(Attribute_Selector);
-  IMPL_MEM_OBJ(Pseudo_Selector);
-  IMPL_MEM_OBJ(Wrapped_Selector);
-  IMPL_MEM_OBJ(Compound_Selector);
-  IMPL_MEM_OBJ(Complex_Selector);
-  IMPL_MEM_OBJ(Selector_List);
-
-  // ###########################################################################
-  // Implement compare, order and hashing operations for AST Nodes
-  // ###########################################################################
-
-  struct HashNodes {
-    template <class T>
-    size_t operator() (const T& ex) const {
-      return ex.isNull() ? 0 : ex->hash();
-    }
-  };
-  template <class T>
-  bool OrderFunction(const T& lhs, const T& rhs) {
-      return !lhs.isNull() && !rhs.isNull() && *lhs < *rhs;
-  };
-  struct OrderNodes {
-    template <class T>
-    bool operator() (const T& lhs, const T& rhs) const {
-      return OrderFunction<T>(lhs, rhs);
-    }
-  };
-  template <class T>
-  bool CompareFunction(const T& lhs, const T& rhs) {
-      // code around sass logic issue. 1px == 1 is true
-      // but both items are still different keys in maps
-      if (dynamic_cast<Number*>(lhs.ptr()))
-        if (dynamic_cast<Number*>(rhs.ptr()))
-          return lhs->hash() == rhs->hash();
-      return !lhs.isNull() && !rhs.isNull() && *lhs == *rhs;
-  }
-  struct CompareNodes {
-    template <class T>
-    bool operator() (const T& lhs, const T& rhs) const {
-      return CompareFunction<T>(lhs, rhs);
-    }
-  };
-
-  struct HashPtr {
-    template <class T>
-    size_t operator() (const T *ref) const {
-      return ref->hash();
-    }
-  };
-  struct ComparePtrs {
-    template <class T>
-    bool operator() (const T *lhs, const T *rhs) const {
-      return *lhs == *rhs;
-    }
-  };
+  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 std::unordered_map<
-    Expression_Obj, // key
-    Expression_Obj, // value
-    HashNodes, // hasher
-    CompareNodes // compare
-  > ExpressionMap;
-  typedef std::unordered_set<
-    Expression_Obj, // value
-    HashNodes, // hasher
-    CompareNodes // compare
-  > ExpressionSet;
-
-  typedef std::string SubSetMapKey;
-  typedef std::vector<std::string> SubSetMapKeys;
-
-  typedef std::pair<Complex_Selector_Obj, Compound_Selector_Obj> SubSetMapPair;
-  typedef std::pair<Compound_Selector_Obj, Complex_Selector_Obj> SubSetMapLookup;
-  typedef std::vector<SubSetMapPair> SubSetMapPairs;
-  typedef std::vector<SubSetMapLookup> SubSetMapLookups;
-
-  typedef std::pair<Complex_Selector_Obj, SubSetMapPairs> SubSetMapResult;
-  typedef std::vector<SubSetMapResult> SubSetMapResults;
-
-  typedef std::set<Selector_Obj, OrderNodes> SelectorSet;
-
-  typedef std::deque<Complex_Selector_Obj> ComplexSelectorDeque;
-  typedef std::set<Simple_Selector_Obj, OrderNodes> SimpleSelectorSet;
-  typedef std::set<Complex_Selector_Obj, OrderNodes> ComplexSelectorSet;
-  typedef std::set<Compound_Selector_Obj, OrderNodes> CompoundSelectorSet;
-  typedef std::unordered_set<Simple_Selector_Obj, HashNodes, CompareNodes> SimpleSelectorDict;
-
-  typedef std::vector<Block*> BlockStack;
-  typedef std::vector<Sass_Callee> CalleeStack;
-  typedef std::vector<AST_Node_Obj> CallStack;
-  typedef std::vector<Media_Block*> MediaStack;
-  typedef std::vector<Selector_List_Obj> SelectorStack;
-  typedef std::vector<Sass_Import_Entry> ImporterStack;
+  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
@@ -325,16 +257,17 @@ namespace Sass {
   DECLARE_BASE_CAST(AST_Node)
   DECLARE_BASE_CAST(Expression)
   DECLARE_BASE_CAST(Statement)
-  DECLARE_BASE_CAST(Has_Block)
+  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(Supports_Condition)
+  DECLARE_BASE_CAST(SupportsCondition)
   DECLARE_BASE_CAST(Selector)
-  DECLARE_BASE_CAST(Simple_Selector)
+  DECLARE_BASE_CAST(SimpleSelector)
+  DECLARE_BASE_CAST(SelectorComponent)
 
 }