claude is gud

1 files changed, 258 insertions, 0 deletions

diff --git a/vere/pkg/noun/jets/e/json_de.c b/vere/pkg/noun/jets/e/json_de.c
new file mode 100644
index 0000000..e54393a
--- /dev/null
+++ b/vere/pkg/noun/jets/e/json_de.c
@@ -0,0 +1,258 @@
+/// @file
+
+#include "jets/k.h"
+#include "jets/q.h"
+#include "jets/w.h"
+
+#include "noun.h"
+
+#include "pdjson.h"
+
+/*
+** custom code for interfacing with external parser:
+** https://github.com/skeeto/pdjson
+*/
+
+typedef struct _u3qedj_coll {
+  u3_noun col;        // collection (list for array, map for object)
+  union {             // store context for recursive arrays/objects:
+    u3_noun* tel;     //   - pointer to tail for array
+    u3_atom  key;     //   - key for object
+  };
+} u3qedj_coll;
+
+static u3qedj_coll*
+_push_stack(const u3a_pile *pil_u)
+{
+  u3qedj_coll *res_u = u3a_push(pil_u);
+  u3a_pile_done(pil_u);
+
+  res_u->col = u3_nul;
+  res_u->key = u3_none;
+
+  return res_u;
+}
+
+static u3qedj_coll*
+_pop_stack(const u3a_pile *pil_u)
+{
+  return u3a_pop(pil_u);
+}
+
+static void
+_close_stack(const u3a_pile *pil_u)
+{
+  while ( c3n == u3a_pile_done(pil_u) ) {
+    u3qedj_coll *tak_u = u3a_peek(pil_u);
+
+    u3z(tak_u->col);
+    if ( u3_none != tak_u->key ) {
+      u3z(tak_u->key);
+    }
+
+    u3a_drop(pil_u);
+  }
+}
+
+static void
+_close_on_error(json_stream *sam_u, const u3a_pile *pil_u)
+{
+  _close_stack(pil_u);
+  json_close(sam_u);
+}
+
+static u3_atom
+_json_get_string_as_atom(json_stream *sam_u) {
+  // length returned by json_get_string includes the trailing null byte
+  // it's possible for json_get_string to return a length of 0, but only if:
+  //    - it's called directly after init
+  //    - it's called directly after init_string
+  size_t      len_i;
+  const c3_c *str_c = json_get_string(sam_u, &len_i);
+  return (len_i <= 1) ?
+          u3_nul :
+          u3i_bytes(len_i - 1, (const c3_y *)str_c);
+}
+
+static u3_noun
+_parse(u3_atom txt)
+{
+  //
+  // vars
+  //
+
+  u3qedj_coll *tak_u;
+
+  json_allocator loc_u = {u3a_malloc, u3a_realloc, u3a_free};
+  json_stream    sem_u;
+  json_stream*   sam_u = &sem_u;
+
+  u3a_pile  pel_u;
+  u3a_pile *pil_u = &pel_u;
+
+  u3_noun res = u3_none;
+  u3_noun val;
+
+  const c3_y *byt_y;
+  c3_z        cnt_z;
+  c3_w        len_w = u3r_met(3, txt);
+
+  //
+  // initialization
+  //
+
+  // XX assumes little-endian
+  //
+  if ( c3y == u3a_is_cat(txt) ) {
+    byt_y = (c3_y*)&txt;
+  }
+  else {
+    u3a_atom* vat_u = u3a_to_ptr(txt);
+    byt_y = (c3_y*)vat_u->buf_w;
+  }
+  json_open_buffer(sam_u, byt_y, len_w);
+  json_set_allocator(sam_u, &loc_u);
+  u3a_pile_prep(pil_u, sizeof(u3qedj_coll));
+
+  //
+  // core logic
+  //
+
+  while ( json_peek(sam_u) != JSON_DONE ) {
+    switch ( json_next(sam_u) ) {
+      // unreachable barring programming error
+      default: u3_assert(0);
+
+      case JSON_ARRAY:
+      case JSON_OBJECT: {
+        tak_u = _push_stack(pil_u);
+      } continue;
+
+      case JSON_ARRAY_END: {
+        val = u3nc(c3__a, tak_u->col);
+        tak_u = _pop_stack(pil_u);
+      } break;
+
+      case JSON_OBJECT_END: {
+        val = u3nc(c3__o, tak_u->col);
+        tak_u = _pop_stack(pil_u);
+      } break;
+
+      case JSON_STRING: {
+        if ( (json_get_context(sam_u, &cnt_z) == JSON_OBJECT) && (cnt_z & 1) ) {
+          // since object key must be followed by value, skip ahead
+          tak_u->key = _json_get_string_as_atom(sam_u);
+          continue;
+        }
+        else {
+          val = u3nc(c3__s, _json_get_string_as_atom(sam_u));
+          break;
+        }
+      }
+
+      case JSON_NUMBER: {
+        // read number from string in the JSON reparser
+        val = u3nc(c3__n, _json_get_string_as_atom(sam_u));
+      } break;
+
+      case JSON_TRUE: {
+        val = u3nc(c3__b, c3y);
+      } break;
+
+      case JSON_FALSE: {
+        val = u3nc(c3__b, c3n);
+      } break;
+
+      case JSON_NULL: {
+        val = u3_nul;
+      } break;
+
+      case JSON_ERROR: {
+        _close_on_error(sam_u, pil_u);
+        return u3_nul;
+      } break;
+    }
+
+    switch ( json_get_context(sam_u, &cnt_z) ) {
+      // unreachable barring programming error
+      default: u3_assert(0);
+
+      case JSON_DONE: {
+        res = val;
+      } break;
+
+      case JSON_ARRAY: {
+        u3_noun* nex;
+        u3_noun* hed;
+
+        if ( tak_u->col == u3_nul ) {
+          nex = &(tak_u->col);
+        }
+        else {
+          nex = tak_u->tel;
+        }
+
+        *nex = u3i_defcons(&hed, &(tak_u->tel));
+        *hed = val;
+        *(tak_u->tel) = u3_nul;
+      } break;
+
+      case JSON_OBJECT: {
+        // odd cnt_z and unset key weeded out by continue command on key
+        u3_assert(!(cnt_z & 1));
+        u3_assert(tak_u->key != u3_none);
+        // cnt_z == 0 weeded out by continue command on array/object open
+        u3_assert(cnt_z);
+
+        tak_u->col = u3kdb_put(tak_u->col, tak_u->key, val);
+        tak_u->key = u3_none;
+      } break;
+    }
+  }
+
+  //
+  // clean up
+  //
+
+  u3_assert(c3y == u3a_pile_done(pil_u));
+
+  // skip over whitespce
+  while ( json_isspace(json_source_peek(sam_u)) ) {
+    json_source_get(sam_u);
+  }
+
+  json_close(sam_u);
+
+  // return null if trailing trash/multiple JSON objects
+  if ( json_get_position(sam_u) != len_w ) {
+    u3z(res);
+    return u3_nul;
+  }
+  else {
+    return u3nc(u3_nul, res);
+  }
+}
+
+/*
+** jet interface functions
+*/
+
+u3_noun
+u3qe_json_de(u3_atom a)
+{
+  return _parse(a);
+}
+
+u3_noun
+u3ke_json_de(u3_atom a)
+{
+  u3_noun res = u3qe_json_de(a);
+  u3z(a);
+  return res;
+}
+
+u3_noun
+u3we_json_de(u3_noun cor)
+{
+  return u3qe_json_de(u3x_atom(u3x_at(u3x_sam, cor)));
+}