inline-method

zlib.c
View Options

			#include <compat.h>

			#include <stdlib.h>
			#include <string.h>
			#include <zlib.h>

			#include "ant.h"
			#include "ptr.h"
			#include "errors.h"
			#include "internal.h"

			#include "silver/engine.h"
			#include "streams/brotli.h"
			#include "modules/buffer.h"
			#include "modules/events.h"
			#include "modules/symbol.h"
			#include "modules/zlib.h"

			#define ZLIB_CHUNK 16384
			#define ZLIB_STREAM_TAG 0x5A4C4942u

			typedef enum {
			ZLIB_KIND_GZIP,
			ZLIB_KIND_GUNZIP,
			ZLIB_KIND_DEFLATE,
			ZLIB_KIND_INFLATE,
			ZLIB_KIND_DEFLATE_RAW,
			ZLIB_KIND_INFLATE_RAW,
			ZLIB_KIND_UNZIP,
			ZLIB_KIND_BROTLI_COMPRESS,
			ZLIB_KIND_BROTLI_DECOMPRESS,
			} zlib_kind_t;

			typedef struct zlib_stream_s {
			z_stream strm;
			brotli_stream_state_t *brotli;
			ant_value_t obj;
			ant_t *js;
			zlib_kind_t kind;
			uint32_t bytes_written;
			bool initialized;
			bool ended;
			bool destroyed;
			struct zlib_stream_s *next_active;
			} zlib_stream_t;

			static ant_value_t g_transform_proto = 0;
			static zlib_stream_t *g_active_streams = NULL;

			static bool zlib_kind_is_compress(zlib_kind_t k) {
			return
			k == ZLIB_KIND_GZIP
			\|\| k == ZLIB_KIND_DEFLATE
			\|\| k == ZLIB_KIND_DEFLATE_RAW
			\|\| k == ZLIB_KIND_BROTLI_COMPRESS;
			}

			static int zlib_window_bits(zlib_kind_t k) {
			switch (k) {
			case ZLIB_KIND_GZIP: return 15 + 16;
			case ZLIB_KIND_GUNZIP: return 15 + 32;
			case ZLIB_KIND_UNZIP: return 15 + 32;
			case ZLIB_KIND_DEFLATE: return 15;
			case ZLIB_KIND_INFLATE: return 15;
			case ZLIB_KIND_DEFLATE_RAW: return -15;
			case ZLIB_KIND_INFLATE_RAW: return -15;
			default: return 15;
			}
			}

			static ant_value_t pick_callback(ant_value_t *args, int nargs) {
			if (nargs > 2 && is_callable(args[2])) return args[2];
			if (nargs > 1 && is_callable(args[1])) return args[1];
			return js_mkundef();
			}

			static zlib_stream_t *zlib_stream_ptr(ant_value_t obj) {
			if (!js_check_native_tag(obj, ZLIB_STREAM_TAG)) return NULL;
			return (zlib_stream_t *)js_get_native_ptr(obj);
			}

			static void zlib_add_active(zlib_stream_t *st) {
			st->next_active = g_active_streams;
			g_active_streams = st;
			}

			static void zlib_remove_active(zlib_stream_t *st) {
			zlib_stream_t **it;
			for (it = &g_active_streams; it; it = &(it)->next_active) {
			if (*it == st) {
			*it = st->next_active;
			st->next_active = NULL;
			return;
			}}
			}

			static void zlib_stream_release(zlib_stream_t *st) {
			if (!st) return;
			if (st->brotli) {
			brotli_stream_state_destroy(st->brotli);
			st->brotli = NULL;
			} else if (st->initialized) {
			if (zlib_kind_is_compress(st->kind)) deflateEnd(&st->strm);
			else inflateEnd(&st->strm);
			st->initialized = false;
			}
			}

			static ant_value_t zlib_make_buffer(ant_t js, const uint8_t data, size_t len) {
			ArrayBufferData *ab = create_array_buffer_data(len);
			if (!ab) return js_mkerr(js, "out of memory");
			if (data && len > 0) memcpy(ab->data, data, len);
			return create_typed_array(js, TYPED_ARRAY_UINT8, ab, 0, len, "Buffer");
			}

			static void zlib_emit_data(ant_t js, ant_value_t obj, const uint8_t data, size_t len) {
			ant_value_t buf = zlib_make_buffer(js, data, len);
			if (!is_err(buf)) eventemitter_emit_args(js, obj, "data", &buf, 1);
			}

			typedef struct { ant_t *js; ant_value_t obj; } brotli_emit_ctx_t;
			typedef struct { ant_t *js; ant_value_t arr; bool error; } brotli_collect_ctx_t;

			static int brotli_emit_cb(void ctx, const uint8_t chunk, size_t len) {
			brotli_emit_ctx_t ec = (brotli_emit_ctx_t )ctx;
			zlib_emit_data(ec->js, ec->obj, chunk, len);
			return 0;
			}

			static int brotli_collect_cb(void ctx, const uint8_t chunk, size_t len) {
			brotli_collect_ctx_t ec = (brotli_collect_ctx_t )ctx;
			ant_value_t buf = zlib_make_buffer(ec->js, chunk, len);
			if (is_err(buf)) { ec->error = true; return -1; }
			js_arr_push(ec->js, ec->arr, buf);
			return 0;
			}

			static ant_value_t zlib_do_process(
			ant_t js, zlib_stream_t st,
			const uint8_t *input, size_t input_len,
			bool finish
			) {
			if (st->destroyed \|\| st->ended) return js_mkundef();

			if (st->brotli) {
			brotli_emit_ctx_t ctx = { js, st->obj };
			int rc;
			if (finish) {
			rc = brotli_stream_finish(st->brotli, brotli_emit_cb, &ctx);
			} else {
			rc = brotli_stream_process(st->brotli, input, input_len, brotli_emit_cb, &ctx);
			}
			if (rc < 0) return js_mkerr(js, "brotli operation failed");
			return js_mkundef();
			}

			bool compress = zlib_kind_is_compress(st->kind);
			int flush = finish ? Z_FINISH : Z_NO_FLUSH;
			uint8_t out[ZLIB_CHUNK];

			if (!finish) {
			st->strm.next_in = (Bytef *)input;
			st->strm.avail_in = (uInt)input_len;
			} else {
			st->strm.next_in = NULL;
			st->strm.avail_in = 0;
			}

			int ret;
			do {
			st->strm.next_out = out;
			st->strm.avail_out = ZLIB_CHUNK;

			if (compress) {
			ret = deflate(&st->strm, flush);
			if (ret == Z_STREAM_ERROR) return js_mkerr(js, "zlib deflate error");
			} else {
			ret = inflate(&st->strm, flush == Z_FINISH ? Z_SYNC_FLUSH : flush);
			if (ret == Z_NEED_DICT \|\| ret == Z_DATA_ERROR \|\| ret == Z_MEM_ERROR)
			return js_mkerr(js, "zlib inflate error");
			}

			size_t have = ZLIB_CHUNK - st->strm.avail_out;
			if (have > 0) zlib_emit_data(js, st->obj, out, have);
			if (ret == Z_STREAM_END) break;
			} while (st->strm.avail_out == 0);

			return js_mkundef();
			}

			static ant_value_t zlib_process_chunk_sync(
			ant_t js, zlib_stream_t st,
			const uint8_t *input, size_t input_len,
			int flush_flag
			) {
			ant_value_t arr = js_mkarr(js);

			if (st->brotli) {
			brotli_collect_ctx_t ctx = { js, arr, false };
			int rc = 0;
			if (input && input_len > 0)
			rc = brotli_stream_process(st->brotli, input, input_len, brotli_collect_cb, &ctx);
			if (rc >= 0 && flush_flag == Z_FINISH)
			rc = brotli_stream_finish(st->brotli, brotli_collect_cb, &ctx);
			if (rc < 0 \|\| ctx.error) return js_mkerr(js, "brotli operation failed");
			return arr;
			}

			bool compress = zlib_kind_is_compress(st->kind);
			uint8_t out[ZLIB_CHUNK];

			st->strm.next_in = input ? (Bytef *)input : NULL;
			st->strm.avail_in = input ? (uInt)input_len : 0;

			int ret;
			do {
			st->strm.next_out = out;
			st->strm.avail_out = ZLIB_CHUNK;

			if (compress) {
			ret = deflate(&st->strm, flush_flag);
			if (ret == Z_STREAM_ERROR) return js_mkerr(js, "zlib deflate error");
			} else {
			ret = inflate(&st->strm, flush_flag);
			if (ret == Z_NEED_DICT \|\| ret == Z_DATA_ERROR \|\| ret == Z_MEM_ERROR)
			return js_mkerr(js, "zlib inflate error");
			}

			size_t have = ZLIB_CHUNK - st->strm.avail_out;
			if (have > 0) {
			ant_value_t buf = zlib_make_buffer(js, out, have);
			if (is_err(buf)) return buf;
			js_arr_push(js, arr, buf);
			}
			if (ret == Z_STREAM_END) break;
			} while (st->strm.avail_out == 0);

			return arr;
			}

			static ant_value_t js_zlib_process_chunk(ant_t js, ant_value_t args, int nargs) {
			zlib_stream_t *st = zlib_stream_ptr(js_getthis(js));
			if (!st) return js_mkerr_typed(js, JS_ERR_TYPE, "Invalid zlib stream");
			if (st->destroyed \|\| st->ended) return js_mkarr(js);

			const uint8_t *input = NULL;
			size_t input_len = 0;
			if (nargs >= 1 && is_object_type(args[0]))
			buffer_source_get_bytes(js, args[0], &input, &input_len);

			int flush_flag = Z_NO_FLUSH;
			if (nargs >= 2 && vtype(args[1]) == T_NUM)
			flush_flag = (int)js_getnum(args[1]);

			return zlib_process_chunk_sync(js, st, input, input_len, flush_flag);
			}

			static ant_value_t js_zlib_write(ant_t js, ant_value_t args, int nargs) {
			zlib_stream_t *st = zlib_stream_ptr(js_getthis(js));
			if (!st) return js_mkerr_typed(js, JS_ERR_TYPE, "Invalid zlib stream");
			if (st->destroyed) return js_false;
			if (st->ended) return js_false;

			if (nargs < 1 \|\| vtype(args[0]) == T_UNDEF \|\| vtype(args[0]) == T_NULL)
			return js_true;

			const uint8_t *bytes = NULL;
			size_t len = 0;

			if (is_object_type(args[0])) {
			buffer_source_get_bytes(js, args[0], &bytes, &len);
			}

			if (!bytes) {
			size_t slen = 0;
			char *s = js_getstr(js, args[0], &slen);
			if (s) { bytes = (const uint8_t *)s; len = slen; }
			}

			if (!bytes \|\| len == 0) return js_true;
			st->bytes_written += (uint32_t)len;

			ant_value_t r = zlib_do_process(js, st, bytes, len, false);
			if (is_err(r)) {
			eventemitter_emit_args(js, st->obj, "error", &r, 1);
			return js_false;
			}

			ant_value_t cb = pick_callback(args, nargs);
			if (is_callable(cb)) {
			ant_value_t null_val = js_mknull();
			sv_vm_call(js->vm, js, cb, js_mkundef(), &null_val, 1, NULL, false);
			}

			return js_true;
			}

			static ant_value_t js_zlib_end(ant_t js, ant_value_t args, int nargs) {
			zlib_stream_t *st = zlib_stream_ptr(js_getthis(js));
			ant_value_t self = js_getthis(js);

			if (!st) return js_mkerr_typed(js, JS_ERR_TYPE, "Invalid zlib stream");
			if (st->destroyed \|\| st->ended) return self;

			if (nargs > 0 && vtype(args[0]) != T_UNDEF && vtype(args[0]) != T_NULL) {
			ant_value_t write_args[1] = { args[0] };
			js_zlib_write(js, write_args, 1);
			}

			st->ended = true;
			ant_value_t r = zlib_do_process(js, st, NULL, 0, true);

			if (is_err(r)) {
			eventemitter_emit_args(js, st->obj, "error", &r, 1);
			return self;
			}

			eventemitter_emit_args(js, st->obj, "end", NULL, 0);
			eventemitter_emit_args(js, st->obj, "finish", NULL, 0);
			eventemitter_emit_args(js, st->obj, "close", NULL, 0);

			ant_value_t cb = pick_callback(args, nargs);
			if (is_callable(cb))
			sv_vm_call(js->vm, js, cb, js_mkundef(), NULL, 0, NULL, false);

			return self;
			}

			static ant_value_t js_zlib_destroy(ant_t js, ant_value_t args, int nargs) {
			zlib_stream_t *st = zlib_stream_ptr(js_getthis(js));
			ant_value_t self = js_getthis(js);

			if (!st \|\| st->destroyed) return self;
			st->destroyed = true;
			zlib_stream_release(st);

			if (nargs > 0 && !js_truthy(js, args[0])) {
			ant_value_t null_val = js_mknull();
			eventemitter_emit_args(js, st->obj, "error", &null_val, 1);
			}

			eventemitter_emit_args(js, st->obj, "close", NULL, 0);
			return self;
			}

			static ant_value_t js_zlib_pause(ant_t js, ant_value_t args, int nargs) {
			return js_getthis(js);
			}

			static ant_value_t js_zlib_resume(ant_t js, ant_value_t args, int nargs) {
			return js_getthis(js);
			}

			static ant_value_t js_zlib_unpipe(ant_t js, ant_value_t args, int nargs) {
			return js_getthis(js);
			}

			static ant_value_t pipe_on_data(ant_t js, ant_value_t args, int nargs) {
			ant_value_t fn = js_getcurrentfunc(js);
			ant_value_t dest = js_get_slot(fn, SLOT_DATA);
			ant_value_t write_fn = js_get(js, dest, "write");

			if (is_callable(write_fn) && nargs > 0)
			sv_vm_call(js->vm, js, write_fn, dest, args, 1, NULL, false);

			return js_mkundef();
			}

			static ant_value_t pipe_on_end(ant_t js, ant_value_t args, int nargs) {
			ant_value_t fn = js_getcurrentfunc(js);
			ant_value_t dest = js_get_slot(fn, SLOT_DATA);
			ant_value_t end_fn = js_get(js, dest, "end");

			if (is_callable(end_fn))
			sv_vm_call(js->vm, js, end_fn, dest, NULL, 0, NULL, false);

			return js_mkundef();
			}

			static ant_value_t js_zlib_pipe(ant_t js, ant_value_t args, int nargs) {
			if (nargs < 1 \|\| !is_object_type(args[0])) return js_mkundef();
			ant_value_t self = js_getthis(js);
			ant_value_t dest = args[0];

			ant_value_t data_handler = js_heavy_mkfun(js, pipe_on_data, dest);
			ant_value_t end_handler = js_heavy_mkfun(js, pipe_on_end, dest);

			eventemitter_add_listener(js, self, "data", data_handler, false);
			eventemitter_add_listener(js, self, "end", end_handler, true);

			return dest;
			}

			static ant_value_t js_zlib_get_bytes_written(ant_t js, ant_value_t args, int nargs) {
			zlib_stream_t *st = zlib_stream_ptr(js_getthis(js));
			if (!st) return js_mknum(0);
			return js_mknum((double)st->bytes_written);
			}

			static ant_value_t zlib_create_stream(ant_t *js, zlib_kind_t kind) {
			bool compress = zlib_kind_is_compress(kind);

			zlib_stream_t *st = calloc(1, sizeof(zlib_stream_t));
			if (!st) return js_mkerr(js, "out of memory");

			st->kind = kind;
			st->js = js;

			if (kind == ZLIB_KIND_BROTLI_COMPRESS \|\| kind == ZLIB_KIND_BROTLI_DECOMPRESS) {
			st->brotli = brotli_stream_state_new(kind == ZLIB_KIND_BROTLI_DECOMPRESS);
			if (!st->brotli) { free(st); return js_mkerr(js, "brotli init failed"); }
			st->initialized = true;
			} else {
			int wbits = zlib_window_bits(kind);
			int ret;
			if (compress) {
			ret = deflateInit2(&st->strm, Z_DEFAULT_COMPRESSION, Z_DEFLATED, wbits, 8, Z_DEFAULT_STRATEGY);
			} else ret = inflateInit2(&st->strm, wbits);

			if (ret != Z_OK) { free(st); return js_mkerr(js, "zlib init failed"); }
			st->initialized = true;
			}

			ant_value_t obj = js_mkobj(js);
			if (is_object_type(g_transform_proto)) js_set_proto_init(obj, g_transform_proto);

			js_set_native_ptr(obj, st);
			js_set_native_tag(obj, ZLIB_STREAM_TAG);

			js_set(js, obj, "readable", js_true);
			js_set(js, obj, "writable", js_true);
			js_set(js, obj, "_processChunk", js_mkfun(js_zlib_process_chunk));

			ant_value_t handle_obj = js_mkobj(js);
			js_set(js, handle_obj, "close", js_mkfun(js_zlib_destroy));
			js_set(js, obj, "_handle", handle_obj);

			st->obj = obj;
			zlib_add_active(st);
			return obj;
			}

			static ant_value_t js_create_gzip(ant_t js, ant_value_t args, int nargs) {
			return zlib_create_stream(js, ZLIB_KIND_GZIP);
			}

			static ant_value_t js_create_gunzip(ant_t js, ant_value_t args, int nargs) {
			return zlib_create_stream(js, ZLIB_KIND_GUNZIP);
			}

			static ant_value_t js_create_deflate(ant_t js, ant_value_t args, int nargs) {
			return zlib_create_stream(js, ZLIB_KIND_DEFLATE);
			}

			static ant_value_t js_create_inflate(ant_t js, ant_value_t args, int nargs) {
			return zlib_create_stream(js, ZLIB_KIND_INFLATE);
			}

			static ant_value_t js_create_deflate_raw(ant_t js, ant_value_t args, int nargs) {
			return zlib_create_stream(js, ZLIB_KIND_DEFLATE_RAW);
			}

			static ant_value_t js_create_inflate_raw(ant_t js, ant_value_t args, int nargs) {
			return zlib_create_stream(js, ZLIB_KIND_INFLATE_RAW);
			}

			static ant_value_t js_create_unzip(ant_t js, ant_value_t args, int nargs) {
			return zlib_create_stream(js, ZLIB_KIND_UNZIP);
			}

			static ant_value_t js_create_brotli_compress(ant_t js, ant_value_t args, int nargs) {
			return zlib_create_stream(js, ZLIB_KIND_BROTLI_COMPRESS);
			}

			static ant_value_t js_create_brotli_decompress(ant_t js, ant_value_t args, int nargs) {
			return zlib_create_stream(js, ZLIB_KIND_BROTLI_DECOMPRESS);
			}

			typedef struct {
			uint8_t *data;
			size_t len;
			size_t cap;
			int error;
			} zbuf_t;

			static int zbuf_append(zbuf_t b, const uint8_t chunk, size_t n) {
			if (b->len + n > b->cap) {
			size_t newcap = b->cap ? b->cap * 2 : 4096;
			while (newcap < b->len + n) newcap *= 2;
			uint8_t *p = realloc(b->data, newcap);

			if (!p) { b->error = 1; return -1; }
			b->data = p;
			b->cap = newcap;
			}

			memcpy(b->data + b->len, chunk, n);
			b->len += n;

			return 0;
			}

			static int zbuf_brotli_cb(void ctx, const uint8_t chunk, size_t n) {
			return zbuf_append((zbuf_t *)ctx, chunk, n);
			}

			static ant_value_t zlib_sync_op(
			ant_t *js, zlib_kind_t kind,
			const uint8_t *input, size_t input_len
			) {
			zbuf_t out = {0};
			uint8_t tmp[ZLIB_CHUNK];
			bool compress = zlib_kind_is_compress(kind);

			if (kind == ZLIB_KIND_BROTLI_COMPRESS \|\| kind == ZLIB_KIND_BROTLI_DECOMPRESS) {
			brotli_stream_state_t *bs = brotli_stream_state_new(kind == ZLIB_KIND_BROTLI_DECOMPRESS);
			if (!bs) return js_mkerr(js, "brotli init failed");

			int rc = brotli_stream_process(bs, input, input_len, zbuf_brotli_cb, &out);
			if (rc >= 0) rc = brotli_stream_finish(bs, zbuf_brotli_cb, &out);

			brotli_stream_state_destroy(bs);
			if (rc < 0 \|\| out.error) { free(out.data); return js_mkerr(js, "brotli operation failed"); }
			ant_value_t buf = zlib_make_buffer(js, out.data, out.len);
			free(out.data);

			return buf;
			}

			z_stream strm = {0};
			int wbits = zlib_window_bits(kind);
			int ret;

			if (compress) ret = deflateInit2(&strm, Z_DEFAULT_COMPRESSION, Z_DEFLATED, wbits, 8, Z_DEFAULT_STRATEGY);
			else ret = inflateInit2(&strm, wbits);
			if (ret != Z_OK) return js_mkerr(js, "zlib init failed");

			strm.next_in = (Bytef *)input;
			strm.avail_in = (uInt)input_len;

			do {
			strm.next_out = tmp;
			strm.avail_out = ZLIB_CHUNK;
			if (compress) ret = deflate(&strm, Z_FINISH);
			else ret = inflate(&strm, Z_SYNC_FLUSH);
			if (ret == Z_STREAM_ERROR \|\| ret == Z_DATA_ERROR \|\| ret == Z_MEM_ERROR) {
			if (compress) deflateEnd(&strm);
			else inflateEnd(&strm);
			free(out.data);
			return js_mkerr(js, "zlib operation failed");
			}
			size_t have = ZLIB_CHUNK - strm.avail_out;
			if (have > 0 && zbuf_append(&out, tmp, have) < 0) {
			if (compress) deflateEnd(&strm);
			else inflateEnd(&strm);
			free(out.data);
			return js_mkerr(js, "out of memory");
			}
			if (ret == Z_STREAM_END) break;
			} while (strm.avail_out == 0 \|\| strm.avail_in > 0);

			if (compress) deflateEnd(&strm);
			else inflateEnd(&strm);

			ant_value_t buf = zlib_make_buffer(js, out.data, out.len);
			free(out.data);
			return buf;
			}

			static bool get_input_bytes(ant_t js, ant_value_t val, const uint8_t out_bytes, size_t out_len) {
			if (is_object_type(val) && buffer_source_get_bytes(js, val, out_bytes, out_len)) return true;
			size_t slen = 0;
			char *s = js_getstr(js, val, &slen);
			if (s) { out_bytes = (const uint8_t )s; *out_len = slen; return true; }
			return false;
			}

			static ant_value_t zlib_sync_fn(ant_t js, ant_value_t args, int nargs, zlib_kind_t kind) {
			if (nargs < 1) return js_mkerr(js, "argument required");
			const uint8_t *bytes = NULL;
			size_t len = 0;
			if (!get_input_bytes(js, args[0], &bytes, &len))
			return js_mkerr_typed(js, JS_ERR_TYPE, "argument must be a string or Buffer");
			return zlib_sync_op(js, kind, bytes, len);
			}

			static ant_value_t zlib_async_fn(ant_t js, ant_value_t args, int nargs, zlib_kind_t kind) {
			if (nargs < 1) return js_mkerr(js, "argument required");

			const uint8_t *bytes = NULL;
			size_t len = 0;
			ant_value_t cb = pick_callback(args, nargs);

			if (!get_input_bytes(js, args[0], &bytes, &len))
			return js_mkerr_typed(js, JS_ERR_TYPE, "argument must be a string or Buffer");

			ant_value_t result = zlib_sync_op(js, kind, bytes, len);

			if (is_callable(cb)) {
			if (is_err(result)) {
			ant_value_t argv[1] = { result };
			sv_vm_call(js->vm, js, cb, js_mkundef(), argv, 1, NULL, false);
			} else {
			ant_value_t null_val = js_mknull();
			ant_value_t argv[2] = { null_val, result };
			sv_vm_call(js->vm, js, cb, js_mkundef(), argv, 2, NULL, false);
			}
			return js_mkundef();
			}

			return result;
			}

			#define ZLIB_SYNC_FN(name, kind) \
			static ant_value_t js_##name##Sync(ant_t js, ant_value_t a, int n) { return zlib_sync_fn(js, a, n, kind); }

			#define ZLIB_ASYNC_FN(name, kind) \
			static ant_value_t js_##name(ant_t js, ant_value_t a, int n) { return zlib_async_fn(js, a, n, kind); }

			ZLIB_SYNC_FN(gzip, ZLIB_KIND_GZIP)
			ZLIB_SYNC_FN(gunzip, ZLIB_KIND_GUNZIP)
			ZLIB_SYNC_FN(deflate, ZLIB_KIND_DEFLATE)
			ZLIB_SYNC_FN(inflate, ZLIB_KIND_INFLATE)
			ZLIB_SYNC_FN(deflateRaw, ZLIB_KIND_DEFLATE_RAW)
			ZLIB_SYNC_FN(inflateRaw, ZLIB_KIND_INFLATE_RAW)
			ZLIB_SYNC_FN(unzip, ZLIB_KIND_UNZIP)
			ZLIB_SYNC_FN(brotliCompress, ZLIB_KIND_BROTLI_COMPRESS)
			ZLIB_SYNC_FN(brotliDecompress, ZLIB_KIND_BROTLI_DECOMPRESS)

			ZLIB_ASYNC_FN(gzip, ZLIB_KIND_GZIP)
			ZLIB_ASYNC_FN(gunzip, ZLIB_KIND_GUNZIP)
			ZLIB_ASYNC_FN(deflate, ZLIB_KIND_DEFLATE)
			ZLIB_ASYNC_FN(inflate, ZLIB_KIND_INFLATE)
			ZLIB_ASYNC_FN(deflateRaw, ZLIB_KIND_DEFLATE_RAW)
			ZLIB_ASYNC_FN(inflateRaw, ZLIB_KIND_INFLATE_RAW)
			ZLIB_ASYNC_FN(unzip, ZLIB_KIND_UNZIP)
			ZLIB_ASYNC_FN(brotliCompress, ZLIB_KIND_BROTLI_COMPRESS)
			ZLIB_ASYNC_FN(brotliDecompress, ZLIB_KIND_BROTLI_DECOMPRESS)

			static ant_value_t js_zlib_crc32(ant_t js, ant_value_t args, int nargs) {
			if (nargs < 1) return js_mkerr(js, "argument required");

			const uint8_t *bytes = NULL;
			size_t len = 0;
			uLong init_val = 0;

			if (nargs >= 2 && vtype(args[1]) == T_NUM)
			init_val = (uLong)js_getnum(args[1]);

			if (!get_input_bytes(js, args[0], &bytes, &len))
			return js_mkerr_typed(js, JS_ERR_TYPE, "argument must be a string or Buffer");

			uLong crc = crc32(init_val, bytes, (uInt)len);
			return js_mknum((double)(uint32_t)crc);
			}

			static ant_value_t make_constants(ant_t *js) {
			ant_value_t c = js_mkobj(js);

			js_set(js, c, "Z_NO_FLUSH", js_mknum(Z_NO_FLUSH));
			js_set(js, c, "Z_PARTIAL_FLUSH", js_mknum(Z_PARTIAL_FLUSH));
			js_set(js, c, "Z_SYNC_FLUSH", js_mknum(Z_SYNC_FLUSH));
			js_set(js, c, "Z_FULL_FLUSH", js_mknum(Z_FULL_FLUSH));
			js_set(js, c, "Z_FINISH", js_mknum(Z_FINISH));
			js_set(js, c, "Z_BLOCK", js_mknum(Z_BLOCK));

			js_set(js, c, "Z_OK", js_mknum(Z_OK));
			js_set(js, c, "Z_STREAM_END", js_mknum(Z_STREAM_END));
			js_set(js, c, "Z_NEED_DICT", js_mknum(Z_NEED_DICT));
			js_set(js, c, "Z_ERRNO", js_mknum(Z_ERRNO));
			js_set(js, c, "Z_STREAM_ERROR", js_mknum(Z_STREAM_ERROR));
			js_set(js, c, "Z_DATA_ERROR", js_mknum(Z_DATA_ERROR));
			js_set(js, c, "Z_MEM_ERROR", js_mknum(Z_MEM_ERROR));
			js_set(js, c, "Z_BUF_ERROR", js_mknum(Z_BUF_ERROR));
			js_set(js, c, "Z_VERSION_ERROR", js_mknum(Z_VERSION_ERROR));

			js_set(js, c, "Z_NO_COMPRESSION", js_mknum(Z_NO_COMPRESSION));
			js_set(js, c, "Z_BEST_SPEED", js_mknum(Z_BEST_SPEED));
			js_set(js, c, "Z_BEST_COMPRESSION", js_mknum(Z_BEST_COMPRESSION));
			js_set(js, c, "Z_DEFAULT_COMPRESSION", js_mknum(Z_DEFAULT_COMPRESSION));

			js_set(js, c, "Z_FILTERED", js_mknum(Z_FILTERED));
			js_set(js, c, "Z_HUFFMAN_ONLY", js_mknum(Z_HUFFMAN_ONLY));
			js_set(js, c, "Z_RLE", js_mknum(Z_RLE));
			js_set(js, c, "Z_FIXED", js_mknum(Z_FIXED));
			js_set(js, c, "Z_DEFAULT_STRATEGY", js_mknum(Z_DEFAULT_STRATEGY));

			js_set(js, c, "BROTLI_OPERATION_PROCESS", js_mknum(0));
			js_set(js, c, "BROTLI_OPERATION_FLUSH", js_mknum(1));
			js_set(js, c, "BROTLI_OPERATION_FINISH", js_mknum(2));
			js_set(js, c, "BROTLI_OPERATION_EMIT_METADATA", js_mknum(3));

			js_set(js, c, "BROTLI_PARAM_MODE", js_mknum(0));
			js_set(js, c, "BROTLI_MODE_GENERIC", js_mknum(0));
			js_set(js, c, "BROTLI_MODE_TEXT", js_mknum(1));
			js_set(js, c, "BROTLI_MODE_FONT", js_mknum(2));
			js_set(js, c, "BROTLI_PARAM_QUALITY", js_mknum(1));
			js_set(js, c, "BROTLI_MIN_QUALITY", js_mknum(0));
			js_set(js, c, "BROTLI_MAX_QUALITY", js_mknum(11));
			js_set(js, c, "BROTLI_DEFAULT_QUALITY", js_mknum(11));
			js_set(js, c, "BROTLI_PARAM_LGWIN", js_mknum(2));
			js_set(js, c, "BROTLI_MIN_WINDOW_BITS", js_mknum(10));
			js_set(js, c, "BROTLI_MAX_WINDOW_BITS", js_mknum(24));
			js_set(js, c, "BROTLI_DEFAULT_WINDOW", js_mknum(22));
			js_set(js, c, "BROTLI_PARAM_SIZE_HINT", js_mknum(3));
			js_set(js, c, "BROTLI_PARAM_LARGE_WINDOW", js_mknum(4));
			js_set(js, c, "BROTLI_DECODER_PARAM_DISABLE_RING_BUFFER_REALLOCATION", js_mknum(0));
			js_set(js, c, "BROTLI_DECODER_PARAM_LARGE_WINDOW", js_mknum(1));

			js_set(js, c, "ZSTD_e_continue", js_mknum(0));
			js_set(js, c, "ZSTD_e_flush", js_mknum(1));
			js_set(js, c, "ZSTD_e_end", js_mknum(2));

			return c;
			}

			static void zlib_init_proto(ant_t *js) {
			if (g_transform_proto) return;

			ant_value_t events = events_library(js);
			ant_value_t ee_ctor = js_get(js, events, "EventEmitter");
			ant_value_t ee_proto = js_get(js, ee_ctor, "prototype");

			g_transform_proto = js_mkobj(js);
			js_set_proto_init(g_transform_proto, ee_proto);

			js_set(js, g_transform_proto, "write", js_mkfun(js_zlib_write));
			js_set(js, g_transform_proto, "end", js_mkfun(js_zlib_end));
			js_set(js, g_transform_proto, "destroy", js_mkfun(js_zlib_destroy));
			js_set(js, g_transform_proto, "pause", js_mkfun(js_zlib_pause));
			js_set(js, g_transform_proto, "resume", js_mkfun(js_zlib_resume));
			js_set(js, g_transform_proto, "unpipe", js_mkfun(js_zlib_unpipe));
			js_set(js, g_transform_proto, "pipe", js_mkfun(js_zlib_pipe));

			js_set_getter_desc(js, g_transform_proto, "bytesWritten", 12,
			js_mkfun(js_zlib_get_bytes_written), JS_DESC_C);
			}

			static ant_value_t zlib_mkctor(ant_t js, ant_value_t (fn)(ant_t , ant_value_t , int)) {
			ant_value_t ctor = js_heavy_mkfun(js, fn, js_mkundef());
			js_mark_constructor(ctor, true);
			return ctor;
			}

			ant_value_t zlib_library(ant_t *js) {
			zlib_init_proto(js);

			ant_value_t lib = js_mkobj(js);
			ant_value_t consts = make_constants(js);

			js_set(js, lib, "gzip", js_mkfun(js_gzip));
			js_set(js, lib, "gzipSync", js_mkfun(js_gzipSync));
			js_set(js, lib, "Gzip", zlib_mkctor(js, js_create_gzip));
			js_set(js, lib, "createGzip", js_mkfun(js_create_gzip));

			js_set(js, lib, "gunzip", js_mkfun(js_gunzip));
			js_set(js, lib, "gunzipSync", js_mkfun(js_gunzipSync));
			js_set(js, lib, "Gunzip", zlib_mkctor(js, js_create_gunzip));
			js_set(js, lib, "createGunzip", js_mkfun(js_create_gunzip));

			js_set(js, lib, "deflate", js_mkfun(js_deflate));
			js_set(js, lib, "deflateSync", js_mkfun(js_deflateSync));
			js_set(js, lib, "Deflate", zlib_mkctor(js, js_create_deflate));
			js_set(js, lib, "createDeflate", js_mkfun(js_create_deflate));

			js_set(js, lib, "inflate", js_mkfun(js_inflate));
			js_set(js, lib, "inflateSync", js_mkfun(js_inflateSync));
			js_set(js, lib, "Inflate", zlib_mkctor(js, js_create_inflate));
			js_set(js, lib, "createInflate", js_mkfun(js_create_inflate));

			js_set(js, lib, "deflateRaw", js_mkfun(js_deflateRaw));
			js_set(js, lib, "deflateRawSync", js_mkfun(js_deflateRawSync));
			js_set(js, lib, "DeflateRaw", zlib_mkctor(js, js_create_deflate_raw));
			js_set(js, lib, "createDeflateRaw", js_mkfun(js_create_deflate_raw));

			js_set(js, lib, "inflateRaw", js_mkfun(js_inflateRaw));
			js_set(js, lib, "inflateRawSync", js_mkfun(js_inflateRawSync));
			js_set(js, lib, "InflateRaw", zlib_mkctor(js, js_create_inflate_raw));
			js_set(js, lib, "createInflateRaw", js_mkfun(js_create_inflate_raw));

			js_set(js, lib, "unzip", js_mkfun(js_unzip));
			js_set(js, lib, "unzipSync", js_mkfun(js_unzipSync));
			js_set(js, lib, "Unzip", zlib_mkctor(js, js_create_unzip));
			js_set(js, lib, "createUnzip", js_mkfun(js_create_unzip));

			js_set(js, lib, "brotliCompress", js_mkfun(js_brotliCompress));
			js_set(js, lib, "brotliCompressSync", js_mkfun(js_brotliCompressSync));
			js_set(js, lib, "BrotliCompress", zlib_mkctor(js, js_create_brotli_compress));
			js_set(js, lib, "createBrotliCompress", js_mkfun(js_create_brotli_compress));

			js_set(js, lib, "brotliDecompress", js_mkfun(js_brotliDecompress));
			js_set(js, lib, "brotliDecompressSync", js_mkfun(js_brotliDecompressSync));
			js_set(js, lib, "BrotliDecompress", zlib_mkctor(js, js_create_brotli_decompress));
			js_set(js, lib, "createBrotliDecompress", js_mkfun(js_create_brotli_decompress));

			js_set(js, lib, "default", lib);
			js_set(js, lib, "constants", consts);
			js_set(js, lib, "crc32", js_mkfun(js_zlib_crc32));
			js_set_sym(js, lib, get_toStringTag_sym(), js_mkstr(js, "zlib", 4));

			return lib;
			}

			void gc_mark_zlib(ant_t js, void (mark)(ant_t *, ant_value_t)) {
			if (g_transform_proto) mark(js, g_transform_proto);
			for (zlib_stream_t *st = g_active_streams; st; st = st->next_active) mark(js, st->obj);
			}

Owner Packages

No Owners

ant/src/modules/zlib.c3fa05edd2fe3mir/inline-method

zlib.cView Options

Owner Packages

ant/src/modules/zlib.c
3fa05edd2fe3mir/inline-method

zlib.c
View Options