yencode 1.0.8 → 1.1.2

package/src/platform.cc

@@ -0,0 +1,147 @@
+#include "common.h"
+#ifdef PLATFORM_ARM
+# ifdef __ANDROID__
+#  include <cpu-features.h>
+# elif defined(__linux__) || (defined(__FreeBSD__) && __FreeBSD__ >= 12)
+#  include <sys/auxv.h>
+#  include <asm/hwcap.h>
+# elif (defined(__FreeBSD__) && __FreeBSD__ < 12)
+#  include <sys/sysctl.h>
+#  include <asm/hwcap.h>
+# elif defined(_WIN32)
+#  define WIN32_LEAN_AND_MEAN
+#  define NOMINMAX
+#  include <Windows.h>
+# elif defined(__APPLE__)
+#  include <sys/types.h>
+#  include <sys/sysctl.h>
+# endif
+bool cpu_supports_neon() {
+# if defined(AT_HWCAP)
+#  ifdef __FreeBSD__
+	unsigned long supported;
+	elf_aux_info(AT_HWCAP, &supported, sizeof(supported));
+#   ifdef __aarch64__
+	return supported & HWCAP_ASIMD;
+#   else
+	return supported & HWCAP_NEON;
+#   endif
+#  else
+#   ifdef __aarch64__
+	return getauxval(AT_HWCAP) & HWCAP_ASIMD;
+#   else
+	return getauxval(AT_HWCAP) & HWCAP_NEON;
+#   endif
+#  endif
+# elif defined(ANDROID_CPU_FAMILY_ARM)
+#  ifdef __aarch64__
+	return android_getCpuFeatures() & ANDROID_CPU_ARM64_FEATURE_ASIMD;
+#  else
+	return android_getCpuFeatures() & ANDROID_CPU_ARM_FEATURE_NEON;
+#  endif
+# elif defined(_WIN32)
+	return IsProcessorFeaturePresent(PF_ARM_NEON_INSTRUCTIONS_AVAILABLE);
+# elif defined(__APPLE__)
+	int supported = 0;
+	size_t len = sizeof(supported);
+	if(sysctlbyname("hw.optional.neon", &supported, &len, NULL, 0))
+		return false;
+	return (bool)supported;
+# endif
+	return true; // assume NEON support, if compiled as such, otherwise (I think Windows and iOS require it)
+}
+#endif
+
+
+#ifdef PLATFORM_X86
+#ifdef _MSC_VER
+# define _cpuid1x(ar) __cpuid(ar, 0x80000001)
+# if _MSC_VER >= 1600
+#  define _cpuidX __cpuidex
+#  include <immintrin.h>
+#  define _GET_XCR() _xgetbv(_XCR_XFEATURE_ENABLED_MASK)
+# else
+// not supported
+#  define _cpuidX(ar, eax, ecx) ar[0]=0, ar[1]=0, ar[2]=0, ar[3]=0
+#  define _GET_XCR() 0
+# endif
+#else
+# define _cpuid1x(ar) __cpuid(0x80000001, ar[0], ar[1], ar[2], ar[3])
+# define _cpuidX(ar, eax, ecx) __cpuid_count(eax, ecx, ar[0], ar[1], ar[2], ar[3])
+static inline int _GET_XCR() {
+	int xcr0;
+	__asm__ __volatile__("xgetbv" : "=a" (xcr0) : "c" (0) : "%edx");
+	return xcr0;
+}
+#endif
+// checks if CPU has 128-bit AVX units; currently not used as AVX2 is beneficial even on Zen1
+// static bool cpu_has_slow_avx(cpuid1flag0) {
+	// int family = ((cpuid1flag0>>8) & 0xf) + ((cpuid1flag0>>16) & 0xff0),
+		// model = ((cpuid1flag0>>4) & 0xf) + ((cpuid1flag0>>12) & 0xf0);
+	// return (
+		   // family == 0x6f // AMD Bulldozer family
+		// || family == 0x7f // AMD Jaguar/Puma family
+		// || (family == 0x8f && (model == 0 /*Summit Ridge ES*/ || model == 1 /*Zen*/ || model == 8 /*Zen+*/ || model == 0x11 /*Zen APU*/ || model == 0x18 /*Zen+ APU*/ || model == 0x50 /*Subor Z+*/)) // AMD Zen1 family
+		// || (family == 6 && model == 0xf) // Centaur/Zhaoxin; overlaps with Intel Core 2, but they don't support AVX
+	// );
+// }
+
+
+int cpu_supports_isa() {
+	int flags[4];
+	_cpuid1(flags);
+	int ret = 0;
+	
+	if(flags[2] & 0x800000)
+		ret |= ISA_FEATURE_POPCNT;
+	int flags2[4];
+	_cpuid1x(flags2);
+	if(flags2[2] & 0x20) // ABM
+		ret |= ISA_FEATURE_LZCNT | ISA_FEATURE_POPCNT;
+	
+	int family = ((flags[0]>>8) & 0xf) + ((flags[0]>>16) & 0xff0);
+	int model = ((flags[0]>>4) & 0xf) + ((flags[0]>>12) & 0xf0);
+	
+	if(family == 6 && (
+		model == 0x1C || model == 0x26 || model == 0x27 || model == 0x35 || model == 0x36 || model == 0x37 || model == 0x4A || model == 0x4C || model == 0x4D || model == 0x5A || model == 0x5D
+	))
+		// Intel Bonnell/Silvermont CPU with very slow PSHUFB and PBLENDVB - pretend SSSE3 doesn't exist
+		return ret | ISA_LEVEL_SSE2;
+	
+	if(family == 0x5f && (model == 0 || model == 1 || model == 2))
+		// AMD Bobcat with slow SSSE3 instructions - pretend it doesn't exist
+		return ret | ISA_LEVEL_SSE2;
+	
+	// Jaguar/Puma performance unkown (slowish PSHUFB/PBLENDVB)
+	
+	if((flags[2] & 0x200) == 0x200) { // SSSE3
+		if(family == 6 && (model == 0x5c || model == 0x5f || model == 0x7a || model == 0x9c))
+			// Intel Goldmont/plus / Tremont with slow PBLENDVB
+			return ret | ISA_LEVEL_SSSE3;
+		
+		if(flags[2] & 0x80000) { // SSE4.1
+			if((flags[2] & 0x18800000) == 0x18800000) { // POPCNT + OSXSAVE + AVX
+				int xcr = _GET_XCR() & 0xff; // ignore unused bits
+				if((xcr & 6) == 6) { // AVX enabled
+					int cpuInfo[4];
+					_cpuidX(cpuInfo, 7, 0);
+					if((cpuInfo[1] & 0x128) == 0x128 && (ret & ISA_FEATURE_LZCNT)) { // BMI2 + AVX2 + BMI1
+						if(((xcr & 0xE0) == 0xE0) && (cpuInfo[1] & 0xC0010000) == 0xC0010000) { // AVX512BW + AVX512VL + AVX512F
+							if(cpuInfo[2] & 0x40)
+								return ret | ISA_LEVEL_VBMI2;
+							return ret | ISA_LEVEL_AVX3;
+						}
+						// AVX2 is beneficial even on Zen1
+						return ret | ISA_LEVEL_AVX2;
+					}
+					return ret | ISA_LEVEL_AVX;
+				}
+			}
+			return ret | ISA_LEVEL_SSE41;
+		}
+		return ret | ISA_LEVEL_SSSE3;
+	}
+	return ret | ISA_LEVEL_SSE2;
+}
+
+#endif // PLATFORM_X86

