From daa4dc223b14e8a73fbf21607e56fae854a2a9cc Mon Sep 17 00:00:00 2001
From: Kaz Kylheku <kaz@kylheku.com>
Date: Wed, 13 Feb 2019 06:27:33 -0800
Subject: Framework for iterating over sequences.

This has been needed for a while. While we have seq_info for
classifying sequences to nicely dispatch code into various
cases, those cases duplicate code. The code base could benefit
from generic traversal.

* lib.c (seq_iter_get_nil, seq_iter_get_list,
seq_iter_get_vec, set_iter_get_hash): New static functions.
(seq_iter_rewind, seq_iter_init): New functions.

* lib.h (struct seq_iter, seq_iter_t): New struct type and its
typedef name.
(seq_iter_init, seq_iter_rewind): Declared.
(seq_get): New inline function.
---
 lib.c | 79 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 lib.h | 15 +++++++++++++
 2 files changed, 94 insertions(+)

diff --git a/lib.c b/lib.c
index 5da925e9..e837939b 100644
--- a/lib.c
+++ b/lib.c
@@ -323,6 +323,85 @@ static void noreturn unsup_obj(val self, val obj)
   abort();
 }
 
+static int seq_iter_get_nil(seq_iter_t *it, val *pval)
+{
+  return 0;
+}
+
+static int seq_iter_get_list(seq_iter_t *it, val *pval)
+{
+  if (!it->ui.iter)
+    return 0;
+  *pval = car(it->ui.iter);
+  it->ui.iter = cdr(it->ui.iter);
+  return 1;
+}
+
+static int seq_iter_get_vec(seq_iter_t *it, val *pval)
+{
+  if (it->ui.index < it->ul.len) {
+    *pval = ref(it->inf.obj, num(it->ui.index++));
+    return 1;
+  }
+  return 0;
+}
+
+static int seq_iter_get_hash(seq_iter_t *it, val *pval)
+{
+  *pval = hash_next(it->ui.iter);
+  return *pval != nil;
+}
+
+void seq_iter_rewind(val self, seq_iter_t *it)
+{
+  switch (it->inf.kind) {
+  case SEQ_NIL:
+    it->ui.iter = nil;
+    break;
+  case SEQ_LISTLIKE:
+    it->ui.iter = it->inf.obj;
+    break;
+  case SEQ_VECLIKE:
+    it->ui.index = 0;
+    break;
+  case SEQ_HASHLIKE:
+    it->ui.iter = hash_begin(it->inf.obj);
+    break;
+  default:
+    break;
+  }
+}
+
+void seq_iter_init(val self, seq_iter_t *it, val obj)
+{
+  it->inf = seq_info(obj);
+
+  switch (it->inf.kind) {
+  case SEQ_NIL:
+    it->ui.iter = nil;
+    it->ul.len = 0;
+    it->get = seq_iter_get_nil;
+    break;
+  case SEQ_LISTLIKE:
+    it->ui.iter = it->inf.obj;
+    it->ul.len = 0;
+    it->get = seq_iter_get_list;
+    break;
+  case SEQ_VECLIKE:
+    it->ui.index = 0;
+    it->ul.len = c_num(length(it->inf.obj));
+    it->get = seq_iter_get_vec;
+    break;
+  case SEQ_HASHLIKE:
+    it->ui.iter = hash_begin(it->inf.obj);
+    it->ul.len = 0;
+    it->get = seq_iter_get_hash;
+    break;
+  default:
+    unsup_obj(self, obj);
+  }
+}
+
 val throw_mismatch(val self, val obj, type_t t)
 {
   type_mismatch(lit("~a: ~s is not of type ~s"), self, obj, code2type(t), nao);
diff --git a/lib.h b/lib.h
index aab0083d..6d706b3d 100644
--- a/lib.h
+++ b/lib.h
@@ -369,6 +369,18 @@ typedef struct seq_info {
   seq_kind_t kind;
 } seq_info_t;
 
+typedef struct seq_iter {
+  seq_info_t inf;
+  union {
+    val iter;
+    cnum index;
+  } ui;
+  union {
+    cnum len;
+  } ul;
+  int (*get)(struct seq_iter *, val *pval);
+} seq_iter_t;
+
 extern const seq_kind_t seq_kind_tab[MAXTYPE+1];
 
 #define SEQ_KIND_PAIR(A, B) ((A) << 3 | (B))
@@ -517,6 +529,9 @@ val typeof(val obj);
 val subtypep(val sub, val sup);
 val typep(val obj, val type);
 seq_info_t seq_info(val cobj);
+void seq_iter_init(val self, seq_iter_t *it, val obj);
+void seq_iter_rewind(val self, seq_iter_t *it);
+INLINE int seq_get(seq_iter_t *it, val *pval) { return it->get(it, pval); }
 val throw_mismatch(val self, val obj, type_t);
 INLINE val type_check(val self, val obj, type_t typecode)
 {
-- 
cgit v1.2.3