sassc 2.3.0 → 2.4.0

data/ext/libsass/src/units.hpp

@@ -55,8 +55,8 @@ namespace Sass {
 
   class Units {
   public:
-    std::vector<std::string> numerators;
-    std::vector<std::string> denominators;
+    sass::vector<sass::string> numerators;
+    sass::vector<sass::string> denominators;
   public:
     // default constructor
     Units() :
@@ -69,7 +69,7 @@ namespace Sass {
       denominators(ptr->denominators)
     { }
     // convert to string
-    std::string unit() const;
+    sass::string unit() const;
     // get if units are empty
     bool is_unitless() const;
     // return if valid for css
@@ -95,15 +95,15 @@ namespace Sass {
   extern const double resolution_conversion_factors[3][3];
 
   UnitType get_main_unit(const UnitClass unit);
-  enum Sass::UnitType string_to_unit(const std::string&);
+  enum Sass::UnitType string_to_unit(const sass::string&);
   const char* unit_to_string(Sass::UnitType unit);
   enum Sass::UnitClass get_unit_type(Sass::UnitType unit);
-  std::string get_unit_class(Sass::UnitType unit);
-  std::string unit_to_class(const std::string&);
+  sass::string get_unit_class(Sass::UnitType unit);
+  sass::string unit_to_class(const sass::string&);
   // throws incompatibleUnits exceptions
-  double conversion_factor(const std::string&, const std::string&);
+  double conversion_factor(const sass::string&, const sass::string&);
   double conversion_factor(UnitType, UnitType, UnitClass, UnitClass);
-  double convert_units(const std::string&, const std::string&, int&, int&);
+  double convert_units(const sass::string&, const sass::string&, int&, int&);
 
 }
 

data/ext/libsass/src/utf8_string.cpp

@@ -11,7 +11,6 @@
 
 namespace Sass {
   namespace UTF_8 {
-    using std::string;
 
     // naming conventions:
     // offset: raw byte offset (0 based)
@@ -19,25 +18,25 @@ namespace Sass {
     // index: code point offset (1 based or negative)
 
     // function that will count the number of code points (utf-8 characters) from the given beginning to the given end
-    size_t code_point_count(const string& str, size_t start, size_t end) {
+    size_t code_point_count(const sass::string& str, size_t start, size_t end) {
       return utf8::distance(str.begin() + start, str.begin() + end);
     }
 
-    size_t code_point_count(const string& str) {
+    size_t code_point_count(const sass::string& str) {
       return utf8::distance(str.begin(), str.end());
     }
 
     // function that will return the byte offset at a code point position
-    size_t offset_at_position(const string& str, size_t position) {
-      string::const_iterator it = str.begin();
+    size_t offset_at_position(const sass::string& str, size_t position) {
+      sass::string::const_iterator it = str.begin();
       utf8::advance(it, position, str.end());
       return std::distance(str.begin(), it);
     }
 
     // function that returns number of bytes in a character at offset
-    size_t code_point_size_at_offset(const string& str, size_t offset) {
+    size_t code_point_size_at_offset(const sass::string& str, size_t offset) {
       // get iterator from string and forward by offset
-      string::const_iterator stop = str.begin() + offset;
+      sass::string::const_iterator stop = str.begin() + offset;
       // check if beyond boundary
       if (stop == str.end()) return 0;
       // advance by one code point
@@ -78,9 +77,9 @@ namespace Sass {
     using std::wstring;
 
     // convert from utf16/wide string to utf8 string
-    string convert_from_utf16(const wstring& utf16)
+    sass::string convert_from_utf16(const wstring& utf16)
     {
-      string utf8;
+      sass::string utf8;
       // pre-allocate expected memory
       utf8.reserve(sizeof(utf16)/2);
       utf8::utf16to8(utf16.begin(), utf16.end(),
@@ -89,7 +88,7 @@ namespace Sass {
     }
 
     // convert from utf8 string to utf16/wide string
-    wstring convert_to_utf16(const string& utf8)
+    wstring convert_to_utf16(const sass::string& utf8)
     {
       wstring utf16;
       // pre-allocate expected memory

data/ext/libsass/src/utf8_string.hpp

@@ -3,6 +3,7 @@
 
 #include <string>
 #include "utf8.h"
+#include "memory.hpp"
 
 namespace Sass {
   namespace UTF_8 {
@@ -13,22 +14,22 @@ namespace Sass {
     // index: code point offset (1 based or negative)
 
     // function that will count the number of code points (utf-8 characters) from the beginning to the given end
-    size_t code_point_count(const std::string& str, size_t start, size_t end);
-    size_t code_point_count(const std::string& str);
+    size_t code_point_count(const sass::string& str, size_t start, size_t end);
+    size_t code_point_count(const sass::string& str);
 
     // function that will return the byte offset of a code point in a
-    size_t offset_at_position(const std::string& str, size_t position);
+    size_t offset_at_position(const sass::string& str, size_t position);
 
     // function that returns number of bytes in a character in a string
-    size_t code_point_size_at_offset(const std::string& str, size_t offset);
+    size_t code_point_size_at_offset(const sass::string& str, size_t offset);
 
     // function that will return a normalized index, given a crazy one
     size_t normalize_index(int index, size_t len);
 
     #ifdef _WIN32
     // functions to handle unicode paths on windows
-    std::string convert_from_utf16(const std::wstring& wstr);
-    std::wstring convert_to_utf16(const std::string& str);
+    sass::string convert_from_utf16(const std::wstring& wstr);
+    std::wstring convert_to_utf16(const sass::string& str);
     #endif
 
   }

data/ext/libsass/src/util.cpp

@@ -76,7 +76,7 @@ namespace Sass {
     free(arr);
   }
 
-  char **copy_strings(const std::vector<std::string>& strings, char*** array, int skip) {
+  char **copy_strings(const sass::vector<sass::string>& strings, char*** array, int skip) {
     int num = static_cast<int>(strings.size()) - skip;
     char** arr = (char**) calloc(num + 1, sizeof(char*));
     if (arr == 0)
@@ -97,10 +97,10 @@ namespace Sass {
   }
 
   // read css string (handle multiline DELIM)
-  std::string read_css_string(const std::string& str, bool css)
+  sass::string read_css_string(const sass::string& str, bool css)
   {
     if (!css) return str;
-    std::string out("");
+    sass::string out("");
     bool esc = false;
     for (auto i : str) {
       if (i == '\\') {
@@ -125,9 +125,9 @@ namespace Sass {
 
   // double escape all escape sequences
   // keep unescaped quotes and backslashes
-  std::string evacuate_escapes(const std::string& str)
+  sass::string evacuate_escapes(const sass::string& str)
   {
-    std::string out("");
+    sass::string out("");
     bool esc = false;
     for (auto i : str) {
       if (i == '\\' && !esc) {
@@ -159,7 +159,7 @@ namespace Sass {
   }
 
   // bell characters are replaced with spaces
-  void newline_to_space(std::string& str)
+  void newline_to_space(sass::string& str)
   {
     std::replace(str.begin(), str.end(), '\n', ' ');
   }
@@ -168,14 +168,14 @@ namespace Sass {
   // 2. Replaces newlines with spaces.
   //
   // This method only considers LF and CRLF as newlines.
-  std::string string_to_output(const std::string& str)
+  sass::string string_to_output(const sass::string& str)
   {
-    std::string result;
+    sass::string result;
     result.reserve(str.size());
     std::size_t pos = 0;
     while (true) {
       const std::size_t newline = str.find_first_of("\n\r", pos);
-      if (newline == std::string::npos) break;
+      if (newline == sass::string::npos) break;
       result.append(str, pos, newline - pos);
       if (str[newline] == '\r') {
         if (str[newline + 1] == '\n') {
@@ -191,17 +191,17 @@ namespace Sass {
       }
       result += ' ';
       const std::size_t non_space = str.find_first_not_of(" \f\n\r\t\v", pos);
-      if (non_space != std::string::npos) {
+      if (non_space != sass::string::npos) {
         pos = non_space;
       }
     }
-    result.append(str, pos, std::string::npos);
+    result.append(str, pos, sass::string::npos);
     return result;
   }
 
-  std::string escape_string(const std::string& str)
+  sass::string escape_string(const sass::string& str)
   {
-    std::string out;
+    sass::string out;
     out.reserve(str.size());
     for (char c : str) {
       switch (c) {
@@ -221,9 +221,9 @@ namespace Sass {
     return out;
   }
 
-  std::string comment_to_compact_string(const std::string& text)
+  sass::string comment_to_compact_string(const sass::string& text)
   {
-    std::string str = "";
+    sass::string str = "";
     size_t has = 0;
     char prev = 0;
     bool clean = false;
@@ -270,10 +270,10 @@ namespace Sass {
     return quote_mark;
   }
 
-  std::string read_hex_escapes(const std::string& s)
+  sass::string read_hex_escapes(const sass::string& s)
   {
 
-    std::string result;
+    sass::string result;
     bool skipped = false;
 
     for (size_t i = 0, L = s.length(); i < L; ++i) {
@@ -339,7 +339,7 @@ namespace Sass {
 
   }
 
-  std::string unquote(const std::string& s, char* qd, bool keep_utf8_sequences, bool strict)
+  sass::string unquote(const sass::string& s, char* qd, bool keep_utf8_sequences, bool strict)
   {
 
     // not enough room for quotes
@@ -355,7 +355,7 @@ namespace Sass {
     else if (*s.begin() == '\'' && *s.rbegin() == '\'') q = '\'';
     else                                                return s;
 
-    std::string unq;
+    sass::string unq;
     unq.reserve(s.length()-2);
 
     for (size_t i = 1, L = s.length() - 1; i < L; ++i) {
@@ -414,7 +414,7 @@ namespace Sass {
       //   // don't be that strict
       //   return s;
       //   // this basically always means an internal error and not users fault
-      //   error("Unescaped delimiter in string to unquote found. [" + s + "]", ParserState("[UNQUOTE]"));
+      //   error("Unescaped delimiter in string to unquote found. [" + s + "]", SourceSpan("[UNQUOTE]"));
       // }
       else {
         if (strict && !skipped) {
@@ -431,16 +431,16 @@ namespace Sass {
 
   }
 
-  std::string quote(const std::string& s, char q)
+  sass::string quote(const sass::string& s, char q)
   {
 
     // autodetect with fallback to given quote
     q = detect_best_quotemark(s.c_str(), q);
 
     // return an empty quoted string
-    if (s.empty()) return std::string(2, q ? q : '"');
+    if (s.empty()) return sass::string(2, q ? q : '"');
 
-    std::string quoted;
+    sass::string quoted;
     quoted.reserve(s.length()+2);
     quoted.push_back(q);
 
@@ -529,7 +529,7 @@ namespace Sass {
 
   namespace Util {
 
-    bool isPrintable(Ruleset* r, Sass_Output_Style style) {
+    bool isPrintable(StyleRule* r, Sass_Output_Style style) {
       if (r == NULL) {
         return false;
       }
@@ -547,11 +547,11 @@ namespace Sass {
       bool hasPrintableChildBlocks = false;
       for (size_t i = 0, L = b->length(); i < L; ++i) {
         Statement_Obj stm = b->at(i);
-        if (Cast<Directive>(stm)) {
+        if (Cast<AtRule>(stm)) {
           return true;
         } else if (Declaration* d = Cast<Declaration>(stm)) {
           return isPrintable(d, style);
-        } else if (Has_Block* p = Cast<Has_Block>(stm)) {
+        } else if (ParentStatement* p = Cast<ParentStatement>(stm)) {
           Block_Obj pChildBlock = p->block();
           if (isPrintable(pChildBlock, style)) {
             hasPrintableChildBlocks = true;
@@ -589,13 +589,13 @@ namespace Sass {
 
     bool isPrintable(Declaration* d, Sass_Output_Style style)
     {
-      Expression_Obj val = d->value();
+      ExpressionObj val = d->value();
       if (String_Quoted_Obj sq = Cast<String_Quoted>(val)) return isPrintable(sq.ptr(), style);
       if (String_Constant_Obj sc = Cast<String_Constant>(val)) return isPrintable(sc.ptr(), style);
       return true;
     }
 
-    bool isPrintable(Supports_Block* f, Sass_Output_Style style) {
+    bool isPrintable(SupportsRule* f, Sass_Output_Style style) {
       if (f == NULL) {
         return false;
       }
@@ -606,10 +606,10 @@ namespace Sass {
       bool hasPrintableChildBlocks = false;
       for (size_t i = 0, L = b->length(); i < L; ++i) {
         Statement_Obj stm = b->at(i);
-        if (Cast<Declaration>(stm) || Cast<Directive>(stm)) {
+        if (Cast<Declaration>(stm) || Cast<AtRule>(stm)) {
           hasDeclarations = true;
         }
-        else if (Has_Block* b = Cast<Has_Block>(stm)) {
+        else if (ParentStatement* b = Cast<ParentStatement>(stm)) {
           Block_Obj pChildBlock = b->block();
           if (!b->is_invisible()) {
             if (isPrintable(pChildBlock, style)) {
@@ -634,19 +634,19 @@ namespace Sass {
       if (m->empty()) return false;
       for (size_t i = 0, L = b->length(); i < L; ++i) {
         Statement_Obj stm = b->at(i);
-        if (Cast<Directive>(stm)) return true;
+        if (Cast<AtRule>(stm)) return true;
         else if (Cast<Declaration>(stm)) return true;
         else if (Comment* c = Cast<Comment>(stm)) {
           if (isPrintable(c, style)) {
             return true;
           }
         }
-        else if (Ruleset* r = Cast<Ruleset>(stm)) {
+        else if (StyleRule* r = Cast<StyleRule>(stm)) {
           if (isPrintable(r, style)) {
             return true;
           }
         }
-        else if (Supports_Block* f = Cast<Supports_Block>(stm)) {
+        else if (SupportsRule* f = Cast<SupportsRule>(stm)) {
           if (isPrintable(f, style)) {
             return true;
           }
@@ -656,7 +656,7 @@ namespace Sass {
             return true;
           }
         }
-        else if (Has_Block* b = Cast<Has_Block>(stm)) {
+        else if (ParentStatement* b = Cast<ParentStatement>(stm)) {
           if (isPrintable(b->block(), style)) {
             return true;
           }
@@ -686,7 +686,7 @@ namespace Sass {
 
       for (size_t i = 0, L = b->length(); i < L; ++i) {
         Statement_Obj stm = b->at(i);
-        if (Cast<Declaration>(stm) || Cast<Directive>(stm)) {
+        if (Cast<Declaration>(stm) || Cast<AtRule>(stm)) {
           return true;
         }
         else if (Comment* c = Cast<Comment>(stm)) {
@@ -694,12 +694,12 @@ namespace Sass {
             return true;
           }
         }
-        else if (Ruleset* r = Cast<Ruleset>(stm)) {
+        else if (StyleRule* r = Cast<StyleRule>(stm)) {
           if (isPrintable(r, style)) {
             return true;
           }
         }
-        else if (Supports_Block* f = Cast<Supports_Block>(stm)) {
+        else if (SupportsRule* f = Cast<SupportsRule>(stm)) {
           if (isPrintable(f, style)) {
             return true;
           }
@@ -709,7 +709,7 @@ namespace Sass {
             return true;
           }
         }
-        else if (Has_Block* b = Cast<Has_Block>(stm)) {
+        else if (ParentStatement* b = Cast<ParentStatement>(stm)) {
           if (isPrintable(b->block(), style)) {
             return true;
           }

data/ext/libsass/src/util.hpp

@@ -34,17 +34,17 @@ namespace Sass {
   double sass_strtod(const char* str);
   const char* safe_str(const char *, const char* = "");
   void free_string_array(char **);
-  char **copy_strings(const std::vector<std::string>&, char ***, int = 0);
-  std::string read_css_string(const std::string& str, bool css = true);
-  std::string evacuate_escapes(const std::string& str);
-  std::string string_to_output(const std::string& str);
-  std::string comment_to_compact_string(const std::string& text);
-  std::string read_hex_escapes(const std::string& str);
-  std::string escape_string(const std::string& str);
-  void newline_to_space(std::string& str);
-
-  std::string quote(const std::string&, char q = 0);
-  std::string unquote(const std::string&, char* q = 0, bool keep_utf8_sequences = false, bool strict = true);
+  char **copy_strings(const sass::vector<sass::string>&, char ***, int = 0);
+  sass::string read_css_string(const sass::string& str, bool css = true);
+  sass::string evacuate_escapes(const sass::string& str);
+  sass::string string_to_output(const sass::string& str);
+  sass::string comment_to_compact_string(const sass::string& text);
+  sass::string read_hex_escapes(const sass::string& str);
+  sass::string escape_string(const sass::string& str);
+  void newline_to_space(sass::string& str);
+
+  sass::string quote(const sass::string&, char q = 0);
+  sass::string unquote(const sass::string&, char* q = 0, bool keep_utf8_sequences = false, bool strict = true);
   char detect_best_quotemark(const char* s, char qm = '"');
 
   bool is_hex_doublet(double n);
@@ -63,21 +63,21 @@ namespace Sass {
 
   // C++20 `starts_with` equivalent.
   // See https://en.cppreference.com/w/cpp/string/basic_string/starts_with
-  inline bool starts_with(const std::string& str, const char* prefix, size_t prefix_len) {
+  inline bool starts_with(const sass::string& str, const char* prefix, size_t prefix_len) {
     return str.compare(0, prefix_len, prefix) == 0;
   }
 
-  inline bool starts_with(const std::string& str, const char* prefix) {
+  inline bool starts_with(const sass::string& str, const char* prefix) {
     return starts_with(str, prefix, std::strlen(prefix));
   }
 
   // C++20 `ends_with` equivalent.
   // See https://en.cppreference.com/w/cpp/string/basic_string/ends_with
-  inline bool ends_with(const std::string& str, const std::string& suffix) {
+  inline bool ends_with(const sass::string& str, const sass::string& suffix) {
     return suffix.size() <= str.size() && std::equal(suffix.rbegin(), suffix.rend(), str.rbegin());
   }
 
-  inline bool ends_with(const std::string& str, const char* suffix, size_t suffix_len) {
+  inline bool ends_with(const sass::string& str, const char* suffix, size_t suffix_len) {
     if (suffix_len > str.size()) return false;
     const char* suffix_it = suffix + suffix_len;
     const char* str_it = str.c_str() + str.size();
@@ -85,14 +85,14 @@ namespace Sass {
     return true;
   }
 
-  inline bool ends_with(const std::string& str, const char* suffix) {
+  inline bool ends_with(const sass::string& str, const char* suffix) {
     return ends_with(str, suffix, std::strlen(suffix));
   }
 
   namespace Util {
 
-    bool isPrintable(Ruleset* r, Sass_Output_Style style = NESTED);
-    bool isPrintable(Supports_Block* r, Sass_Output_Style style = NESTED);
+    bool isPrintable(StyleRule* r, Sass_Output_Style style = NESTED);
+    bool isPrintable(SupportsRule* r, Sass_Output_Style style = NESTED);
     bool isPrintable(CssMediaRule* r, Sass_Output_Style style = NESTED);
     bool isPrintable(Comment* b, Sass_Output_Style style = NESTED);
     bool isPrintable(Block_Obj b, Sass_Output_Style style = NESTED);