sassc 2.3.0 → 2.4.0

data/ext/libsass/src/memory/{SharedPtr.cpp → shared_ptr.cpp}

@@ -2,7 +2,7 @@
 #include <iostream>
 #include <typeinfo>
 
-#include "SharedPtr.hpp"
+#include "shared_ptr.hpp"
 #include "../ast_fwd_decl.hpp"
 
 #ifdef DEBUG_SHARED_PTR
@@ -26,7 +26,7 @@ namespace Sass {
       }
     }
   }
-  std::vector<SharedObj*> SharedObj::all;
+  sass::vector<SharedObj*> SharedObj::all;
   #endif
 
   bool SharedObj::taint = false;

data/ext/libsass/src/memory/{SharedPtr.hpp → shared_ptr.hpp}

@@ -3,6 +3,8 @@
 
 #include "sass/base.h"
 
+#include "../sass.hpp"
+#include "allocator.hpp"
 #include <cstddef>
 #include <iostream>
 #include <string>
@@ -15,6 +17,7 @@
 
 namespace Sass {
 
+  // Forward declaration
   class SharedPtr;
 
   ///////////////////////////////////////////////////////////////////////////////
@@ -76,12 +79,12 @@ namespace Sass {
 
     #ifdef DEBUG_SHARED_PTR
     static void dumpMemLeaks();
-    SharedObj* trace(std::string file, size_t line) {
+    SharedObj* trace(sass::string file, size_t line) {
       this->file = file;
       this->line = line;
       return this;
     }
-    std::string getDbgFile() { return file; }
+    sass::string getDbgFile() { return file; }
     size_t getDbgLine() { return line; }
     void setDbg(bool dbg) { this->dbg = dbg; }
     size_t getRefCount() const { return refcount; }
@@ -89,7 +92,16 @@ namespace Sass {
 
     static void setTaint(bool val) { taint = val; }
 
-    virtual std::string to_string() const = 0;
+    #ifdef SASS_CUSTOM_ALLOCATOR
+    inline void* operator new(size_t nbytes) {
+      return allocateMem(nbytes);
+    }
+    inline void operator delete(void* ptr) {
+      return deallocateMem(ptr);
+    }
+    #endif
+
+    virtual sass::string to_string() const = 0;
    protected:
     friend class SharedPtr;
     friend class Memory_Manager;
@@ -97,10 +109,10 @@ namespace Sass {
     bool detached;
     static bool taint;
     #ifdef DEBUG_SHARED_PTR
-    std::string file;
+    sass::string file;
     size_t line;
     bool dbg = false;
-    static std::vector<SharedObj*> all;
+    static sass::vector<SharedObj*> all;
     #endif
   };
 
@@ -205,7 +217,7 @@ namespace Sass {
         SharedPtr::operator=(static_cast<const SharedImpl<T>&>(rhs)));
     }
 
-    operator std::string() const {
+    operator sass::string() const {
       if (node) return node->to_string();
       return "null";
     }

data/ext/libsass/src/operation.hpp

@@ -19,13 +19,13 @@ namespace Sass {
   #define ATTACH_ABSTRACT_CRTP_PERFORM_METHODS()\
     virtual void perform(Operation<void>* op) = 0; \
     virtual Value* perform(Operation<Value*>* op) = 0; \
-    virtual std::string perform(Operation<std::string>* op) = 0; \
+    virtual sass::string perform(Operation<sass::string>* op) = 0; \
     virtual AST_Node* perform(Operation<AST_Node*>* op) = 0; \
     virtual Selector* perform(Operation<Selector*>* op) = 0; \
     virtual Statement* perform(Operation<Statement*>* op) = 0; \
     virtual Expression* perform(Operation<Expression*>* op) = 0; \
     virtual union Sass_Value* perform(Operation<union Sass_Value*>* op) = 0; \
-    virtual Supports_Condition* perform(Operation<Supports_Condition*>* op) = 0; \
+    virtual SupportsCondition* perform(Operation<SupportsCondition*>* op) = 0; \
 
   // you must add operators to every class
   // ensures `this` of actual instance type
@@ -34,13 +34,13 @@ namespace Sass {
   #define ATTACH_CRTP_PERFORM_METHODS()\
     virtual void perform(Operation<void>* op) override { return (*op)(this); } \
     virtual Value* perform(Operation<Value*>* op) override { return (*op)(this); } \
-    virtual std::string perform(Operation<std::string>* op) override { return (*op)(this); } \
+    virtual sass::string perform(Operation<sass::string>* op) override { return (*op)(this); } \
     virtual AST_Node* perform(Operation<AST_Node*>* op) override { return (*op)(this); } \
     virtual Selector* perform(Operation<Selector*>* op) override { return (*op)(this); } \
     virtual Statement* perform(Operation<Statement*>* op) override { return (*op)(this); } \
     virtual Expression* perform(Operation<Expression*>* op) override { return (*op)(this); } \
     virtual union Sass_Value* perform(Operation<union Sass_Value*>* op) override { return (*op)(this); } \
-    virtual Supports_Condition* perform(Operation<Supports_Condition*>* op) override { return (*op)(this); } \
+    virtual SupportsCondition* perform(Operation<SupportsCondition*>* op) override { return (*op)(this); } \
 
   template<typename T>
   class Operation {
@@ -48,28 +48,28 @@ namespace Sass {
     virtual T operator()(AST_Node* x)               = 0;
     // statements
     virtual T operator()(Block* x)                  = 0;
-    virtual T operator()(Ruleset* x)                = 0;
+    virtual T operator()(StyleRule* x)                = 0;
     virtual T operator()(Bubble* x)                 = 0;
     virtual T operator()(Trace* x)                  = 0;
-    virtual T operator()(Supports_Block* x)         = 0;
+    virtual T operator()(SupportsRule* x)         = 0;
     virtual T operator()(MediaRule* x) = 0;
     virtual T operator()(CssMediaRule* x) = 0;
     virtual T operator()(CssMediaQuery* x) = 0;
-    virtual T operator()(At_Root_Block* x)          = 0;
-    virtual T operator()(Directive* x)              = 0;
+    virtual T operator()(AtRootRule* x)          = 0;
+    virtual T operator()(AtRule* x)              = 0;
     virtual T operator()(Keyframe_Rule* x)          = 0;
     virtual T operator()(Declaration* x)            = 0;
     virtual T operator()(Assignment* x)             = 0;
     virtual T operator()(Import* x)                 = 0;
     virtual T operator()(Import_Stub* x)            = 0;
-    virtual T operator()(Warning* x)                = 0;
-    virtual T operator()(Error* x)                  = 0;
-    virtual T operator()(Debug* x)                  = 0;
+    virtual T operator()(WarningRule* x)                = 0;
+    virtual T operator()(ErrorRule* x)                  = 0;
+    virtual T operator()(DebugRule* x)                  = 0;
     virtual T operator()(Comment* x)                = 0;
     virtual T operator()(If* x)                     = 0;
-    virtual T operator()(For* x)                    = 0;
-    virtual T operator()(Each* x)                   = 0;
-    virtual T operator()(While* x)                  = 0;
+    virtual T operator()(ForRule* x)                    = 0;
+    virtual T operator()(EachRule* x)                   = 0;
+    virtual T operator()(WhileRule* x)                  = 0;
     virtual T operator()(Return* x)                 = 0;
     virtual T operator()(Content* x)                = 0;
     virtual T operator()(ExtendRule* x)              = 0;
@@ -94,10 +94,10 @@ namespace Sass {
     virtual T operator()(String_Schema* x)          = 0;
     virtual T operator()(String_Quoted* x)          = 0;
     virtual T operator()(String_Constant* x)        = 0;
-    virtual T operator()(Supports_Condition* x)     = 0;
-    virtual T operator()(Supports_Operator* x)      = 0;
-    virtual T operator()(Supports_Negation* x)      = 0;
-    virtual T operator()(Supports_Declaration* x)   = 0;
+    virtual T operator()(SupportsCondition* x)     = 0;
+    virtual T operator()(SupportsOperation* x)      = 0;
+    virtual T operator()(SupportsNegation* x)      = 0;
+    virtual T operator()(SupportsDeclaration* x)   = 0;
     virtual T operator()(Supports_Interpolation* x) = 0;
     virtual T operator()(Media_Query* x) = 0;
     virtual T operator()(Media_Query_Expression* x) = 0;
@@ -110,12 +110,12 @@ namespace Sass {
     virtual T operator()(Arguments* x)              = 0;
     // selectors
     virtual T operator()(Selector_Schema* x)        = 0;
-    virtual T operator()(Placeholder_Selector* x)   = 0;
-    virtual T operator()(Type_Selector* x)       = 0;
-    virtual T operator()(Class_Selector* x)         = 0;
-    virtual T operator()(Id_Selector* x)            = 0;
-    virtual T operator()(Attribute_Selector* x)     = 0;
-    virtual T operator()(Pseudo_Selector* x)        = 0;
+    virtual T operator()(PlaceholderSelector* x)   = 0;
+    virtual T operator()(TypeSelector* x)       = 0;
+    virtual T operator()(ClassSelector* x)         = 0;
+    virtual T operator()(IDSelector* x)            = 0;
+    virtual T operator()(AttributeSelector* x)     = 0;
+    virtual T operator()(PseudoSelector* x)        = 0;
     virtual T operator()(SelectorComponent* x) = 0;
     virtual T operator()(SelectorCombinator* x) = 0;
     virtual T operator()(CompoundSelector* x) = 0;
@@ -134,28 +134,28 @@ namespace Sass {
     T operator()(AST_Node* x)               { return static_cast<D*>(this)->fallback(x); }
     // statements
     T operator()(Block* x)                  { return static_cast<D*>(this)->fallback(x); }
-    T operator()(Ruleset* x)                { return static_cast<D*>(this)->fallback(x); }
+    T operator()(StyleRule* x)                { return static_cast<D*>(this)->fallback(x); }
     T operator()(Bubble* x)                 { return static_cast<D*>(this)->fallback(x); }
     T operator()(Trace* x)                  { return static_cast<D*>(this)->fallback(x); }
-    T operator()(Supports_Block* x)         { return static_cast<D*>(this)->fallback(x); }
+    T operator()(SupportsRule* x)         { return static_cast<D*>(this)->fallback(x); }
     T operator()(MediaRule* x) { return static_cast<D*>(this)->fallback(x); }
     T operator()(CssMediaRule* x) { return static_cast<D*>(this)->fallback(x); }
     T operator()(CssMediaQuery* x) { return static_cast<D*>(this)->fallback(x); }
-    T operator()(At_Root_Block* x)          { return static_cast<D*>(this)->fallback(x); }
-    T operator()(Directive* x)              { return static_cast<D*>(this)->fallback(x); }
+    T operator()(AtRootRule* x)          { return static_cast<D*>(this)->fallback(x); }
+    T operator()(AtRule* x)              { return static_cast<D*>(this)->fallback(x); }
     T operator()(Keyframe_Rule* x)          { return static_cast<D*>(this)->fallback(x); }
     T operator()(Declaration* x)            { return static_cast<D*>(this)->fallback(x); }
     T operator()(Assignment* x)             { return static_cast<D*>(this)->fallback(x); }
     T operator()(Import* x)                 { return static_cast<D*>(this)->fallback(x); }
     T operator()(Import_Stub* x)            { return static_cast<D*>(this)->fallback(x); }
-    T operator()(Warning* x)                { return static_cast<D*>(this)->fallback(x); }
-    T operator()(Error* x)                  { return static_cast<D*>(this)->fallback(x); }
-    T operator()(Debug* x)                  { return static_cast<D*>(this)->fallback(x); }
+    T operator()(WarningRule* x)                { return static_cast<D*>(this)->fallback(x); }
+    T operator()(ErrorRule* x)                  { return static_cast<D*>(this)->fallback(x); }
+    T operator()(DebugRule* x)                  { return static_cast<D*>(this)->fallback(x); }
     T operator()(Comment* x)                { return static_cast<D*>(this)->fallback(x); }
     T operator()(If* x)                     { return static_cast<D*>(this)->fallback(x); }
-    T operator()(For* x)                    { return static_cast<D*>(this)->fallback(x); }
-    T operator()(Each* x)                   { return static_cast<D*>(this)->fallback(x); }
-    T operator()(While* x)                  { return static_cast<D*>(this)->fallback(x); }
+    T operator()(ForRule* x)                    { return static_cast<D*>(this)->fallback(x); }
+    T operator()(EachRule* x)                   { return static_cast<D*>(this)->fallback(x); }
+    T operator()(WhileRule* x)                  { return static_cast<D*>(this)->fallback(x); }
     T operator()(Return* x)                 { return static_cast<D*>(this)->fallback(x); }
     T operator()(Content* x)                { return static_cast<D*>(this)->fallback(x); }
     T operator()(ExtendRule* x)              { return static_cast<D*>(this)->fallback(x); }
@@ -180,10 +180,10 @@ namespace Sass {
     T operator()(String_Schema* x)          { return static_cast<D*>(this)->fallback(x); }
     T operator()(String_Constant* x)        { return static_cast<D*>(this)->fallback(x); }
     T operator()(String_Quoted* x)          { return static_cast<D*>(this)->fallback(x); }
-    T operator()(Supports_Condition* x)     { return static_cast<D*>(this)->fallback(x); }
-    T operator()(Supports_Operator* x)      { return static_cast<D*>(this)->fallback(x); }
-    T operator()(Supports_Negation* x)      { return static_cast<D*>(this)->fallback(x); }
-    T operator()(Supports_Declaration* x)   { return static_cast<D*>(this)->fallback(x); }
+    T operator()(SupportsCondition* x)     { return static_cast<D*>(this)->fallback(x); }
+    T operator()(SupportsOperation* x)      { return static_cast<D*>(this)->fallback(x); }
+    T operator()(SupportsNegation* x)      { return static_cast<D*>(this)->fallback(x); }
+    T operator()(SupportsDeclaration* x)   { return static_cast<D*>(this)->fallback(x); }
     T operator()(Supports_Interpolation* x) { return static_cast<D*>(this)->fallback(x); }
     T operator()(Media_Query* x)            { return static_cast<D*>(this)->fallback(x); }
     T operator()(Media_Query_Expression* x) { return static_cast<D*>(this)->fallback(x); }
@@ -196,12 +196,12 @@ namespace Sass {
     T operator()(Arguments* x)              { return static_cast<D*>(this)->fallback(x); }
     // selectors
     T operator()(Selector_Schema* x)        { return static_cast<D*>(this)->fallback(x); }
-    T operator()(Placeholder_Selector* x)   { return static_cast<D*>(this)->fallback(x); }
-    T operator()(Type_Selector* x)       { return static_cast<D*>(this)->fallback(x); }
-    T operator()(Class_Selector* x)         { return static_cast<D*>(this)->fallback(x); }
-    T operator()(Id_Selector* x)            { return static_cast<D*>(this)->fallback(x); }
-    T operator()(Attribute_Selector* x)     { return static_cast<D*>(this)->fallback(x); }
-    T operator()(Pseudo_Selector* x)        { return static_cast<D*>(this)->fallback(x); }
+    T operator()(PlaceholderSelector* x)   { return static_cast<D*>(this)->fallback(x); }
+    T operator()(TypeSelector* x)       { return static_cast<D*>(this)->fallback(x); }
+    T operator()(ClassSelector* x)         { return static_cast<D*>(this)->fallback(x); }
+    T operator()(IDSelector* x)            { return static_cast<D*>(this)->fallback(x); }
+    T operator()(AttributeSelector* x)     { return static_cast<D*>(this)->fallback(x); }
+    T operator()(PseudoSelector* x)        { return static_cast<D*>(this)->fallback(x); }
     T operator()(SelectorComponent* x) { return static_cast<D*>(this)->fallback(x); }
     T operator()(SelectorCombinator* x) { return static_cast<D*>(this)->fallback(x); }
     T operator()(CompoundSelector* x) { return static_cast<D*>(this)->fallback(x); }

data/ext/libsass/src/operators.cpp

@@ -31,7 +31,7 @@ namespace Sass {
     };
 
     /* static function, has no pstate or traces */
-    bool eq(Expression_Obj lhs, Expression_Obj rhs)
+    bool eq(ExpressionObj lhs, ExpressionObj rhs)
     {
       // operation is undefined if one is not a number
       if (!lhs || !rhs) throw Exception::UndefinedOperation(lhs, rhs, Sass_OP::EQ);
@@ -40,7 +40,7 @@ namespace Sass {
     }
 
     /* static function, throws OperationError, has no pstate or traces */
-    bool cmp(Expression_Obj lhs, Expression_Obj rhs, const Sass_OP op)
+    bool cmp(ExpressionObj lhs, ExpressionObj rhs, const Sass_OP op)
     {
       // can only compare numbers!?
       Number_Obj l = Cast<Number>(lhs);
@@ -52,14 +52,14 @@ namespace Sass {
     }
 
     /* static functions, throws OperationError, has no pstate or traces */
-    bool lt(Expression_Obj lhs, Expression_Obj rhs) { return cmp(lhs, rhs, Sass_OP::LT); }
-    bool neq(Expression_Obj lhs, Expression_Obj rhs) { return eq(lhs, rhs) == false; }
-    bool gt(Expression_Obj lhs, Expression_Obj rhs) { return !cmp(lhs, rhs, Sass_OP::GT) && neq(lhs, rhs); }
-    bool lte(Expression_Obj lhs, Expression_Obj rhs) { return cmp(lhs, rhs, Sass_OP::LTE) || eq(lhs, rhs); }
-    bool gte(Expression_Obj lhs, Expression_Obj rhs) { return !cmp(lhs, rhs, Sass_OP::GTE) || eq(lhs, rhs); }
+    bool lt(ExpressionObj lhs, ExpressionObj rhs) { return cmp(lhs, rhs, Sass_OP::LT); }
+    bool neq(ExpressionObj lhs, ExpressionObj rhs) { return eq(lhs, rhs) == false; }
+    bool gt(ExpressionObj lhs, ExpressionObj rhs) { return !cmp(lhs, rhs, Sass_OP::GT) && neq(lhs, rhs); }
+    bool lte(ExpressionObj lhs, ExpressionObj rhs) { return cmp(lhs, rhs, Sass_OP::LTE) || eq(lhs, rhs); }
+    bool gte(ExpressionObj lhs, ExpressionObj rhs) { return !cmp(lhs, rhs, Sass_OP::GTE) || eq(lhs, rhs); }
 
     /* colour math deprecation warning */
-    void op_color_deprecation(enum Sass_OP op, std::string lsh, std::string rhs, const ParserState& pstate)
+    void op_color_deprecation(enum Sass_OP op, sass::string lsh, sass::string rhs, const SourceSpan& pstate)
     {
       deprecated(
         "The operation `" + lsh + " " + sass_op_to_name(op) + " " + rhs +
@@ -70,20 +70,20 @@ namespace Sass {
     }
 
     /* static function, throws OperationError, has no traces but optional pstate for returned value */
-    Value* op_strings(Sass::Operand operand, Value& lhs, Value& rhs, struct Sass_Inspect_Options opt, const ParserState& pstate, bool delayed)
+    Value* op_strings(Sass::Operand operand, Value& lhs, Value& rhs, struct Sass_Inspect_Options opt, const SourceSpan& pstate, bool delayed)
     {
       enum Sass_OP op = operand.operand;
 
       String_Quoted* lqstr = Cast<String_Quoted>(&lhs);
       String_Quoted* rqstr = Cast<String_Quoted>(&rhs);
 
-      std::string lstr(lqstr ? lqstr->value() : lhs.to_string(opt));
-      std::string rstr(rqstr ? rqstr->value() : rhs.to_string(opt));
+      sass::string lstr(lqstr ? lqstr->value() : lhs.to_string(opt));
+      sass::string rstr(rqstr ? rqstr->value() : rhs.to_string(opt));
 
       if (Cast<Null>(&lhs)) throw Exception::InvalidNullOperation(&lhs, &rhs, op);
       if (Cast<Null>(&rhs)) throw Exception::InvalidNullOperation(&lhs, &rhs, op);
 
-      std::string sep;
+      sass::string sep;
       switch (op) {
         case Sass_OP::ADD: sep = "";   break;
         case Sass_OP::SUB: sep = "-";  break;
@@ -121,7 +121,7 @@ namespace Sass {
 
     /* ToDo: allow to operate also with hsla colors */
     /* static function, throws OperationError, has no traces but optional pstate for returned value */
-    Value* op_colors(enum Sass_OP op, const Color_RGBA& lhs, const Color_RGBA& rhs, struct Sass_Inspect_Options opt, const ParserState& pstate, bool delayed)
+    Value* op_colors(enum Sass_OP op, const Color_RGBA& lhs, const Color_RGBA& rhs, struct Sass_Inspect_Options opt, const SourceSpan& pstate, bool delayed)
     {
 
       if (lhs.a() != rhs.a()) {
@@ -142,7 +142,7 @@ namespace Sass {
     }
 
     /* static function, throws OperationError, has no traces but optional pstate for returned value */
-    Value* op_numbers(enum Sass_OP op, const Number& lhs, const Number& rhs, struct Sass_Inspect_Options opt, const ParserState& pstate, bool delayed)
+    Value* op_numbers(enum Sass_OP op, const Number& lhs, const Number& rhs, struct Sass_Inspect_Options opt, const SourceSpan& pstate, bool delayed)
     {
       double lval = lhs.value();
       double rval = rhs.value();
@@ -152,7 +152,7 @@ namespace Sass {
       }
 
       if (op == Sass_OP::DIV && rval == 0) {
-        std::string result(lval ? "Infinity" : "NaN");
+        sass::string result(lval ? "Infinity" : "NaN");
         return SASS_MEMORY_NEW(String_Quoted, pstate, result);
       }
 
@@ -212,7 +212,7 @@ namespace Sass {
     }
 
     /* static function, throws OperationError, has no traces but optional pstate for returned value */
-    Value* op_number_color(enum Sass_OP op, const Number& lhs, const Color_RGBA& rhs, struct Sass_Inspect_Options opt, const ParserState& pstate, bool delayed)
+    Value* op_number_color(enum Sass_OP op, const Number& lhs, const Color_RGBA& rhs, struct Sass_Inspect_Options opt, const SourceSpan& pstate, bool delayed)
     {
       double lval = lhs.value();
 
@@ -229,7 +229,7 @@ namespace Sass {
         }
         case Sass_OP::SUB:
         case Sass_OP::DIV: {
-          std::string color(rhs.to_string(opt));
+          sass::string color(rhs.to_string(opt));
           op_color_deprecation(op, lhs.to_string(), color, pstate);
           return SASS_MEMORY_NEW(String_Quoted,
                                 pstate,
@@ -243,7 +243,7 @@ namespace Sass {
     }
 
     /* static function, throws OperationError, has no traces but optional pstate for returned value */
-    Value* op_color_number(enum Sass_OP op, const Color_RGBA& lhs, const Number& rhs, struct Sass_Inspect_Options opt, const ParserState& pstate, bool delayed)
+    Value* op_color_number(enum Sass_OP op, const Color_RGBA& lhs, const Number& rhs, struct Sass_Inspect_Options opt, const SourceSpan& pstate, bool delayed)
     {
       double rval = rhs.value();
 

data/ext/libsass/src/operators.hpp

@@ -9,19 +9,19 @@ namespace Sass {
   namespace Operators {
 
     // equality operator using AST Node operator==
-    bool eq(Expression_Obj, Expression_Obj);
-    bool neq(Expression_Obj, Expression_Obj);
+    bool eq(ExpressionObj, ExpressionObj);
+    bool neq(ExpressionObj, ExpressionObj);
     // specific operators based on cmp and eq
-    bool lt(Expression_Obj, Expression_Obj);
-    bool gt(Expression_Obj, Expression_Obj);
-    bool lte(Expression_Obj, Expression_Obj);
-    bool gte(Expression_Obj, Expression_Obj);
+    bool lt(ExpressionObj, ExpressionObj);
+    bool gt(ExpressionObj, ExpressionObj);
+    bool lte(ExpressionObj, ExpressionObj);
+    bool gte(ExpressionObj, ExpressionObj);
     // arithmetic for all the combinations that matter
-    Value* op_strings(Sass::Operand, Value&, Value&, struct Sass_Inspect_Options opt, const ParserState& pstate, bool delayed = false);
-    Value* op_colors(enum Sass_OP, const Color_RGBA&, const Color_RGBA&, struct Sass_Inspect_Options opt, const ParserState& pstate, bool delayed = false);
-    Value* op_numbers(enum Sass_OP, const Number&, const Number&, struct Sass_Inspect_Options opt, const ParserState& pstate, bool delayed = false);
-    Value* op_number_color(enum Sass_OP, const Number&, const Color_RGBA&, struct Sass_Inspect_Options opt, const ParserState& pstate, bool delayed = false);
-    Value* op_color_number(enum Sass_OP, const Color_RGBA&, const Number&, struct Sass_Inspect_Options opt, const ParserState& pstate, bool delayed = false);
+    Value* op_strings(Sass::Operand, Value&, Value&, struct Sass_Inspect_Options opt, const SourceSpan& pstate, bool delayed = false);
+    Value* op_colors(enum Sass_OP, const Color_RGBA&, const Color_RGBA&, struct Sass_Inspect_Options opt, const SourceSpan& pstate, bool delayed = false);
+    Value* op_numbers(enum Sass_OP, const Number&, const Number&, struct Sass_Inspect_Options opt, const SourceSpan& pstate, bool delayed = false);
+    Value* op_number_color(enum Sass_OP, const Number&, const Color_RGBA&, struct Sass_Inspect_Options opt, const SourceSpan& pstate, bool delayed = false);
+    Value* op_color_number(enum Sass_OP, const Color_RGBA&, const Number&, struct Sass_Inspect_Options opt, const SourceSpan& pstate, bool delayed = false);
 
   };
 

data/ext/libsass/src/ordered_map.hpp

@@ -5,7 +5,7 @@ namespace Sass {
 
   // ##########################################################################
   // Very simple and limited container for insert ordered hash map.
-  // Piggy-back implementation on std::unordered_map and std::vector
+  // Piggy-back implementation on std::unordered_map and sass::vector
   // ##########################################################################
   template<
     class Key,
@@ -26,8 +26,8 @@ namespace Sass {
     map_type _map;
 
     // Keep insertion order
-    std::vector<Key> _keys;
-    std::vector<T> _values;
+    sass::vector<Key> _keys;
+    sass::vector<T> _values;
 
     const KeyEqual _keyEqual;
 
@@ -81,8 +81,8 @@ namespace Sass {
       return false;
     }
 
-    const std::vector<Key>& keys() const { return _keys; }
-    const std::vector<T>& values() const { return _values; }
+    const sass::vector<Key>& keys() const { return _keys; }
+    const sass::vector<T>& values() const { return _values; }
 
     const T& get(const Key& key) {
       if (hasKey(key)) {
@@ -91,19 +91,19 @@ namespace Sass {
       throw std::runtime_error("Key does not exist");
     }
 
-    using iterator = typename std::vector<Key>::iterator;
-    using const_iterator = typename std::vector<Key>::const_iterator;
-    using reverse_iterator = typename std::vector<Key>::reverse_iterator;
-    using const_reverse_iterator = typename std::vector<Key>::const_reverse_iterator;
-
-    typename std::vector<Key>::iterator end() { return _keys.end(); }
-    typename std::vector<Key>::iterator begin() { return _keys.begin(); }
-    typename std::vector<Key>::reverse_iterator rend() { return _keys.rend(); }
-    typename std::vector<Key>::reverse_iterator rbegin() { return _keys.rbegin(); }
-    typename std::vector<Key>::const_iterator end() const { return _keys.end(); }
-    typename std::vector<Key>::const_iterator begin() const { return _keys.begin(); }
-    typename std::vector<Key>::const_reverse_iterator rend() const { return _keys.rend(); }
-    typename std::vector<Key>::const_reverse_iterator rbegin() const { return _keys.rbegin(); }
+    using iterator = typename sass::vector<Key>::iterator;
+    using const_iterator = typename sass::vector<Key>::const_iterator;
+    using reverse_iterator = typename sass::vector<Key>::reverse_iterator;
+    using const_reverse_iterator = typename sass::vector<Key>::const_reverse_iterator;
+
+    typename sass::vector<Key>::iterator end() { return _keys.end(); }
+    typename sass::vector<Key>::iterator begin() { return _keys.begin(); }
+    typename sass::vector<Key>::reverse_iterator rend() { return _keys.rend(); }
+    typename sass::vector<Key>::reverse_iterator rbegin() { return _keys.rbegin(); }
+    typename sass::vector<Key>::const_iterator end() const { return _keys.end(); }
+    typename sass::vector<Key>::const_iterator begin() const { return _keys.begin(); }
+    typename sass::vector<Key>::const_reverse_iterator rend() const { return _keys.rend(); }
+    typename sass::vector<Key>::const_reverse_iterator rbegin() const { return _keys.rbegin(); }
 
   };