sassc 1.11.4 → 1.12.0

data/ext/libsass/src/units.hpp

@@ -4,6 +4,7 @@
 #include <cmath>
 #include <string>
 #include <sstream>
+#include <vector>
 
 namespace Sass {
 
@@ -52,40 +53,56 @@ namespace Sass {
 
   };
 
+  class Units {
+  public:
+    std::vector<std::string> numerators;
+    std::vector<std::string> denominators;
+  public:
+    // default constructor
+    Units() :
+      numerators(),
+      denominators()
+    { }
+    // copy constructor
+    Units(const Units* ptr) :
+      numerators(ptr->numerators),
+      denominators(ptr->denominators)
+    { }
+    // convert to string
+    std::string unit() const;
+    // get if units are empty
+    bool is_unitless() const;
+    // return if valid for css
+    bool is_valid_css_unit() const;
+    // reduce units for output
+    // returns conversion factor
+    double reduce();
+    // normalize units for compare
+    // returns conversion factor
+    double normalize();
+    // compare operations
+    bool operator< (const Units& rhs) const;
+    bool operator== (const Units& rhs) const;
+    // factor to convert into given units
+    double convert_factor(const Units&) const;
+  };
+
   extern const double size_conversion_factors[6][6];
   extern const double angle_conversion_factors[4][4];
   extern const double time_conversion_factors[2][2];
   extern const double frequency_conversion_factors[2][2];
   extern const double resolution_conversion_factors[3][3];
 
+  UnitType get_main_unit(const UnitClass unit);
   enum Sass::UnitType string_to_unit(const std::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&);
   // throws incompatibleUnits exceptions
-  double conversion_factor(const std::string&, const std::string&, bool = true);
-
-  class incompatibleUnits: public std::exception
-  {
-    public:
-      const char* msg;
-      incompatibleUnits(Sass::UnitType a, Sass::UnitType b)
-      : exception()
-      {
-        std::stringstream ss;
-        ss << "Incompatible units: ";
-        ss << "'" << unit_to_string(a) << "' and ";
-        ss << "'" << unit_to_string(b) << "'";
-        // hold on to string on stack!
-        std::string str(ss.str());
-        msg = str.c_str();
-      }
-      virtual const char* what() const throw()
-      {
-        return msg;
-      }
-  };
+  double conversion_factor(const std::string&, const std::string&);
+  double conversion_factor(UnitType, UnitType, UnitClass, UnitClass);
+  double convert_units(const std::string&, const std::string&, int&, int&);
 
 }
 

data/ext/libsass/src/utf8/checked.h

@@ -193,6 +193,13 @@ namespace utf8
             utf8::next(it, end);
     }
 
+    template <typename octet_iterator, typename distance_type>
+    void retreat (octet_iterator& it, distance_type n, octet_iterator start)
+    {
+        for (distance_type i = 0; i < n; ++i)
+            utf8::prior(it, start);
+    }
+
     template <typename octet_iterator>
     typename std::iterator_traits<octet_iterator>::difference_type
     distance (octet_iterator first, octet_iterator last)

data/ext/libsass/src/utf8/unchecked.h

@@ -116,6 +116,13 @@ namespace utf8
                 utf8::unchecked::next(it);
         }
 
+        template <typename octet_iterator, typename distance_type>
+        void retreat (octet_iterator& it, distance_type n)
+        {
+            for (distance_type i = 0; i < n; ++i)
+                utf8::unchecked::prior(it);
+        }
+
         template <typename octet_iterator>
         typename std::iterator_traits<octet_iterator>::difference_type
         distance (octet_iterator first, octet_iterator last)

data/ext/libsass/src/utf8_string.cpp

