sassc 2.0.0 → 2.4.0

data/ext/libsass/src/inspect.hpp

@@ -13,90 +13,88 @@ namespace Sass {
     // import all the class-specific methods and override as desired
     using Operation_CRTP<void, Inspect>::operator();
 
-    void fallback_impl(AST_Node_Ptr n);
-
   public:
 
     Inspect(const Emitter& emi);
     virtual ~Inspect();
 
     // statements
-    virtual void operator()(Block_Ptr);
-    virtual void operator()(Ruleset_Ptr);
-    virtual void operator()(Bubble_Ptr);
-    virtual void operator()(Supports_Block_Ptr);
-    virtual void operator()(Media_Block_Ptr);
-    virtual void operator()(At_Root_Block_Ptr);
-    virtual void operator()(Directive_Ptr);
-    virtual void operator()(Keyframe_Rule_Ptr);
-    virtual void operator()(Declaration_Ptr);
-    virtual void operator()(Assignment_Ptr);
-    virtual void operator()(Import_Ptr);
-    virtual void operator()(Import_Stub_Ptr);
-    virtual void operator()(Warning_Ptr);
-    virtual void operator()(Error_Ptr);
-    virtual void operator()(Debug_Ptr);
-    virtual void operator()(Comment_Ptr);
-    virtual void operator()(If_Ptr);
-    virtual void operator()(For_Ptr);
-    virtual void operator()(Each_Ptr);
-    virtual void operator()(While_Ptr);
-    virtual void operator()(Return_Ptr);
-    virtual void operator()(Extension_Ptr);
-    virtual void operator()(Definition_Ptr);
-    virtual void operator()(Mixin_Call_Ptr);
-    virtual void operator()(Content_Ptr);
+    virtual void operator()(Block*);
+    virtual void operator()(StyleRule*);
+    virtual void operator()(Bubble*);
+    virtual void operator()(SupportsRule*);
+    virtual void operator()(AtRootRule*);
+    virtual void operator()(AtRule*);
+    virtual void operator()(Keyframe_Rule*);
+    virtual void operator()(Declaration*);
+    virtual void operator()(Assignment*);
+    virtual void operator()(Import*);
+    virtual void operator()(Import_Stub*);
+    virtual void operator()(WarningRule*);
+    virtual void operator()(ErrorRule*);
+    virtual void operator()(DebugRule*);
+    virtual void operator()(Comment*);
+    virtual void operator()(If*);
+    virtual void operator()(ForRule*);
+    virtual void operator()(EachRule*);
+    virtual void operator()(WhileRule*);
+    virtual void operator()(Return*);
+    virtual void operator()(ExtendRule*);
+    virtual void operator()(Definition*);
+    virtual void operator()(Mixin_Call*);
+    virtual void operator()(Content*);
     // expressions
-    virtual void operator()(Map_Ptr);
-    virtual void operator()(Function_Ptr);
-    virtual void operator()(List_Ptr);
-    virtual void operator()(Binary_Expression_Ptr);
-    virtual void operator()(Unary_Expression_Ptr);
-    virtual void operator()(Function_Call_Ptr);
-    virtual void operator()(Function_Call_Schema_Ptr);
-    // virtual void operator()(Custom_Warning_Ptr);
-    // virtual void operator()(Custom_Error_Ptr);
-    virtual void operator()(Variable_Ptr);
-    virtual void operator()(Number_Ptr);
-    virtual void operator()(Color_Ptr);
-    virtual void operator()(Boolean_Ptr);
-    virtual void operator()(String_Schema_Ptr);
-    virtual void operator()(String_Constant_Ptr);
-    virtual void operator()(String_Quoted_Ptr);
-    virtual void operator()(Custom_Error_Ptr);
-    virtual void operator()(Custom_Warning_Ptr);
-    virtual void operator()(Supports_Operator_Ptr);
-    virtual void operator()(Supports_Negation_Ptr);
-    virtual void operator()(Supports_Declaration_Ptr);
-    virtual void operator()(Supports_Interpolation_Ptr);
-    virtual void operator()(Media_Query_Ptr);
-    virtual void operator()(Media_Query_Expression_Ptr);
-    virtual void operator()(At_Root_Query_Ptr);
-    virtual void operator()(Null_Ptr);
-    virtual void operator()(Parent_Selector_Ptr p);
+    virtual void operator()(Map*);
+    virtual void operator()(Function*);
+    virtual void operator()(List*);
+    virtual void operator()(Binary_Expression*);
+    virtual void operator()(Unary_Expression*);
+    virtual void operator()(Function_Call*);
+    // virtual void operator()(Custom_Warning*);
+    // virtual void operator()(Custom_Error*);
+    virtual void operator()(Variable*);
+    virtual void operator()(Number*);
+    virtual void operator()(Color_RGBA*);
+    virtual void operator()(Color_HSLA*);
+    virtual void operator()(Boolean*);
+    virtual void operator()(String_Schema*);
+    virtual void operator()(String_Constant*);
+    virtual void operator()(String_Quoted*);
+    virtual void operator()(Custom_Error*);
+    virtual void operator()(Custom_Warning*);
+    virtual void operator()(SupportsOperation*);
+    virtual void operator()(SupportsNegation*);
+    virtual void operator()(SupportsDeclaration*);
+    virtual void operator()(Supports_Interpolation*);
+    virtual void operator()(MediaRule*);
+    virtual void operator()(CssMediaRule*);
+    virtual void operator()(CssMediaQuery*);
+    virtual void operator()(Media_Query*);
+    virtual void operator()(Media_Query_Expression*);
+    virtual void operator()(At_Root_Query*);
+    virtual void operator()(Null*);
+    virtual void operator()(Parent_Reference* p);
     // parameters and arguments
-    virtual void operator()(Parameter_Ptr);
-    virtual void operator()(Parameters_Ptr);
-    virtual void operator()(Argument_Ptr);
-    virtual void operator()(Arguments_Ptr);
+    virtual void operator()(Parameter*);
+    virtual void operator()(Parameters*);
+    virtual void operator()(Argument*);
+    virtual void operator()(Arguments*);
     // selectors
-    virtual void operator()(Selector_Schema_Ptr);
-    virtual void operator()(Placeholder_Selector_Ptr);
-    virtual void operator()(Element_Selector_Ptr);
-    virtual void operator()(Class_Selector_Ptr);
-    virtual void operator()(Id_Selector_Ptr);
-    virtual void operator()(Attribute_Selector_Ptr);
-    virtual void operator()(Pseudo_Selector_Ptr);
-    virtual void operator()(Wrapped_Selector_Ptr);
-    virtual void operator()(Compound_Selector_Ptr);
-    virtual void operator()(Complex_Selector_Ptr);
-    virtual void operator()(Selector_List_Ptr);
-
-    virtual std::string lbracket(List_Ptr);
-    virtual std::string rbracket(List_Ptr);
+    virtual void operator()(Selector_Schema*);
+    virtual void operator()(PlaceholderSelector*);
+    virtual void operator()(TypeSelector*);
+    virtual void operator()(ClassSelector*);
+    virtual void operator()(IDSelector*);
+    virtual void operator()(AttributeSelector*);
+    virtual void operator()(PseudoSelector*);
+    virtual void operator()(SelectorComponent*);
+    virtual void operator()(SelectorCombinator*);
+    virtual void operator()(CompoundSelector*);
+    virtual void operator()(ComplexSelector*);
+    virtual void operator()(SelectorList*);
+    virtual sass::string lbracket(List*);
+    virtual sass::string rbracket(List*);
 
-    // template <typename U>
-    // void fallback(U x) { fallback_impl(reinterpret_cast<AST_Node_Ptr>(x)); }
   };
 
 }

