Fully implemented the new resolution method for overloaded built-ins.

context.cpp

@@ -78,17 +78,24 @@ namespace Sass {
     // function_env[pair<string, size_t>(f.name, arity)] = f;
     function_env[f.name] = f;
   }
+
+  inline void Context::register_overload_stub(string name)
+  {
+    function_env[name] = Function(name, true);
+  }
   
   void Context::register_functions()
   {
     using namespace Functions;
     // RGB Functions
     register_function(rgb_descriptor,  rgb);
+    register_overload_stub("rgba");
     register_function(rgba_4_descriptor, rgba_4);
     register_function(rgba_2_descriptor, rgba_2);
     register_function(red_descriptor, red);
     register_function(green_descriptor, green);
     register_function(blue_descriptor, blue);
+    register_overload_stub("mix");
     register_function(mix_2_descriptor, mix_2);
     register_function(mix_3_descriptor, mix_3);
     // HSL Functions
@@ -114,10 +121,13 @@ namespace Sass {
     // List Functions
     register_function(length_descriptor, length);
     register_function(nth_descriptor, nth);
+    register_overload_stub("join");
     register_function(join_2_descriptor, join_2);
     register_function(join_3_descriptor, join_3);
+    register_overload_stub("append");
     register_function(append_2_descriptor, append_2);
     register_function(append_3_descriptor, append_3);
+    register_overload_stub("compact");
     register_function(compact_1_descriptor, compact);
     register_function(compact_2_descriptor, compact);
     register_function(compact_3_descriptor, compact);

context.hpp

@@ -59,6 +59,7 @@ namespace Sass {
     
     void register_function(Function_Descriptor d, Primitive ip);
     void register_function(Function_Descriptor d, Primitive ip, size_t arity);
+    void register_overload_stub(string name);
     void register_functions();
   };
 

eval_apply.cpp

@@ -305,13 +305,13 @@ namespace Sass {
         else {
           // check to see if the function is primitive/built-in
           Function f(f_env[name]);
-          if (f.primitive && f.overloaded) {
+          if (f.overloaded) {
             stringstream s;
             s << name << " " << expr[1].size();
-            f = f_env[s.str()];
-            cerr << "applying overloaded primitive [" << s.str() << "]" << endl;
+            string resolved_name(s.str());
+            if (!f_env.count(resolved_name)) throw_eval_error("wrong number of arguments to " + name, expr.path(), expr.line());
+            f = f_env[resolved_name];
           }
-          cerr << "about to apply function " << f.name << endl;
           return apply_function(f, expr[1], prefix, env, f_env, new_Node, ctx);
         }
       } break;

functions.cpp

@@ -34,7 +34,7 @@ namespace Sass {
     }
 
     Function_Descriptor rgba_4_descriptor = 
-    { "rgba", "$red", "$green", "$blue", "$alpha", 0 };
+    { "rgba 4", "$red", "$green", "$blue", "$alpha", 0 };
     Node rgba_4(const Node parameters, map<Token, Node>& bindings, Node_Factory& new_Node) {
       Node r(bindings[parameters[0].token()]);
       Node g(bindings[parameters[1].token()]);
@@ -47,7 +47,7 @@ namespace Sass {
     }
     
     Function_Descriptor rgba_2_descriptor = 
-    { "rgba", "$color", "$alpha", 0 };
+    { "rgba 2", "$color", "$alpha", 0 };
     Node rgba_2(const Node parameters, map<Token, Node>& bindings, Node_Factory& new_Node) {
       Node color(bindings[parameters[0].token()]);
       Node r(color[0]);
@@ -104,13 +104,13 @@ namespace Sass {
     }
     
     Function_Descriptor mix_2_descriptor =
-    { "mix", "$color1", "$color2", 0 };
+    { "mix 2", "$color1", "$color2", 0 };
     Node mix_2(const Node parameters, map<Token, Node>& bindings, Node_Factory& new_Node) {
       return mix_impl(bindings[parameters[0].token()], bindings[parameters[1].token()], 50, new_Node);
     }
     
     Function_Descriptor mix_3_descriptor =
-    { "mix", "$color1", "$color2", "$weight", 0 };
+    { "mix 3", "$color1", "$color2", "$weight", 0 };
     Node mix_3(const Node parameters, map<Token, Node>& bindings, Node_Factory& new_Node) {
       Node percentage(bindings[parameters[2].token()]);
       if (!(percentage.type() == Node::number || percentage.type() == Node::numeric_percentage || percentage.type() == Node::numeric_dimension)) {
@@ -505,13 +505,13 @@ namespace Sass {
     }
     
     Function_Descriptor join_2_descriptor =
-    { "join", "$list1", "$list2", 0 };
+    { "join 2", "$list1", "$list2", 0 };
     Node join_2(const Node parameters, map<Token, Node>& bindings, Node_Factory& new_Node) {
       return join_impl(parameters, bindings, false, new_Node);
     }
     
     Function_Descriptor join_3_descriptor =
-    { "join", "$list1", "$list2", "$separator", 0 };
+    { "join 3", "$list1", "$list2", "$separator", 0 };
     Node join_3(const Node parameters, map<Token, Node>& bindings, Node_Factory& new_Node) {
       return join_impl(parameters, bindings, true, new_Node);
     }
@@ -545,13 +545,13 @@ namespace Sass {
     }
 
     Function_Descriptor append_2_descriptor =
-    { "append", "$list", "$val", 0 };
+    { "append 2", "$list", "$val", 0 };
     Node append_2(const Node parameters, map<Token, Node>& bindings, Node_Factory& new_Node) {
       return append_impl(parameters, bindings, false, new_Node);
     }
 
     Function_Descriptor append_3_descriptor =
-    { "append", "$list", "$val", "$separator", 0 };
+    { "append 3", "$list", "$val", "$separator", 0 };
     Node append_3(const Node parameters, map<Token, Node>& bindings, Node_Factory& new_Node) {
       return append_impl(parameters, bindings, true, new_Node);
     }
@@ -583,29 +583,29 @@ namespace Sass {
     }
 
     Function_Descriptor compact_1_descriptor =
-    { "compact", "$arg1", 0 };
+    { "compact 1", "$arg1", 0 };
     Function_Descriptor compact_2_descriptor =
-    { "compact", "$arg1", "$arg2", 0 };
+    { "compact 2", "$arg1", "$arg2", 0 };
     Function_Descriptor compact_3_descriptor =
-    { "compact", "$arg1", "$arg2", "$arg3", 0 };
+    { "compact 3", "$arg1", "$arg2", "$arg3", 0 };
     Function_Descriptor compact_4_descriptor =
-    { "compact", "$arg1", "$arg2", "$arg3", "$arg4", 0 };
+    { "compact 4", "$arg1", "$arg2", "$arg3", "$arg4", 0 };
     Function_Descriptor compact_5_descriptor =
-    { "compact", "$arg1", "$arg2", "$arg3", "$arg4", "$arg5", 0 };
+    { "compact 5", "$arg1", "$arg2", "$arg3", "$arg4", "$arg5", 0 };
     Function_Descriptor compact_6_descriptor =
-    { "compact", "$arg1", "$arg2", "$arg3", "$arg4", "$arg5", 
+    { "compact 6", "$arg1", "$arg2", "$arg3", "$arg4", "$arg5", 
                  "$arg6", 0 };
     Function_Descriptor compact_7_descriptor =
-    { "compact", "$arg1", "$arg2", "$arg3", "$arg4", "$arg5", 
+    { "compact 7", "$arg1", "$arg2", "$arg3", "$arg4", "$arg5", 
                  "$arg6", "$arg7", 0 };
     Function_Descriptor compact_8_descriptor =
-    { "compact", "$arg1", "$arg2", "$arg3", "$arg4", "$arg5", 
+    { "compact 8", "$arg1", "$arg2", "$arg3", "$arg4", "$arg5", 
                  "$arg6", "$arg7", "$arg8", 0 };
     Function_Descriptor compact_9_descriptor =
-    { "compact", "$arg1", "$arg2", "$arg3", "$arg4", "$arg5", 
+    { "compact 9", "$arg1", "$arg2", "$arg3", "$arg4", "$arg5", 
                  "$arg6", "$arg7", "$arg8", "$arg9", 0 };
     Function_Descriptor compact_10_descriptor =
-    { "compact", "$arg1", "$arg2", "$arg3", "$arg4", "$arg5", 
+    { "compact 10", "$arg1", "$arg2", "$arg3", "$arg4", "$arg5", 
                  "$arg6", "$arg7", "$arg8", "$arg9", "$arg10", 0 };
 
     

functions.hpp

@@ -31,13 +31,22 @@ namespace Sass {
       primitive(0),
       overloaded(false)
     { }
+
+    // Stub for overloaded primitives
+    Function(string name, bool overloaded = true)
+    : name(name),
+      parameters(Node()),
+      definition(Node()),
+      primitive(0),
+      overloaded(overloaded)
+    { }
     
-    Function(Function_Descriptor d, Primitive ip, Node_Factory& new_Node, bool overloaded = false)
+    Function(Function_Descriptor d, Primitive ip, Node_Factory& new_Node)
     : name(d[0]),
       parameters(new_Node(Node::parameters, "[PRIMITIVE FUNCTIONS]", 0, 0)),
       definition(Node()),
       primitive(ip),
-      overloaded(overloaded)
+      overloaded(false)
     {
       size_t len = 0;
       while (d[len+1]) ++len;