Parsing mixin definitions, and tweaking the other functions to handle one-pass…

Parsing mixin definitions, and tweaking the other functions to handle one-pass parsing and expansion.

context.hpp

@@ -3,11 +3,13 @@ namespace Sass {
   
   struct Context {
     map<Token, Node> environment;
+    map<Token, Node> mixins;
     vector<char*> source_refs;
     size_t ref_count;
 
     Context()
     : environment(map<Token, Node>()),
+      mixins(map<Token, Node>()),
       source_refs(vector<char*>()),
       ref_count(0)
     { }

document.hpp

@@ -111,6 +111,8 @@ namespace Sass {
     
     void parse_scss();
     Node parse_import();
+    void parse_mixin_def();
+    Node parse_mixin_params();
     void parse_var_def();
     Node parse_ruleset();
     Node parse_selector_group();
@@ -119,16 +121,16 @@ namespace Sass {
     Node parse_simple_selector();
     Node parse_pseudo();
     Node parse_attribute_selector();
-    Node parse_block();
-    Node parse_rule();
+    Node parse_block(bool delay = false);
+    Node parse_rule(bool delay = false);
     Node parse_values();
-    Node parse_list();
-    Node parse_comma_list();
-    Node parse_space_list();
-    Node parse_expression();
-    Node parse_term();
-    Node parse_factor();
-    Node parse_value();
+    Node parse_list(bool delay = false);
+    Node parse_comma_list(bool delay = false);
+    Node parse_space_list(bool delay = false);
+    Node parse_expression(bool delay = false);
+    Node parse_term(bool delay = false);
+    Node parse_factor(bool delay = false);
+    Node parse_value(bool delay = false);
     
     const char* look_for_rule(const char* start = 0);
     const char* look_for_values(const char* start = 0);

document_parser.cpp

@@ -16,6 +16,9 @@ namespace Sass {
         root += parse_import();
         lex< exactly<';'> >();
       }
+      else if (peek< mixin >(position)) {
+        parse_mixin_def();
+      }
       else if (peek< variable >(position)) {
         parse_var_def();
         lex< exactly<';'> >();
@@ -41,6 +44,41 @@ namespace Sass {
     return importee.root;
   }
   
+  void Document::parse_mixin_def() {
+    lex< mixin >();
+    lex< identifier >();
+    Node name(line_number, Node::identifier, lexed);
+    Node params(parse_mixin_params());
+    Node body(parse_block(true));
+    Node mixin(line_number, Node::mixin, 3);
+    mixin << name << params << body;
+    context.mixins[name.token] = mixin;
+
+    cerr << "parsing mixin definition: ";
+    cerr << string(mixin[0].token) << "(";
+    if (params.size() > 0) {
+      cerr << string(params[0].token);
+      for (int i = 1; i < params.size(); ++i) {
+        cerr << " ," << string(params[i].token);
+      }
+    }
+    cerr << ")" << endl;
+  }
+  
+  Node Document::parse_mixin_params() {
+    Node params(line_number, Node::parameters);
+    lex< exactly<'('> >();
+    if (lex< variable >()) {
+      params << Node(line_number, Node::variable, lexed);
+      while (lex< exactly<','> >()) {
+        lex< variable >();
+        params << Node(line_number, Node::variable, lexed);
+      }
+    }
+    lex< exactly<')'> >();
+    return params;
+  }
+
   void Document::parse_var_def()
   {
     lex< variable >();
@@ -196,7 +234,7 @@ namespace Sass {
     return attr_sel;
   }
 
-  Node Document::parse_block()
+  Node Document::parse_block(bool delay)
   {
     lex< exactly<'{'> >();
     bool semicolon = false;
@@ -244,7 +282,7 @@ namespace Sass {
         block.has_rulesets = true;
       }
       else if (!peek< exactly<';'> >()) {
-        block << parse_rule();
+        block << parse_rule(delay);
         block.has_rules_or_comments = true;
         semicolon = true;        
       }
@@ -253,13 +291,13 @@ namespace Sass {
     return block;
   }
 
-  Node Document::parse_rule() {
+  Node Document::parse_rule(bool delay) {
     Node rule(line_number, Node::rule, 2);
     lex< identifier >();
     rule << Node(line_number, Node::property, lexed);
     lex< exactly<':'> >();
     // rule << parse_values();
-    rule << parse_list();
+    rule << parse_list(delay);
     return rule;
   }
 
@@ -283,10 +321,11 @@ namespace Sass {
     return values;
   }
   
-  Node Document::parse_list()
+  Node Document::parse_list(bool delay)
   {
 
-    Node val(parse_comma_list());
+    Node val(parse_comma_list(delay));
+    if (!delay) {
       if (val.type != Node::comma_list && val.type != Node::space_list && val.eval_me) {
         return eval(val);
       }
@@ -296,19 +335,26 @@ namespace Sass {
             val.children->at(i) = eval(val.children->at(i));
           }
         }
+        return val;
       }
+      else {
         return val;
+      }
+    }
+    else {
+      return val;
+    }
       // return parse_comma_list();
   }
   
-  Node Document::parse_comma_list()
+  Node Document::parse_comma_list(bool delay)
   {
     if (peek< exactly<';'> >(position) ||
         peek< exactly<'}'> >(position) ||
         peek< exactly<')'> >(position)) {
       return Node(line_number, Node::nil);
     }
-    Node list1(parse_space_list());
+    Node list1(parse_space_list(delay));
     // if it's a singleton, return it directly; don't wrap it
     if (!peek< exactly<','> >(position)) return list1;
     
@@ -316,14 +362,14 @@ namespace Sass {
     comma_list << list1;
     
     while (lex< exactly<','> >())
-    { comma_list << parse_space_list(); }
+    { comma_list << parse_space_list(delay); }
     
     return comma_list;
   }
   
-  Node Document::parse_space_list()
+  Node Document::parse_space_list(bool delay)
   {
-    Node expr1(parse_expression());
+    Node expr1(parse_expression(delay));
     // if it's a singleton, return it directly; don't wrap it
     if (peek< exactly<';'> >(position) ||
         peek< exactly<'}'> >(position) ||
@@ -342,14 +388,14 @@ namespace Sass {
              peek< exactly<','> >(position)))
     // { Node expr(parse_expression());
     //       space_list << (expr.eval_me ? eval(expr) : expr); }
-    {  space_list << parse_expression(); }
+    {  space_list << parse_expression(delay); }
     
     return space_list;
   }
   
-  Node Document::parse_expression()
+  Node Document::parse_expression(bool delay)
   {
-    Node term1(parse_term());
+    Node term1(parse_term(delay));
     // if it's a singleton, return it directly; don't wrap it
     if (!(peek< exactly<'+'> >(position) ||
           peek< exactly<'-'> >(position)))
@@ -366,7 +412,7 @@ namespace Sass {
       else {
         expression << Node(line_number, Node::sub, lexed);
       }
-      Node term(parse_term());
+      Node term(parse_term(delay));
       term.eval_me = true;
       expression << term;
     }
@@ -386,9 +432,9 @@ namespace Sass {
     return expression;
   }
   
-  Node Document::parse_term()
+  Node Document::parse_term(bool delay)
   {
-    Node fact1(parse_factor());
+    Node fact1(parse_factor(delay));
     // if it's a singleton, return it directly; don't wrap it
     if (!(peek< exactly<'*'> >(position) ||
           peek< exactly<'/'> >(position)))
@@ -406,7 +452,7 @@ namespace Sass {
       else {
         term << Node(line_number, Node::div, lexed);
       }
-      Node fact(parse_factor());
+      Node fact(parse_factor(delay));
       if (fact.from_variable || fact.eval_me) term.eval_me = true;
       term << fact;
     }
@@ -419,11 +465,11 @@ namespace Sass {
     return term;
   }
   
-  Node Document::parse_factor()
+  Node Document::parse_factor(bool delay)
   {
     if (lex< exactly<'('> >()) {
       // Node value(parse_list());
-      Node value(parse_comma_list());
+      Node value(parse_comma_list(delay));
       value.eval_me = true;
       if (value.type == Node::comma_list || value.type == Node::space_list) {
         value.children->front().eval_me = true;
@@ -432,11 +478,11 @@ namespace Sass {
       return value;
     }
     else {
-      return parse_value();
+      return parse_value(delay);
     }
   }
   
-  Node Document::parse_value()
+  Node Document::parse_value(bool delay)
   {
     if (lex< uri_prefix >())
     {
@@ -479,8 +525,14 @@ namespace Sass {
     if (lex< string_constant >())
     { return Node(line_number, Node::string_constant, lexed); }
 
-    if (lex< variable >())
-    { return context.environment[lexed]; }
+    if (lex< variable >()) {
+      if (delay) {
+        return Node(line_number, Node::var_ref, lexed);
+      }
+      else {
+        return context.environment[lexed];
+      }
+    }
   }
 
   // const char* Document::look_for_rule(const char* start)

mixins.scss

@@ -5,6 +5,9 @@ $z: global-z;
 @mixin foo($x, $y) {
   /* begin foo */
   margin: $x $y;
+  blip {
+    hey: now;
+  }
   /* end foo */
 }
 
@@ -56,3 +59,8 @@ div {
   /* calls to nullary mixins may omit the empty argument list */
   @include bung;
 }
+
+div {
+  @include foo(arg1, arg2, $x: kwdarg1, $y: kwdarg2);
+  @include foo($x: kwdarg1, $y: kwdarg2, arg1, arg2);
+}

node.hpp

@@ -60,7 +60,13 @@ namespace Sass {
       number,
       hex_triple,
 
-      comment
+      comment,
+      
+      mixin,
+      parameters,
+      variable,
+      var_ref,
+      include
     };
     
     static size_t fresh;
@@ -214,6 +220,12 @@ namespace Sass {
     
     //~Node() { delete children; }
     
+    size_t size()
+    { return children->size(); }
+    
+    Node& operator[](const size_t i)
+    { return children->at(i); }
+    
     Node& operator=(const Node& n)
     {
       line_number = n.line_number;

prelexer.cpp

@@ -38,7 +38,7 @@ namespace Sass {
     extern const char slash_star[] = "/*";
     extern const char star_slash[] = "*/";
     const char* block_comment(const char* src) {
-      return delimited_by<slash_star, star_slash, false>(src);
+      return sequence< optional_spaces, delimited_by<slash_star, star_slash, false> >(src);
     }
     // Match either comment.
     const char* comment(const char* src) {
@@ -87,6 +87,10 @@ namespace Sass {
     const char* import(const char* src) {
       return exactly<import_kwd>(src);
     }
+    extern const char mixin_kwd[] = "@mixin";
+    const char* mixin(const char* src) {
+      return exactly<mixin_kwd>(src);
+    }
     
     const char* name(const char* src) {
       return one_plus< alternatives< alnum,

prelexer.hpp

@@ -275,6 +275,7 @@ namespace Sass {
     // Match CSS '@' keywords.
     const char* at_keyword(const char* src);
     const char* import(const char* src);
+    const char* mixin(const char* src);
     // Match CSS type selectors
     const char* namespace_prefix(const char* src);
     const char* type_selector(const char* src);

test.scss

 $blah: bloo blee;
 $blip: "a 'red' and \"blue\" value";
 
+@mixin foo($arg) {
+  whatever: $arg;
+}
+
 /* top level comment -- should be preserved */
 div {
   /* another comment that should be preserved */