Jet zlib decompression library

pkg/noun/BUILD.bazel

@@ -40,6 +40,7 @@ vere_library(
         "@sigsegv",
         "@softfloat",
         "@urcrypt",
+        "@zlib",
     ] + select({
         "@platforms//os:macos": ["//pkg/noun/platform/darwin"],
         "@platforms//os:linux": ["//pkg/noun/platform/linux"],

pkg/noun/jets/e/crc32.c

@@ -0,0 +1,59 @@
+/// @file
+
+#include <stdio.h>
+#include <allocate.h>
+#include "zlib.h"
+
+#include "jets/w.h"
+
+#include "noun.h"
+
+u3_noun
+u3qe_crc32(u3_noun input_octs)
+{
+  u3_atom head = u3h(input_octs);
+  u3_atom tail = u3t(input_octs);
+  c3_w  tel_w = u3r_met(3, tail);
+  c3_w hed_w;
+  if ( c3n == u3r_safe_word(head, &hed_w) ) {
+    return u3m_bail(c3__fail);
+  }
+  c3_y* input;
+
+  if (c3y == u3a_is_cat(tail)) {
+    input = &tail;
+  }
+  else {
+    u3a_atom* vat_u = u3a_to_ptr(tail);
+    input = (c3_y*)vat_u->buf_w;
+  }
+
+  if ( tel_w > hed_w ) {
+    return u3m_error("subtract-underflow");
+  }
+
+  c3_w led_w = hed_w - tel_w;
+  c3_w crc_w = 0;
+
+  crc_w = crc32(crc_w, input, tel_w);
+
+  while ( led_w > 0 ) {
+    c3_y byt_y = 0;
+    crc_w = crc32(crc_w, &byt_y, 1);
+    led_w--;
+  }
+
+  return u3i_word(crc_w);
+}
+
+u3_noun
+u3we_crc32(u3_noun cor)
+{
+  u3_noun a = u3r_at(u3x_sam, cor);
+
+  if ( (u3du(a) == c3y) && (u3ud(u3h(a)) == c3y) && (u3ud(u3t(a)) == c3y) ) {
+    return u3qe_crc32(a);
+  } else {
+    return u3m_bail(c3__exit);
+  }
+}

pkg/noun/jets/e/zlib.c

@@ -0,0 +1,225 @@
+/// @file
+
+#include <allocate.h>
+#include <stdio.h>
+#include "zlib.h"
+
+#include "jets/q.h"
+#include "jets/w.h"
+
+#include "noun.h"
+
+static void*
+zlib_malloc(voidpf opaque, uInt items, uInt size)
+{
+  size_t len = items * size;
+  void* result = u3a_malloc(len);
+  return result;
+}
+
+static void
+zlib_free(voidpf opaque, voidpf address)
+{
+  u3a_free(address);
+}
+
+u3_noun
+_decompress(u3_atom pos, u3_noun octs, int window_bits)
+{
+  u3_atom p_octs = u3h(octs);
+  u3_atom q_octs = u3t(octs);
+
+  c3_w p_octs_w, pos_w;
+
+  if ( c3n == u3r_safe_word(p_octs, &p_octs_w) ) {
+    return u3_none;
+  }
+  if (c3n == u3r_safe_word(pos, &pos_w)) {
+    return u3_none;
+  }
+
+  c3_w len_w = u3r_met(3, q_octs);
+
+  int leading_zeros = 0;
+
+  if (p_octs_w > len_w) {
+    leading_zeros = p_octs_w - len_w;
+  }
+  else {
+    len_w = p_octs_w;
+  }
+
+  // Bytestream exhausted
+  //
+  if (pos_w >= len_w) {
+    return u3_none;
+  }
+
+  c3_y* input;
+
+  if (c3y == u3a_is_cat(q_octs)) {
+    input = (c3_y*)&q_octs + pos_w;
+  }
+  else {
+    u3a_atom* vat_u = u3a_to_ptr(q_octs);
+    input = (c3_y*)vat_u->buf_w + pos_w;
+  }
+
+  int ret;
+  z_stream strm;
+
+  if (pos_w < len_w) {
+    strm.avail_in = (len_w - pos_w);
+  }
+  else {
+    strm.avail_in = 0;
+  }
+
+  strm.zalloc = zlib_malloc;
+  strm.zfree = zlib_free;
+  strm.opaque = Z_NULL;
+  strm.next_in = input;
+
+  ret = inflateInit2(&strm, window_bits);
+
+  if (ret != Z_OK) {
+    u3l_log("%i", ret);
+    u3l_log("%s", strm.msg);
+    return u3m_bail(c3__exit);
+  }
+
+  c3_w chunk_w = len_w / 10;
+  u3i_slab sab_u;
+
+#define INIT_SZ 16384
+  strm.avail_out = INIT_SZ;
+  u3i_slab_init(&sab_u, 3, INIT_SZ);
+  strm.next_out = sab_u.buf_y;
+
+  void* this_address = strm.next_out;
+
+#define ZEROS_SZ 256
+  c3_y zeros[ZEROS_SZ];
+
+  if (leading_zeros) {
+    memset(zeros, 0, ZEROS_SZ);
+  }
+
+  while ((ret = inflate(&strm, Z_FINISH)) == Z_BUF_ERROR) {
+
+    // Output exhausted: reallocate
+    //
+    if (strm.avail_out == 0) {
+      strm.avail_out = chunk_w;
+
+      u3i_slab_grow(&sab_u, 3, strm.total_out + chunk_w);
+      strm.next_out = sab_u.buf_y + strm.total_out;
+    }
+
+    // Input exhausted: input leading zeros?
+    //
+    if (strm.avail_in == 0) {
+
+      if (leading_zeros) {
+        // Position in the stream exceeded atom bytes,
+        // but is still below stream length
+        //
+        if (strm.total_in + pos_w >= len_w
+            && strm.total_in + pos_w < p_octs_w) {
+
+          c3_w rem_w = p_octs_w - (strm.total_in + pos_w);
+          strm.next_in = zeros;
+
+          if (rem_w > ZEROS_SZ) {
+            strm.avail_in = ZEROS_SZ;
+          }
+          else {
+            strm.avail_in = rem_w;
+          }
+        }
+        else {
+          u3l_log("%i", ret);
+          u3l_log("%s", strm.msg);
+          inflateEnd(&strm);
+          u3i_slab_free(&sab_u);
+          return u3m_bail(c3__exit);
+        }
+      }
+      else {
+        u3l_log("%i", ret);
+        u3l_log("%s", strm.msg);
+        inflateEnd(&strm);
+        u3i_slab_free(&sab_u);
+        return u3m_bail(c3__exit);
+      }
+    }
+  }
+  if (ret != Z_STREAM_END) {
+    u3l_log("%i", ret);
+    u3l_log("%s", strm.msg);
+    inflateEnd(&strm);
+    u3i_slab_free(&sab_u);
+    return u3m_bail(c3__exit);
+  }
+  ret = inflateEnd(&strm);
+
+  if (ret != Z_OK) {
+    u3l_log("%i", ret);
+    u3l_log("%s", strm.msg);
+    u3i_slab_free(&sab_u);
+    return u3m_bail(c3__exit);
+  }
+
+  u3_noun decompressed_octs = u3nc(strm.total_out, u3i_slab_mint(&sab_u));
+  u3_noun new_pos = pos_w + strm.total_in;
+  u3_noun new_stream = u3nc(u3i_word(new_pos), u3k(octs));
+
+  return u3nc(decompressed_octs, new_stream);
+}
+
+u3_noun
+u3qe_decompress_gzip(u3_atom pos, u3_noun octs)
+{
+  return _decompress(pos, octs, 31);
+}
+u3_noun
+u3qe_decompress_zlib(u3_atom pos, u3_noun octs)
+{
+  return _decompress(pos, octs, 15);
+}
+
+u3_noun
+u3we_decompress_gzip(u3_noun cor)
+{
+  u3_atom pos;
+  u3_noun octs;
+
+  u3_noun a = u3r_at(u3x_sam, cor);
+  u3x_cell(a, &pos, &octs);
+
+  if(_(u3a_is_atom(pos)) && _(u3a_is_cell(octs))) {
+    return u3qe_decompress_gzip(pos, octs);
+  }
+
+  else {
+    return u3m_bail(c3__exit);
+  }
+}
+
+u3_noun
+u3we_decompress_zlib(u3_noun cor)
+{
+  u3_atom pos;
+  u3_noun octs;
+
+  u3_noun a = u3r_at(u3x_sam, cor);
+  u3x_cell(a, &pos, &octs);
+
+  if(_(u3a_is_atom(pos)) && _(u3a_is_cell(octs))) {
+    return u3qe_decompress_zlib(pos, octs);
+  }
+
+  else {
+    return u3m_bail(c3__exit);
+  }
+}

pkg/noun/jets/q.h

@@ -212,6 +212,9 @@
     u3_noun u3qes_gte(u3_atom, u3_atom);
     u3_noun u3qes_gth(u3_atom, u3_atom);
 
+    u3_noun  u3qe_decompress_zlib(u3_atom, u3_noun);
+    u3_noun  u3qe_decompress_gzip(u3_atom, u3_noun);
+
   /** Tier 6.
   **/
     u3_noun u3qf_bull(u3_noun, u3_noun);

pkg/noun/jets/tree.c

@@ -269,7 +269,14 @@ static c3_c* _140_hex_lune_ha[] = {
   "417472f35b885fe6dd0715e78fd0920cb59f68b738aadc9768e73bc5efa0e570",
   0
 };
-
+static u3j_harm _137_hex__crc32_a[] = {{".2", u3we_crc32}, {}};
+static u3j_core _137_hex__crc_d[] = {{"crc32", 7, _137_hex__crc32_a, 0, no_hashes }, {}};
+static u3j_harm _139_hex__decompress_zlib_a[] = {{".2", u3we_decompress_zlib}, {}};
+static u3j_harm _139_hex__decompress_gzip_a[] = {{".2", u3we_decompress_gzip}, {}};
+static u3j_core _139_hex__zlib_d[] = {
+  {"decompress-zlib", 7, _139_hex__decompress_zlib_a, 0, no_hashes },
+  {"decompress-gzip", 7, _139_hex__decompress_gzip_a, 0, no_hashes },
+  {}};
 static u3j_harm _140_hex_coed__ed_puck_a[] = {{".2", u3wee_puck}, {}};
 static c3_c* _140_hex_coed__ed_puck_ha[] = {
   "1bc694675842345c50b0e20a2193bb5bcbb42f163fc832431a3d1822a81e4c98",
@@ -2346,6 +2353,9 @@ static u3j_core _138_hex_d[] =
   { "leer",  63, _140_hex_leer_a, 0, no_hashes },
   { "loss",  63, _140_hex_loss_a, 0, no_hashes },
   { "lune", 127, _140_hex_lune_a, 0, no_hashes },
+  // XX move me to 137 when it exists
+  { "crc", 31, 0, _137_hex__crc_d, no_hashes },
+  { "zlib", 31, 0, _139_hex__zlib_d, no_hashes },
 
   { "coed", 63, 0, _140_hex_coed_d, no_hashes },
   { "aes",  31, 0, _140_hex_aes_d,  no_hashes },
@@ -2621,6 +2631,7 @@ static u3j_core _d[] =
 { { "k140", 0, 0, _k140_d, _k140_ha,  0, (u3j_core*) 140,     0 },
   { "k139", 0, 0, _k139_d, no_hashes, 0, (u3j_core*) 139,     0 },
   { "k138", 0, 0, _k138_d, no_hashes, 0, (u3j_core*) 138,     0 },
+  { "k137", 0, 0, _k138_d, no_hashes, 0, (u3j_core*) 137,     0 },
   { "a50",  0, 0, _a50_d,  _k140_ha,  0, (u3j_core*) c3__a50, 0 },
   {}
 };

pkg/noun/jets/w.h

@@ -291,6 +291,10 @@
     u3_noun u3wes_gte(u3_noun);
     u3_noun u3wes_gth(u3_noun);
 
+    u3_noun u3we_crc32(u3_noun);
+    u3_noun u3we_decompress_zlib(u3_noun);
+    u3_noun u3we_decompress_gzip(u3_noun);
+
   /** Tier 6.
   **/
     u3_noun u3wf_bull(u3_noun);

pkg/vere/dawn.c

@@ -41,24 +41,6 @@ _dawn_buf_to_oct(uv_buf_t buf_u)
   return u3nc(len, u3i_bytes(buf_u.len, (const c3_y*)buf_u.base));
 }
 
-
-/* _dawn_curl_alloc(): allocate a response buffer for curl
-*/
-static size_t
-_dawn_curl_alloc(void* dat_v, size_t uni_t, size_t mem_t, void* buf_v)
-{
-  uv_buf_t* buf_u = buf_v;
-
-  size_t siz_t = uni_t * mem_t;
-  buf_u->base = c3_realloc(buf_u->base, 1 + siz_t + buf_u->len);
-
-  memcpy(buf_u->base + buf_u->len, dat_v, siz_t);
-  buf_u->len += siz_t;
-  buf_u->base[buf_u->len] = 0;
-
-  return siz_t;
-}
-
 /* _dawn_post_json(): POST JSON to url_c
 */
 static uv_buf_t
@@ -84,7 +66,7 @@ _dawn_post_json(c3_c* url_c, uv_buf_t lod_u)
   //
   u3K.ssl_curl_f(curl);
   curl_easy_setopt(curl, CURLOPT_URL, url_c);
-  curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, _dawn_curl_alloc);
+  curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, king_curl_alloc);
   curl_easy_setopt(curl, CURLOPT_WRITEDATA, (void*)&buf_u);
   curl_easy_setopt(curl, CURLOPT_HTTPHEADER, hed_u);
 
@@ -131,7 +113,7 @@ _dawn_get_jam(c3_c* url_c)
   //
   u3K.ssl_curl_f(curl);
   curl_easy_setopt(curl, CURLOPT_URL, url_c);
-  curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, _dawn_curl_alloc);
+  curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, king_curl_alloc);
   curl_easy_setopt(curl, CURLOPT_WRITEDATA, (void*)&buf_u);
 
   result = curl_easy_perform(curl);