@@ -28,7 +28,7 @@ namespace Sass {
     size_t offset_at_position(const string& str, size_t position) {
       string::const_iterator it = str.begin();
       utf8::advance(it, position, str.end());
-      return distance(str.begin(), it);
+      return std::distance(str.begin(), it);
     }
 
     // function that returns number of bytes in a character at offset

data/ext/libsass/src/util.cpp

@@ -9,11 +9,22 @@
 
 #include <cmath>
 #include <stdint.h>
+#if defined(_MSC_VER) && _MSC_VER >= 1800 && _MSC_VER < 1900 && defined(_M_X64)
+#include <mutex>
+#endif
 
 namespace Sass {
 
   double round(double val, size_t precision)
   {
+    // Disable FMA3-optimized implementation when compiling with VS2013 for x64 targets
+    // See https://github.com/sass/node-sass/issues/1854 for details
+    // FIXME: Remove this workaround when we switch to VS2015+
+    #if defined(_MSC_VER) && _MSC_VER >= 1800 && _MSC_VER < 1900 && defined(_M_X64)
+      static std::once_flag flag;
+      std::call_once(flag, []() { _set_FMA3_enable(0); });
+    #endif
+
     // https://github.com/sass/sass/commit/4e3e1d5684cc29073a507578fc977434ff488c93
     if (fmod(val, 1) - 0.5 > - std::pow(0.1, precision + 1)) return std::ceil(val);
     else if (fmod(val, 1) - 0.5 > std::pow(0.1, precision)) return std::floor(val);
@@ -24,7 +35,7 @@ namespace Sass {
   }
 
   /* Locale unspecific atof function. */
-  double sass_atof(const char *str)
+  double sass_strtod(const char *str)
   {
     char separator = *(localeconv()->decimal_point);
     if(separator != '.'){
@@ -37,13 +48,13 @@ namespace Sass {
         // of the string. This is slower but it is thread safe.
         char *copy = sass_copy_c_string(str);
         *(copy + (found - str)) = separator;
-        double res = atof(copy);
+        double res = strtod(copy, NULL);
         free(copy);
         return res;
       }
     }
 
-    return atof(str);
+    return strtod(str, NULL);
   }
 
   // helper for safe access to c_ctx
@@ -85,8 +96,9 @@ namespace Sass {
   }
 
   // read css string (handle multiline DELIM)
-  std::string read_css_string(const std::string& str)
+  std::string read_css_string(const std::string& str, bool css)
   {
+    if (!css) return str;
     std::string out("");
     bool esc = false;
     for (auto i : str) {
@@ -169,6 +181,23 @@ namespace Sass {
     return out;
   }
 
+  std::string escape_string(const std::string& str)
+  {
+    std::string out("");
+    for (auto i : str) {
+      if (i == '\n') {
+        out += "\\n";
+      } else if (i == '\r') {
+        out += "\\r";
+      } else if (i == '\t') {
+        out += "\\t";
+      } else {
+        out += i;
+      }
+    }
+    return out;
+  }
+
   std::string comment_to_string(const std::string& text)
   {
     std::string str = "";
@@ -221,6 +250,75 @@ namespace Sass {
     return quote_mark;
   }
 
+  std::string read_hex_escapes(const std::string& s)
+  {
+
+    std::string result;
+    bool skipped = false;
+
+    for (size_t i = 0, L = s.length(); i < L; ++i) {
+
+      // implement the same strange ruby sass behavior
+      // an escape sequence can also mean a unicode char
+      if (s[i] == '\\' && !skipped) {
+
+        // remember
+        skipped = true;
+
+        // escape length
+        size_t len = 1;
+
+        // parse as many sequence chars as possible
+        // ToDo: Check if ruby aborts after possible max
+        while (i + len < L && s[i + len] && isxdigit(s[i + len])) ++ len;
+
+        if (len > 1) {
+
+          // convert the extracted hex string to code point value
+          // ToDo: Maybe we could do this without creating a substring
+          uint32_t cp = strtol(s.substr (i + 1, len - 1).c_str(), NULL, 16);
+
+          if (s[i + len] == ' ') ++ len;
+
+          // assert invalid code points
+          if (cp == 0) cp = 0xFFFD;
+          // replace bell character
+          // if (cp == '\n') cp = 32;
+
+          // use a very simple approach to convert via utf8 lib
+          // maybe there is a more elegant way; maybe we shoud
+          // convert the whole output from string to a stream!?
+          // allocate memory for utf8 char and convert to utf8
+          unsigned char u[5] = {0,0,0,0,0}; utf8::append(cp, u);
+          for(size_t m = 0; m < 5 && u[m]; m++) result.push_back(u[m]);
+
+          // skip some more chars?
+          i += len - 1; skipped = false;
+
+        }
+
+        else {
+
+          skipped = false;
+
+          result.push_back(s[i]);
+
+        }
+
+      }
+
+      else {
+
+        result.push_back(s[i]);
+
+      }
+
+    }
+
+    return result;
+
+  }
+
   std::string unquote(const std::string& s, char* qd, bool keep_utf8_sequences, bool strict)
   {
 
@@ -281,7 +379,7 @@ namespace Sass {
           // convert the whole output from string to a stream!?
           // allocate memory for utf8 char and convert to utf8
           unsigned char u[5] = {0,0,0,0,0}; utf8::append(cp, u);
-          for(size_t m = 0; u[m] && m < 5; m++) unq.push_back(u[m]);
+          for(size_t m = 0; m < 5 && u[m]; m++) unq.push_back(u[m]);
 
           // skip some more chars?
           i += len - 1; skipped = false;
@@ -445,7 +543,7 @@ namespace Sass {
 
       Block_Obj b = r->block();
 
-      Selector_List_Ptr sl = SASS_MEMORY_CAST(Selector_List, r->selector());
+      Selector_List_Ptr sl = Cast<Selector_List>(r->selector());
       bool hasSelectors = sl ? sl->length() > 0 : false;
 
       if (!hasSelectors) {
@@ -456,16 +554,16 @@ namespace Sass {
       bool hasPrintableChildBlocks = false;
       for (size_t i = 0, L = b->length(); i < L; ++i) {
         Statement_Obj stm = b->at(i);
-        if (dynamic_cast<Directive_Ptr>(&stm)) {
+        if (Cast<Directive>(stm)) {
           return true;
-        } else if (Declaration_Ptr d = dynamic_cast<Declaration_Ptr>(&stm)) {
+        } else if (Declaration_Ptr d = Cast<Declaration>(stm)) {
           return isPrintable(d, style);
-        } else if (dynamic_cast<Has_Block_Ptr>(&stm)) {
-          Block_Obj pChildBlock = ((Has_Block_Ptr)&stm)->block();
-          if (isPrintable(&pChildBlock, style)) {
+        } else if (Has_Block_Ptr p = Cast<Has_Block>(stm)) {
+          Block_Obj pChildBlock = p->block();
+          if (isPrintable(pChildBlock, style)) {
             hasPrintableChildBlocks = true;
           }
-        } else if (Comment_Ptr c = dynamic_cast<Comment_Ptr>(&stm)) {
+        } else if (Comment_Ptr c = Cast<Comment>(stm)) {
           // keep for uncompressed
           if (style != COMPRESSED) {
             hasDeclarations = true;
@@ -499,8 +597,8 @@ namespace Sass {
     bool isPrintable(Declaration_Ptr d, Sass_Output_Style style)
     {
       Expression_Obj val = d->value();
-      if (String_Quoted_Obj sq = SASS_MEMORY_CAST(String_Quoted, val)) return isPrintable(&sq, style);
-      if (String_Constant_Obj sc = SASS_MEMORY_CAST(String_Constant, val)) return isPrintable(&sc, style);
+      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;
     }
 
@@ -511,19 +609,19 @@ namespace Sass {
 
       Block_Obj b = f->block();
 
-//      bool hasSelectors = f->selector() && static_cast<Selector_List_Ptr>(f->selector())->length() > 0;
-
       bool hasDeclarations = false;
       bool hasPrintableChildBlocks = false;
       for (size_t i = 0, L = b->length(); i < L; ++i) {
         Statement_Obj stm = b->at(i);
-        if (dynamic_cast<Declaration_Ptr>(&stm) || dynamic_cast<Directive_Ptr>(&stm)) {
+        if (Cast<Declaration>(stm) || Cast<Directive>(stm)) {
           hasDeclarations = true;
         }
-        else if (dynamic_cast<Has_Block_Ptr>(&stm)) {
-          Block_Obj pChildBlock = ((Has_Block_Ptr)&stm)->block();
-          if (isPrintable(&pChildBlock, style)) {
-            hasPrintableChildBlocks = true;
+        else if (Has_Block_Ptr b = Cast<Has_Block>(stm)) {
+          Block_Obj pChildBlock = b->block();
+          if (!b->is_invisible()) {
+            if (isPrintable(pChildBlock, style)) {
+              hasPrintableChildBlocks = true;
+            }
           }
         }
 
@@ -542,34 +640,32 @@ namespace Sass {
       if (b == 0) return false;
       for (size_t i = 0, L = b->length(); i < L; ++i) {
         Statement_Obj stm = b->at(i);
-        if (dynamic_cast<Directive_Ptr>(&stm)) return true;
-        else if (dynamic_cast<Declaration_Ptr>(&stm)) return true;
-        else if (dynamic_cast<Comment_Ptr>(&stm)) {
-          Comment_Ptr c = (Comment_Ptr) &stm;
+        if (Cast<Directive>(stm)) return true;
+        else if (Cast<Declaration>(stm)) return true;
+        else if (Comment_Ptr c = Cast<Comment>(stm)) {
           if (isPrintable(c, style)) {
             return true;
           }
         }
-        else if (dynamic_cast<Ruleset_Ptr>(&stm)) {
-          Ruleset_Ptr r = (Ruleset_Ptr) &stm;
+        else if (Ruleset_Ptr r = Cast<Ruleset>(stm)) {
           if (isPrintable(r, style)) {
             return true;
           }
         }
-        else if (dynamic_cast<Supports_Block_Ptr>(&stm)) {
-          Supports_Block_Ptr f = (Supports_Block_Ptr) &stm;
+        else if (Supports_Block_Ptr f = Cast<Supports_Block>(stm)) {
           if (isPrintable(f, style)) {
             return true;
           }
         }
-        else if (dynamic_cast<Media_Block_Ptr>(&stm)) {
-          Media_Block_Ptr m = (Media_Block_Ptr) &stm;
-          if (isPrintable(m, style)) {
+        else if (Media_Block_Ptr mb = Cast<Media_Block>(stm)) {
+          if (isPrintable(mb, style)) {
             return true;
           }
         }
-        else if (dynamic_cast<Has_Block_Ptr>(&stm) && isPrintable(((Has_Block_Ptr)&stm)->block(), style)) {
-          return true;
+        else if (Has_Block_Ptr b = Cast<Has_Block>(stm)) {
+          if (isPrintable(b->block(), style)) {
+            return true;
+          }
         }
       }
       return false;
@@ -596,35 +692,33 @@ namespace Sass {
 
       for (size_t i = 0, L = b->length(); i < L; ++i) {
         Statement_Obj stm = b->at(i);
-        if (dynamic_cast<Declaration_Ptr>(&stm) || dynamic_cast<Directive_Ptr>(&stm)) {
+        if (Cast<Declaration>(stm) || Cast<Directive>(stm)) {
           return true;
         }
-        else if (dynamic_cast<Comment_Ptr>(&stm)) {
-          Comment_Ptr c = (Comment_Ptr) &stm;
+        else if (Comment_Ptr c = Cast<Comment>(stm)) {
           if (isPrintable(c, style)) {
             return true;
           }
         }
-        else if (dynamic_cast<Ruleset_Ptr>(&stm)) {
-          Ruleset_Ptr r = (Ruleset_Ptr) &stm;
+        else if (Ruleset_Ptr r = Cast<Ruleset>(stm)) {
           if (isPrintable(r, style)) {
             return true;
           }
         }
-        else if (dynamic_cast<Supports_Block_Ptr>(&stm)) {
-          Supports_Block_Ptr f = (Supports_Block_Ptr) &stm;
+        else if (Supports_Block_Ptr f = Cast<Supports_Block>(stm)) {
           if (isPrintable(f, style)) {
             return true;
           }
         }
-        else if (dynamic_cast<Media_Block_Ptr>(&stm)) {
-          Media_Block_Ptr m = (Media_Block_Ptr) &stm;
+        else if (Media_Block_Ptr m = Cast<Media_Block>(stm)) {
           if (isPrintable(m, style)) {
             return true;
           }
         }
-        else if (dynamic_cast<Has_Block_Ptr>(&stm) && isPrintable(((Has_Block_Ptr)&stm)->block(), style)) {
-          return true;
+        else if (Has_Block_Ptr b = Cast<Has_Block>(stm)) {
+          if (isPrintable(b->block(), style)) {
+            return true;
+          }
         }
       }
 

data/ext/libsass/src/util.hpp

@@ -12,20 +12,17 @@
 
 namespace Sass {
 
-  #define out_of_memory() do {            \
-      std::cerr << "Out of memory.\n";    \
-      exit(EXIT_FAILURE);                 \
-    } while (0)
-
   double round(double val, size_t precision = 0);
-  double sass_atof(const char* str);
+  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);
+  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_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);