Implement initial parts for reference combinators

Author: mgreter

ast.hpp

@@ -1979,11 +1979,12 @@ namespace Sass {
   ////////////////////////////////////////////////////////////////////////////
   class Complex_Selector : public Selector {
   public:
-    enum Combinator { ANCESTOR_OF, PARENT_OF, PRECEDES, ADJACENT_TO };
+    enum Combinator { ANCESTOR_OF, PARENT_OF, PRECEDES, ADJACENT_TO, REFERENCE };
   private:
     ADD_PROPERTY(Combinator, combinator)
     ADD_PROPERTY(Compound_Selector*, head)
     ADD_PROPERTY(Complex_Selector*, tail)
+    ADD_PROPERTY(String*, reference);
   public:
     bool contains_placeholder() {
       if (head() && head()->contains_placeholder()) return true;
@@ -1994,7 +1995,7 @@ namespace Sass {
                      Combinator c = ANCESTOR_OF,
                      Compound_Selector* h = 0,
                      Complex_Selector* t = 0)
-    : Selector(pstate), combinator_(c), head_(h), tail_(t)
+    : Selector(pstate), combinator_(c), head_(h), tail_(t), reference_(0)
     {
       if ((h && h->has_reference())   || (t && t->has_reference()))   has_reference(true);
       if ((h && h->has_placeholder()) || (t && t->has_placeholder())) has_placeholder(true);

debugger.hpp

@@ -123,7 +123,9 @@ inline void debug_ast(AST_Node* node, string ind = "", Env* env = 0)
         case Complex_Selector::PRECEDES:    del = "~"; break;
         case Complex_Selector::ADJACENT_TO: del = "+"; break;
         case Complex_Selector::ANCESTOR_OF: del = " "; break;
+        case Complex_Selector::REFERENCE:   del = "//"; break;
       }
+      // if (del = "/") del += selector->reference()->perform(&to_string) + "/";
     cerr << " <" << prettyprint(selector->pstate().token.ws_before()) << ">" << endl;
     debug_ast(selector->head(), ind + " " /* + "[" + del + "]" */, env);
     if (selector->tail()) {

eval.cpp

@@ -1402,8 +1402,11 @@ namespace Sass {
     bool parentized = false;
     Complex_Selector* tail = s->tail();
     Compound_Selector* head = s->head();
+    String* reference = s->reference();
     Complex_Selector::Combinator combinator = s->combinator();
     Selector_List* sl = new (ctx.mem) Selector_List(s->pstate());
+    if (reference) reference = (String*) reference->perform(this);
+
     if (head) {
       // check if we have a parent selector reference (expands to list)
       if (head->length() > 1 && dynamic_cast<Parent_Selector*>((*head)[0])) {
@@ -1418,6 +1421,7 @@ namespace Sass {
             for (size_t i = 1, L = head->length(); i < L; ++i) *lst_h << (*head)[i];
             lst_t->tail(tail); // now connect old tail back to new intermediate
             lst_t->combinator(combinator); // and dont forget the combinator
+            lst_t->reference(reference);
             // if (s->has_line_feed()) lst_t->has_line_feed(true); // and dont forget the combinator
           }
           return ns;
@@ -1450,6 +1454,7 @@ namespace Sass {
                 lst->tail(ins);
               } else {
                 lst->combinator(combinator);
+                lst->reference(reference);
               }
             }
             if (s->has_line_feed()) (*ns)[n]->has_line_feed(true);

extend.cpp

@@ -76,6 +76,7 @@ namespace Sass {
       case Complex_Selector::PARENT_OF:   os << "\">\""; break;
       case Complex_Selector::PRECEDES:    os << "\"~\""; break;
       case Complex_Selector::ADJACENT_TO: os << "\"+\""; break;
+      case Complex_Selector::REFERENCE: os    << "\"/\""; break;
     }
 
     return os;

inspect.cpp

@@ -925,6 +925,13 @@ namespace Sass {
         append_string("+");
         append_optional_space();
       break;
+      case Complex_Selector::REFERENCE:
+        append_mandatory_space();
+        append_string("/");
+        c->reference()->perform(this);
+        append_string("/");
+        append_mandatory_space();
+      break;
       case Complex_Selector::PRECEDES:
         if (is_empty) append_optional_space();
         else append_mandatory_space();

listize.cpp

@@ -45,6 +45,9 @@ namespace Sass {
       if (hh) *l << hh;
     }
 
+    To_String to_string;
+    string reference = ! sel->reference() ? ""
+      : sel->reference()->perform(&to_string);
     switch(sel->combinator())
     {
       case Complex_Selector::PARENT_OF:
@@ -53,6 +56,9 @@ namespace Sass {
       case Complex_Selector::ADJACENT_TO:
         *l << new (ctx.mem) String_Quoted(sel->pstate(), "+");
       break;
+      case Complex_Selector::REFERENCE:
+        *l << new (ctx.mem) String_Quoted(sel->pstate(), "/" + reference + "/");
+      break;
       case Complex_Selector::PRECEDES:
         *l << new (ctx.mem) String_Quoted(sel->pstate(), "~");
       break;

node.cpp

@@ -142,6 +142,7 @@ namespace Sass {
         case Complex_Selector::PARENT_OF:   os << "\">\""; break;
         case Complex_Selector::PRECEDES:    os << "\"~\""; break;
         case Complex_Selector::ADJACENT_TO: os << "\"+\""; break;
+        case Complex_Selector::REFERENCE: os    << "\"/\""; break;
       }
 
     } else if (node.isNil()) {

parser.cpp

@@ -151,7 +151,7 @@ namespace Sass {
     // loop until end of string
     while (position < end) {
 
-      // parse comment blocks
+      // we should be able to refactor this
       parse_block_comments();
       lex < css_whitespace >();
 
@@ -717,6 +717,7 @@ namespace Sass {
   Complex_Selector* Parser::parse_complex_selector(bool in_root)
   {
 
+    String* reference = 0;
     lex < block_comment >();
     // parse the left hand side
     Compound_Selector* lhs = 0;
@@ -734,6 +735,13 @@ namespace Sass {
     if      (lex< exactly<'+'> >()) combinator = Complex_Selector::ADJACENT_TO;
     else if (lex< exactly<'~'> >()) combinator = Complex_Selector::PRECEDES;
     else if (lex< exactly<'>'> >()) combinator = Complex_Selector::PARENT_OF;
+    else if (lex< sequence < exactly<'/'>, negate < exactly < '*' > > > >()) {
+      // comments are allowed, but not spaces?
+      combinator = Complex_Selector::REFERENCE;
+      if (!lex < identifier >()) return 0; // ToDo: error msg?
+      reference = new (ctx.mem) String_Quoted(pstate, lexed);
+      if (!lex < exactly < '/' > >()) return 0; // ToDo: error msg?
+    }
     else /* if (lex< zero >()) */   combinator = Complex_Selector::ANCESTOR_OF;
 
     if (!lhs && combinator == Complex_Selector::ANCESTOR_OF) return 0;
@@ -742,6 +750,7 @@ namespace Sass {
     // source position of a complex selector points to the combinator
     // ToDo: make sure we update pstate for ancestor of (lex < zero >());
     Complex_Selector* sel = new (ctx.mem) Complex_Selector(pstate, combinator, lhs);
+    if (combinator == Complex_Selector::REFERENCE) sel->reference(reference);
     // has linfeed after combinator?
     sel->has_line_break(peek_newline());
     // sel->has_line_feed(has_line_feed);
@@ -841,7 +850,7 @@ namespace Sass {
     else if (lex< quoted_string >()) {
       return new (ctx.mem) Type_Selector(pstate, unquote(lexed));
     }
-    else if (lex< alternatives < variable, number, kwd_sel_deep > >()) {
+    else if (lex< alternatives < variable, number, re_reference_selector > >()) {
       return new (ctx.mem) Type_Selector(pstate, lexed);
     }
     else if (peek< pseudo_not >()) {
@@ -939,7 +948,7 @@ namespace Sass {
     ParserState p = pstate;
     if (!lex_css< attribute_name >()) error("invalid attribute name in attribute selector", pstate);
     string name(lexed);
-    if (lex_css< exactly<']'> >()) return new (ctx.mem) Attribute_Selector(p, name, "", 0);
+    if (lex_css< alternatives < exactly<']'>, exactly<'/'> > >()) return new (ctx.mem) Attribute_Selector(p, name, "", 0);
     if (!lex_css< alternatives< exact_match, class_match, dash_match,
                                 prefix_match, suffix_match, substring_match > >()) {
       error("invalid operator in attribute selector for " + name, pstate);
@@ -957,7 +966,7 @@ namespace Sass {
       error("expected a string constant or identifier in attribute selector for " + name, pstate);
     }
 
-    if (!lex_css< exactly<']'> >()) error("unterminated attribute selector for " + name, pstate);
+    if (!lex_css< alternatives < exactly<']'>, exactly<'/'> > >()) error("unterminated attribute selector for " + name, pstate);
     return new (ctx.mem) Attribute_Selector(p, name, matcher, value);
   }
 
@@ -2137,7 +2146,7 @@ namespace Sass {
             spaces, block_comment, line_comment,
             // match `/deep/` selector (pass-trough)
             // there is no functionality for it yet
-            exactly<sel_deep_kwd>,
+            re_reference_selector,
             // match selector ops /[*&%,()\[\]]/
             class_char < selector_lookahead_ops >,
             // match selector combinators /[>+~]/

prelexer.cpp

@@ -214,8 +214,8 @@ namespace Sass {
       return sequence<exactly<'@'>, identifier>(src);
     }
 
-    const char* kwd_sel_deep(const char* src) {
-      return word<sel_deep_kwd>(src);
+    const char* re_reference_selector(const char* src) {
+      return sequence < exactly <'/'>, identifier, exactly <'/'> >(src);
     }
 
     const char* kwd_import(const char* src) {

prelexer.hpp

@@ -196,9 +196,8 @@ namespace Sass {
     const char* identifier_alpha(const char* src);
     const char* identifier_alnum(const char* src);
     const char* identifier_alnums(const char* src);
-    // Match selector names.
-    // const char* sel_ident(const char* src);
-    const char* kwd_sel_deep(const char* src);
+    // Match reference selector.
+    const char* re_reference_selector(const char* src);
 
     // Match interpolant schemas
     const char* identifier_schema(const char* src);