From fb84541e1124565ee7af32cd842771cf81326dc7 Mon Sep 17 00:00:00 2001
From: Stephen Dolan <mu@netsoc.tcd.ie>
Date: Mon, 31 Dec 2012 23:27:00 +0000
Subject: [PATCH] Clean up jv_object_foreach and add jv_array_foreach

---
 builtin.c  | 17 ++++++-----------
 jv.c       | 23 +++++++++--------------
 jv.h       | 21 ++++++++++++++++-----
 jv_aux.c   | 21 +++++++++++----------
 jv_print.c |  9 ++++-----
 5 files changed, 46 insertions(+), 45 deletions(-)

diff --git a/builtin.c b/builtin.c
index 5818a6a4..32b67ccc 100644
--- a/builtin.c
+++ b/builtin.c
@@ -71,11 +71,10 @@ static jv f_minus(jv input, jv a, jv b) {
     return jv_number(jv_number_value(a) - jv_number_value(b));
   } else if (jv_get_kind(a) == JV_KIND_ARRAY && jv_get_kind(b) == JV_KIND_ARRAY) {
     jv out = jv_array();
-    for (int i=0; i<jv_array_length(jv_copy(a)); i++) {
-      jv x = jv_array_get(jv_copy(a), i);
+    jv_array_foreach(a, i, x) {
       int include = 1;
-      for (int j=0; j<jv_array_length(jv_copy(b)); j++) {
-        if (jv_equal(jv_copy(x), jv_array_get(jv_copy(b), j))) {
+      jv_array_foreach(b, j, y) {
+        if (jv_equal(jv_copy(x), y)) {
           include = 0;
           break;
         }
@@ -153,9 +152,7 @@ static jv f_greatereq(jv input, jv a, jv b) {
 }
 
 static jv f_contains(jv a, jv b) {
-  jv_kind akind = jv_get_kind(a);
-
-  if (akind == jv_get_kind(b)) {
+  if (jv_get_kind(a) == jv_get_kind(b)) {
     return jv_bool(jv_contains(a, b));
   } else {
     return type_error2(a, b, "cannot have their containment checked");
@@ -248,9 +245,8 @@ static jv f_format(jv input, jv fmt) {
     if (jv_get_kind(input) != JV_KIND_ARRAY)
       return type_error(input, "cannot be csv-formatted, only array");
     jv line = jv_string("");
-    for (int i=0; i<jv_array_length(jv_copy(input)); i++) {
+    jv_array_foreach(input, i, x) {
       if (i) line = jv_string_append_str(line, ",");
-      jv x = jv_array_get(jv_copy(input), i);
       switch (jv_get_kind(x)) {
       case JV_KIND_NULL:
         /* null rendered as empty string */
@@ -311,9 +307,8 @@ static jv f_format(jv input, jv fmt) {
     if (jv_get_kind(input) != JV_KIND_ARRAY)
       input = jv_array_set(jv_array(), 0, input);
     jv line = jv_string("");
-    for (int i=0; i<jv_array_length(jv_copy(input)); i++) {
+    jv_array_foreach(input, i, x) {
       if (i) line = jv_string_append_str(line, " ");
-      jv x = jv_array_get(jv_copy(input), i);
       switch (jv_get_kind(x)) {
       case JV_KIND_NULL:
       case JV_KIND_TRUE:
diff --git a/jv.c b/jv.c
index 9a362a6c..fb4d2103 100644
--- a/jv.c
+++ b/jv.c
@@ -315,8 +315,8 @@ jv jv_array_concat(jv a, jv b) {
   assert(jv_get_kind(b) == JV_KIND_ARRAY);
 
   // FIXME: could be much faster
-  for (int i=0; i<jv_array_length(jv_copy(b)); i++) {
-    a = jv_array_append(a, jv_array_get(jv_copy(b), i));
+  jv_array_foreach(b, i, elem) {
+    a = jv_array_append(a, elem);
   }
   jv_free(b);
   return a;
@@ -331,16 +331,15 @@ jv jv_array_slice(jv a, int start, int end) {
 
 int jv_array_contains(jv a, jv b) {
   int r = 1;
-  int a_length = jv_array_length(jv_copy(a));
-  int b_length = jv_array_length(jv_copy(b));
-  for (int bi = 0; bi < b_length; bi++) {
+  jv_array_foreach(b, bi, belem) {
     int ri = 0;
-    for (int ai = 0; ai < a_length; ai++) {
-      if (jv_contains(jv_array_get(jv_copy(a), ai), jv_array_get(jv_copy(b), bi))) {
+    jv_array_foreach(a, ai, aelem) {
+      if (jv_contains(aelem, jv_copy(belem))) {
         ri = 1;
         break;
       }
     }
+    jv_free(belem);
     if (!ri) {
       r = 0;
       break;
@@ -876,10 +875,8 @@ int jv_object_length(jv object) {
 
 jv jv_object_merge(jv a, jv b) {
   assert(jv_get_kind(a) == JV_KIND_OBJECT);
-  jv_object_foreach(i, b) {
-    a = jv_object_set(a, 
-                      jv_object_iter_key(b, i),
-                      jv_object_iter_value(b, i));
+  jv_object_foreach(b, k, v) {
+    a = jv_object_set(a, k, v);
   }
   jv_free(b);
   return a;
@@ -890,10 +887,8 @@ int jv_object_contains(jv a, jv b) {
   assert(jv_get_kind(b) == JV_KIND_OBJECT);
   int r = 1;
 
-  jv_object_foreach(i, b) {
-    jv key = jv_object_iter_key(b, i);
+  jv_object_foreach(b, key, b_val) {
     jv a_val = jv_object_get(jv_copy(a), jv_copy(key));
-    jv b_val = jv_object_get(jv_copy(b), jv_copy(key));
 
     r = jv_contains(a_val, b_val);
     jv_free(key);
diff --git a/jv.h b/jv.h
index 12e7c790..c3bff367 100644
--- a/jv.h
+++ b/jv.h
@@ -72,7 +72,13 @@ jv jv_array_set(jv, int, jv);
 jv jv_array_append(jv, jv);
 jv jv_array_concat(jv, jv);
 jv jv_array_slice(jv, int, int);
-
+#define jv_array_foreach(a, i, x) \
+  for (int jv_len__ = jv_array_length(jv_copy(a)), i=0, jv_j__ = 1;     \
+       jv_j__; jv_j__ = 0)                                              \
+    for (jv x;                                                          \
+         i < jv_len__ ?                                                 \
+           (x = jv_array_get(jv_copy(a), i), 1) : 0;                    \
+         i++)
 
 jv jv_string(const char*);
 jv jv_string_sized(const char*, int);
@@ -96,10 +102,15 @@ int jv_object_iter_next(jv, int);
 int jv_object_iter_valid(jv, int);
 jv jv_object_iter_key(jv, int);
 jv jv_object_iter_value(jv, int);
-#define jv_object_foreach(i,t) \
-  for (int i = jv_object_iter(t);               \
-       jv_object_iter_valid(t, i);              \
-       i = jv_object_iter_next(t, i))           \
+#define jv_object_foreach(t, k, v)                                      \
+  for (int jv_i__ = jv_object_iter(t), jv_j__ = 1; jv_j__; jv_j__ = 0)  \
+    for (jv k, v;                                                       \
+         jv_object_iter_valid((t), jv_i__) ?                            \
+           (k = jv_object_iter_key(t, jv_i__),                          \
+            v = jv_object_iter_value(t, jv_i__),                        \
+            1)                                                          \
+           : 0;                                                         \
+         jv_i__ = jv_object_iter_next(t, jv_i__))                       \
  
 
 
diff --git a/jv_aux.c b/jv_aux.c
index f0e15b50..2c33491d 100644
--- a/jv_aux.c
+++ b/jv_aux.c
@@ -70,7 +70,7 @@ jv jv_dels(jv t, jv keys) {
   } else if (jv_get_kind(t) == JV_KIND_ARRAY) {
     jv new_array = jv_array();
     int kidx = 0;
-    for (int i=0; i<jv_array_length(jv_copy(t)); i++) {
+    jv_array_foreach(t, i, elem) {
       int del = 0;
       while (kidx < jv_array_length(jv_copy(keys))) {
         jv nextdel = jv_array_get(jv_copy(keys), kidx);
@@ -79,6 +79,7 @@ jv jv_dels(jv t, jv keys) {
                                                      jv_kind_name(jv_get_kind(nextdel))));
           jv_free(nextdel);
           jv_free(new_array);
+          jv_free(elem);
           new_array = err;
           goto arr_out; // break twice
         }
@@ -93,14 +94,15 @@ jv jv_dels(jv t, jv keys) {
         kidx++;
       }
       if (!del)
-        new_array = jv_array_append(new_array, jv_array_get(jv_copy(t), i));
+        new_array = jv_array_append(new_array, elem);
+      else
+        jv_free(elem);
     }
   arr_out:
     jv_free(t);
     t = new_array;
   } else if (jv_get_kind(t) == JV_KIND_OBJECT) {
-    for (int i=0; i<jv_array_length(jv_copy(keys)); i++) {
-      jv k = jv_array_get(jv_copy(keys), i);
+    jv_array_foreach(keys, i, k) {
       if (jv_get_kind(k) != JV_KIND_STRING) {
         jv_free(t);
         t = jv_invalid_with_msg(jv_string_fmt("Cannot delete %s field of object",
@@ -212,8 +214,7 @@ static jv delpaths_sorted(jv object, jv paths, int start) {
 
 jv jv_delpaths(jv object, jv paths) {
   paths = jv_sort(paths, jv_copy(paths));
-  for (int i=0; i<jv_array_length(jv_copy(paths)); i++) {
-    jv elem = jv_array_get(jv_copy(paths), i);
+  jv_array_foreach(paths, i, elem) {
     if (jv_get_kind(elem) != JV_KIND_ARRAY) {
       jv_free(object);
       jv_free(paths);
@@ -255,8 +256,9 @@ jv jv_keys(jv x) {
     int nkeys = jv_object_length(jv_copy(x));
     jv* keys = jv_mem_alloc(sizeof(jv) * nkeys);
     int kidx = 0;
-    jv_object_foreach(i, x) {
-      keys[kidx++] = jv_object_iter_key(x, i);
+    jv_object_foreach(x, key, value) {
+      keys[kidx++] = key;
+      jv_free(value);
     }
     qsort(keys, nkeys, sizeof(jv), string_cmp);
     jv answer = jv_array_sized(nkeys);
@@ -337,8 +339,7 @@ int jv_cmp(jv a, jv b) {
     jv keys_b = jv_keys(jv_copy(b));
     r = jv_cmp(jv_copy(keys_a), keys_b);
     if (r == 0) {
-      for (int i=0; i<jv_array_length(jv_copy(keys_a)); i++) {
-        jv key = jv_array_get(jv_copy(keys_a), i);
+      jv_array_foreach(keys_a, i, key) {
         jv xa = jv_object_get(jv_copy(a), jv_copy(key));
         jv xb = jv_object_get(jv_copy(b), key);
         r = jv_cmp(xa, xb);
diff --git a/jv_print.c b/jv_print.c
index acade6cd..388bf663 100644
--- a/jv_print.c
+++ b/jv_print.c
@@ -162,7 +162,7 @@ static void jv_dump_term(struct dtoa_context* C, jv x, int flags, int indent, FI
       put_char('\n', F, S);
       put_space(indent+INDENT, F, S);
     }
-    for (int i=0; i<jv_array_length(jv_copy(x)); i++) {
+    jv_array_foreach(x, i, elem) {
       if (i!=0) {
         if (flags & JV_PRINT_PRETTY) {
           put_str(",\n", F, S);
@@ -171,7 +171,7 @@ static void jv_dump_term(struct dtoa_context* C, jv x, int flags, int indent, FI
           put_str(",", F, S);
         }
       }
-      jv_dump_term(C, jv_array_get(jv_copy(x), i), flags, indent + INDENT, F, S);
+      jv_dump_term(C, elem, flags, indent + INDENT, F, S);
       if (colour) put_str(colour, F, S);
     }
     if (flags & JV_PRINT_PRETTY) {
@@ -193,7 +193,7 @@ static void jv_dump_term(struct dtoa_context* C, jv x, int flags, int indent, FI
       put_space(indent+INDENT, F, S);
     }
     int first = 1;
-    jv_object_foreach(i, x) {
+    jv_object_foreach(x, key, value) {
       if (!first) {
         if (flags & JV_PRINT_PRETTY){
           put_str(",\n", F, S);
@@ -205,7 +205,6 @@ static void jv_dump_term(struct dtoa_context* C, jv x, int flags, int indent, FI
       if (colour) put_str(COLRESET, F, S);
 
       first = 0;
-      jv key = jv_object_iter_key(x, i);
       if (colour) put_str(FIELD_COLOUR, F, S);
       jvp_dump_string(key, flags & JV_PRINT_ASCII, F, S);
       jv_free(key);
@@ -215,7 +214,7 @@ static void jv_dump_term(struct dtoa_context* C, jv x, int flags, int indent, FI
       put_str((flags & JV_PRINT_PRETTY) ? ": " : ":", F, S);
       if (colour) put_str(COLRESET, F, S);
       
-      jv_dump_term(C, jv_object_iter_value(x, i), flags, indent + INDENT, F, S);
+      jv_dump_term(C, value, flags, indent + INDENT, F, S);
       if (colour) put_str(colour, F, S);
     }
     if (flags & JV_PRINT_PRETTY) {