sassc 2.2.1 → 2.4.0

data/ext/libsass/src/ast_values.hpp

@@ -4,35 +4,7 @@
 // sass.hpp must go before all system headers to get the
 // __EXTENSIONS__ fix on Solaris.
 #include "sass.hpp"
-
-#include <set>
-#include <deque>
-#include <vector>
-#include <string>
-#include <sstream>
-#include <iostream>
-#include <typeinfo>
-#include <algorithm>
-#include "sass/base.h"
-#include "ast_fwd_decl.hpp"
-
-#include "util.hpp"
-#include "units.hpp"
-#include "context.hpp"
-#include "position.hpp"
-#include "constants.hpp"
-#include "operation.hpp"
-#include "position.hpp"
-#include "inspect.hpp"
-#include "source_map.hpp"
-#include "environment.hpp"
-#include "error_handling.hpp"
-#include "ast_def_macros.hpp"
-#include "ast_fwd_decl.hpp"
-#include "source_map.hpp"
-#include "fn_utils.hpp"
-
-#include "sass.h"
+#include "ast.hpp"
 
 namespace Sass {
 
@@ -41,7 +13,7 @@ namespace Sass {
   //////////////////////////////////////////////////////////////////////
   class PreValue : public Expression {
   public:
-    PreValue(ParserState pstate, bool d = false, bool e = false, bool i = false, Type ct = NONE);
+    PreValue(SourceSpan pstate, bool d = false, bool e = false, bool i = false, Type ct = NONE);
     ATTACH_VIRTUAL_AST_OPERATIONS(PreValue);
     virtual ~PreValue() { }
   };
@@ -51,36 +23,53 @@ namespace Sass {
   //////////////////////////////////////////////////////////////////////
   class Value : public PreValue {
   public:
-    Value(ParserState pstate, bool d = false, bool e = false, bool i = false, Type ct = NONE);
-    ATTACH_VIRTUAL_AST_OPERATIONS(Value);
+    Value(SourceSpan pstate, bool d = false, bool e = false, bool i = false, Type ct = NONE);
+
+    // Some obects are not meant to be compared
+    // ToDo: maybe fallback to pointer comparison?
+    virtual bool operator< (const Expression& rhs) const override = 0;
     virtual bool operator== (const Expression& rhs) const override = 0;
+
+    // We can give some reasonable implementations by using
+    // inverst operators on the specialized implementations
+    virtual bool operator> (const Expression& rhs) const {
+      return rhs < *this;
+    }
+    virtual bool operator!= (const Expression& rhs) const {
+      return !(*this == rhs);
+    }
+
+    ATTACH_VIRTUAL_AST_OPERATIONS(Value);
+
   };
 
   ///////////////////////////////////////////////////////////////////////
   // Lists of values, both comma- and space-separated (distinguished by a
   // type-tag.) Also used to represent variable-length argument lists.
   ///////////////////////////////////////////////////////////////////////
-  class List : public Value, public Vectorized<Expression_Obj> {
-    void adjust_after_pushing(Expression_Obj e) override { is_expanded(false); }
+  class List : public Value, public Vectorized<ExpressionObj> {
+    void adjust_after_pushing(ExpressionObj e) override { is_expanded(false); }
   private:
     ADD_PROPERTY(enum Sass_Separator, separator)
     ADD_PROPERTY(bool, is_arglist)
     ADD_PROPERTY(bool, is_bracketed)
     ADD_PROPERTY(bool, from_selector)
   public:
-    List(ParserState pstate, size_t size = 0, enum Sass_Separator sep = SASS_SPACE, bool argl = false, bool bracket = false);
-    std::string type() const override { return is_arglist_ ? "arglist" : "list"; }
-    static std::string type_name() { return "list"; }
+    List(SourceSpan pstate, size_t size = 0, enum Sass_Separator sep = SASS_SPACE, bool argl = false, bool bracket = false);
+    sass::string type() const override { return is_arglist_ ? "arglist" : "list"; }
+    static sass::string type_name() { return "list"; }
     const char* sep_string(bool compressed = false) const {
       return separator() == SASS_SPACE ?
         " " : (compressed ? "," : ", ");
     }
     bool is_invisible() const override { return empty() && !is_bracketed(); }
-    Expression_Obj value_at_index(size_t i);
+    ExpressionObj value_at_index(size_t i);
 
     virtual size_t hash() const override;
     virtual size_t size() const;
     virtual void set_delayed(bool delayed) override;
+
+    virtual bool operator< (const Expression& rhs) const override;
     virtual bool operator== (const Expression& rhs) const override;
 
     ATTACH_AST_OPERATIONS(List)
@@ -90,16 +79,18 @@ namespace Sass {
   ///////////////////////////////////////////////////////////////////////
   // Key value paris.
   ///////////////////////////////////////////////////////////////////////
-  class Map : public Value, public Hashed {
-    void adjust_after_pushing(std::pair<Expression_Obj, Expression_Obj> p) override { is_expanded(false); }
+  class Map : public Value, public Hashed<ExpressionObj, ExpressionObj, Map_Obj> {
+    void adjust_after_pushing(std::pair<ExpressionObj, ExpressionObj> p) override { is_expanded(false); }
   public:
-    Map(ParserState pstate, size_t size = 0);
-    std::string type() const override { return "map"; }
-    static std::string type_name() { return "map"; }
+    Map(SourceSpan pstate, size_t size = 0);
+    sass::string type() const override { return "map"; }
+    static sass::string type_name() { return "map"; }
     bool is_invisible() const override { return empty(); }
-    List_Obj to_list(ParserState& pstate);
+    List_Obj to_list(SourceSpan& pstate);
 
     virtual size_t hash() const override;
+
+    virtual bool operator< (const Expression& rhs) const override;
     virtual bool operator== (const Expression& rhs) const override;
 
     ATTACH_AST_OPERATIONS(Map)
@@ -115,21 +106,22 @@ namespace Sass {
   class Binary_Expression : public PreValue {
   private:
     HASH_PROPERTY(Operand, op)
-    HASH_PROPERTY(Expression_Obj, left)
-    HASH_PROPERTY(Expression_Obj, right)
+    HASH_PROPERTY(ExpressionObj, left)
+    HASH_PROPERTY(ExpressionObj, right)
     mutable size_t hash_;
   public:
-    Binary_Expression(ParserState pstate,
-                      Operand op, Expression_Obj lhs, Expression_Obj rhs);
+    Binary_Expression(SourceSpan pstate,
+                      Operand op, ExpressionObj lhs, ExpressionObj rhs);
 
-    const std::string type_name();
-    const std::string separator();
+    const sass::string type_name();
+    const sass::string separator();
     bool is_left_interpolant(void) const override;
     bool is_right_interpolant(void) const override;
     bool has_interpolant() const override;
 
     virtual void set_delayed(bool delayed) override;
 
+    virtual bool operator< (const Expression& rhs) const override;
     virtual bool operator==(const Expression& rhs) const override;
 
     virtual size_t hash() const override;
@@ -146,14 +138,15 @@ namespace Sass {
     ADD_PROPERTY(Definition_Obj, definition)
     ADD_PROPERTY(bool, is_css)
   public:
-    Function(ParserState pstate, Definition_Obj def, bool css);
+    Function(SourceSpan pstate, Definition_Obj def, bool css);
 
-    std::string type() const override { return "function"; }
-    static std::string type_name() { return "function"; }
+    sass::string type() const override { return "function"; }
+    static sass::string type_name() { return "function"; }
     bool is_invisible() const override { return true; }
 
-    std::string name();
+    sass::string name();
 
+    bool operator< (const Expression& rhs) const override;
     bool operator== (const Expression& rhs) const override;
 
     ATTACH_AST_OPERATIONS(Function)
@@ -171,15 +164,15 @@ namespace Sass {
     ADD_PROPERTY(void*, cookie)
     mutable size_t hash_;
   public:
-    Function_Call(ParserState pstate, std::string n, Arguments_Obj args, void* cookie);
-    Function_Call(ParserState pstate, std::string n, Arguments_Obj args, Function_Obj func);
-    Function_Call(ParserState pstate, std::string n, Arguments_Obj args);
+    Function_Call(SourceSpan pstate, sass::string n, Arguments_Obj args, void* cookie);
+    Function_Call(SourceSpan pstate, sass::string n, Arguments_Obj args, Function_Obj func);
+    Function_Call(SourceSpan pstate, sass::string n, Arguments_Obj args);
 
-    Function_Call(ParserState pstate, String_Obj n, Arguments_Obj args, void* cookie);
-    Function_Call(ParserState pstate, String_Obj n, Arguments_Obj args, Function_Obj func);
-    Function_Call(ParserState pstate, String_Obj n, Arguments_Obj args);
+    Function_Call(SourceSpan pstate, String_Obj n, Arguments_Obj args, void* cookie);
+    Function_Call(SourceSpan pstate, String_Obj n, Arguments_Obj args, Function_Obj func);
+    Function_Call(SourceSpan pstate, String_Obj n, Arguments_Obj args);
 
-    std::string name() const;
+    sass::string name() const;
     bool is_css();
 
     bool operator==(const Expression& rhs) const override;
@@ -194,9 +187,9 @@ namespace Sass {
   // Variable references.
   ///////////////////////
   class Variable final : public PreValue {
-    ADD_CONSTREF(std::string, name)
+    ADD_CONSTREF(sass::string, name)
   public:
-    Variable(ParserState pstate, std::string n);
+    Variable(SourceSpan pstate, sass::string n);
     virtual bool operator==(const Expression& rhs) const override;
     virtual size_t hash() const override;
     ATTACH_AST_OPERATIONS(Variable)
@@ -211,12 +204,12 @@ namespace Sass {
     ADD_PROPERTY(bool, zero)
     mutable size_t hash_;
   public:
-    Number(ParserState pstate, double val, std::string u = "", bool zero = true);
+    Number(SourceSpan pstate, double val, sass::string u = "", bool zero = true);
 
     bool zero() { return zero_; }
 
-    std::string type() const override { return "number"; }
-    static std::string type_name() { return "number"; }
+    sass::string type() const override { return "number"; }
+    static sass::string type_name() { return "number"; }
 
     // cancel out unnecessary units
     // result will be in input units
@@ -230,6 +223,7 @@ namespace Sass {
 
     bool operator< (const Number& rhs) const;
     bool operator== (const Number& rhs) const;
+    bool operator< (const Expression& rhs) const override;
     bool operator== (const Expression& rhs) const override;
     ATTACH_AST_OPERATIONS(Number)
     ATTACH_CRTP_PERFORM_METHODS()
@@ -239,18 +233,19 @@ namespace Sass {
   // Colors.
   //////////
   class Color : public Value {
-    ADD_CONSTREF(std::string, disp)
+    ADD_CONSTREF(sass::string, disp)
     HASH_PROPERTY(double, a)
   protected:
     mutable size_t hash_;
   public:
-    Color(ParserState pstate, double a = 1, const std::string disp = "");
+    Color(SourceSpan pstate, double a = 1, const sass::string disp = "");
 
-    std::string type() const override { return "color"; }
-    static std::string type_name() { return "color"; }
+    sass::string type() const override { return "color"; }
+    static sass::string type_name() { return "color"; }
 
     virtual size_t hash() const override = 0;
 
+    bool operator< (const Expression& rhs) const override;
     bool operator== (const Expression& rhs) const override;
 
     virtual Color_RGBA* copyAsRGBA() const = 0;
@@ -270,10 +265,10 @@ namespace Sass {
     HASH_PROPERTY(double, g)
     HASH_PROPERTY(double, b)
   public:
-    Color_RGBA(ParserState pstate, double r, double g, double b, double a = 1, const std::string disp = "");
+    Color_RGBA(SourceSpan pstate, double r, double g, double b, double a = 1, const sass::string disp = "");
 
-    std::string type() const override { return "color"; }
-    static std::string type_name() { return "color"; }
+    sass::string type() const override { return "color"; }
+    static sass::string type_name() { return "color"; }
 
     size_t hash() const override;
 
@@ -283,6 +278,7 @@ namespace Sass {
     Color_HSLA* copyAsHSLA() const override;
     Color_HSLA* toHSLA() override { return copyAsHSLA(); }
 
+    bool operator< (const Expression& rhs) const override;
     bool operator== (const Expression& rhs) const override;
 
     ATTACH_AST_OPERATIONS(Color_RGBA)
@@ -298,10 +294,10 @@ namespace Sass {
     HASH_PROPERTY(double, s)
     HASH_PROPERTY(double, l)
   public:
-    Color_HSLA(ParserState pstate, double h, double s, double l, double a = 1, const std::string disp = "");
+    Color_HSLA(SourceSpan pstate, double h, double s, double l, double a = 1, const sass::string disp = "");
 
-    std::string type() const override { return "color"; }
-    static std::string type_name() { return "color"; }
+    sass::string type() const override { return "color"; }
+    static sass::string type_name() { return "color"; }
 
     size_t hash() const override;
 
@@ -311,6 +307,7 @@ namespace Sass {
     Color_HSLA* copyAsHSLA() const override;
     Color_HSLA* toHSLA() override { return this; }
 
+    bool operator< (const Expression& rhs) const override;
     bool operator== (const Expression& rhs) const override;
 
     ATTACH_AST_OPERATIONS(Color_HSLA)
@@ -321,9 +318,10 @@ namespace Sass {
   // Errors from Sass_Values.
   //////////////////////////////
   class Custom_Error final : public Value {
-    ADD_CONSTREF(std::string, message)
+    ADD_CONSTREF(sass::string, message)
   public:
-    Custom_Error(ParserState pstate, std::string msg);
+    Custom_Error(SourceSpan pstate, sass::string msg);
+    bool operator< (const Expression& rhs) const override;
     bool operator== (const Expression& rhs) const override;
     ATTACH_AST_OPERATIONS(Custom_Error)
     ATTACH_CRTP_PERFORM_METHODS()
@@ -333,9 +331,10 @@ namespace Sass {
   // Warnings from Sass_Values.
   //////////////////////////////
   class Custom_Warning final : public Value {
-    ADD_CONSTREF(std::string, message)
+    ADD_CONSTREF(sass::string, message)
   public:
-    Custom_Warning(ParserState pstate, std::string msg);
+    Custom_Warning(SourceSpan pstate, sass::string msg);
+    bool operator< (const Expression& rhs) const override;
     bool operator== (const Expression& rhs) const override;
     ATTACH_AST_OPERATIONS(Custom_Warning)
     ATTACH_CRTP_PERFORM_METHODS()
@@ -348,16 +347,17 @@ namespace Sass {
     HASH_PROPERTY(bool, value)
     mutable size_t hash_;
   public:
-    Boolean(ParserState pstate, bool val);
+    Boolean(SourceSpan pstate, bool val);
     operator bool() override { return value_; }
 
-    std::string type() const override { return "bool"; }
-    static std::string type_name() { return "bool"; }
+    sass::string type() const override { return "bool"; }
+    static sass::string type_name() { return "bool"; }
 
     size_t hash() const override;
 
     bool is_false() override { return !value_; }
 
+    bool operator< (const Expression& rhs) const override;
     bool operator== (const Expression& rhs) const override;
 
     ATTACH_AST_OPERATIONS(Boolean)
@@ -370,13 +370,16 @@ namespace Sass {
   ////////////////////////////////////////////////////////////////////////
   class String : public Value {
   public:
-    String(ParserState pstate, bool delayed = false);
-    static std::string type_name() { return "string"; }
+    String(SourceSpan pstate, bool delayed = false);
+    static sass::string type_name() { return "string"; }
     virtual ~String() = 0;
     virtual void rtrim() = 0;
     virtual bool operator<(const Expression& rhs) const override {
       return this->to_string() < rhs.to_string();
     };
+    virtual bool operator==(const Expression& rhs) const override {
+      return this->to_string() == rhs.to_string();
+    };
     ATTACH_VIRTUAL_AST_OPERATIONS(String);
     ATTACH_CRTP_PERFORM_METHODS()
   };
@@ -386,14 +389,14 @@ namespace Sass {
   // Interpolated strings. Meant to be reduced to flat strings during the
   // evaluation phase.
   ///////////////////////////////////////////////////////////////////////
-  class String_Schema final : public String, public Vectorized<PreValue_Obj> {
+  class String_Schema final : public String, public Vectorized<PreValueObj> {
     ADD_PROPERTY(bool, css)
     mutable size_t hash_;
   public:
-    String_Schema(ParserState pstate, size_t size = 0, bool css = true);
+    String_Schema(SourceSpan pstate, size_t size = 0, bool css = true);
 
-    std::string type() const override { return "string"; }
-    static std::string type_name() { return "string"; }
+    sass::string type() const override { return "string"; }
+    static sass::string type_name() { return "string"; }
 
     bool is_left_interpolant(void) const override;
     bool is_right_interpolant(void) const override;
@@ -403,6 +406,7 @@ namespace Sass {
     size_t hash() const override;
     virtual void set_delayed(bool delayed) override;
 
+    bool operator< (const Expression& rhs) const override;
     bool operator==(const Expression& rhs) const override;
     ATTACH_AST_OPERATIONS(String_Schema)
     ATTACH_CRTP_PERFORM_METHODS()
@@ -413,23 +417,23 @@ namespace Sass {
   ////////////////////////////////////////////////////////
   class String_Constant : public String {
     ADD_PROPERTY(char, quote_mark)
-    ADD_PROPERTY(bool, can_compress_whitespace)
-    HASH_CONSTREF(std::string, value)
+    HASH_CONSTREF(sass::string, value)
   protected:
     mutable size_t hash_;
   public:
-    String_Constant(ParserState pstate, std::string val, bool css = true);
-    String_Constant(ParserState pstate, const char* beg, bool css = true);
-    String_Constant(ParserState pstate, const char* beg, const char* end, bool css = true);
-    String_Constant(ParserState pstate, const Token& tok, bool css = true);
-    std::string type() const override { return "string"; }
-    static std::string type_name() { return "string"; }
+    String_Constant(SourceSpan pstate, sass::string val, bool css = true);
+    String_Constant(SourceSpan pstate, const char* beg, bool css = true);
+    String_Constant(SourceSpan pstate, const char* beg, const char* end, bool css = true);
+    String_Constant(SourceSpan pstate, const Token& tok, bool css = true);
+    sass::string type() const override { return "string"; }
+    static sass::string type_name() { return "string"; }
     bool is_invisible() const override;
     virtual void rtrim() override;
     size_t hash() const override;
+    bool operator< (const Expression& rhs) const override;
     bool operator==(const Expression& rhs) const override;
     // quotes are forced on inspection
-    virtual std::string inspect() const override;
+    virtual sass::string inspect() const override;
     ATTACH_AST_OPERATIONS(String_Constant)
     ATTACH_CRTP_PERFORM_METHODS()
   };
@@ -439,12 +443,13 @@ namespace Sass {
   ////////////////////////////////////////////////////////
   class String_Quoted final : public String_Constant {
   public:
-    String_Quoted(ParserState pstate, std::string val, char q = 0,
+    String_Quoted(SourceSpan pstate, sass::string val, char q = 0,
       bool keep_utf8_escapes = false, bool skip_unquoting = false,
       bool strict_unquoting = true, bool css = true);
+    bool operator< (const Expression& rhs) const override;
     bool operator==(const Expression& rhs) const override;
     // quotes are forced on inspection
-    std::string inspect() const override;
+    sass::string inspect() const override;
     ATTACH_AST_OPERATIONS(String_Quoted)
     ATTACH_CRTP_PERFORM_METHODS()
   };
@@ -454,15 +459,16 @@ namespace Sass {
   //////////////////
   class Null final : public Value {
   public:
-    Null(ParserState pstate);
-    std::string type() const override { return "null"; }
-    static std::string type_name() { return "null"; }
+    Null(SourceSpan pstate);
+    sass::string type() const override { return "null"; }
+    static sass::string type_name() { return "null"; }
     bool is_invisible() const override { return true; }
     operator bool() override { return false; }
     bool is_false() override { return true; }
 
     size_t hash() const override;
 
+    bool operator< (const Expression& rhs) const override;
     bool operator== (const Expression& rhs) const override;
 
     ATTACH_AST_OPERATIONS(Null)
@@ -474,11 +480,14 @@ namespace Sass {
   //////////////////////////////////
   class Parent_Reference final : public Value {
   public:
-    Parent_Reference(ParserState pstate);
-    std::string type() const override { return "parent"; }
-    static std::string type_name() { return "parent"; }
+    Parent_Reference(SourceSpan pstate);
+    sass::string type() const override { return "parent"; }
+    static sass::string type_name() { return "parent"; }
+    bool operator< (const Expression& rhs) const override {
+      return false; // they are always equal
+    }
     bool operator==(const Expression& rhs) const override {
-      return true; // can they ever be not equal?
+      return true; // they are always equal
     };
     ATTACH_AST_OPERATIONS(Parent_Reference)
     ATTACH_CRTP_PERFORM_METHODS()

data/ext/libsass/src/backtrace.cpp

@@ -2,20 +2,20 @@
 
 namespace Sass {
 
-  const std::string traces_to_string(Backtraces traces, std::string indent) {
+  const sass::string traces_to_string(Backtraces traces, sass::string indent) {
 
-    std::stringstream ss;
-    std::string cwd(File::get_cwd());
+    sass::ostream ss;
+    sass::string cwd(File::get_cwd());
 
     bool first = true;
     size_t i_beg = traces.size() - 1;
-    size_t i_end = std::string::npos;
+    size_t i_end = sass::string::npos;
     for (size_t i = i_beg; i != i_end; i --) {
 
       const Backtrace& trace = traces[i];
 
       // make path relative to the current directory
-      std::string rel_path(File::abs2rel(trace.pstate.path, cwd, cwd));
+      sass::string rel_path(File::abs2rel(trace.pstate.getPath(), cwd, cwd));
 
       // skip functions on error cases (unsure why ruby sass does this)
       // if (trace.caller.substr(0, 6) == ", in f") continue;
@@ -23,9 +23,9 @@ namespace Sass {
       if (first) {
         ss << indent;
         ss << "on line ";
-        ss << trace.pstate.line + 1;
+        ss << trace.pstate.getLine();
         ss << ":";
-        ss << trace.pstate.column + 1;
+        ss << trace.pstate.getColumn();
         ss << " of " << rel_path;
         // ss << trace.caller;
         first = false;
@@ -34,9 +34,9 @@ namespace Sass {
         ss << std::endl;
         ss << indent;
         ss << "from line ";
-        ss << trace.pstate.line + 1;
+        ss << trace.pstate.getLine();
         ss << ":";
-        ss << trace.pstate.column + 1;
+        ss << trace.pstate.getColumn();
         ss << " of " << rel_path;
       }
 

data/ext/libsass/src/backtrace.hpp

@@ -10,19 +10,19 @@ namespace Sass {
 
   struct Backtrace {
 
-    ParserState pstate;
-    std::string caller;
+    SourceSpan pstate;
+    sass::string caller;
 
-    Backtrace(ParserState pstate, std::string c = "")
+    Backtrace(SourceSpan pstate, sass::string c = "")
     : pstate(pstate),
       caller(c)
     { }
 
   };
 
-  typedef std::vector<Backtrace> Backtraces;
+  typedef sass::vector<Backtrace> Backtraces;
 
-  const std::string traces_to_string(Backtraces traces, std::string indent = "\t");
+  const sass::string traces_to_string(Backtraces traces, sass::string indent = "\t");
 
 }
 

data/ext/libsass/src/base64vlq.cpp

@@ -6,9 +6,9 @@
 
 namespace Sass {
 
-  std::string Base64VLQ::encode(const int number) const
+  sass::string Base64VLQ::encode(const int number) const
   {
-    std::string encoded = "";
+    sass::string encoded = "";
 
     int vlq = to_vlq_signed(number);
 

data/ext/libsass/src/base64vlq.hpp

@@ -9,7 +9,7 @@ namespace Sass {
 
   public:
 
-    std::string encode(const int number) const;
+    sass::string encode(const int number) const;
 
   private: