sassc 1.9.0 → 1.10.0

data/ext/libsass/src/extend.hpp

@@ -24,6 +24,10 @@ namespace Sass {
   public:
     static Node subweave(Node& one, Node& two, Context& ctx);
     static Selector_List* extendSelectorList(Selector_List* pSelectorList, Context& ctx, ExtensionSubsetMap& subset_map, bool isReplace, bool& extendedSomething);
+    static Selector_List* extendSelectorList(Selector_List* pSelectorList, Context& ctx, ExtensionSubsetMap& subset_map, bool isReplace = false) {
+      bool extendedSomething = false;
+      return extendSelectorList(pSelectorList, ctx, subset_map, isReplace, extendedSomething);
+    }
     Extend(Context&, ExtensionSubsetMap&);
     ~Extend() { }
 
@@ -31,7 +35,7 @@ namespace Sass {
     void operator()(Ruleset*);
     void operator()(Supports_Block*);
     void operator()(Media_Block*);
-    void operator()(At_Rule*);
+    void operator()(Directive*);
 
     template <typename U>
     void fallback(U x) { return fallback_impl(x); }

data/ext/libsass/src/functions.cpp

@@ -902,9 +902,16 @@ namespace Sass {
     BUILT_IN(sass_quote)
     {
       AST_Node* arg = env["$string"];
+      // only set quote mark to true if already a string
+      if (String_Quoted* qstr = dynamic_cast<String_Quoted*>(arg)) {
+        qstr->quote_mark('*');
+        return qstr;
+      }
+      // all other nodes must be converted to a string node
       std::string str(quote(arg->to_string(ctx.c_options), String_Constant::double_quote()));
       String_Quoted* result = SASS_MEMORY_NEW(ctx.mem, String_Quoted, pstate, str);
       result->is_delayed(true);
+      result->quote_mark('*');
       return result;
     }
 
@@ -1815,7 +1822,7 @@ namespace Sass {
             }
 
             // Cannot be a Universal selector
-            Type_Selector* pType = dynamic_cast<Type_Selector*>(base->head()->first());
+            Type_Selector* pType = dynamic_cast<Type_Selector*>(childSeq->head()->first());
             if(pType && pType->name() == "*") {
               std::string msg("Can't append  `");
               msg += childSeq->to_string();
@@ -1882,8 +1889,7 @@ namespace Sass {
       ExtensionSubsetMap subset_map;
       extender->populate_extends(extendee, ctx, subset_map);
 
-      bool extendedSomething;
-      Selector_List* result = Extend::extendSelectorList(selector, ctx, subset_map, false, extendedSomething);
+      Selector_List* result = Extend::extendSelectorList(selector, ctx, subset_map, false);
 
       Listize listize(ctx.mem);
       return result->perform(&listize);
@@ -1899,8 +1905,7 @@ namespace Sass {
       ExtensionSubsetMap subset_map;
       replacement->populate_extends(original, ctx, subset_map);
 
-      bool extendedSomething;
-      Selector_List* result = Extend::extendSelectorList(selector, ctx, subset_map, true, extendedSomething);
+      Selector_List* result = Extend::extendSelectorList(selector, ctx, subset_map, true);
 
       Listize listize(ctx.mem);
       return result->perform(&listize);

data/ext/libsass/src/inspect.cpp

@@ -96,7 +96,7 @@ namespace Sass {
     at_root_block->block()->perform(this);
   }
 
-  void Inspect::operator()(At_Rule* at_rule)
+  void Inspect::operator()(Directive* at_rule)
   {
     append_indentation();
     append_token(at_rule->keyword(), at_rule);
@@ -385,9 +385,12 @@ namespace Sass {
     bool was_space_array = in_space_array;
     bool was_comma_array = in_comma_array;
     // probably ruby sass eqivalent of element_needs_parens
-    if (output_style() == TO_SASS && list->length() == 1 &&
-      (!dynamic_cast<List*>((*list)[0]) &&
-       !dynamic_cast<Selector_List*>((*list)[0]))) {
+    if (output_style() == TO_SASS &&
+        list->length() == 1 &&
+        !list->from_selector() &&
+        !dynamic_cast<List*>((*list)[0]) &&
+        !dynamic_cast<List*>((*list)[0]) &&
+        !dynamic_cast<Selector_List*>((*list)[0])) {
       append_string("(");
     }
     else if (!in_declaration && (list->separator() == SASS_HASH ||
@@ -424,9 +427,12 @@ namespace Sass {
     in_comma_array = was_comma_array;
     in_space_array = was_space_array;
     // probably ruby sass eqivalent of element_needs_parens
-    if (output_style() == TO_SASS && list->length() == 1 &&
-      (!dynamic_cast<List*>((*list)[0]) &&
-       !dynamic_cast<Selector_List*>((*list)[0]))) {
+    if (output_style() == TO_SASS &&
+        list->length() == 1 &&
+        !list->from_selector() &&
+        !dynamic_cast<List*>((*list)[0]) &&
+        !dynamic_cast<List*>((*list)[0]) &&
+        !dynamic_cast<Selector_List*>((*list)[0])) {
       append_string(",)");
     }
     else if (!in_declaration && (list->separator() == SASS_HASH ||
@@ -806,20 +812,15 @@ namespace Sass {
     }
   }
 
-  void Inspect::operator()(At_Root_Expression* ae)
+  void Inspect::operator()(At_Root_Query* ae)
   {
-    if (ae->is_interpolated()) {
-      ae->feature()->perform(this);
-    }
-    else {
-      append_string("(");
-      ae->feature()->perform(this);
-      if (ae->value()) {
-        append_colon_separator();
-        ae->value()->perform(this);
-      }
-      append_string(")");
+    append_string("(");
+    ae->feature()->perform(this);
+    if (ae->value()) {
+      append_colon_separator();
+      ae->value()->perform(this);
     }
+    append_string(")");
   }
 
   void Inspect::operator()(Null* n)
@@ -974,6 +975,11 @@ namespace Sass {
     Complex_Selector*            tail = c->tail();
     Complex_Selector::Combinator comb = c->combinator();
 
+    if (comb == Complex_Selector::ANCESTOR_OF && (!head || head->empty())) {
+      if (tail) tail->perform(this);
+      return;
+    }
+
     if (c->has_line_feed()) {
       if (!(c->has_parent_ref())) {
         append_optional_linefeed();

data/ext/libsass/src/inspect.hpp

@@ -28,7 +28,7 @@ namespace Sass {
     virtual void operator()(Supports_Block*);
     virtual void operator()(Media_Block*);
     virtual void operator()(At_Root_Block*);
-    virtual void operator()(At_Rule*);
+    virtual void operator()(Directive*);
     virtual void operator()(Keyframe_Rule*);
     virtual void operator()(Declaration*);
     virtual void operator()(Assignment*);
@@ -72,7 +72,7 @@ namespace Sass {
     virtual void operator()(Supports_Interpolation*);
     virtual void operator()(Media_Query*);
     virtual void operator()(Media_Query_Expression*);
-    virtual void operator()(At_Root_Expression*);
+    virtual void operator()(At_Root_Query*);
     virtual void operator()(Null*);
     virtual void operator()(Parent_Selector* p);
     // parameters and arguments

data/ext/libsass/src/json.cpp

@@ -28,6 +28,10 @@
 
 #include "json.hpp"
 
+// include utf8 library used by libsass
+// ToDo: replace internal json utf8 code
+#include "utf8.h"
+
 #include <assert.h>
 #include <stdint.h>
 #include <stdio.h>
@@ -548,7 +552,7 @@ static void append_node(JsonNode *parent, JsonNode *child)
       child->parent = parent;
       child->prev = parent->children.tail;
       child->next = NULL;
-      
+
       if (parent->children.tail != NULL)
           parent->children.tail->next = child;
       else
@@ -563,7 +567,7 @@ static void prepend_node(JsonNode *parent, JsonNode *child)
       child->parent = parent;
       child->prev = NULL;
       child->next = parent->children.head;
-      
+
       if (parent->children.head != NULL)
           parent->children.head->prev = child;
       else
@@ -585,7 +589,7 @@ void json_append_element(JsonNode *array, JsonNode *element)
   if (array != NULL && element !=NULL) {
       assert(array->tag == JSON_ARRAY);
       assert(element->parent == NULL);
-      
+
       append_node(array, element);
   }
 }
@@ -603,7 +607,7 @@ void json_append_member(JsonNode *object, const char *key, JsonNode *value)
   if (object != NULL && key != NULL && value != NULL) {
       assert(object->tag == JSON_OBJECT);
       assert(value->parent == NULL);
-      
+
       append_member(object, json_strdup(key), value);
   }
 }
@@ -613,7 +617,7 @@ void json_prepend_member(JsonNode *object, const char *key, JsonNode *value)
   if (object != NULL && key != NULL && value != NULL) {
       assert(object->tag == JSON_OBJECT);
       assert(value->parent == NULL);
-      
+
       value->key = json_strdup(key);
       prepend_node(object, value);
   }
@@ -623,20 +627,20 @@ void json_remove_from_parent(JsonNode *node)
 {
   if (node != NULL) {
       JsonNode *parent = node->parent;
-      
+
       if (parent != NULL) {
           if (node->prev != NULL)
               node->prev->next = node->next;
           else
               parent->children.head = node->next;
-		  
+
           if (node->next != NULL)
               node->next->prev = node->prev;
           else
               parent->children.tail = node->prev;
-          
+
           free(node->key);
-          
+
           node->parent = NULL;
           node->prev = node->next = NULL;
           node->key = NULL;
@@ -1141,6 +1145,13 @@ void emit_string(SB *out, const char *str)
   const char *s = str;
   char *b;
 
+// make assertion catchable
+#ifndef NDEBUG
+  if (!utf8_validate(str)) {
+    throw utf8::invalid_utf8(0);
+  }
+#endif
+
   assert(utf8_validate(str));
 
   /*

data/ext/libsass/src/json.hpp

@@ -43,21 +43,21 @@ struct JsonNode
   /* only if parent is an object or array (NULL otherwise) */
   JsonNode *parent;
   JsonNode *prev, *next;
-  
+
   /* only if parent is an object (NULL otherwise) */
   char *key; /* Must be valid UTF-8. */
-  
+
   JsonTag tag;
   union {
     /* JSON_BOOL */
     bool bool_;
-    
+
     /* JSON_STRING */
     char *string_; /* Must be valid UTF-8. */
-    
+
     /* JSON_NUMBER */
     double number_;
-    
+
     /* JSON_ARRAY */
     /* JSON_OBJECT */
     struct {

data/ext/libsass/src/lexer.cpp

@@ -91,7 +91,8 @@ namespace Sass {
     // valid in a uri (copied from Ruby Sass)
     bool is_uri_character(const char& chr)
     {
-      return unsigned(chr) > 41 && unsigned(chr) < 127;
+      return (unsigned(chr) > 41 && unsigned(chr) < 127) ||
+             unsigned(chr) == ':' || unsigned(chr) == '/';
     }
 
     // check if char is within a reduced ascii range
@@ -121,6 +122,7 @@ namespace Sass {
     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* 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; }
@@ -128,6 +130,7 @@ namespace Sass {
     // Match multiple ctype characters.
     const char* spaces(const char* src) { return one_plus<space>(src); }
     const char* digits(const char* src) { return one_plus<digit>(src); }
+    const char* hyphens(const char* src) { return one_plus<hyphen>(src); }
 
     // Whitespace handling.
     const char* no_spaces(const char* src) { return negate< space >(src); }

data/ext/libsass/src/lexer.hpp

@@ -44,6 +44,7 @@ namespace Sass {
     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);
@@ -53,6 +54,7 @@ namespace Sass {
     // Match multiple ctype characters.
     const char* spaces(const char* src);
     const char* digits(const char* src);
+    const char* hyphens(const char* src);
 
     // Whitespace handling.
     const char* no_spaces(const char* src);
@@ -142,6 +144,25 @@ namespace Sass {
       return p == src ? 0 : p;
     }
 
+    // Match for members of char class.
+    // Regex equivalent: /[^axy]/
+    template <const char* neg_char_class>
+    const char* neg_class_char(const char* src) {
+      if (*src == 0) return 0;
+      const char* cc = neg_char_class;
+      while (*cc && *src != *cc) ++cc;
+      return *cc ? 0 : src + 1;
+    }
+
+    // Match for members of char class.
+    // Regex equivalent: /[^axy]+/
+    template <const char* neg_char_class>
+    const char* neg_class_chars(const char* src) {
+      const char* p = src;
+      while (neg_class_char<neg_char_class>(p)) ++p;
+      return p == src ? 0 : p;
+    }
+
     // Match all except the supplied one.
     // Regex equivalent: /[^x]/
     template <const char chr>

data/ext/libsass/src/listize.cpp

@@ -17,6 +17,7 @@ namespace Sass {
   Expression* Listize::operator()(Selector_List* sel)
   {
     List* l = SASS_MEMORY_NEW(mem, List, sel->pstate(), sel->length(), SASS_COMMA);
+    l->from_selector(true);
     for (size_t i = 0, L = sel->length(); i < L; ++i) {
       if (!(*sel)[i]) continue;
       *l << (*sel)[i]->perform(this);
@@ -38,7 +39,7 @@ namespace Sass {
   Expression* Listize::operator()(Complex_Selector* sel)
   {
     List* l = SASS_MEMORY_NEW(mem, List, sel->pstate(), 2);
-
+    l->from_selector(true);
     Compound_Selector* head = sel->head();
     if (head && !head->is_empty_reference())
     {

data/ext/libsass/src/operation.hpp

@@ -18,7 +18,7 @@ namespace Sass {
     virtual T operator()(Supports_Block* x)         = 0;
     virtual T operator()(Media_Block* x)            = 0;
     virtual T operator()(At_Root_Block* x)          = 0;
-    virtual T operator()(At_Rule* x)                = 0;
+    virtual T operator()(Directive* x)                = 0;
     virtual T operator()(Keyframe_Rule* x)          = 0;
     virtual T operator()(Declaration* x)            = 0;
     virtual T operator()(Assignment* x)             = 0;
@@ -61,7 +61,7 @@ namespace Sass {
     virtual T operator()(Supports_Interpolation* x) = 0;
     virtual T operator()(Media_Query* x)            = 0;
     virtual T operator()(Media_Query_Expression* x) = 0;
-    virtual T operator()(At_Root_Expression* x)     = 0;
+    virtual T operator()(At_Root_Query* x)     = 0;
     virtual T operator()(Null* x)                   = 0;
     virtual T operator()(Parent_Selector* x)        = 0;
     // parameters and arguments
@@ -99,7 +99,7 @@ namespace Sass {
     T operator()(Supports_Block* x)         { return static_cast<D*>(this)->fallback(x); }
     T operator()(Media_Block* x)            { return static_cast<D*>(this)->fallback(x); }
     T operator()(At_Root_Block* x)          { return static_cast<D*>(this)->fallback(x); }
-    T operator()(At_Rule* x)                { return static_cast<D*>(this)->fallback(x); }
+    T operator()(Directive* x)                { return static_cast<D*>(this)->fallback(x); }
     T operator()(Keyframe_Rule* x)          { return static_cast<D*>(this)->fallback(x); }
     T operator()(Declaration* x)            { return static_cast<D*>(this)->fallback(x); }
     T operator()(Assignment* x)             { return static_cast<D*>(this)->fallback(x); }
@@ -142,7 +142,7 @@ namespace Sass {
     T operator()(Supports_Interpolation* x) { return static_cast<D*>(this)->fallback(x); }
     T operator()(Media_Query* x)            { return static_cast<D*>(this)->fallback(x); }
     T operator()(Media_Query_Expression* x) { return static_cast<D*>(this)->fallback(x); }
-    T operator()(At_Root_Expression* x)     { return static_cast<D*>(this)->fallback(x); }
+    T operator()(At_Root_Query* x)     { return static_cast<D*>(this)->fallback(x); }
     T operator()(Null* x)                   { return static_cast<D*>(this)->fallback(x); }
     T operator()(Parent_Selector* x)        { return static_cast<D*>(this)->fallback(x); }
     // parameters and arguments

data/ext/libsass/src/output.cpp

@@ -310,7 +310,7 @@ namespace Sass {
     append_scope_closer();
   }
 
-  void Output::operator()(At_Rule* a)
+  void Output::operator()(Directive* a)
   {
     std::string      kwd   = a->keyword();
     Selector*   s     = a->selector();

data/ext/libsass/src/output.hpp

@@ -38,7 +38,7 @@ namespace Sass {
     // virtual void operator()(Propset*);
     virtual void operator()(Supports_Block*);
     virtual void operator()(Media_Block*);
-    virtual void operator()(At_Rule*);
+    virtual void operator()(Directive*);
     virtual void operator()(Keyframe_Rule*);
     virtual void operator()(Import*);
     virtual void operator()(Comment*);

data/ext/libsass/src/parser.cpp

@@ -250,7 +250,9 @@ namespace Sass {
     else if (lex< kwd_charset_directive >(true)) { parse_charset_directive(); }
 
     // generic at keyword (keep last)
-    else if (lex< at_keyword >(true)) { (*block) << parse_at_rule(); }
+    else if (lex< re_special_directive >(true)) { (*block) << parse_special_directive(); }
+    else if (lex< re_prefixed_directive >(true)) { (*block) << parse_prefixed_directive(); }
+    else if (lex< at_keyword >(true)) { (*block) << parse_directive(); }
 
     else if (block->is_root()) {
       lex< css_whitespace >();
@@ -1325,10 +1327,7 @@ namespace Sass {
     else if (peek< ie_keyword_arg >()) {
       return parse_ie_keyword_arg();
     }
-    else if (peek< exactly< calc_kwd > >() ||
-             peek< exactly< moz_calc_kwd > >() ||
-             peek< exactly< ms_calc_kwd > >() ||
-             peek< exactly< webkit_calc_kwd > >()) {
+    else if (peek< sequence < calc_fn_call, exactly <'('> > >()) {
       return parse_calc_function();
     }
     else if (lex < functional_schema >()) {
@@ -1773,6 +1772,7 @@ namespace Sass {
       prefix = std::string(lexed);
     }
 
+    lex < optional_spaces >();
     String* url_string = parse_url_function_argument();
 
     std::string suffix("");
@@ -1809,7 +1809,7 @@ namespace Sass {
     if (peek< exactly< hash_lbrace > >()) {
       const char* pp = position;
       // TODO: error checking for unclosed interpolants
-      while (peek< exactly< hash_lbrace > >(pp)) {
+      while (pp && peek< exactly< hash_lbrace > >(pp)) {
         pp = sequence< interpolant, real_uri_value >(pp);
       }
       position = pp;
@@ -2142,13 +2142,14 @@ namespace Sass {
   {
     ParserState at_source_position = pstate;
     Block* body = 0;
-    At_Root_Expression* expr = 0;
+    At_Root_Query* expr = 0;
     Lookahead lookahead_result;
     LOCAL_FLAG(in_at_root, true);
-    if (lex< exactly<'('> >()) {
-      expr = parse_at_root_expression();
+    if (lex_css< exactly<'('> >()) {
+      expr = parse_at_root_query();
     }
-    if (peek < exactly<'{'> >()) {
+    if (peek_css < exactly<'{'> >()) {
+      lex <optional_spaces>();
       body = parse_block(true);
     }
     else if ((lookahead_result = lookahead_for_selector(position)).found) {
@@ -2161,7 +2162,7 @@ namespace Sass {
     return at_root;
   }
 
-  At_Root_Expression* Parser::parse_at_root_expression()
+  At_Root_Query* Parser::parse_at_root_query()
   {
     if (peek< exactly<')'> >()) error("at-root feature required in at-root expression", pstate);
 
@@ -2169,29 +2170,60 @@ namespace Sass {
       css_error("Invalid CSS", " after ", ": expected \"with\" or \"without\", was ");
     }
 
-    Declaration* declaration = parse_declaration();
-    List* value = SASS_MEMORY_NEW(ctx.mem, List, declaration->value()->pstate(), 1);
+    Expression* feature = parse_list();
+    if (!lex_css< exactly<':'> >()) error("style declaration must contain a value", pstate);
+    Expression* expression = parse_list();
+    List* value = SASS_MEMORY_NEW(ctx.mem, List, feature->pstate(), 1);
 
-    if (declaration->value()->concrete_type() == Expression::LIST) {
-        value = static_cast<List*>(declaration->value());
+    if (expression->concrete_type() == Expression::LIST) {
+        value = static_cast<List*>(expression);
     }
-    else *value << declaration->value();
+    else *value << expression;
 
-    At_Root_Expression* cond = SASS_MEMORY_NEW(ctx.mem, At_Root_Expression,
-                                               declaration->pstate(),
-                                               declaration->property(),
-                                               value);
-    if (!lex< exactly<')'> >()) error("unclosed parenthesis in @at-root expression", pstate);
+    At_Root_Query* cond = SASS_MEMORY_NEW(ctx.mem, At_Root_Query,
+                                          value->pstate(),
+                                          feature,
+                                          value);
+    if (!lex_css< exactly<')'> >()) error("unclosed parenthesis in @at-root expression", pstate);
     return cond;
   }
 
-  At_Rule* Parser::parse_at_rule()
+  Directive* Parser::parse_special_directive()
+  {
+    std::string kwd(lexed);
+
+    if (lexed == "@else") error("Invalid CSS: @else must come after @if", pstate);
+
+    Directive* at_rule = SASS_MEMORY_NEW(ctx.mem, Directive, pstate, kwd);
+    Lookahead lookahead = lookahead_for_include(position);
+    if (lookahead.found && !lookahead.has_interpolants) {
+      at_rule->selector(parse_selector_list(true));
+    }
+
+    lex < css_comments >(false);
+
+    if (lex < static_property >()) {
+      at_rule->value(parse_interpolated_chunk(Token(lexed)));
+    } else if (!(peek < alternatives < exactly<'{'>, exactly<'}'>, exactly<';'> > >())) {
+      at_rule->value(parse_list());
+    }
+
+    lex < css_comments >(false);
+
+    if (peek< exactly<'{'> >()) {
+      at_rule->block(parse_block());
+    }
+
+    return at_rule;
+  }
+
+  Directive* Parser::parse_prefixed_directive()
   {
     std::string kwd(lexed);
 
     if (lexed == "@else") error("Invalid CSS: @else must come after @if", pstate);
 
-    At_Rule* at_rule = SASS_MEMORY_NEW(ctx.mem, At_Rule, pstate, kwd);
+    Directive* at_rule = SASS_MEMORY_NEW(ctx.mem, Directive, pstate, kwd);
     Lookahead lookahead = lookahead_for_include(position);
     if (lookahead.found && !lookahead.has_interpolants) {
       at_rule->selector(parse_selector_list(true));
@@ -2214,6 +2246,137 @@ namespace Sass {
     return at_rule;
   }
 
+
+  Directive* Parser::parse_directive()
+  {
+    Directive* directive = SASS_MEMORY_NEW(ctx.mem, Directive, pstate, lexed);
+    Expression* val = parse_almost_any_value();
+    // strip left and right if they are of type string
+    // debug_ast(val);
+    // std::cerr << "HAASDASD\n";
+    directive->value(val);
+    if (peek< exactly<'{'> >()) {
+      directive->block(parse_block());
+    } else if (!val) {
+      css_error("most def");
+    }
+    return directive;
+  }
+
+  Expression* Parser::lex_interpolation()
+  {
+    if (lex < interpolant >(true) != NULL) {
+      return parse_interpolated_chunk(lexed, true);
+    }
+    return 0;
+  }
+
+  Expression* Parser::lex_interp_uri()
+  {
+    // create a string schema by lexing optional interpolations
+    return lex_interp< re_string_uri_open, re_string_uri_close >();
+  }
+
+  Expression* Parser::lex_interp_string()
+  {
+    Expression* rv = 0;
+    if ((rv = lex_interp< re_string_double_open, re_string_double_close >()) != NULL) return rv;
+    if ((rv = lex_interp< re_string_single_open, re_string_single_close >()) != NULL) return rv;
+    return rv;
+  }
+
+  Expression* Parser::lex_almost_any_value_chars()
+  {
+    const char* match =
+    lex <
+      one_plus <
+        alternatives <
+          sequence <
+            exactly <'\\'>,
+            any_char
+          >,
+          sequence <
+            negate <
+              sequence <
+                exactly < url_kwd >,
+                exactly <'('>
+              >
+            >,
+            neg_class_char <
+              almost_any_value_class
+            >
+          >,
+          sequence <
+            exactly <'/'>,
+            negate <
+              alternatives <
+                exactly <'/'>,
+                exactly <'*'>
+              >
+            >
+          >,
+          sequence <
+            exactly <'\\'>,
+            exactly <'#'>,
+            negate <
+              exactly <'{'>
+            >
+          >,
+          sequence <
+            exactly <'!'>,
+            negate <
+              alpha
+            >
+          >
+        >
+      >
+    >(false);
+    if (match) {
+      // std::cerr << "[[" << std::string(lexed) << "]\n";
+      return SASS_MEMORY_NEW(ctx.mem, String_Constant, pstate, lexed);
+    }
+    return NULL;
+  }
+
+  Expression* Parser::lex_almost_any_value_token()
+  {
+    Expression* rv = 0;
+    if (*position == 0) return 0;
+    if ((rv = lex_almost_any_value_chars()) != NULL) return rv;
+    // if ((rv = lex_block_comment()) != NULL) return rv;
+    // if ((rv = lex_single_line_comment()) != NULL) return rv;
+    if ((rv = lex_interp_string()) != NULL) return rv;
+    if ((rv = lex_interp_uri()) != NULL) return rv;
+    if ((rv = lex_interpolation()) != NULL) return rv;
+    return rv;
+  }
+
+  String_Schema* Parser::parse_almost_any_value()
+  {
+
+    String_Schema* schema = SASS_MEMORY_NEW(ctx.mem, String_Schema, pstate);
+    if (*position == 0) return 0;
+    lex < spaces >(false);
+    Expression* token = lex_almost_any_value_token();
+    if (!token) return 0;
+    // std::cerr << "LEX [" << std::string(lexed) << "]\n";
+    *schema << token;
+    if (*position == 0) {
+      schema->rtrim();
+      return schema;
+    }
+
+    while ((token = lex_almost_any_value_token())) {
+      *schema << token;
+    }
+
+    lex < css_whitespace >();
+
+    schema->rtrim();
+
+    return schema;
+  }
+
   Warning* Parser::parse_warning()
   {
     if (stack.back() != Scope::Root &&
@@ -2268,72 +2431,7 @@ namespace Sass {
     rv.error = p;
     if (const char* q =
       peek <
-        alternatives <
-          // partial BEM selector
-          sequence <
-            ampersand,
-            one_plus <
-              exactly < '-' >
-            >,
-            word_boundary
-          >,
-          // main selector matching
-          one_plus <
-            alternatives <
-              // consume whitespace and comments
-              spaces, block_comment, line_comment,
-              // match `/deep/` selector (pass-trough)
-              // there is no functionality for it yet
-              schema_reference_combinator,
-              // match selector ops /[*&%,()\[\]]/
-              class_char < selector_lookahead_ops >,
-              // match selector combinators /[>+~]/
-              class_char < selector_combinator_ops >,
-              // match attribute compare operators
-              alternatives <
-                exact_match, class_match, dash_match,
-                prefix_match, suffix_match, substring_match
-              >,
-              // main selector match
-              sequence <
-                // allow namespace prefix
-                optional < namespace_schema >,
-                // modifiers prefixes
-                alternatives <
-                  sequence <
-                    exactly <'#'>,
-                    // not for interpolation
-                    negate < exactly <'{'> >
-                  >,
-                  // class match
-                  exactly <'.'>,
-                  // single or double colon
-                  optional < pseudo_prefix >
-                >,
-                // accept hyphens in token
-                one_plus < sequence <
-                  // can start with hyphens
-                  zero_plus < exactly<'-'> >,
-                  // now the main token
-                  alternatives <
-                    kwd_optional,
-                    exactly <'*'>,
-                    quoted_string,
-                    interpolant,
-                    identifier,
-                    variable,
-                    percentage,
-                    binomial,
-                    dimension,
-                    alnum
-                  >
-                > >,
-                // can also end with hyphens
-                zero_plus < exactly<'-'> >
-              >
-            >
-          >
-        >
+        re_selector_list
       >(p)
     ) {
       while (p < q) {
@@ -2353,6 +2451,7 @@ namespace Sass {
       // check expected opening bracket
       // only after successfull matching
       if (peek < exactly<'{'> >(q)) rv.found = q;
+      else if (peek < exactly<'('> >(q)) rv.found = q;
       // else if (peek < exactly<';'> >(q)) rv.found = q;
       // else if (peek < exactly<'}'> >(q)) rv.found = q;
       if (rv.found || *p == 0) rv.error = 0;
@@ -2366,7 +2465,7 @@ namespace Sass {
   }
   // EO lookahead_for_selector
 
-  // used in parse_block_nodes and parse_at_rule
+  // used in parse_block_nodes and parse_special_directive
   // ToDo: actual usage is still not really clear to me?
   Lookahead Parser::lookahead_for_include(const char* start)
   {