data/ext/libsass/src/json.cpp

@@ -402,7 +402,7 @@ char *json_encode_string(const char *str)
   try {
     emit_string(&sb, str);
   }
-  catch (std::exception) {
+  catch (std::exception&) {
     sb_free(&sb);
     throw;
   }
@@ -421,7 +421,7 @@ char *json_stringify(const JsonNode *node, const char *space)
     else
       emit_value(&sb, node);
   }
-  catch (std::exception) {
+  catch (std::exception&) {
     sb_free(&sb);
     throw;
   }

data/ext/libsass/src/lexer.cpp

@@ -1,9 +1,12 @@
+// sass.hpp must go before all system headers to get the
+// __EXTENSIONS__ fix on Solaris.
 #include "sass.hpp"
-#include <cctype>
+
 #include <iostream>
 #include <iomanip>
 #include "lexer.hpp"
 #include "constants.hpp"
+#include "util_string.hpp"
 
 
 namespace Sass {
@@ -25,77 +28,14 @@ namespace Sass {
     const char* kwd_minus(const char* src) { return exactly<'-'>(src); };
     const char* kwd_slash(const char* src) { return exactly<'/'>(src); };
 
-    //####################################
-    // implement some function that do exist in the standard
-    // but those are locale aware which brought some trouble
-    // this even seems to improve performance by quite a bit
-    //####################################
-
-    bool is_alpha(const char& chr)
-    {
-      return unsigned(chr - 'A') <= 'Z' - 'A' ||
-             unsigned(chr - 'a') <= 'z' - 'a';
-    }
-
-    bool is_space(const char& chr)
-    {
-      // adapted the technique from is_alpha
-      return chr == ' ' || unsigned(chr - '\t') <= '\r' - '\t';
-    }
-
-    bool is_digit(const char& chr)
-    {
-      // adapted the technique from is_alpha
-      return unsigned(chr - '0') <= '9' - '0';
-    }
-
-    bool is_number(const char& chr)
-    {
-      // adapted the technique from is_alpha
-      return is_digit(chr) || chr == '-' || chr == '+';
-    }
-
-    bool is_xdigit(const char& chr)
-    {
-      // adapted the technique from is_alpha
-      return unsigned(chr - '0') <= '9' - '0' ||
-             unsigned(chr - 'a') <= 'f' - 'a' ||
-             unsigned(chr - 'A') <= 'F' - 'A';
-    }
-
-    bool is_punct(const char& chr)
-    {
-      // locale independent
-      return chr == '.';
-    }
-
-    bool is_alnum(const char& chr)
-    {
-      return is_alpha(chr) || is_digit(chr);
-    }
-
-    // check if char is outside ascii range
-    bool is_unicode(const char& chr)
-    {
-      // check for unicode range
-      return unsigned(chr) > 127;
-    }
-
-    // check if char is outside ascii range
-    // but with specific ranges (copied from Ruby Sass)
-    bool is_nonascii(const char& chr)
-    {
-      unsigned int cmp = unsigned(chr);
-      return (
-        (cmp >= 128 && cmp <= 15572911) ||
-        (cmp >= 15630464 && cmp <= 15712189) ||
-        (cmp >= 4036001920)
-      );
+    bool is_number(char chr) {
+      return Util::ascii_isdigit(static_cast<unsigned char>(chr)) ||
+        chr == '-' || chr == '+';
     }
 
     // check if char is within a reduced ascii range
     // valid in a uri (copied from Ruby Sass)
-    bool is_uri_character(const char& chr)
+    bool is_uri_character(char chr)
     {
       unsigned int cmp = unsigned(chr);
       return (cmp > 41 && cmp < 127) ||
@@ -104,17 +44,19 @@ namespace Sass {
 
     // check if char is within a reduced ascii range
     // valid for escaping (copied from Ruby Sass)
-    bool is_escapable_character(const char& chr)
+    bool is_escapable_character(char chr)
     {
       unsigned int cmp = unsigned(chr);
       return cmp > 31 && cmp < 127;
     }
 
     // Match word character (look ahead)
-    bool is_character(const char& chr)
+    bool is_character(char chr)
     {
       // valid alpha, numeric or unicode char (plus hyphen)
-      return is_alnum(chr) || is_unicode(chr) || chr == '-';
+      return Util::ascii_isalnum(static_cast<unsigned char>(chr)) ||
+        !Util::ascii_isascii(static_cast<unsigned char>(chr)) ||
+        chr == '-';
     }
 
     //####################################
@@ -122,16 +64,13 @@ namespace Sass {
     //####################################
 
     // create matchers that advance the position
-    const char* space(const char* src) { return is_space(*src) ? src + 1 : 0; }
-    const char* alpha(const char* src) { return is_alpha(*src) ? src + 1 : 0; }
-    const char* unicode(const char* src) { return is_unicode(*src) ? src + 1 : 0; }
-    const char* nonascii(const char* src) { return is_nonascii(*src) ? src + 1 : 0; }
-    const char* digit(const char* src) { return is_digit(*src) ? src + 1 : 0; }
-    const char* xdigit(const char* src) { return is_xdigit(*src) ? src + 1 : 0; }
-    const char* alnum(const char* src) { return is_alnum(*src) ? src + 1 : 0; }
-    const char* punct(const char* src) { return is_punct(*src) ? src + 1 : 0; }
-    const char* hyphen(const char* src) { return *src && *src == '-' ? src + 1 : 0; }
-    const char* character(const char* src) { return is_character(*src) ? src + 1 : 0; }
+    const char* space(const char* src) { return Util::ascii_isspace(static_cast<unsigned char>(*src)) ? src + 1 : nullptr; }
+    const char* alpha(const char* src) { return Util::ascii_isalpha(static_cast<unsigned char>(*src)) ? src + 1 : nullptr; }
+    const char* nonascii(const char* src) { return Util::ascii_isascii(static_cast<unsigned char>(*src)) ? nullptr : src + 1; }
+    const char* digit(const char* src) { return Util::ascii_isdigit(static_cast<unsigned char>(*src)) ? src + 1 : nullptr; }
+    const char* xdigit(const char* src) { return Util::ascii_isxdigit(static_cast<unsigned char>(*src)) ? src + 1 : nullptr; }
+    const char* alnum(const char* src) { return Util::ascii_isalnum(static_cast<unsigned char>(*src)) ? src + 1 : nullptr; }
+    const char* hyphen(const char* src) { return *src == '-' ? src + 1 : 0; }
     const char* uri_character(const char* src) { return is_uri_character(*src) ? src + 1 : 0; }
     const char* escapable_character(const char* src) { return is_escapable_character(*src) ? src + 1 : 0; }
 
@@ -150,11 +89,13 @@ namespace Sass {
     // Match word boundary (zero-width lookahead).
     const char* word_boundary(const char* src) { return is_character(*src) || *src == '#' ? 0 : src; }
 
-    // Match linefeed /(?:\n|\r\n?)/
+    // Match linefeed /(?:\n|\r\n?|\f)/
     const char* re_linebreak(const char* src)
     {
       // end of file or unix linefeed return here
-      if (*src == 0 || *src == '\n') return src + 1;
+      if (*src == 0) return src;
+      // end of file or unix linefeed return here
+      if (*src == '\n' || *src == '\f') return src + 1;
       // a carriage return may optionally be followed by a linefeed
       if (*src == '\r') return *(src + 1) == '\n' ? src + 2 : src + 1;
       // no linefeed
@@ -166,7 +107,7 @@ namespace Sass {
     const char* end_of_line(const char* src)
     {
       // end of file or unix linefeed return here
-      return *src == 0 || *src == '\n' || *src == '\r' ? src : 0;
+      return *src == 0 || *src == '\n' || *src == '\r' || *src == '\f' ? src : 0;
     }
 
     // Assert end_of_file boundary (/\z/)

data/ext/libsass/src/lexer.hpp

@@ -24,19 +24,11 @@ namespace Sass {
     // BASIC CLASS MATCHERS
     //####################################
 
-    // These are locale independant
-    bool is_space(const char& src);
-    bool is_alpha(const char& src);
-    bool is_punct(const char& src);
-    bool is_digit(const char& src);
-    bool is_number(const char& src);
-    bool is_alnum(const char& src);
-    bool is_xdigit(const char& src);
-    bool is_unicode(const char& src);
-    bool is_nonascii(const char& src);
-    bool is_character(const char& src);
-    bool is_uri_character(const char& src);
-    bool escapable_character(const char& src);
+    // Matches ASCII digits, +, and -.
+    bool is_number(char src);
+
+    bool is_uri_character(char src);
+    bool escapable_character(char src);
 
     // Match a single ctype predicate.
     const char* space(const char* src);
@@ -44,11 +36,8 @@ namespace Sass {
     const char* digit(const char* src);
     const char* xdigit(const char* src);
     const char* alnum(const char* src);
-    const char* punct(const char* src);
     const char* hyphen(const char* src);
-    const char* unicode(const char* src);
     const char* nonascii(const char* src);
-    const char* character(const char* src);
     const char* uri_character(const char* src);
     const char* escapable_character(const char* src);
 

data/ext/libsass/src/listize.cpp

@@ -1,4 +1,7 @@
+// sass.hpp must go before all system headers to get the
+// __EXTENSIONS__ fix on Solaris.
 #include "sass.hpp"
+
 #include <iostream>
 #include <typeinfo>
 #include <string>
@@ -13,7 +16,13 @@ namespace Sass {
   Listize::Listize()
   {  }
 
-  Expression_Ptr Listize::operator()(Selector_List_Ptr sel)
+  Expression* Listize::perform(AST_Node* node)
+  {
+    Listize listize;
+    return node->perform(&listize);
+  }
+
+  Expression* Listize::operator()(SelectorList* sel)
   {
     List_Obj l = SASS_MEMORY_NEW(List, sel->pstate(), sel->length(), SASS_COMMA);
     l->from_selector(true);
@@ -25,62 +34,37 @@ namespace Sass {
     return SASS_MEMORY_NEW(Null, l->pstate());
   }
 
-  Expression_Ptr Listize::operator()(Compound_Selector_Ptr sel)
+  Expression* Listize::operator()(CompoundSelector* sel)
   {
-    std::string str;
+    sass::string str;
     for (size_t i = 0, L = sel->length(); i < L; ++i) {
-      Expression_Ptr e = (*sel)[i]->perform(this);
+      Expression* e = (*sel)[i]->perform(this);
       if (e) str += e->to_string();
     }
     return SASS_MEMORY_NEW(String_Quoted, sel->pstate(), str);
   }
 
-  Expression_Ptr Listize::operator()(Complex_Selector_Ptr sel)
+  Expression* Listize::operator()(ComplexSelector* sel)
   {
-    List_Obj l = SASS_MEMORY_NEW(List, sel->pstate(), 2);
+    List_Obj l = SASS_MEMORY_NEW(List, sel->pstate());
+    // ToDo: investigate what this does
+    // Note: seems reated to parent ref
     l->from_selector(true);
-    Compound_Selector_Obj head = sel->head();
-    if (head && !head->is_empty_reference())
-    {
-      Expression_Ptr hh = head->perform(this);
-      if (hh) l->append(hh);
-    }
 
-    std::string reference = ! sel->reference() ? ""
-      : sel->reference()->to_string();
-    switch(sel->combinator())
-    {
-      case Complex_Selector::PARENT_OF:
-        l->append(SASS_MEMORY_NEW(String_Quoted, sel->pstate(), ">"));
-      break;
-      case Complex_Selector::ADJACENT_TO:
-        l->append(SASS_MEMORY_NEW(String_Quoted, sel->pstate(), "+"));
-      break;
-      case Complex_Selector::REFERENCE:
-        l->append(SASS_MEMORY_NEW(String_Quoted, sel->pstate(), "/" + reference + "/"));
-      break;
-      case Complex_Selector::PRECEDES:
-        l->append(SASS_MEMORY_NEW(String_Quoted, sel->pstate(), "~"));
-      break;
-      case Complex_Selector::ANCESTOR_OF:
-      break;
-      default: break;
+    for (auto component : sel->elements()) {
+      if (CompoundSelectorObj compound = Cast<CompoundSelector>(component)) {
+        if (!compound->empty()) {
+          ExpressionObj hh = compound->perform(this);
+          if (hh) l->append(hh);
+        }
+      }
+      else if (component) {
+        l->append(SASS_MEMORY_NEW(String_Quoted, component->pstate(), component->to_string()));
+      }
     }
 
-    Complex_Selector_Obj tail = sel->tail();
-    if (tail)
-    {
-      Expression_Obj tt = tail->perform(this);
-      if (List_Ptr ls = Cast<List>(tt))
-      { l->concat(ls); }
-    }
     if (l->length() == 0) return 0;
     return l.detach();
   }
 
-  Expression_Ptr Listize::fallback_impl(AST_Node_Ptr n)
-  {
-    return Cast<Expression>(n);
-  }
-
 }