sassc 2.0.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
@@ -83,6 +83,7 @@ namespace Sass {
     // compare operations
     bool operator< (const Units& rhs) const;
     bool operator== (const Units& rhs) const;
+    bool operator!= (const Units& rhs) const;
     // factor to convert into given units
     double convert_factor(const Units&) const;
   };
@@ -94,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/checked.h

@@ -1,4 +1,4 @@
-// Copyright 2006 Nemanja Trifunovic
+// Copyright 2006-2016 Nemanja Trifunovic
 
 /*
 Permission is hereby granted, free of charge, to any person or organization
@@ -41,7 +41,7 @@ namespace utf8
     class invalid_code_point : public exception {
         uint32_t cp;
     public:
-        invalid_code_point(uint32_t cp) : cp(cp) {}
+        invalid_code_point(uint32_t codepoint) : cp(codepoint) {}
         virtual const char* what() const throw() { return "Invalid code point"; }
         uint32_t code_point() const {return cp;}
     };
@@ -107,7 +107,9 @@ namespace utf8
                         *out++ = *it;
                     break;
                 case internal::NOT_ENOUGH_ROOM:
-                    throw not_enough_room();
+                    out = utf8::append (replacement, out);
+                    start = end;
+                    break;
                 case internal::INVALID_LEAD:
                     out = utf8::append (replacement, out);
                     ++start;
@@ -194,10 +196,10 @@ namespace utf8
     }
 
     template <typename octet_iterator, typename distance_type>
-    void retreat (octet_iterator& it, distance_type n, octet_iterator start)
+    void retreat (octet_iterator& it, distance_type n, octet_iterator end)
     {
         for (distance_type i = 0; i < n; ++i)
-            utf8::prior(it, start);
+            utf8::prior(it, end);
     }
 
     template <typename octet_iterator>
@@ -240,7 +242,7 @@ namespace utf8
     template <typename u16bit_iterator, typename octet_iterator>
     u16bit_iterator utf8to16 (octet_iterator start, octet_iterator end, u16bit_iterator result)
     {
-        while (start != end) {
+        while (start < end) {
             uint32_t cp = utf8::next(start, end);
             if (cp > 0xffff) { //make a surrogate pair
                 *result++ = static_cast<uint16_t>((cp >> 10)   + internal::LEAD_OFFSET);
@@ -264,7 +266,7 @@ namespace utf8
     template <typename octet_iterator, typename u32bit_iterator>
     u32bit_iterator utf8to32 (octet_iterator start, octet_iterator end, u32bit_iterator result)
     {
-        while (start != end)
+        while (start < end)
             (*result++) = utf8::next(start, end);
 
         return result;
@@ -279,9 +281,9 @@ namespace utf8
       public:
       iterator () {}
       explicit iterator (const octet_iterator& octet_it,
-                         const octet_iterator& range_start,
-                         const octet_iterator& range_end) :
-               it(octet_it), range_start(range_start), range_end(range_end)
+                         const octet_iterator& rangestart,
+                         const octet_iterator& rangeend) :
+               it(octet_it), range_start(rangestart), range_end(rangeend)
       {
           if (it < range_start || it > range_end)
               throw std::out_of_range("Invalid utf-8 iterator position");

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

@@ -222,6 +222,9 @@ namespace internal
     template <typename octet_iterator>
     utf_error validate_next(octet_iterator& it, octet_iterator end, uint32_t& code_point)
     {
+        if (it == end)
+            return NOT_ENOUGH_ROOM;
+
         // Save the original value of it so we can go back in case of failure
         // Of course, it does not make much sense with i.e. stream iterators
         octet_iterator original_it = it;

data/ext/libsass/src/utf8_string.cpp

@@ -1,4 +1,7 @@
+// sass.hpp must go before all system headers to get the
+// __EXTENSIONS__ fix on Solaris.
 #include "sass.hpp"
+
 #include <string>
 #include <vector>
 #include <cstdlib>
@@ -8,7 +11,6 @@
 
 namespace Sass {
   namespace UTF_8 {
-    using std::string;
 
     // naming conventions:
     // offset: raw byte offset (0 based)
@@ -16,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
@@ -75,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(),
@@ -86,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

@@ -2,6 +2,7 @@
 #include "sass.h"
 #include "ast.hpp"
 #include "util.hpp"
+#include "util_string.hpp"
 #include "lexer.hpp"
 #include "prelexer.hpp"
 #include "constants.hpp"
@@ -26,8 +27,8 @@ namespace Sass {
     #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);
+    if (std::fmod(val, 1) - 0.5 > - std::pow(0.1, precision + 1)) return std::ceil(val);
+    else if (std::fmod(val, 1) - 0.5 > std::pow(0.1, precision)) return std::floor(val);
     // work around some compiler issue
     // cygwin has it not defined in std
     using namespace std;
@@ -75,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)
@@ -96,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 == '\\') {
@@ -124,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) {
@@ -158,56 +159,77 @@ 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', ' ');
   }
 
-  // bell characters are replaced with spaces
-  // also eats spaces after line-feeds (ltrim)
-  std::string string_to_output(const std::string& str)
+  // 1. Removes whitespace after newlines.
+  // 2. Replaces newlines with spaces.
+  //
+  // This method only considers LF and CRLF as newlines.
+  sass::string string_to_output(const sass::string& str)
   {
-    std::string out("");
-    bool lf = false;
-    for (auto i : str) {
-      if (i == '\n') {
-        out += ' ';
-        lf = true;
-      } else if (!(lf && isspace(i))) {
-        out += i;
-        lf = false;
+    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 == sass::string::npos) break;
+      result.append(str, pos, newline - pos);
+      if (str[newline] == '\r') {
+        if (str[newline + 1] == '\n') {
+          pos = newline + 2;
+        } else {
+          // CR without LF: append as-is and continue.
+          result += '\r';
+          pos = newline + 1;
+          continue;
+        }
+      } else {
+        pos = newline + 1;
+      }
+      result += ' ';
+      const std::size_t non_space = str.find_first_not_of(" \f\n\r\t\v", pos);
+      if (non_space != sass::string::npos) {
+        pos = non_space;
       }
     }
-    return out;
+    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("");
-    for (auto i : str) {
-      if (i == '\n') {
-        out += "\\n";
-      } else if (i == '\r') {
-        out += "\\r";
-      } else if (i == '\t') {
-        out += "\\t";
-      } else {
-        out += i;
+    sass::string out;
+    out.reserve(str.size());
+    for (char c : str) {
+      switch (c) {
+        case '\n':
+          out.append("\\n");
+          break;
+        case '\r':
+          out.append("\\r");
+          break;
+        case '\f':
+          out.append("\\f");
+          break;
+        default:
+          out += c;
       }
     }
     return out;
   }
 
-  std::string comment_to_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;
     for (auto i : text) {
       if (clean) {
         if (i == '\n') { has = 0; }
-        else if (i == '\r') { has = 0; }
         else if (i == '\t') { ++ has; }
         else if (i == ' ') { ++ has; }
         else if (i == '*') {}
@@ -219,8 +241,6 @@ namespace Sass {
         }
       } else if (i == '\n') {
         clean = true;
-      } else if (i == '\r') {
-        clean = true;
       } else {
         str += i;
       }
@@ -250,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) {
@@ -270,7 +290,7 @@ namespace Sass {
 
         // 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;
+        while (i + len < L && s[i + len] && Util::ascii_isxdigit(static_cast<unsigned char>(s[i + len]))) ++ len;
 
         if (len > 1) {
 
@@ -319,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
@@ -335,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) {
@@ -356,7 +376,7 @@ namespace Sass {
 
         // 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;
+        while (i + len < L && s[i + len] && Util::ascii_isxdigit(static_cast<unsigned char>(s[i + len]))) ++ len;
 
         // hex string?
         if (keep_utf8_sequences) {
@@ -394,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) {
@@ -411,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);
 
@@ -508,42 +528,15 @@ namespace Sass {
   }
 
   namespace Util {
-    using std::string;
-
-    std::string rtrim(const std::string &str) {
-      std::string trimmed = str;
-      size_t pos_ws = trimmed.find_last_not_of(" \t\n\v\f\r");
-      if (pos_ws != std::string::npos)
-      { trimmed.erase(pos_ws + 1); }
-      else { trimmed.clear(); }
-      return trimmed;
-    }
-
-    std::string normalize_underscores(const std::string& str) {
-      std::string normalized = str;
-      for(size_t i = 0, L = normalized.length(); i < L; ++i) {
-        if(normalized[i] == '_') {
-          normalized[i] = '-';
-        }
-      }
-      return normalized;
-    }
 
-    std::string normalize_decimals(const std::string& str) {
-      std::string prefix = "0";
-      std::string normalized = str;
-
-      return normalized[0] == '.' ? normalized.insert(0, prefix) : normalized;
-    }
-
-    bool isPrintable(Ruleset_Ptr r, Sass_Output_Style style) {
+    bool isPrintable(StyleRule* r, Sass_Output_Style style) {
       if (r == NULL) {
         return false;
       }
 
       Block_Obj b = r->block();
 
-      Selector_List_Ptr sl = Cast<Selector_List>(r->selector());
+      SelectorList* sl = r->selector();
       bool hasSelectors = sl ? sl->length() > 0 : false;
 
       if (!hasSelectors) {
@@ -554,16 +547,16 @@ 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_Ptr d = Cast<Declaration>(stm)) {
+        } else if (Declaration* d = Cast<Declaration>(stm)) {
           return isPrintable(d, style);
-        } else if (Has_Block_Ptr p = Cast<Has_Block>(stm)) {
+        } else if (ParentStatement* p = Cast<ParentStatement>(stm)) {
           Block_Obj pChildBlock = p->block();
           if (isPrintable(pChildBlock, style)) {
             hasPrintableChildBlocks = true;
           }
-        } else if (Comment_Ptr c = Cast<Comment>(stm)) {
+        } else if (Comment* c = Cast<Comment>(stm)) {
           // keep for uncompressed
           if (style != COMPRESSED) {
             hasDeclarations = true;
@@ -584,25 +577,25 @@ namespace Sass {
       return false;
     }
 
-    bool isPrintable(String_Constant_Ptr s, Sass_Output_Style style)
+    bool isPrintable(String_Constant* s, Sass_Output_Style style)
     {
       return ! s->value().empty();
     }
 
-    bool isPrintable(String_Quoted_Ptr s, Sass_Output_Style style)
+    bool isPrintable(String_Quoted* s, Sass_Output_Style style)
     {
       return true;
     }
 
-    bool isPrintable(Declaration_Ptr d, Sass_Output_Style style)
+    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_Ptr f, Sass_Output_Style style) {
+    bool isPrintable(SupportsRule* f, Sass_Output_Style style) {
       if (f == NULL) {
         return false;
       }
@@ -613,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_Ptr 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)) {
@@ -633,36 +626,37 @@ namespace Sass {
       return false;
     }
 
-    bool isPrintable(Media_Block_Ptr m, Sass_Output_Style style)
+    bool isPrintable(CssMediaRule* m, Sass_Output_Style style)
     {
-      if (m == 0) return false;
+      if (m == nullptr) return false;
       Block_Obj b = m->block();
-      if (b == 0) return false;
+      if (b == nullptr) return false;
+      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_Ptr c = Cast<Comment>(stm)) {
+        else if (Comment* c = Cast<Comment>(stm)) {
           if (isPrintable(c, style)) {
             return true;
           }
         }
-        else if (Ruleset_Ptr r = Cast<Ruleset>(stm)) {
+        else if (StyleRule* r = Cast<StyleRule>(stm)) {
           if (isPrintable(r, style)) {
             return true;
           }
         }
-        else if (Supports_Block_Ptr f = Cast<Supports_Block>(stm)) {
+        else if (SupportsRule* f = Cast<SupportsRule>(stm)) {
           if (isPrintable(f, style)) {
             return true;
           }
         }
-        else if (Media_Block_Ptr mb = Cast<Media_Block>(stm)) {
+        else if (CssMediaRule* mb = Cast<CssMediaRule>(stm)) {
           if (isPrintable(mb, style)) {
             return true;
           }
         }
-        else if (Has_Block_Ptr b = Cast<Has_Block>(stm)) {
+        else if (ParentStatement* b = Cast<ParentStatement>(stm)) {
           if (isPrintable(b->block(), style)) {
             return true;
           }
@@ -671,7 +665,7 @@ namespace Sass {
       return false;
     }
 
-    bool isPrintable(Comment_Ptr c, Sass_Output_Style style)
+    bool isPrintable(Comment* c, Sass_Output_Style style)
     {
       // keep for uncompressed
       if (style != COMPRESSED) {
@@ -692,30 +686,30 @@ 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_Ptr c = Cast<Comment>(stm)) {
+        else if (Comment* c = Cast<Comment>(stm)) {
           if (isPrintable(c, style)) {
             return true;
           }
         }
-        else if (Ruleset_Ptr r = Cast<Ruleset>(stm)) {
+        else if (StyleRule* r = Cast<StyleRule>(stm)) {
           if (isPrintable(r, style)) {
             return true;
           }
         }
-        else if (Supports_Block_Ptr f = Cast<Supports_Block>(stm)) {
+        else if (SupportsRule* f = Cast<SupportsRule>(stm)) {
           if (isPrintable(f, style)) {
             return true;
           }
         }
-        else if (Media_Block_Ptr m = Cast<Media_Block>(stm)) {
+        else if (CssMediaRule * m = Cast<CssMediaRule>(stm)) {
           if (isPrintable(m, style)) {
             return true;
           }
         }
-        else if (Has_Block_Ptr b = Cast<Has_Block>(stm)) {
+        else if (ParentStatement* b = Cast<ParentStatement>(stm)) {
           if (isPrintable(b->block(), style)) {
             return true;
           }
@@ -725,9 +719,5 @@ namespace Sass {
       return false;
     }
 
-    bool isAscii(const char chr) {
-      return unsigned(chr) < 128;
-    }
-
   }
 }