Implemented list builtins.

basic.scss

@@ -46,4 +46,21 @@ div {
   f: ceil(10.4px);
   g: ceil(10.6px);
   h: abs(-23em);
+  
+  a: length(10px);
+  b: length(10px 20 30em);
+  c: length(());
+  
+  a: nth(3px, 1);
+  b: nth((a, b, c), 2);
+  c: nth(foo bar hux, 3);
+  
+  a: join(a b c, d e f, "comma");
+  b: length(join(a b c, d e f, comma));
+  c: join(10px 20px, 30px 40px);
+  d: join((), 1 2 3);
+  e: join(1 2 3, (), comma);
+  f: join((1,2,3), ());
+  g: join((), (1,2,3));
+  h: hello join((),(), auto);
 }

context.cpp

@@ -57,6 +57,11 @@ namespace Sass {
     register_function(ceil_descriptor, ceil);
     register_function(floor_descriptor, floor);
     register_function(abs_descriptor, abs);
+    // List Functions
+    register_function(length_descriptor, length);
+    register_function(nth_descriptor, nth);
+    register_function(join_2_descriptor, join_2);
+    register_function(join_3_descriptor, join_3);
   }
   
 }
\ No newline at end of file

functions.cpp

@@ -219,16 +219,77 @@ namespace Sass {
       return cpy;
     }
     
+    // List Functions //////////////////////////////////////////////////////
+    Function_Descriptor length_descriptor =
+    { "length", "$list", 0 };
+    Node length(const vector<Token>& parameters, map<Token, Node>& bindings) {
+      Node arg(bindings[parameters[0]]);
+      if (arg.type == Node::space_list || arg.type == Node::comma_list) {
+        return Node(arg.line_number, arg.size());
+      }
+      else if (arg.type == Node::nil) {
+        return Node(arg.line_number, 0);
+      }
+      else {
+        return Node(arg.line_number, 1);
+      }
+    }
     
+    Function_Descriptor nth_descriptor =
+    { "nth", "$list", "$n", 0 };
+    Node nth(const vector<Token>& parameters, map<Token, Node>& bindings) {
+      Node l(bindings[parameters[0]]);
+      // TO DO: check for empty list
+      if (l.type != Node::space_list && l.type != Node::comma_list) {
+        l = Node(Node::space_list, l.line_number, 1) << l;
+      }
+      return l[bindings[parameters[1]].content.numeric_value - 1];
+    }
     
+    extern const char separator_kwd[] = "$separator";
+    Node join_impl(const vector<Token>& parameters, map<Token, Node>& bindings, bool has_sep = false) {
+      Node l1(bindings[parameters[0]]);
+      if (l1.type != Node::space_list && l1.type != Node::comma_list && l1.type != Node::nil) {
+        l1 = Node(Node::space_list, l1.line_number, 1) << l1;
+        cerr << "listified singleton" << endl;
+      }
+      Node l2(bindings[parameters[1]]);
+      if (l2.type != Node::space_list && l2.type != Node::comma_list && l2.type != Node::nil) {
+        l2 = Node(Node::space_list, l2.line_number, 1) << l2;
+        cerr << "listified singleton" << endl;
+      }
       
+      if (l1.type == Node::nil && l2.type == Node::nil) return Node(Node::nil, l1.line_number);
 
+      size_t size = 0;
+      if (l1.type != Node::nil) size += l1.size();
+      if (l2.type != Node::nil) size += l2.size();
       
+      Node lr(Node::space_list, l1.line_number, size);
+      if (has_sep) {
+        string sep(bindings[parameters[2]].content.token.unquote());
+        if (sep == "comma") lr.type = Node::comma_list;
+        // TO DO: check for "space" or "auto"
+      }
+      else if (l1.type != Node::nil) lr.type = l1.type;
+      else if (l2.type != Node::nil) lr.type = l2.type;
       
+      if (l1.type != Node::nil) lr += l1;
+      if (l2.type != Node::nil) lr += l2;
+      return lr;
+    }
     
+    Function_Descriptor join_2_descriptor =
+    { "join", "$list1", "$list2", 0 };
+    Node join_2(const vector<Token>& parameters, map<Token, Node>& bindings) {
+      return join_impl(parameters, bindings);
+    }
     
-    
-    
+    Function_Descriptor join_3_descriptor =
+    { "join", "$list1", "$list2", "$separator", 0 };
+    Node join_3(const vector<Token>& parameters, map<Token, Node>& bindings) {
+      return join_impl(parameters, bindings, true);
+    }
     
     
     

functions.hpp

@@ -114,6 +114,20 @@ namespace Sass {
     extern Function_Descriptor abs_descriptor;    
     Node abs(const vector<Token>& parameters, map<Token, Node>& bindings);
     
+    // List Functions //////////////////////////////////////////////////////
+    
+    extern Function_Descriptor length_descriptor;
+    Node length(const vector<Token>& parameters, map<Token, Node>& bindings);
+
+    extern Function_Descriptor nth_descriptor;
+    Node nth(const vector<Token>& parameters, map<Token, Node>& bindings);
+
+    extern Function_Descriptor join_2_descriptor;    
+    Node join_2(const vector<Token>& parameters, map<Token, Node>& bindings);
+    
+    extern Function_Descriptor join_3_descriptor;    
+    Node join_3(const vector<Token>& parameters, map<Token, Node>& bindings);
+
   }
   
 }

node.cpp

@@ -104,6 +104,7 @@ namespace Sass {
       case comma_list: {
         string result(at(0).to_string(prefix));
         for (int i = 1; i < size(); ++i) {
+          if (at(i).type == nil) continue;
           result += ", ";
           result += at(i).to_string(prefix);
         }
@@ -113,6 +114,7 @@ namespace Sass {
       case space_list: {
         string result(at(0).to_string(prefix));
         for (int i = 1; i < size(); ++i) {
+          if (at(i).type == nil) continue;
           result += " ";
           result += at(i).to_string(prefix);
         }