sassc 2.0.0 → 2.4.0

data/ext/libsass/src/source_map.hpp

@@ -9,6 +9,9 @@
 #include "position.hpp"
 #include "mapping.hpp"
 
+#include "backtrace.hpp"
+#include "memory.hpp"
+
 #define VECTOR_PUSH(vec, ins) vec.insert(vec.end(), ins.begin(), ins.end())
 #define VECTOR_UNSHIFT(vec, ins) vec.insert(vec.begin(), ins.begin(), ins.end())
 
@@ -20,28 +23,28 @@ namespace Sass {
   class SourceMap {
 
   public:
-    std::vector<size_t> source_index;
+    sass::vector<size_t> source_index;
     SourceMap();
-    SourceMap(const std::string& file);
+    SourceMap(const sass::string& file);
 
     void append(const Offset& offset);
     void prepend(const Offset& offset);
     void append(const OutputBuffer& out);
     void prepend(const OutputBuffer& out);
-    void add_open_mapping(const AST_Node_Ptr node);
-    void add_close_mapping(const AST_Node_Ptr node);
+    void add_open_mapping(const AST_Node* node);
+    void add_close_mapping(const AST_Node* node);
 
-    std::string render_srcmap(Context &ctx);
-    ParserState remap(const ParserState& pstate);
+    sass::string render_srcmap(Context &ctx);
+    SourceSpan remap(const SourceSpan& pstate);
 
   private:
 
-    std::string serialize_mappings();
+    sass::string serialize_mappings();
 
-    std::vector<Mapping> mappings;
+    sass::vector<Mapping> mappings;
     Position current_position;
 public:
-    std::string file;
+    sass::string file;
 private:
     Base64VLQ base64vlq;
   };
@@ -49,11 +52,11 @@ private:
   class OutputBuffer {
     public:
       OutputBuffer(void)
-      : buffer(""),
+      : buffer(),
         smap()
       { }
     public:
-      std::string buffer;
+      sass::string buffer;
       SourceMap smap;
   };
 

data/ext/libsass/src/stylesheet.cpp

@@ -0,0 +1,22 @@
+// sass.hpp must go before all system headers to get the
+// __EXTENSIONS__ fix on Solaris.
+#include "sass.hpp"
+
+#include "stylesheet.hpp"
+
+namespace Sass {
+
+  // Constructor
+  Sass::StyleSheet::StyleSheet(const Resource& res, Block_Obj root) :
+    Resource(res),
+    root(root)
+  {
+  }
+
+  StyleSheet::StyleSheet(const StyleSheet& sheet) :
+    Resource(sheet),
+    root(sheet.root)
+  {
+  }
+
+}

data/ext/libsass/src/stylesheet.hpp

@@ -0,0 +1,57 @@
+#ifndef SASS_STYLESHEET_H
+#define SASS_STYLESHEET_H
+
+// sass.hpp must go before all system headers to get the
+// __EXTENSIONS__ fix on Solaris.
+#include "sass.hpp"
+
+#include "ast_fwd_decl.hpp"
+#include "extender.hpp"
+#include "file.hpp"
+
+namespace Sass {
+
+  // parsed stylesheet from loaded resource
+  // this should be a `Module` for sass 4.0
+  class StyleSheet : public Resource {
+    public:
+
+      // The canonical URL for this module's source file. This may be `null`
+      // if the module was loaded from a string without a URL provided.
+      // Uri get url;
+
+      // Modules that this module uses.
+      // List<Module> get upstream;
+
+      // The module's variables.
+      // Map<String, Value> get variables;
+
+      // The module's functions. Implementations must ensure
+      // that each [Callable] is stored under its own name.
+      // Map<String, Callable> get functions;
+
+      // The module's mixins. Implementations must ensure that
+      // each [Callable] is stored under its own name.
+      // Map<String, Callable> get mixins;
+
+      // The extensions defined in this module, which is also able to update
+      // [css]'s style rules in-place based on downstream extensions.
+      // Extender extender;
+
+      // The module's CSS tree.
+      Block_Obj root;
+
+    public:
+
+      // default argument constructor
+      StyleSheet(const Resource& res, Block_Obj root);
+
+      // Copy constructor
+      StyleSheet(const StyleSheet& res);
+
+  };
+
+
+}
+
+#endif

data/ext/libsass/src/to_value.cpp

@@ -1,60 +1,62 @@
+// sass.hpp must go before all system headers to get the
+// __EXTENSIONS__ fix on Solaris.
 #include "sass.hpp"
+
 #include "ast.hpp"
 #include "to_value.hpp"
 
 namespace Sass {
 
-  Value_Ptr To_Value::fallback_impl(AST_Node_Ptr n)
-  {
-    // throw a runtime error if this happens
-    // we want a well defined set of possible nodes
-    throw std::runtime_error("invalid node for to_value");
-  }
-
   // Custom_Error is a valid value
-  Value_Ptr To_Value::operator()(Custom_Error_Ptr e)
+  Value* To_Value::operator()(Custom_Error* e)
   {
     return e;
   }
 
   // Custom_Warning is a valid value
-  Value_Ptr To_Value::operator()(Custom_Warning_Ptr w)
+  Value* To_Value::operator()(Custom_Warning* w)
   {
     return w;
   }
 
   // Boolean is a valid value
-  Value_Ptr To_Value::operator()(Boolean_Ptr b)
+  Value* To_Value::operator()(Boolean* b)
   {
     return b;
   }
 
   // Number is a valid value
-  Value_Ptr To_Value::operator()(Number_Ptr n)
+  Value* To_Value::operator()(Number* n)
   {
     return n;
   }
 
   // Color is a valid value
-  Value_Ptr To_Value::operator()(Color_Ptr c)
+  Value* To_Value::operator()(Color_RGBA* c)
+  {
+    return c;
+  }
+
+  // Color is a valid value
+  Value* To_Value::operator()(Color_HSLA* c)
   {
     return c;
   }
 
   // String_Constant is a valid value
-  Value_Ptr To_Value::operator()(String_Constant_Ptr s)
+  Value* To_Value::operator()(String_Constant* s)
   {
     return s;
   }
 
   // String_Quoted is a valid value
-  Value_Ptr To_Value::operator()(String_Quoted_Ptr s)
+  Value* To_Value::operator()(String_Quoted* s)
   {
     return s;
   }
 
   // List is a valid value
-  Value_Ptr To_Value::operator()(List_Ptr l)
+  Value* To_Value::operator()(List* l)
   {
     List_Obj ll = SASS_MEMORY_NEW(List,
                                l->pstate(),
@@ -69,32 +71,32 @@ namespace Sass {
   }
 
   // Map is a valid value
-  Value_Ptr To_Value::operator()(Map_Ptr m)
+  Value* To_Value::operator()(Map* m)
   {
     return m;
   }
 
   // Null is a valid value
-  Value_Ptr To_Value::operator()(Null_Ptr n)
+  Value* To_Value::operator()(Null* n)
   {
     return n;
   }
 
   // Function is a valid value
-  Value_Ptr To_Value::operator()(Function_Ptr n)
+  Value* To_Value::operator()(Function* n)
   {
     return n;
   }
 
   // Argument returns its value
-  Value_Ptr To_Value::operator()(Argument_Ptr arg)
+  Value* To_Value::operator()(Argument* arg)
   {
     if (!arg->name().empty()) return 0;
     return arg->value()->perform(this);
   }
 
-  // Selector_List is converted to a string
-  Value_Ptr To_Value::operator()(Selector_List_Ptr s)
+  // SelectorList is converted to a string
+  Value* To_Value::operator()(SelectorList* s)
   {
     return SASS_MEMORY_NEW(String_Quoted,
                            s->pstate(),
@@ -102,7 +104,7 @@ namespace Sass {
   }
 
   // Binary_Expression is converted to a string
-  Value_Ptr To_Value::operator()(Binary_Expression_Ptr s)
+  Value* To_Value::operator()(Binary_Expression* s)
   {
     return SASS_MEMORY_NEW(String_Quoted,
                            s->pstate(),

data/ext/libsass/src/to_value.hpp

@@ -7,9 +7,7 @@
 
 namespace Sass {
 
-  class To_Value : public Operation_CRTP<Value_Ptr, To_Value> {
-
-    Value_Ptr fallback_impl(AST_Node_Ptr n);
+  class To_Value : public Operation_CRTP<Value*, To_Value> {
 
   private:
 
@@ -21,28 +19,26 @@ namespace Sass {
     : ctx(ctx)
     { }
     ~To_Value() { }
-    using Operation<Value_Ptr>::operator();
-
-    Value_Ptr operator()(Argument_Ptr);
-    Value_Ptr operator()(Boolean_Ptr);
-    Value_Ptr operator()(Number_Ptr);
-    Value_Ptr operator()(Color_Ptr);
-    Value_Ptr operator()(String_Constant_Ptr);
-    Value_Ptr operator()(String_Quoted_Ptr);
-    Value_Ptr operator()(Custom_Warning_Ptr);
-    Value_Ptr operator()(Custom_Error_Ptr);
-    Value_Ptr operator()(List_Ptr);
-    Value_Ptr operator()(Map_Ptr);
-    Value_Ptr operator()(Null_Ptr);
-    Value_Ptr operator()(Function_Ptr);
+    using Operation<Value*>::operator();
+
+    Value* operator()(Argument*);
+    Value* operator()(Boolean*);
+    Value* operator()(Number*);
+    Value* operator()(Color_RGBA*);
+    Value* operator()(Color_HSLA*);
+    Value* operator()(String_Constant*);
+    Value* operator()(String_Quoted*);
+    Value* operator()(Custom_Warning*);
+    Value* operator()(Custom_Error*);
+    Value* operator()(List*);
+    Value* operator()(Map*);
+    Value* operator()(Null*);
+    Value* operator()(Function*);
 
     // convert to string via `To_String`
-    Value_Ptr operator()(Selector_List_Ptr);
-    Value_Ptr operator()(Binary_Expression_Ptr);
+    Value* operator()(SelectorList*);
+    Value* operator()(Binary_Expression*);
 
-    // fallback throws error
-    template <typename U>
-    Value_Ptr fallback(U x) { return fallback_impl(x); }
   };
 
 }

data/ext/libsass/src/units.cpp

@@ -1,5 +1,7 @@
 #include "sass.hpp"
+#include <map>
 #include <stdexcept>
+#include <algorithm>
 #include "units.hpp"
 #include "error_handling.hpp"
 
@@ -63,7 +65,7 @@ namespace Sass {
     }
   };
 
-  std::string get_unit_class(UnitType unit)
+  sass::string get_unit_class(UnitType unit)
   {
     switch (unit & 0xFF00)
     {
@@ -89,7 +91,7 @@ namespace Sass {
     }
   };
 
-  UnitType string_to_unit(const std::string& s)
+  UnitType string_to_unit(const sass::string& s)
   {
     // size units
     if      (s == "px")   return UnitType::PX;
@@ -147,7 +149,7 @@ namespace Sass {
     }
   }
 
-  std::string unit_to_class(const std::string& s)
+  sass::string unit_to_class(const sass::string& s)
   {
     if      (s == "px")   return "LENGTH";
     else if (s == "pt")   return "LENGTH";
@@ -175,7 +177,7 @@ namespace Sass {
   }
 
   // throws incompatibleUnits exceptions
-  double conversion_factor(const std::string& s1, const std::string& s2)
+  double conversion_factor(const sass::string& s1, const sass::string& s2)
   {
     // assert for same units
     if (s1 == s2) return 1;
@@ -217,7 +219,7 @@ namespace Sass {
     return 0;
   }
 
-  double convert_units(const std::string& lhs, const std::string& rhs, int& lhsexp, int& rhsexp)
+  double convert_units(const sass::string& lhs, const sass::string& rhs, int& lhsexp, int& rhsexp)
   {
     double f = 0;
     // do not convert same ones
@@ -266,6 +268,10 @@ namespace Sass {
     return (numerators == rhs.numerators) &&
            (denominators == rhs.denominators);
   }
+  bool Units::operator!= (const Units& rhs) const
+  {
+    return ! (*this == rhs);
+  }
 
   double Units::normalize()
   {
@@ -277,7 +283,7 @@ namespace Sass {
     double factor = 1;
 
     for (size_t i = 0; i < iL; i++) {
-      std::string &lhs = numerators[i];
+      sass::string &lhs = numerators[i];
       UnitType ulhs = string_to_unit(lhs);
       if (ulhs == UNKNOWN) continue;
       UnitClass clhs = get_unit_type(ulhs);
@@ -290,7 +296,7 @@ namespace Sass {
     }
 
     for (size_t n = 0; n < nL; n++) {
-      std::string &rhs = denominators[n];
+      sass::string &rhs = denominators[n];
       UnitType urhs = string_to_unit(rhs);
       if (urhs == UNKNOWN) continue;
       UnitClass crhs = get_unit_type(urhs);
@@ -322,9 +328,9 @@ namespace Sass {
     // it seems that a map table will fit nicely to do this
     // we basically construct exponents for each unit
     // has the advantage that they will be pre-sorted
-    std::map<std::string, int> exponents;
+    std::map<sass::string, int> exponents;
 
-    // initialize by summing up occurences in unit vectors
+    // initialize by summing up occurrences in unit vectors
     // this will already cancel out equivalent units (e.q. px/px)
     for (size_t i = 0; i < iL; i ++) exponents[numerators[i]] += 1;
     for (size_t n = 0; n < nL; n ++) exponents[denominators[n]] -= 1;
@@ -335,7 +341,7 @@ namespace Sass {
     // convert between compatible units
     for (size_t i = 0; i < iL; i++) {
       for (size_t n = 0; n < nL; n++) {
-        std::string &lhs = numerators[i], &rhs = denominators[n];
+        sass::string &lhs = numerators[i], &rhs = denominators[n];
         int &lhsexp = exponents[lhs], &rhsexp = exponents[rhs];
         double f(convert_units(lhs, rhs, lhsexp, rhsexp));
         if (f == 0) continue;
@@ -361,9 +367,9 @@ namespace Sass {
 
   }
 
-  std::string Units::unit() const
+  sass::string Units::unit() const
   {
-    std::string u;
+    sass::string u;
     size_t iL = numerators.size();
     size_t nL = denominators.size();
     for (size_t i = 0; i < iL; i += 1) {
@@ -390,15 +396,15 @@ namespace Sass {
            denominators.size() == 0;
   }
 
-  // this does not cover all cases (multiple prefered units)
+  // this does not cover all cases (multiple preferred units)
   double Units::convert_factor(const Units& r) const
   {
 
-    std::vector<std::string> miss_nums(0);
-    std::vector<std::string> miss_dens(0);
+    sass::vector<sass::string> miss_nums(0);
+    sass::vector<sass::string> miss_dens(0);
     // create copy since we need these for state keeping
-    std::vector<std::string> r_nums(r.numerators);
-    std::vector<std::string> r_dens(r.denominators);
+    sass::vector<sass::string> r_nums(r.numerators);
+    sass::vector<sass::string> r_dens(r.denominators);
 
     auto l_num_it = numerators.begin();
     auto l_num_end = numerators.end();
@@ -413,7 +419,7 @@ namespace Sass {
     while (l_num_it != l_num_end)
     {
       // get and increment afterwards
-      const std::string l_num = *(l_num_it ++);
+      const sass::string l_num = *(l_num_it ++);
 
       auto r_num_it = r_nums.begin(), r_num_end = r_nums.end();
 
@@ -422,7 +428,7 @@ namespace Sass {
       while (r_num_it != r_num_end)
       {
         // get and increment afterwards
-        const std::string r_num = *(r_num_it);
+        const sass::string r_num = *(r_num_it);
         // get possible conversion factor for units
         double conversion = conversion_factor(l_num, r_num);
         // skip incompatible numerator
@@ -450,7 +456,7 @@ namespace Sass {
     while (l_den_it != l_den_end)
     {
       // get and increment afterwards
-      const std::string l_den = *(l_den_it ++);
+      const sass::string l_den = *(l_den_it ++);
 
       auto r_den_it = r_dens.begin();
       auto r_den_end = r_dens.end();
@@ -460,8 +466,8 @@ namespace Sass {
       while (r_den_it != r_den_end)
       {
         // get and increment afterwards
-        const std::string r_den = *(r_den_it);
-        // get possible converstion factor for units
+        const sass::string r_den = *(r_den_it);
+        // get possible conversion factor for units
         double conversion = conversion_factor(l_den, r_den);
         // skip incompatible denominator
         if (conversion == 0) {