1 files changed, 22 insertions, 19 deletions

diff --git a/tools/build/v2/engine/modules/order.c b/tools/build/v2/engine/modules/order.c
index d77943a79c..ed632be3ac 100644
--- a/tools/build/v2/engine/modules/order.c
+++ b/tools/build/v2/engine/modules/order.c
@@ -5,18 +5,19 @@
 #include "../native.h"
 #include "../lists.h"
 #include "../strings.h"
-#include "../newstr.h"
+#include "../object.h"
 #include "../variable.h"
 
 
 /* Use quite klugy approach: when we add order dependency from 'a' to 'b',
    just append 'b' to of value of variable 'a'.
 */
-LIST *add_pair( PARSE *parse, FRAME *frame )
+LIST *add_pair( FRAME *frame, int flags )
 {
     LIST* arg = lol_get( frame->args, 0 );    
+    LISTITER iter = list_begin( arg ), end = list_end( arg );
 
-    var_set(arg->string, list_copy(0, arg->next), VAR_APPEND);
+    var_set( frame->module, list_item( iter ), list_copy_range( arg, list_next( iter ), end ), VAR_APPEND );
 
     return L0;
 }
@@ -24,11 +25,12 @@ LIST *add_pair( PARSE *parse, FRAME *frame )
 /** Given a list and a value, returns position of that value in
     the list, or -1 if not found.
 */
-int list_index(LIST* list, const char* value)
+int list_index(LIST* list, OBJECT* value)
 {
     int result = 0;
-    for(; list; list = list->next, ++result) {
-        if (strcmp(list->string, value) == 0)
+    LISTITER iter = list_begin(list), end = list_end(list);
+    for(; iter != end; iter = list_next(iter), ++result) {
+        if (object_equal(list_item(iter), value))
             return result;
     }
     return -1;
@@ -74,12 +76,12 @@ void topological_sort(int** graph, int num_vertices, int* result)
     BJAM_FREE(colors);
 }
 
-LIST *order( PARSE *parse, FRAME *frame )
+LIST *order( FRAME *frame, int flags )
 {
-    LIST* arg = lol_get( frame->args, 0 );  
-    LIST* tmp;
-    LIST* result = 0;
+    LIST* arg = lol_get( frame->args, 0 );
+    LIST* result = L0;
     int src;
+    LISTITER iter = list_begin(arg), end = list_end(arg);
 
     /* We need to create a graph of order dependencies between
        the passed objects. We assume that there are no duplicates
@@ -89,15 +91,16 @@ LIST *order( PARSE *parse, FRAME *frame )
     int** graph = (int**)BJAM_CALLOC(length, sizeof(int*));
     int* order = (int*)BJAM_MALLOC((length+1)*sizeof(int));
    
-    for(tmp = arg, src = 0; tmp; tmp = tmp->next, ++src) {
+    for(src = 0; iter != end; iter = list_next(iter), ++src) {
         /* For all object this one depend upon, add elements
            to 'graph' */
-        LIST* dependencies = var_get(tmp->string);
+        LIST* dependencies = var_get(frame->module, list_item(iter));
         int index = 0;
+        LISTITER dep_iter = list_begin(dependencies), dep_end = list_end(dependencies);
 
         graph[src] = (int*)BJAM_CALLOC(list_length(dependencies)+1, sizeof(int));
-        for(; dependencies; dependencies = dependencies->next) {          
-            int dst = list_index(arg, dependencies->string);
+        for(; dep_iter != dep_end; dep_iter = list_next(dep_iter)) {          
+            int dst = list_index(arg, list_item(dep_iter));
             if (dst != -1)
                 graph[src][index++] = dst;
         }
@@ -110,9 +113,9 @@ LIST *order( PARSE *parse, FRAME *frame )
         int index = length-1;
         for(; index >= 0; --index) {
             int i;
-            tmp = arg;
-            for (i = 0; i < order[index]; ++i, tmp = tmp->next);
-            result = list_new(result, tmp->string);
+            iter = list_begin(arg), end = list_end(arg);
+            for (i = 0; i < order[index]; ++i, iter = list_next(iter));
+            result = list_push_back(result, object_copy(list_item(iter)));
         }
     }
 
@@ -131,12 +134,12 @@ LIST *order( PARSE *parse, FRAME *frame )
 void init_order()
 {
     {
-        char* args[] = { "first", "second", 0 };
+        const char* args[] = { "first", "second", 0 };
         declare_native_rule("class@order", "add-pair", args, add_pair, 1);
     }
 
     {
-        char* args[] = { "objects", "*", 0 };
+        const char* args[] = { "objects", "*", 0 };
         declare_native_rule("class@order", "order", args, order, 1);
     }