package/src/yencode.cc

@@ -0,0 +1,449 @@
+
+#include <node.h>
+#include <node_buffer.h>
+#include <node_version.h>
+#include <v8.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "encoder.h"
+#include "decoder.h"
+#include "crc.h"
+
+using namespace v8;
+
+static void free_buffer(char* data, void* _size) {
+#if !NODE_VERSION_AT_LEAST(0, 11, 0)
+	int size = (int)(size_t)_size;
+	V8::AdjustAmountOfExternalAllocatedMemory(-size);
+#endif
+	//Isolate::GetCurrent()->AdjustAmountOfExternalAllocatedMemory(-size);
+	free(data);
+}
+
+// TODO: encode should return col num for incremental processing
+//       line limit + return input consumed
+//       async processing?
+
+static inline size_t YENC_MAX_SIZE(size_t len, size_t line_size) {
+	size_t ret = len * 2    /* all characters escaped */
+		+ 2 /* allocation for offset and that a newline may occur early */
+#if !defined(YENC_DISABLE_AVX256)
+		+ 64 /* allocation for YMM overflowing */
+#else
+		+ 32 /* allocation for XMM overflowing */
+#endif
+	;
+	/* add newlines, considering the possibility of all chars escaped */
+	if(line_size == 128) // optimize common case
+		return ret + 2 * (len >> 6);
+	return ret + 2 * ((len*2) / line_size);
+}
+
+
+
+#if NODE_VERSION_AT_LEAST(0, 11, 0)
+// for node 0.12.x
+# define FUNC(name) static void name(const FunctionCallbackInfo<Value>& args)
+# define FUNC_START \
+	Isolate* isolate = args.GetIsolate(); \
+	HandleScope scope(isolate)
+
+# if NODE_VERSION_AT_LEAST(8, 0, 0)
+#  define NEW_STRING(s) String::NewFromOneByte(isolate, (const uint8_t*)(s), NewStringType::kNormal).ToLocalChecked()
+#  define RETURN_ERROR(e) { isolate->ThrowException(Exception::Error(String::NewFromOneByte(isolate, (const uint8_t*)(e), NewStringType::kNormal).ToLocalChecked())); return; }
+#  define ARG_TO_INT(a) (a).As<Integer>()->Value()
+#  define ARG_TO_BOOL(a) (a).As<Boolean>()->Value()
+# else
+#  define NEW_STRING(s) String::NewFromUtf8(isolate, s)
+#  define RETURN_ERROR(e) { isolate->ThrowException(Exception::Error(String::NewFromUtf8(isolate, e))); return; }
+#  define ARG_TO_INT(a) (a)->ToInteger()->Value()
+#  define ARG_TO_BOOL(a) (a)->ToBoolean()->Value()
+# endif
+# define NEW_OBJECT Object::New(isolate)
+# if NODE_VERSION_AT_LEAST(3, 0, 0) // iojs3
+#  define NEW_BUFFER(...) node::Buffer::New(ISOLATE __VA_ARGS__).ToLocalChecked()
+# else
+#  define NEW_BUFFER(...) node::Buffer::New(ISOLATE __VA_ARGS__)
+# endif
+
+# define RETURN_VAL(v) { args.GetReturnValue().Set(v); return; }
+# define RETURN_UNDEF return
+# define ISOLATE isolate,
+//# define MARK_EXT_MEM isolate->AdjustAmountOfExternalAllocatedMemory
+# define MARK_EXT_MEM(x)
+
+#else
+// for node 0.10.x
+#define FUNC(name) static Handle<Value> name(const Arguments& args)
+#define FUNC_START HandleScope scope
+#define NEW_STRING String::New
+#define NEW_OBJECT Object::New()
+#define NEW_BUFFER(...) Local<Object>::New(node::Buffer::New(ISOLATE __VA_ARGS__)->handle_)
+#define ARG_TO_INT(a) (a)->ToInteger()->Value()
+#define ARG_TO_BOOL(a) (a)->ToBoolean()->Value()
+
+#define RETURN_ERROR(e) \
+	return ThrowException(Exception::Error( \
+		String::New(e)) \
+	)
+#define RETURN_VAL(v) return scope.Close(v)
+#define RETURN_UNDEF RETURN_VAL( Undefined() )
+#define ISOLATE
+#define MARK_EXT_MEM V8::AdjustAmountOfExternalAllocatedMemory
+#endif
+
+#if NODE_VERSION_AT_LEAST(12, 0, 0)
+# define SET_OBJ(obj, key, val) (obj)->Set(isolate->GetCurrentContext(), NEW_STRING(key), val).Check()
+#else
+# define SET_OBJ(obj, key, val) (obj)->Set(NEW_STRING(key), val)
+#endif
+
+
+// encode(str, line_size, col)
+FUNC(Encode) {
+	FUNC_START;
+	
+	if (args.Length() == 0 || !node::Buffer::HasInstance(args[0]))
+		RETURN_ERROR("You must supply a Buffer");
+	
+	size_t arg_len = node::Buffer::Length(args[0]);
+	if (arg_len == 0)
+		RETURN_VAL(NEW_BUFFER(0));
+	
+	int line_size = 128, col = 0;
+	if (args.Length() >= 2) {
+		line_size = (int)ARG_TO_INT(args[1]);
+		if (line_size == 0) line_size = 128; // allow this case
+		if (line_size < 0)
+			RETURN_ERROR("Line size must be at least 1 byte");
+		if (args.Length() >= 3) {
+			col = (int)ARG_TO_INT(args[2]);
+			if (col > line_size || col < 0)
+				RETURN_ERROR("Column offset cannot exceed the line size and cannot be negative");
+			if (col == line_size) col = 0; // allow this case
+		}
+	}
+	
+	// allocate enough memory to handle worst case requirements
+	size_t dest_len = YENC_MAX_SIZE(arg_len, line_size);
+	
+	unsigned char *result = (unsigned char*) malloc(dest_len);
+	size_t len = do_encode(line_size, &col, (const unsigned char*)node::Buffer::Data(args[0]), result, arg_len, true);
+	result = (unsigned char*)realloc(result, len);
+	MARK_EXT_MEM(len);
+	RETURN_VAL( NEW_BUFFER((char*)result, len, free_buffer, (void*)len) );
+}
+
+FUNC(EncodeTo) {
+	FUNC_START;
+	
+	if (args.Length() < 2 || !node::Buffer::HasInstance(args[0]) || !node::Buffer::HasInstance(args[1]))
+		RETURN_ERROR("You must supply two Buffers");
+	
+	size_t arg_len = node::Buffer::Length(args[0]);
+	if (arg_len == 0)
+		RETURN_VAL(Integer::New(ISOLATE 0));
+	
+	int line_size = 128, col = 0;
+	if (args.Length() >= 3) {
+		line_size = (int)ARG_TO_INT(args[2]);
+		if (line_size == 0) line_size = 128; // allow this case
+		if (line_size < 0)
+			RETURN_ERROR("Line size must be at least 1 byte");
+		if (args.Length() >= 4) {
+			col = (int)ARG_TO_INT(args[3]);
+			if (col > line_size || col < 0)
+				RETURN_ERROR("Column offset cannot exceed the line size and cannot be negative");
+			if (col == line_size) col = 0; // allow this case
+		}
+	}
+	
+	// check that destination buffer has enough space
+	size_t dest_len = YENC_MAX_SIZE(arg_len, line_size);
+	if(node::Buffer::Length(args[1]) < dest_len)
+		RETURN_ERROR("Destination buffer does not have enough space (use `maxSize` to compute required space)");
+	
+	size_t len = do_encode(line_size, &col, (const unsigned char*)node::Buffer::Data(args[0]), (unsigned char*)node::Buffer::Data(args[1]), arg_len, true);
+	RETURN_VAL( Integer::New(ISOLATE len) );
+}
+
+FUNC(EncodeIncr) {
+	FUNC_START;
+	
+	if (args.Length() == 0 || !node::Buffer::HasInstance(args[0]))
+		RETURN_ERROR("You must supply a Buffer");
+	
+	int line_size = 128, col = 0;
+	bool allocResult = true;
+	unsigned char* result;
+	size_t arg_len = node::Buffer::Length(args[0]);
+	if(args.Length() > 1) {
+		int argp = 1;
+		if(node::Buffer::HasInstance(args[1])) {
+			// grab destination
+			allocResult = false;
+			// check that destination buffer has enough space
+			size_t dest_len = YENC_MAX_SIZE(arg_len, line_size);
+			if(node::Buffer::Length(args[1]) < dest_len)
+				RETURN_ERROR("Destination buffer does not have enough space (use `maxSize` to compute required space)");
+			result = (unsigned char*)node::Buffer::Data(args[1]);
+			argp++;
+		}
+		if (args.Length() > argp) {
+			line_size = (int)ARG_TO_INT(args[argp]);
+			if (line_size == 0) line_size = 128; // allow this case
+			if (line_size < 0)
+				RETURN_ERROR("Line size must be at least 1 byte");
+			argp++;
+			if (args.Length() > argp) {
+				col = (int)ARG_TO_INT(args[argp]);
+				if (col > line_size || col < 0)
+					RETURN_ERROR("Column offset cannot exceed the line size and cannot be negative");
+				if (col == line_size) col = 0; // allow this case
+			}
+		}
+	}
+	
+	Local<Object> ret = NEW_OBJECT;
+	
+	if (arg_len == 0) {
+		SET_OBJ(ret, "written", Integer::New(ISOLATE 0));
+		// TODO: set 'output'?
+		SET_OBJ(ret, "col", Integer::New(ISOLATE col));
+		RETURN_VAL( ret );
+	}
+	
+	if(allocResult) {
+		// allocate enough memory to handle worst case requirements
+		size_t dest_len = YENC_MAX_SIZE(arg_len, line_size);
+		result = (unsigned char*) malloc(dest_len);
+	}
+	
+	size_t len = do_encode(line_size, &col, (const unsigned char*)node::Buffer::Data(args[0]), result, arg_len, false);
+	
+	SET_OBJ(ret, "written", Integer::New(ISOLATE len));
+	if(allocResult) {
+		result = (unsigned char*)realloc(result, len);
+		SET_OBJ(ret, "output", NEW_BUFFER((char*)result, len, free_buffer, (void*)len));
+		MARK_EXT_MEM(len);
+	}
+	SET_OBJ(ret, "col", Integer::New(ISOLATE col));
+	RETURN_VAL( ret );
+}
+
+FUNC(Decode) {
+	FUNC_START;
+	
+	if (args.Length() == 0 || !node::Buffer::HasInstance(args[0]))
+		RETURN_ERROR("You must supply a Buffer");
+	
+	size_t arg_len = node::Buffer::Length(args[0]);
+	if (arg_len == 0)
+		RETURN_VAL( NEW_BUFFER(0) );
+	
+	bool isRaw = false;
+	if (args.Length() > 1)
+		isRaw = ARG_TO_BOOL(args[1]);
+	
+	unsigned char *result = (unsigned char*) malloc(arg_len);
+	size_t len = do_decode(isRaw, (const unsigned char*)node::Buffer::Data(args[0]), result, arg_len, NULL);
+	result = (unsigned char*)realloc(result, len);
+	MARK_EXT_MEM(len);
+	RETURN_VAL( NEW_BUFFER((char*)result, len, free_buffer, (void*)len) );
+}
+
+FUNC(DecodeTo) {
+	FUNC_START;
+	
+	if (args.Length() < 2 || !node::Buffer::HasInstance(args[0]) || !node::Buffer::HasInstance(args[1]))
+		RETURN_ERROR("You must supply two Buffers");
+	
+	size_t arg_len = node::Buffer::Length(args[0]);
+	if (arg_len == 0)
+		RETURN_VAL( Integer::New(ISOLATE 0) );
+	
+	// check that destination buffer has enough space
+	if(node::Buffer::Length(args[1]) < arg_len)
+		RETURN_VAL( Integer::New(ISOLATE 0) );
+	
+	bool isRaw = false;
+	if (args.Length() > 2)
+		isRaw = ARG_TO_BOOL(args[2]);
+	
+	size_t len = do_decode(isRaw, (const unsigned char*)node::Buffer::Data(args[0]), (unsigned char*)node::Buffer::Data(args[1]), arg_len, NULL);
+	RETURN_VAL( Integer::New(ISOLATE len) );
+}
+
+
+FUNC(DecodeIncr) {
+	FUNC_START;
+	
+	if (args.Length() == 0 || !node::Buffer::HasInstance(args[0]))
+		RETURN_ERROR("You must supply a Buffer");
+	
+	size_t arg_len = node::Buffer::Length(args[0]);
+	if (arg_len == 0)
+		// handled properly in Javascript
+		RETURN_UNDEF;
+	
+	YencDecoderState state = YDEC_STATE_CRLF;
+	unsigned char *result = NULL;
+	bool allocResult = true;
+	if (args.Length() > 1) {
+		state = (YencDecoderState)(ARG_TO_INT(args[1]));
+		if (args.Length() > 2 && node::Buffer::HasInstance(args[2])) {
+			if(node::Buffer::Length(args[2]) < arg_len)
+				RETURN_ERROR("Destination buffer does not have enough space");
+			result = (unsigned char*)node::Buffer::Data(args[2]);
+			allocResult = false;
+		}
+	}
+	
+	const unsigned char* src = (const unsigned char*)node::Buffer::Data(args[0]);
+	const unsigned char* sp = src;
+#ifdef DBG_ALIGN_SOURCE
+	void* newSrc = valloc(arg_len);
+	memcpy(newSrc, src, arg_len);
+	sp = (const unsigned char*)newSrc;
+#endif
+	
+	if(allocResult) result = (unsigned char*) malloc(arg_len);
+	unsigned char* dp = result;
+	YencDecoderEnd ended = do_decode_end(&sp, &dp, arg_len, &state);
+	size_t len = dp - result;
+	if(allocResult) result = (unsigned char*)realloc(result, len);
+	
+#ifdef DBG_ALIGN_SOURCE
+	free(newSrc);
+#endif
+	
+	Local<Object> ret = NEW_OBJECT;
+	SET_OBJ(ret, "read", Integer::New(ISOLATE sp - src));
+	SET_OBJ(ret, "written", Integer::New(ISOLATE len));
+	if(allocResult) {
+		SET_OBJ(ret, "output", NEW_BUFFER((char*)result, len, free_buffer, (void*)len));
+		MARK_EXT_MEM(len);
+	}
+	SET_OBJ(ret, "ended", Integer::New(ISOLATE (int)ended));
+	SET_OBJ(ret, "state", Integer::New(ISOLATE state));
+	RETURN_VAL( ret );
+}
+
+
+static inline uint32_t read_crc32(const Local<Value>& buf) {
+	const uint8_t* arr = (const uint8_t*)node::Buffer::Data(buf);
+	return (((uint_fast32_t)arr[0] << 24) | ((uint_fast32_t)arr[1] << 16) | ((uint_fast32_t)arr[2] << 8) | (uint_fast32_t)arr[3]);
+}
+static inline Local<Object> pack_crc32(
+#if NODE_VERSION_AT_LEAST(0, 11, 0)
+	Isolate* isolate,
+#endif
+uint32_t crc) {
+	Local<Object> buff = NEW_BUFFER(4);
+	unsigned char* d = (unsigned char*)node::Buffer::Data(buff);
+	d[0] = (unsigned char)(crc >> 24) & 0xFF;
+	d[1] = (unsigned char)(crc >> 16) & 0xFF;
+	d[2] = (unsigned char)(crc >>  8) & 0xFF;
+	d[3] = (unsigned char)crc & 0xFF;
+	return buff;
+}
+
+// crc32(str, init)
+FUNC(CRC32) {
+	FUNC_START;
+	
+	if (args.Length() == 0 || !node::Buffer::HasInstance(args[0]))
+		RETURN_ERROR("You must supply a Buffer");
+	// TODO: support string args??
+	
+	uint32_t crc = 0;
+	if (args.Length() >= 2) {
+		if (!node::Buffer::HasInstance(args[1]) || node::Buffer::Length(args[1]) != 4)
+			RETURN_ERROR("Second argument must be a 4 byte buffer");
+		crc = read_crc32(args[1]);
+	}
+	crc = do_crc32(
+		(const void*)node::Buffer::Data(args[0]),
+		node::Buffer::Length(args[0]),
+		crc
+	);
+	RETURN_VAL(pack_crc32(ISOLATE crc));
+}
+
+FUNC(CRC32Combine) {
+	FUNC_START;
+	
+	if (args.Length() < 3)
+		RETURN_ERROR("At least 3 arguments required");
+	if (!node::Buffer::HasInstance(args[0]) || node::Buffer::Length(args[0]) != 4
+	|| !node::Buffer::HasInstance(args[1]) || node::Buffer::Length(args[1]) != 4)
+		RETURN_ERROR("You must supply a 4 byte Buffer for the first two arguments");
+	
+	uint32_t crc1 = read_crc32(args[0]), crc2 = read_crc32(args[1]);
+	size_t len = (size_t)ARG_TO_INT(args[2]);
+	
+	crc1 = do_crc32_combine(crc1, crc2, len);
+	RETURN_VAL(pack_crc32(ISOLATE crc1));
+}
+
+FUNC(CRC32Zeroes) {
+	FUNC_START;
+	
+	if (args.Length() < 1)
+		RETURN_ERROR("At least 1 argument required");
+	
+	uint32_t crc1 = 0;
+	if (args.Length() >= 2) {
+		if (!node::Buffer::HasInstance(args[1]) || node::Buffer::Length(args[1]) != 4)
+			RETURN_ERROR("Second argument must be a 4 byte buffer");
+		crc1 = read_crc32(args[1]);
+	}
+	size_t len = (size_t)ARG_TO_INT(args[0]);
+	crc1 = do_crc32_zeros(crc1, len);
+	RETURN_VAL(pack_crc32(ISOLATE crc1));
+}
+
+static void init_all() {
+	encoder_init();
+	decoder_init();
+	crc_init();	
+}
+
+#if NODE_VERSION_AT_LEAST(10, 7, 0)
+// signal context aware module for node if it supports it
+# include <uv.h>
+static uv_once_t init_once = UV_ONCE_INIT;
+NODE_MODULE_INIT(/* exports, module, context */)
+#else
+void yencode_init(
+# if NODE_VERSION_AT_LEAST(4, 0, 0)
+ Local<Object> exports,
+ Local<Value> module,
+ void* priv
+# else
+ Handle<Object> exports
+# endif
+)
+#endif
+{
+	NODE_SET_METHOD(exports, "encode", Encode);
+	NODE_SET_METHOD(exports, "encodeTo", EncodeTo);
+	NODE_SET_METHOD(exports, "encodeIncr", EncodeIncr);
+	NODE_SET_METHOD(exports, "decode", Decode);
+	NODE_SET_METHOD(exports, "decodeTo", DecodeTo);
+	NODE_SET_METHOD(exports, "decodeIncr", DecodeIncr);
+	NODE_SET_METHOD(exports, "crc32", CRC32);
+	NODE_SET_METHOD(exports, "crc32_combine", CRC32Combine);
+	NODE_SET_METHOD(exports, "crc32_zeroes", CRC32Zeroes);
+	
+#if NODE_VERSION_AT_LEAST(10, 7, 0)
+	uv_once(&init_once, init_all);
+#else
+	init_all();
+#endif
+}
+
+#if !NODE_VERSION_AT_LEAST(10, 7, 0)
+NODE_MODULE(yencode, yencode_init);
+#endif

package/test/_maxsize.js

@@ -0,0 +1,9 @@
+"use strict";
+module.exports = function(length, line_size) {
+	if(!length) return 0;
+	return Math.ceil(length*2) // all characters escaped
+		+ 2 * Math.floor((length*2) / (line_size||128)) // newlines, considering the possibility of all chars escaped
+		+ 2 // allocation for offset and that a newline may occur early
+		+ 64 // extra space just in case things go awry... just kidding, it's just extra padding to make SIMD logic easier
+	;
+};