@agoric/xsnap 0.14.3-u13.0 → 0.14.3-u16.0

package/xsnap-native/xsnap/sources/xsnapPlatform.c

@@ -0,0 +1,1501 @@
+#include "xsAll.h"
+#include "xsScript.h"
+#include "xsSnapshot.h"
+
+#ifndef mxReserveChunkSize
+	#define mxReserveChunkSize 1024 * 1024 * 1024
+#endif
+
+
+mxExport void fxRunModuleFile(txMachine* the, txString path);
+mxExport void fxRunProgramFile(txMachine* the, txString path);
+mxExport void fxRunLoop(txMachine* the);
+
+mxExport void fxClearTimer(txMachine* the);
+mxExport void fxSetTimer(txMachine* the, txNumber interval, txBoolean repeat);
+
+mxExport void fxVersion(txString theBuffer, txSize theSize);
+#ifdef mxMetering
+mxExport txUnsigned fxGetCurrentMeter(txMachine* the);
+mxExport void fxSetCurrentMeter(txMachine* the, txUnsigned value);
+#endif
+
+typedef struct sxJob txJob;
+
+struct sxJob {
+	txJob* next;
+	txMachine* the;
+	txNumber when;
+	txSlot self;
+	txSlot function;
+	txSlot argument;
+	txNumber interval;
+};
+
+static void fxDestroyTimer(void* data);
+static void fxMarkTimer(txMachine* the, void* it, txMarkRoot markRoot);
+
+static txHostHooks gxTimerHooks = {
+	fxDestroyTimer,
+	fxMarkTimer
+};
+
+void fxClearTimer(txMachine* the)
+{
+	txHostHooks* hooks = fxGetHostHooks(the, mxArgv(0));
+	if (hooks == &gxTimerHooks) {
+		txJob* job = fxGetHostData(the, mxArgv(0));
+		if (job) {
+			fxForget(the, &job->self);
+			fxSetHostData(the, mxArgv(0), NULL);
+			job->the = NULL;
+		}
+	}
+	else
+		mxTypeError("no timer");
+}
+
+void fxDestroyTimer(void* data)
+{
+}
+
+void fxMarkTimer(txMachine* the, void* it, txMarkRoot markRoot)
+{
+	txJob* job = it;
+	if (job) {
+		(*markRoot)(the, &job->function);
+		(*markRoot)(the, &job->argument);
+	}
+}
+
+void fxSetTimer(txMachine* the, txNumber interval, txBoolean repeat)
+{
+	c_timeval tv;
+	txJob* job;
+	txJob** address = (txJob**)&(the->timerJobs);
+	while ((job = *address))
+		address = &(job->next);
+	job = *address = malloc(sizeof(txJob));
+	c_memset(job, 0, sizeof(txJob));
+	job->the = the;
+	c_gettimeofday(&tv, NULL);
+	if (repeat)
+		job->interval = interval;
+	job->when = ((txNumber)(tv.tv_sec) * 1000.0) + ((txNumber)(tv.tv_usec) / 1000.0) + interval;
+	fxNewHostObject(the, NULL);
+    mxPull(job->self);
+	job->function = *mxArgv(0);
+	if (mxArgc > 2)
+		job->argument = *mxArgv(2);
+	else
+		job->argument = mxUndefined;
+	fxSetHostData(the, &job->self, job);
+	fxSetHostHooks(the, &job->self, &gxTimerHooks);
+	fxRemember(the, &job->self);
+	fxAccess(the, &job->self);
+	*mxResult = the->scratch;
+}
+
+/* PLATFORM */
+
+static void fxFulfillModuleFile(txMachine* the);
+static void fxRejectModuleFile(txMachine* the);
+static txScript* fxLoadScript(txMachine* the, txString path, txUnsigned flags);
+
+void fxAbort(txMachine* the, int status)
+{
+	switch (status) {
+	case XS_STACK_OVERFLOW_EXIT:
+		fxReport(the, "stack overflow\n");
+#ifdef mxDebug
+		fxDebugger(the, (char *)__FILE__, __LINE__);
+#endif
+		the->abortStatus = status;
+		fxExitToHost(the);
+		break;
+	case XS_NOT_ENOUGH_MEMORY_EXIT:
+		fxReport(the, "memory full\n");
+#ifdef mxDebug
+		fxDebugger(the, (char *)__FILE__, __LINE__);
+#endif
+		the->abortStatus = status;
+		fxExitToHost(the);
+		break;
+	case XS_NO_MORE_KEYS_EXIT:
+		fxReport(the, "not enough keys\n");
+#ifdef mxDebug
+		fxDebugger(the, (char *)__FILE__, __LINE__);
+#endif
+		the->abortStatus = status;
+		fxExitToHost(the);
+		break;
+	case XS_TOO_MUCH_COMPUTATION_EXIT:
+		fxReport(the, "too much computation\n");
+#ifdef mxDebug
+		fxDebugger(the, (char *)__FILE__, __LINE__);
+#endif
+		the->abortStatus = status;
+		fxExitToHost(the);
+		break;
+	case XS_UNHANDLED_EXCEPTION_EXIT: {
+		mxPush(mxException);
+		txSlot *exc = the->stack;
+		fxReport(the, "unhandled exception: %s\n", fxToString(the, &mxException));
+		mxException = mxUndefined;
+		mxTry(the) {
+			mxOverflow(-8);
+			mxPush(mxGlobal);
+			fxGetID(the, fxFindName(the, "console"));
+			fxCallID(the, fxFindName(the, "error"));
+			mxPushStringC("Unhandled exception:");
+			mxPushSlot(exc);
+			fxRunCount(the, 2);
+			mxPop();
+		}
+		mxCatch(the) {
+			fprintf(stderr, "Unhandled exception %s\n", fxToString(the, exc));
+		}
+		the->abortStatus = status;
+		fxExitToHost(the);
+		mxPop();
+		break;
+	}
+	case XS_UNHANDLED_REJECTION_EXIT: {
+		mxPush(mxException);
+		txSlot *exc = the->stack;
+		fxReport(the, "unhandled rejection: %s\n", fxToString(the, &mxException));
+		mxException = mxUndefined;
+		mxTry(the) {
+			mxOverflow(-8);
+			mxPush(mxGlobal);
+			fxGetID(the, fxFindName(the, "console"));
+			fxCallID(the, fxFindName(the, "error"));
+			mxPushStringC("UnhandledPromiseRejectionWarning:");
+			mxPushSlot(exc);
+			fxRunCount(the, 2);
+			mxPop();
+		}
+		mxCatch(the) {
+			fprintf(stderr, "Unhandled exception %s\n", fxToString(the, exc));
+		}
+		break;
+	}
+	default:
+		fxReport(the, "fxAbort(%d) - %s\n", status, fxToString(the, &mxException));
+#ifdef mxDebug
+		fxDebugger(the, (char *)__FILE__, __LINE__);
+#endif
+		the->abortStatus = status;
+		fxExitToHost(the);
+		break;
+	}
+}
+
+static txSize gxPageSize = 0;
+
+static txSize fxRoundToPageSize(txMachine* the, txSize size)
+{
+	txSize modulo;
+	if (!gxPageSize) {
+#if mxWindows
+		SYSTEM_INFO info;
+		GetSystemInfo(&info);
+		gxPageSize = (txSize)info.dwAllocationGranularity;
+#else
+		gxPageSize = getpagesize();
+#endif
+	}
+	modulo = size & (gxPageSize - 1);
+	if (modulo)
+		size = fxAddChunkSizes(the, size, gxPageSize - modulo);
+	return size;
+}
+
+static void adjustSpaceMeter(txMachine* the, txSize theSize)
+{
+	size_t previous = the->allocatedSpace;
+	the->allocatedSpace += theSize;
+	if (the->allocatedSpace > the->allocationLimit ||
+		// overflow?
+		the->allocatedSpace < previous) {
+		fxAbort(the, XS_NOT_ENOUGH_MEMORY_EXIT);
+	}
+}
+
+void* fxAllocateChunks(txMachine* the, txSize size)
+{
+	txByte* base;
+	txByte* result;
+	adjustSpaceMeter(the, size);
+	if (the->firstBlock) {
+		base = (txByte*)(the->firstBlock);
+		result = (txByte*)(the->firstBlock->limit);
+	}
+	else
+#if mxWindows
+		base = result = VirtualAlloc(NULL, mxReserveChunkSize, MEM_RESERVE, PAGE_READWRITE);
+#else
+		base = result = mmap(NULL, mxReserveChunkSize, PROT_NONE, MAP_PRIVATE | MAP_ANON, -1, 0);
+#endif
+	if (result) {
+		txSize current = (txSize)(result - base);
+		size = fxAddChunkSizes(the, current, size);
+		current = fxRoundToPageSize(the, current);
+		size = fxRoundToPageSize(the, size);
+#if mxWindows
+		if (!VirtualAlloc(base + current, size - current, MEM_COMMIT, PAGE_READWRITE))
+#else
+		if (size > mxReserveChunkSize)
+			result = NULL;
+		else if (mprotect(base + current, size - current, PROT_READ | PROT_WRITE))
+#endif
+			result = NULL;
+	}
+	return result;
+}
+
+void fxFreeChunks(txMachine* the, void* theChunks)
+{
+#if mxWindows
+	VirtualFree(theChunks, 0, MEM_RELEASE);
+#else
+	munmap(theChunks, mxReserveChunkSize);
+#endif
+}
+
+txSlot* fxAllocateSlots(txMachine* the, txSize theCount)
+{
+	// fprintf(stderr, "fxAllocateSlots(%u) * %d = %ld\n", theCount, sizeof(txSlot), theCount * sizeof(txSlot));
+	adjustSpaceMeter(the, theCount * sizeof(txSlot));
+	return (txSlot*)c_malloc(theCount * sizeof(txSlot));
+}
+
+void fxFreeSlots(txMachine* the, void* theSlots)
+{
+	c_free(theSlots);
+}
+
+void fxCreateMachinePlatform(txMachine* the)
+{
+#ifdef mxDebug
+#ifdef mxInstrument
+#else
+	the->connection = mxNoSocket;
+#endif
+#endif
+	// Original 10x strategy:
+	// SLOGFILE=out.slog agoric start local-chain
+	// jq -s '.|.[]|.dr[2].allocate' < out.slog|grep -v null|sort -u | sort -nr
+	// int MB = 1024 * 1024;
+	// int measured_max = 30 * MB;
+	// the->allocationLimit = 10 * measured_max;
+
+	size_t GB = 1024 * 1024 * 1024;
+	the->allocationLimit = 2 * GB;
+}
+
+void fxDeleteMachinePlatform(txMachine* the)
+{
+}
+
+void fxQueuePromiseJobs(txMachine* the)
+{
+	the->promiseJobs = 1;
+}
+
+void fxRunDebugger(txMachine* the)
+{
+#ifdef mxDebug
+	fxDebugCommand(the);
+#endif
+}
+
+void fxRunLoop(txMachine* the)
+{
+	c_timeval tv;
+	txNumber when;
+	txJob* job;
+	txJob** address;
+	for (;;) {
+		while (the->promiseJobs) {
+			the->promiseJobs = 0;
+			fxRunPromiseJobs(the);
+		}
+		fxEndJob(the);
+		if (the->promiseJobs) {
+			continue;
+		}
+		c_gettimeofday(&tv, NULL);
+		when = ((txNumber)(tv.tv_sec) * 1000.0) + ((txNumber)(tv.tv_usec) / 1000.0);
+		address = (txJob**)&(the->timerJobs);
+		if (!*address)
+			break;
+		while ((job = *address)) {
+			txMachine* the = job->the;
+			if (the) {
+				if (job->when <= when) {
+					fxBeginHost(the);
+					mxTry(the) {
+						mxPushUndefined();
+						mxPush(job->function);
+						mxCall();
+						mxPush(job->argument);
+						mxRunCount(1);
+						mxPop();
+						if (job->the) {
+							if (job->interval) {
+								job->when += job->interval;
+							}
+							else {
+								fxAccess(the, &job->self);
+								*mxResult = the->scratch;
+								fxForget(the, &job->self);
+								fxSetHostData(the, mxResult, NULL);
+								job->the = NULL;
+							}
+						}
+					}
+					mxCatch(the) {
+						fxAccess(the, &job->self);
+						*mxResult = the->scratch;
+						fxForget(the, &job->self);
+						fxSetHostData(the, mxResult, NULL);
+						job->the = NULL;
+						fxAbort(the, XS_UNHANDLED_EXCEPTION_EXIT);
+					}
+					fxEndHost(the);
+					break; // to run promise jobs queued by the timer in the same "tick"
+				}
+				address = &(job->next);
+			}
+			else {
+				*address = job->next;
+				c_free(job);
+			}
+		}
+	}
+	fxCheckUnhandledRejections(the, 1);
+}
+
+void fxFulfillModuleFile(txMachine* the)
+{
+	mxException = mxUndefined;
+}
+
+void fxRejectModuleFile(txMachine* the)
+{
+	mxException = *mxArgv(0);
+}
+
+void fxRunModuleFile(txMachine* the, txString path)
+{
+	txSlot* realm = mxProgram.value.reference->next->value.module.realm;
+	mxPushStringC(path);
+	fxRunImport(the, realm, XS_NO_ID);
+	mxDub();
+	fxGetID(the, mxID(_then));
+	mxCall();
+	fxNewHostFunction(the, fxFulfillModuleFile, 1, XS_NO_ID, XS_NO_ID);
+	fxNewHostFunction(the, fxRejectModuleFile, 1, XS_NO_ID, XS_NO_ID);
+	mxRunCount(2);
+	mxPop();
+}
+
+void fxRunProgramFile(txMachine* the, txString path)
+{
+	txSlot* realm = mxProgram.value.reference->next->value.module.realm;
+	txScript* script = fxLoadScript(the, path, mxProgramFlag | mxDebugFlag);
+	mxModuleInstanceInternal(mxProgram.value.reference)->value.module.id = fxID(the, path);
+	fxRunScript(the, script, mxRealmGlobal(realm), C_NULL, mxRealmClosures(realm)->value.reference, C_NULL, mxProgram.value.reference);
+	mxPullSlot(mxResult);
+}
+
+txID fxFindModule(txMachine* the, txSlot* realm, txID moduleID, txSlot* slot)
+{
+	char name[C_PATH_MAX];
+	char path[C_PATH_MAX];
+	txInteger dot = 0;
+	txString slash;
+	fxToStringBuffer(the, slot, name, sizeof(name));
+	if (name[0] == '.') {
+		if (name[1] == '/') {
+			dot = 1;
+		}
+		else if ((name[1] == '.') && (name[2] == '/')) {
+			dot = 2;
+		}
+	}
+	if (dot) {
+		if (moduleID == XS_NO_ID)
+			return XS_NO_ID;
+		c_strncpy(path, fxGetKeyName(the, moduleID), C_PATH_MAX - 1);
+		path[C_PATH_MAX - 1] = 0;
+		slash = c_strrchr(path, mxSeparator);
+		if (!slash)
+			return XS_NO_ID;
+		if (dot == 2) {
+			*slash = 0;
+			slash = c_strrchr(path, mxSeparator);
+			if (!slash)
+				return XS_NO_ID;
+		}
+#if mxWindows
+		{
+			char c;
+			char* s = name;
+			while ((c = *s)) {
+				if (c == '/')
+					*s = '\\';
+				s++;
+			}
+		}
+#endif
+	}
+	else
+		slash = path;
+	*slash = 0;
+	if ((c_strlen(path) + c_strlen(name + dot)) >= sizeof(path))
+		mxRangeError("path too long");
+	c_strcat(path, name + dot);
+	return fxNewNameC(the, path);
+}
+
+void fxLoadModule(txMachine* the, txSlot* module, txID moduleID)
+{
+	char path[C_PATH_MAX];
+	char real[C_PATH_MAX];
+	txScript* script;
+#ifdef mxDebug
+	txUnsigned flags = mxDebugFlag;
+#else
+	txUnsigned flags = 0;
+#endif
+	c_strncpy(path, fxGetKeyName(the, moduleID), C_PATH_MAX - 1);
+	path[C_PATH_MAX - 1] = 0;
+	if (c_realpath(path, real)) {
+		script = fxLoadScript(the, real, flags);
+		if (script)
+			fxResolveModule(the, module, moduleID, script, C_NULL, C_NULL);
+	}
+}
+
+txScript* fxLoadScript(txMachine* the, txString path, txUnsigned flags)
+{
+	txParser _parser;
+	txParser* parser = &_parser;
+	txParserJump jump;
+	FILE* file = NULL;
+	txString name = NULL;
+	char map[C_PATH_MAX];
+	txScript* script = NULL;
+	fxInitializeParser(parser, the, the->parserBufferSize, the->parserTableModulo);
+	parser->firstJump = &jump;
+	file = fopen(path, "r");
+	if (c_setjmp(jump.jmp_buf) == 0) {
+		mxParserThrowElse(file);
+		parser->path = fxNewParserSymbol(parser, path);
+		fxParserTree(parser, file, (txGetter)fgetc, flags, &name);
+		fclose(file);
+		file = NULL;
+		if (name) {
+			mxParserThrowElse(c_realpath(fxCombinePath(parser, path, name), map));
+			parser->path = fxNewParserSymbol(parser, map);
+			file = fopen(map, "r");
+			mxParserThrowElse(file);
+			fxParserSourceMap(parser, file, (txGetter)fgetc, flags, &name);
+			fclose(file);
+			file = NULL;
+			if ((parser->errorCount == 0) && name) {
+				mxParserThrowElse(c_realpath(fxCombinePath(parser, map, name), map));
+				parser->path = fxNewParserSymbol(parser, map);
+			}
+		}
+		fxParserHoist(parser);
+		fxParserBind(parser);
+		script = fxParserCode(parser);
+	}
+	if (file)
+		fclose(file);
+#ifdef mxInstrument
+	if (the->peakParserSize < parser->total)
+		the->peakParserSize = parser->total;
+#endif
+	fxTerminateParser(parser);
+	return script;
+}
+
+/* DEBUG */
+
+#ifdef mxDebug
+
+#ifdef mxInstrument
+
+void fxConnect(txMachine* the)
+{
+}
+
+void fxDisconnect(txMachine* the)
+{
+}
+
+txBoolean fxIsConnected(txMachine* the)
+{
+	return 1;
+}
+
+txBoolean fxIsReadable(txMachine* the)
+{
+	return 0;
+}
+
+void fxReceive(txMachine* the)
+{
+	ssize_t count;
+again:
+	count = read(5, the->debugBuffer, sizeof(the->debugBuffer) - 1);
+	if (count < 0) {
+		if (errno == EINTR)
+			goto again;
+		the->debugOffset = 0;
+	}
+	else
+		the->debugOffset = count;
+	the->debugBuffer[the->debugOffset] = 0;
+}
+
+void fxSend(txMachine* the, txBoolean more)
+{
+	ssize_t count;
+again:
+	count = write(6, the->echoBuffer, the->echoOffset);
+	if (count < 0) {
+		if (errno == EINTR)
+			goto again;
+	}
+}
+
+#else
+
+void fxConnect(txMachine* the)
+{
+	char name[256];
+	char* colon;
+	int port;
+	struct sockaddr_in address;
+#if mxWindows
+	if (GetEnvironmentVariable("XSBUG_HOST", name, sizeof(name))) {
+#else
+	colon = getenv("XSBUG_HOST");
+	if ((colon) && (c_strlen(colon) + 1 < sizeof(name))) {
+		c_strcpy(name, colon);
+#endif		
+		colon = strchr(name, ':');
+		if (colon == NULL)
+			port = 5002;
+		else {
+			*colon = 0;
+			colon++;
+			port = strtol(colon, NULL, 10);
+		}
+	}
+	else {
+		// Require XSBUG_HOST to be set for debugging.
+		return;
+		// strcpy(name, "localhost");
+		// port = 5002;
+	}
+	memset(&address, 0, sizeof(address));
+  	address.sin_family = AF_INET;
+	address.sin_addr.s_addr = inet_addr(name);
+	if (address.sin_addr.s_addr == INADDR_NONE) {
+		struct hostent *host = gethostbyname(name);
+		if (!host)
+			return;
+		memcpy(&(address.sin_addr), host->h_addr, host->h_length);
+	}
+  	address.sin_port = htons(port);
+#if mxWindows
+{  	
+	WSADATA wsaData;
+	unsigned long flag;
+	if (WSAStartup(0x202, &wsaData) == SOCKET_ERROR)
+		return;
+	the->connection = socket(AF_INET, SOCK_STREAM, 0);
+	if (the->connection == INVALID_SOCKET)
+		return;
+  	flag = 1;
+  	ioctlsocket(the->connection, FIONBIO, &flag);
+	if (connect(the->connection, (struct sockaddr*)&address, sizeof(address)) == SOCKET_ERROR) {
+		if (WSAEWOULDBLOCK == WSAGetLastError()) {
+			fd_set fds;
+			struct timeval timeout = { 2, 0 }; // 2 seconds, 0 micro-seconds
+			FD_ZERO(&fds);
+			FD_SET(the->connection, &fds);
+			if (select(0, NULL, &fds, NULL, &timeout) == 0)
+				goto bail;
+			if (!FD_ISSET(the->connection, &fds))
+				goto bail;
+		}
+		else
+			goto bail;
+	}
+ 	flag = 0;
+ 	ioctlsocket(the->connection, FIONBIO, &flag);
+}
+#else
+{  	
+	int	flag;
+	the->connection = socket(AF_INET, SOCK_STREAM, 0);
+	if (the->connection <= 0)
+		goto bail;
+	c_signal(SIGPIPE, SIG_IGN);
+#if mxMacOSX
+	{
+		int set = 1;
+		setsockopt(the->connection, SOL_SOCKET, SO_NOSIGPIPE, (void *)&set, sizeof(int));
+	}
+#endif
+	flag = fcntl(the->connection, F_GETFL, 0);
+	fcntl(the->connection, F_SETFL, flag | O_NONBLOCK);
+	if (connect(the->connection, (struct sockaddr*)&address, sizeof(address)) < 0) {
+    	 if (errno == EINPROGRESS) { 
+			fd_set fds;
+			struct timeval timeout = { 2, 0 }; // 2 seconds, 0 micro-seconds
+			int error = 0;
+			unsigned int length = sizeof(error);
+			FD_ZERO(&fds);
+			FD_SET(the->connection, &fds);
+			if (select(the->connection + 1, NULL, &fds, NULL, &timeout) == 0)
+				goto bail;
+			if (!FD_ISSET(the->connection, &fds))
+				goto bail;
+			if (getsockopt(the->connection, SOL_SOCKET, SO_ERROR, &error, &length) < 0)
+				goto bail;
+			if (error)
+				goto bail;
+		}
+		else
+			goto bail;
+	}
+	fcntl(the->connection, F_SETFL, flag);
+	c_signal(SIGPIPE, SIG_DFL);
+}
+#endif
+	return;
+bail:
+	fxDisconnect(the);
+}
+
+void fxDisconnect(txMachine* the)
+{
+#if mxWindows
+	if (the->connection != INVALID_SOCKET) {
+		closesocket(the->connection);
+		the->connection = INVALID_SOCKET;
+	}
+	WSACleanup();
+#else
+	if (the->connection >= 0) {
+		close(the->connection);
+		the->connection = mxNoSocket;
+	}
+#endif
+}
+
+txBoolean fxIsConnected(txMachine* the)
+{
+	return (the->connection != mxNoSocket) ? 1 : 0;
+}
+
+txBoolean fxIsReadable(txMachine* the)
+{
+	return 0;
+}
+
+void fxReceive(txMachine* the)
+{
+	int count;
+	if (the->connection != mxNoSocket) {
+#if mxWindows
+		count = recv(the->connection, the->debugBuffer, sizeof(the->debugBuffer) - 1, 0);
+		if (count < 0)
+			fxDisconnect(the);
+		else
+			the->debugOffset = count;
+#else
+	again:
+		count = read(the->connection, the->debugBuffer, sizeof(the->debugBuffer) - 1);
+		if (count < 0) {
+			if (errno == EINTR)
+				goto again;
+			else
+				fxDisconnect(the);
+		}
+		else
+			the->debugOffset = count;
+#endif
+	}
+	the->debugBuffer[the->debugOffset] = 0;
+}
+
+void fxSend(txMachine* the, txBoolean more)
+{
+	if (the->connection != mxNoSocket) {
+#if mxWindows
+		if (send(the->connection, the->echoBuffer, the->echoOffset, 0) <= 0)
+			fxDisconnect(the);
+#else
+	again:
+		if (write(the->connection, the->echoBuffer, the->echoOffset) <= 0) {
+			if (errno == EINTR)
+				goto again;
+			else
+				fxDisconnect(the);
+		}
+#endif
+	}
+}
+
+#endif /* mxInstrument */
+
+#endif /* mxDebug */
+
+void fxVersion(txString theBuffer, txSize theSize)
+{
+	c_snprintf(theBuffer, theSize, "%d.%d.%d", XS_MAJOR_VERSION, XS_MINOR_VERSION, XS_PATCH_VERSION);
+}
+
+#ifdef mxMetering
+txUnsigned fxGetCurrentMeter(txMachine* the)
+{
+	return the->meterIndex;
+}
+
+void fxSetCurrentMeter(txMachine* the, txUnsigned value)
+{
+	the->meterIndex = value;
+}
+#endif
+
+txSize fxGetCurrentHeapCount(txMachine* the)
+{
+	return the->currentHeapCount;
+}
+
+extern void fxDumpSnapshot(txMachine* the, txSnapshot* snapshot);
+
+typedef void (*txDumpChunk)(FILE* file, txByte* data, txSize size);
+
+#define mxThrowIf(_ERROR) { if (_ERROR) { snapshot->error = _ERROR; fxJump(the); } }
+
+static void fxDumpChunk(txSlot* slot, txByte* block);
+static void fxDumpChunkAddress(FILE* file, void* address);
+static void fxDumpChunkArray(FILE* file, txByte* data, txSize size);
+static void fxDumpChunkData(FILE* file, txByte* data, txSize size);
+static void fxDumpChunkString(FILE* file, txByte* data, txSize size);
+static void fxDumpChunkTable(FILE* file, txByte* data, txSize size); 
+static void fxDumpID(FILE* file, txID id);
+static void fxDumpNumber(FILE* file, txNumber value);
+static void fxDumpSlot(FILE* file, txSlot* slot);
+static void fxDumpSlotAddress(FILE* file, void* address);
+static void fxDumpSlotTable(FILE* file, txByte* buffer, txSize size);
+
+void fxDumpSnapshot(txMachine* the, txSnapshot* snapshot)
+{
+	Atom atom;
+	txByte byte;
+	txCreation creation;
+	txID profileID;
+	txInteger tag;
+	Atom blockAtom;
+	txByte* block = C_NULL;
+// 	txByte* blockLimit;
+	Atom heapAtom;
+	txSlot* heap = C_NULL;
+	txSlot* heapLimit;
+	Atom stackAtom;
+	txSlot* stack = C_NULL;
+	txSlot* stackLimit;
+	
+	txSlot* current;
+	
+	txByte* buffer = C_NULL;
+	txByte* address;
+	txSize offset, size;
+	txString string;
+
+	mxTry(the) {
+		mxThrowIf((*snapshot->read)(snapshot->stream, &atom, sizeof(Atom)));
+		atom.atomSize = ntohl(atom.atomSize) - 8;
+		fprintf(stderr, "%4.4s %d\n", (txString)&(atom.atomType), atom.atomSize + 8);
+		
+		mxThrowIf((*snapshot->read)(snapshot->stream, &atom, sizeof(Atom)));
+		atom.atomSize = ntohl(atom.atomSize) - 8;
+		fprintf(stderr, "%4.4s %d\n", (txString)&(atom.atomType), atom.atomSize + 8);
+		mxThrowIf((*snapshot->read)(snapshot->stream, &byte, 1));
+		fprintf(stderr, "\t%d.", byte);
+		mxThrowIf((*snapshot->read)(snapshot->stream, &byte, 1));
+		fprintf(stderr, "%d.", byte);
+		mxThrowIf((*snapshot->read)(snapshot->stream, &byte, 1));
+		fprintf(stderr, "%d ", byte);
+		mxThrowIf((*snapshot->read)(snapshot->stream, &byte, 1));
+		fprintf(stderr, "(%d)\n", byte);
+		
+		mxThrowIf((*snapshot->read)(snapshot->stream, &atom, sizeof(Atom)));
+		atom.atomSize = ntohl(atom.atomSize) - 8;
+		buffer = c_malloc(atom.atomSize);
+		mxThrowIf(buffer == C_NULL);
+		mxThrowIf((*snapshot->read)(snapshot->stream, buffer, atom.atomSize));
+		fprintf(stderr, "%4.4s %d\n", (txString)&(atom.atomType), atom.atomSize + 8);
+		fprintf(stderr, "\t%s\n", (txString)buffer);
+		c_free(buffer);
+	
+		mxThrowIf((*snapshot->read)(snapshot->stream, &atom, sizeof(Atom)));
+		atom.atomSize = ntohl(atom.atomSize) - 8;
+		mxThrowIf((*snapshot->read)(snapshot->stream, &creation, sizeof(txCreation)));
+		mxThrowIf((*snapshot->read)(snapshot->stream, &profileID, sizeof(txID)));
+		mxThrowIf((*snapshot->read)(snapshot->stream, &tag, sizeof(txInteger)));
+		fprintf(stderr, "%4.4s %d\n", (txString)&(atom.atomType), atom.atomSize + 8);
+		fprintf(stderr, "\tinitialChunkSize: %d\n", creation.initialChunkSize);
+		fprintf(stderr, "\tincrementalChunkSize: %d\n", creation.incrementalChunkSize);
+		fprintf(stderr, "\tinitialHeapCount: %d\n", creation.initialHeapCount);
+		fprintf(stderr, "\tincrementalHeapCount: %d\n", creation.incrementalHeapCount);
+		fprintf(stderr, "\tstackCount: %d\n", creation.stackCount);
+		fprintf(stderr, "\tinitialKeyCount: %d\n", creation.initialKeyCount);
+		fprintf(stderr, "\tincrementalKeyCount: %d\n", creation.incrementalKeyCount);
+		fprintf(stderr, "\tnameModulo: %d\n", creation.nameModulo);
+		fprintf(stderr, "\tsymbolModulo: %d\n", creation.symbolModulo);
+		fprintf(stderr, "\tparserBufferSize: %d\n", creation.parserBufferSize);
+		fprintf(stderr, "\tparserTableModulo: %d\n", creation.parserTableModulo);
+		fprintf(stderr, "\tstaticSize: %d\n", creation.staticSize);
+		fprintf(stderr, "\tprofileID: %d\n", profileID);
+		fprintf(stderr, "\ttag: %d\n", tag);
+
+		mxThrowIf((*snapshot->read)(snapshot->stream, &blockAtom, sizeof(Atom)));
+		blockAtom.atomSize = ntohl(blockAtom.atomSize) - 8;
+		block = c_malloc(blockAtom.atomSize);
+		mxThrowIf(block == C_NULL);
+		mxThrowIf((*snapshot->read)(snapshot->stream, block, blockAtom.atomSize));
+//		blockLimit = block + blockAtom.atomSize;
+
+		mxThrowIf((*snapshot->read)(snapshot->stream, &heapAtom, sizeof(Atom)));
+		heapAtom.atomSize = ntohl(heapAtom.atomSize) - 8;
+		heap = c_malloc(sizeof(txSlot) + heapAtom.atomSize);
+		mxThrowIf(heap == C_NULL);
+		c_memset(heap, 0, sizeof(txSlot));
+		mxThrowIf((*snapshot->read)(snapshot->stream, heap + 1, heapAtom.atomSize));
+		heapLimit = heap + 1 + (heapAtom.atomSize / sizeof(txSlot));
+		
+		mxThrowIf((*snapshot->read)(snapshot->stream, &stackAtom, sizeof(Atom)));
+		stackAtom.atomSize = ntohl(stackAtom.atomSize) - 8;
+		stack = c_malloc(stackAtom.atomSize);
+		mxThrowIf(stack == C_NULL);
+		mxThrowIf((*snapshot->read)(snapshot->stream, stack, stackAtom.atomSize));
+		stackLimit = stack + (stackAtom.atomSize / sizeof(txSlot));
+		
+		current = heap;
+		while (current < heapLimit) {
+			fxDumpChunk(current, block);
+			current++;
+		}
+		current = stack;
+		while (current < stackLimit) {
+			fxDumpChunk(current, block);
+			current++;
+		}
+
+		fprintf(stderr, "%4.4s %d\n", (txString)&(blockAtom.atomType), blockAtom.atomSize + 8);
+		address = block;
+		offset = 0;
+		while (offset < blockAtom.atomSize) {
+			txChunk* chunk = (txChunk*)address;
+			fprintf(stderr, "\t<%8.8lu> %8d ", offset + sizeof(txChunk), chunk->size);
+			if (chunk->temporary)
+				(*(txDumpChunk)(chunk->temporary))(stderr, address + sizeof(txChunk), chunk->size - sizeof(txChunk));
+			else
+				fxDumpChunkData(stderr, address + sizeof(txChunk), chunk->size - sizeof(txChunk));
+// 			fxDumpChunkData(stderr, address + sizeof(txChunk), chunk->size - sizeof(txChunk));
+			fprintf(stderr, "\n");
+			address += chunk->size;
+			offset += chunk->size;
+		}
+		
+		fprintf(stderr, "%4.4s %d\n", (txString)&(heapAtom.atomType), heapAtom.atomSize + 8);
+		current = heap;
+		offset = 0;
+		while (current < heapLimit) {
+			fprintf(stderr, "\t[%8.8d] ", offset);
+			fxDumpSlotAddress(stderr, current->next);
+			fprintf(stderr, " ");
+			fxDumpSlot(stderr, current);
+			fprintf(stderr, "\n");
+			current++;
+			offset++;
+		}
+		
+		fprintf(stderr, "%4.4s %d\n", (txString)&(stackAtom.atomType), stackAtom.atomSize + 8);
+		current = stack;
+		while (current < stackLimit) {
+			fprintf(stderr, "\t           ");
+			fxDumpSlotAddress(stderr, current->next);
+			fprintf(stderr, " ");
+			fxDumpSlot(stderr, current);
+			fprintf(stderr, "\n");
+			current++;
+		}
+
+		mxThrowIf((*snapshot->read)(snapshot->stream, &atom, sizeof(Atom)));
+		atom.atomSize = ntohl(atom.atomSize) - 8;
+		buffer = c_malloc(atom.atomSize);
+		mxThrowIf(buffer == C_NULL);
+		mxThrowIf((*snapshot->read)(snapshot->stream, buffer, atom.atomSize));
+		fprintf(stderr, "%4.4s %d\n", (txString)&(atom.atomType), atom.atomSize + 8);
+		address = buffer;
+		offset = 0;
+		size = atom.atomSize / sizeof(txSlot*);
+		while (offset < size) {
+			txSlot* slot = *((txSlot**)address);
+			fprintf(stderr, "\tID_%6.6d", offset);
+			if (slot) {
+				fprintf(stderr, " [%8.8zu]", (size_t)slot);
+				slot = ((txSlot*)heap) + (size_t)slot;
+				string = ((txString)block) + (size_t)(slot->value.key.string);
+				fprintf(stderr, " %s\n", string);
+			}
+			else
+				fprintf(stderr, " [        ]\n");
+			address += sizeof(txSlot*);
+			offset++;
+		}
+		c_free(buffer);
+		buffer = C_NULL;
+
+		mxThrowIf((*snapshot->read)(snapshot->stream, &atom, sizeof(Atom)));
+		atom.atomSize = ntohl(atom.atomSize) - 8;
+		buffer = c_malloc(atom.atomSize);
+		mxThrowIf(buffer == C_NULL);
+		mxThrowIf((*snapshot->read)(snapshot->stream, buffer, atom.atomSize));
+		fprintf(stderr, "%4.4s %d", (txString)&(atom.atomType), atom.atomSize + 8);
+		fxDumpSlotTable(stderr, buffer, atom.atomSize);
+		fprintf(stderr, "\n");
+
+		mxThrowIf((*snapshot->read)(snapshot->stream, &atom, sizeof(Atom)));
+		atom.atomSize = ntohl(atom.atomSize) - 8;
+		buffer = c_malloc(atom.atomSize);
+		mxThrowIf(buffer == C_NULL);
+		mxThrowIf((*snapshot->read)(snapshot->stream, buffer, atom.atomSize));
+		fprintf(stderr, "%4.4s %d", (txString)&(atom.atomType), atom.atomSize + 8);
+		fxDumpSlotTable(stderr, buffer, atom.atomSize);
+		fprintf(stderr, "\n");
+		
+		c_free(stack);
+		c_free(heap);
+		c_free(block);
+	}
+	mxCatch(the) {
+		if (buffer)
+			c_free(buffer);
+		if (stack)
+			c_free(stack);
+		if (heap)
+			c_free(heap);
+		if (block)
+			c_free(block);
+	}
+}
+
+void fxDumpChunk(txSlot* slot, txByte* block) 
+{
+	txChunk* chunk;
+	switch (slot->kind) {
+	case XS_STRING_KIND: {
+		chunk = (txChunk*)(block + (size_t)(slot->value.string) - sizeof(txChunk));
+		chunk->temporary = (txByte*)fxDumpChunkString;
+	} break;
+	case XS_BIGINT_KIND: {
+		chunk = (txChunk*)(block + (size_t)(slot->value.bigint.data) - sizeof(txChunk));
+		chunk->temporary = (txByte*)fxDumpChunkData;
+	} break;
+	case XS_ARGUMENTS_SLOPPY_KIND:
+	case XS_ARGUMENTS_STRICT_KIND:
+	case XS_ARRAY_KIND:
+	case XS_STACK_KIND: {
+		if (slot->value.array.address) {
+			chunk = (txChunk*)(block + (size_t)(slot->value.array.address) - sizeof(txChunk));
+			chunk->temporary = (txByte*)fxDumpChunkArray;
+			
+			{
+				txIndex size = chunk->size / sizeof(txSlot);
+				txSlot* item = (txSlot*)(block + (size_t)(slot->value.array.address));
+				while (size) {
+					fxDumpChunk(item, block);
+					size--;
+					item++;
+				}
+			}
+			
+		}
+	} break;
+	case XS_ARRAY_BUFFER_KIND: {
+		if (slot->value.arrayBuffer.address) {
+			chunk = (txChunk*)(block + (size_t)(slot->value.arrayBuffer.address) - sizeof(txChunk));
+			chunk->temporary = (txByte*)fxDumpChunkData;
+		}
+	} break;
+	case XS_CODE_KIND:  {
+		chunk = (txChunk*)(block + (size_t)(slot->value.code.address) - sizeof(txChunk));
+		chunk->temporary = (txByte*)fxDumpChunkData;
+	} break;
+	case XS_REGEXP_KIND: {
+		if (slot->value.regexp.code) {
+			chunk = (txChunk*)(block + (size_t)(slot->value.regexp.code) - sizeof(txChunk));
+			chunk->temporary = (txByte*)fxDumpChunkData;
+		}
+		if (slot->value.regexp.data) {
+			chunk = (txChunk*)(block + (size_t)(slot->value.regexp.data) - sizeof(txChunk));
+			chunk->temporary = (txByte*)fxDumpChunkData;
+		}
+	} break;
+	case XS_KEY_KIND: {
+		if (slot->value.key.string) {
+			chunk = (txChunk*)(block + (size_t)(slot->value.key.string) - sizeof(txChunk));
+			chunk->temporary = (txByte*)fxDumpChunkString;
+		}
+	} break;
+	case XS_GLOBAL_KIND:
+	case XS_MAP_KIND:
+	case XS_SET_KIND: {
+		chunk = (txChunk*)(block + (size_t)(slot->value.table.address) - sizeof(txChunk));
+		chunk->temporary = (txByte*)fxDumpChunkTable;
+	} break;
+	case XS_HOST_KIND: {
+		if (slot->value.host.data) {
+			chunk = (txChunk*)(block + (size_t)(slot->value.host.data) - sizeof(txChunk));
+			chunk->temporary = (txByte*)fxDumpChunkData;
+		}
+	} break;
+	default:
+		break;
+	}
+}
+
+void fxDumpChunkAddress(FILE* file, void* address) 
+{
+	if (address)
+		fprintf(file, "<%8.8zu>", (size_t)address);
+	else
+		fprintf(file, "<        >");
+}
+
+void fxDumpChunkArray(FILE* file, txByte* data, txSize size) 
+{
+	txSize offset = 0;
+	txSlot* slot = (txSlot*)data;
+	size /= sizeof(txSlot);
+	while (offset < size) {
+		fprintf(file, "\n\t\t%8zu ", (size_t)slot->next);
+		fxDumpSlot(file, slot);
+		offset++;
+		slot++;
+	}
+}
+
+void fxDumpChunkData(FILE* file, txByte* data, txSize size) 
+{
+	txSize offset = 0;
+	txU1* address = (txU1*)data;
+	while (offset < size) {
+		if (offset % 32)
+			fprintf(file, " ");
+		else
+			fprintf(file, "\n\t\t");
+		fprintf(file, "%2.2x", address[offset]);
+		offset++;
+	}
+}
+
+void fxDumpChunkString(FILE* file, txByte* data, txSize size) 
+{
+	fprintf(file, " %s", data);
+}
+
+void fxDumpChunkTable(FILE* file, txByte* data, txSize size) 
+{
+	txSize offset = 0;
+	txSlot** address = (txSlot**)data;
+	size /= sizeof(txSlot*);
+	while (offset < size) {
+		txSlot* slot = *((txSlot**)address);
+		if (offset % 8)
+			fprintf(file, " ");
+		else
+			fprintf(file, "\n\t\t");
+		fxDumpSlotAddress(file, slot);
+		offset++;
+		address++;
+	}
+}
+
+void fxDumpID(FILE* file, txID id)
+{
+	if (id == 0)
+		fprintf(file, "         ");
+	else
+		fprintf(file, "ID_%6.6d", id);
+}
+
+void fxDumpNumber(FILE* file, txNumber value) 
+{
+	switch (c_fpclassify(value)) {
+	case C_FP_INFINITE:
+		if (value < 0)
+			fprintf(file, "-C_INFINITY");
+		else
+			fprintf(file, "C_INFINITY");
+		break;
+	case C_FP_NAN:
+		fprintf(file, "C_NAN");
+		break;
+	default:
+		fprintf(file, "%.20e", value);
+		break;
+	}
+}
+
+void fxDumpSlot(FILE* file, txSlot* slot)
+{
+	if (slot->flag & XS_MARK_FLAG)
+		fprintf(file, "M");
+	else
+		fprintf(file, "_");
+	if (slot->kind == XS_INSTANCE_KIND) {
+		if (slot->flag & XS_DONT_MARSHALL_FLAG)
+			fprintf(file, "H");
+		else
+			fprintf(file, "_");
+		if (slot->flag & XS_LEVEL_FLAG)
+			fprintf(file, "L");
+		else
+			fprintf(file, "_");
+		if (slot->flag & XS_DONT_PATCH_FLAG)
+			fprintf(file, "P");
+		else
+			fprintf(file, "_");
+		if (slot->flag & XS_FIELD_FLAG)
+			fprintf(file, "F");
+		else
+			fprintf(file, "_");
+		if (slot->flag & XS_CAN_CONSTRUCT_FLAG)
+			fprintf(file, "N");
+		else
+			fprintf(file, "_");
+		if (slot->flag & XS_CAN_CALL_FLAG)
+			fprintf(file, "C");
+		else
+			fprintf(file, "_");
+		if (slot->flag & XS_EXOTIC_FLAG)
+			fprintf(file, "X");
+		else
+			fprintf(file, "_");
+	}
+	else {
+		if (slot->flag & XS_DERIVED_FLAG)
+			fprintf(file, "H");
+		else
+			fprintf(file, "_");
+		if (slot->flag & XS_BASE_FLAG)
+			fprintf(file, "B");
+		else
+			fprintf(file, "_");
+		if (slot->flag & XS_INSPECTOR_FLAG)
+			fprintf(file, "L");
+		else
+			fprintf(file, "_");
+		if (slot->flag & XS_DONT_SET_FLAG)
+			fprintf(file, "S");
+		else
+			fprintf(file, "_");
+		if (slot->flag & XS_DONT_ENUM_FLAG)
+			fprintf(file, "E");
+		else
+			fprintf(file, "_");
+		if (slot->flag & XS_DONT_DELETE_FLAG)
+			fprintf(file, "D");
+		else
+			fprintf(file, "_");
+		if (slot->flag & XS_INTERNAL_FLAG)
+			fprintf(file, "I");
+		else
+			fprintf(file, "_");
+	
+	}
+	fprintf(file, " ");
+	fxDumpID(file, slot->ID);
+	fprintf(file, " ");
+	switch (slot->kind) {
+	case XS_UNINITIALIZED_KIND: {
+		fprintf(file, "unititialized");
+	} break;
+	case XS_UNDEFINED_KIND: {
+		fprintf(file, "undefined");
+	} break;
+	case XS_NULL_KIND: {
+		fprintf(file, "null");
+	} break;
+	case XS_BOOLEAN_KIND: {
+		fprintf(file, "boolean = %d", slot->value.boolean);
+	} break;
+	case XS_INTEGER_KIND: {
+		fprintf(file, "integer = %d", slot->value.integer);
+	} break;
+	case XS_NUMBER_KIND: {
+		fprintf(file, "number = ");
+		fxDumpNumber(file, slot->value.number);
+	} break;
+	case XS_STRING_KIND: {
+		fprintf(file, "string = ");
+		fxDumpChunkAddress(file, slot->value.string);
+	} break;
+	case XS_SYMBOL_KIND: {
+		fprintf(file, "symbol = ");
+		fxDumpID(file, slot->value.symbol);
+	} break;
+	case XS_BIGINT_KIND: {
+		fprintf(file, "bigint = { .data = ");
+		fxDumpChunkAddress(file, slot->value.bigint.data);
+		fprintf(file, ", .size = %d, ", slot->value.bigint.size);
+		fprintf(file, ".sign = %d, ", slot->value.bigint.sign);
+		fprintf(file, " }");
+	} break;
+	case XS_REFERENCE_KIND: {
+		fprintf(file, "reference = ");
+		fxDumpSlotAddress(file, slot->value.reference);
+	} break;
+	case XS_CLOSURE_KIND: {
+		fprintf(file, "closure = ");
+		fxDumpSlotAddress(file, slot->value.closure);
+	} break; 
+	case XS_INSTANCE_KIND: {
+		fprintf(file, "instance = { .garbage = ");
+		fxDumpSlotAddress(file, slot->value.instance.garbage);
+		fprintf(file, ", .prototype = ");
+		fxDumpSlotAddress(file, slot->value.instance.prototype);
+		fprintf(file, " }");
+	} break;
+	case XS_ARGUMENTS_SLOPPY_KIND:
+	case XS_ARGUMENTS_STRICT_KIND:
+	case XS_ARRAY_KIND: {
+		fprintf(file, "array = { .address = ");
+		fxDumpChunkAddress(file, slot->value.array.address);
+		fprintf(file, ", .length = %d }", (int)slot->value.array.length);
+	} break;
+	case XS_ARRAY_BUFFER_KIND: {
+		fprintf(file, "arrayBuffer = { .address = ");
+		fxDumpChunkAddress(file, slot->value.arrayBuffer.address);
+		fprintf(file, " }");
+	} break;
+	case XS_BUFFER_INFO_KIND: {
+		fprintf(file, "bufferInfo = { .length = %d, maxLength = %d }", slot->value.bufferInfo.length, slot->value.bufferInfo.maxLength);
+	} break;
+	case XS_CALLBACK_KIND: {
+		fprintf(file, "callback");
+	} break;
+	case XS_CODE_KIND:  {
+		fprintf(file, "code = { .address = ");
+		fxDumpChunkAddress(file, slot->value.code.address);
+		fprintf(file, ", .closures = ");
+		fxDumpSlotAddress(file, slot->value.code.closures);
+		fprintf(file, " }");
+	} break;
+	case XS_DATE_KIND: {
+		fprintf(file, "date = ");
+		fxDumpNumber(file, slot->value.number);
+	} break;
+	case XS_DATA_VIEW_KIND: {
+		fprintf(file, "dataView = { .offset = %d, .size = %d }", slot->value.dataView.offset, slot->value.dataView.size);
+	} break;
+	case XS_FINALIZATION_CELL_KIND: {
+		fprintf(file, "finalizationCell = { .target = ");
+		fxDumpSlotAddress(file, slot->value.finalizationCell.target);
+		fprintf(file, ", .token = ");
+		fxDumpSlotAddress(file, slot->value.finalizationCell.token);
+		fprintf(file, " }");
+	} break;
+	case XS_FINALIZATION_REGISTRY_KIND: {
+		fprintf(file, "finalizationRegistry = { .target = ");
+		fxDumpSlotAddress(file, slot->value.finalizationRegistry.callback);
+		fprintf(file, ", .flags = %d }", slot->value.finalizationRegistry.flags);
+	} break;
+	case XS_GLOBAL_KIND: {
+		fprintf(file, "global = { .address = ");
+		fxDumpChunkAddress(file, slot->value.table.address);
+		fprintf(file, ", .length = %d }", (int)slot->value.table.length);
+	} break;
+	case XS_MAP_KIND: {
+		fprintf(file, "map = { .address = ");
+		fxDumpChunkAddress(file, slot->value.table.address);
+		fprintf(file, ", .length = %d }", (int)slot->value.table.length);
+	} break;
+	case XS_MODULE_KIND: {
+		fprintf(file, "module = { .realm = ");
+		fxDumpSlotAddress(file, slot->value.module.realm);
+		fprintf(file, ", .id = ");
+		fxDumpID(file, slot->value.module.id);
+		fprintf(file, " }");
+	} break;
+	case XS_PROGRAM_KIND: {
+		fprintf(file, "program = { .realm = ");
+		fxDumpSlotAddress(file, slot->value.module.realm);
+		fprintf(file, ", .id = ");
+		fxDumpID(file, slot->value.module.id);
+		fprintf(file, " }");
+	} break;
+	case XS_PROMISE_KIND: {
+		fprintf(file, "promise = %d }", slot->value.integer);
+	} break;
+	case XS_PROXY_KIND: {
+		fprintf(file, "proxy = { .handler = ");
+		fxDumpSlotAddress(file, slot->value.proxy.handler);
+		fprintf(file, ", .target = ");
+		fxDumpSlotAddress(file, slot->value.proxy.target);
+		fprintf(file, " }");
+	} break;
+	case XS_REGEXP_KIND: {
+		fprintf(file, "regexp = { .code = ");
+		fxDumpChunkAddress(file, slot->value.regexp.code);
+		fprintf(file, ", .data = ");
+		fxDumpChunkAddress(file, slot->value.regexp.data);
+		fprintf(file, " }");
+	} break;
+	case XS_SET_KIND: {
+		fprintf(file, "set = { .address = ");
+		fxDumpChunkAddress(file, slot->value.table.address);
+		fprintf(file, ", .length = %d }", (int)slot->value.table.length);
+	} break;
+	case XS_TYPED_ARRAY_KIND: {
+		fprintf(file, ".kind = XS_TYPED_ARRAY_KIND}, ");
+		fprintf(file, ".value = { .typedArray = { .dispatch = gxTypeDispatches[%zu], .atomics = gxTypeAtomics[%zu] }", (size_t)slot->value.typedArray.dispatch, (size_t)slot->value.typedArray.atomics);
+	} break;
+	case XS_WEAK_MAP_KIND: {
+		fprintf(file, "weakMap = { .first = ");
+		fxDumpSlotAddress(file, slot->value.weakList.first);
+		fprintf(file, ", .link = ");
+		fxDumpSlotAddress(file, slot->value.weakList.link);
+		fprintf(file, " }");
+	} break;
+	case XS_WEAK_SET_KIND: {
+		fprintf(file, "weakSet = { .first = ");
+		fxDumpSlotAddress(file, slot->value.weakList.first);
+		fprintf(file, ", .link = ");
+		fxDumpSlotAddress(file, slot->value.weakList.link);
+		fprintf(file, " }");
+	} break;
+	case XS_WEAK_REF_KIND: {
+		fprintf(file, "weakRef = { .target = ");
+		fxDumpSlotAddress(file, slot->value.weakRef.target);
+		fprintf(file, ", .link = ");
+		fxDumpSlotAddress(file, slot->value.weakRef.link);
+		fprintf(file, " }");
+	} break;
+	case XS_ACCESSOR_KIND: {
+		fprintf(file, "accessor = { .getter = ");
+		fxDumpSlotAddress(file, slot->value.accessor.getter);
+		fprintf(file, ", .setter = ");
+		fxDumpSlotAddress(file, slot->value.accessor.setter);
+		fprintf(file, " }");
+	} break;
+	case XS_AT_KIND: {
+		fprintf(file, "at = { 0x%x, %d }", slot->value.at.index, slot->value.at.id);
+	} break;
+	case XS_ENTRY_KIND: {
+		fprintf(file, "entry = { ");
+		fxDumpSlotAddress(file, slot->value.entry.slot);
+		fprintf(file, ", 0x%x }", slot->value.entry.sum);
+	} break;
+	case XS_ERROR_KIND: {
+		fprintf(file, "error = { ");
+		fxDumpSlotAddress(file, slot->value.error.info);
+		fprintf(file, ", %d }", slot->value.error.which);
+	} break;
+	case XS_EXPORT_KIND: {
+		fprintf(file, "export = { .closure = ");
+		fxDumpSlotAddress(file, slot->value.export.closure);
+		fprintf(file, ", .module = ");
+		fxDumpSlotAddress(file, slot->value.export.module);
+		fprintf(file, " }");
+	} break;
+	case XS_HOME_KIND: {
+		fprintf(file, "home = { .object = ");
+		fxDumpSlotAddress(file, slot->value.home.object);
+		fprintf(file, ", .module = ");
+		fxDumpSlotAddress(file, slot->value.home.module);
+		fprintf(file, " }");
+	} break;
+	case XS_KEY_KIND: {
+		fprintf(file, "key = { .string = ");
+		fxDumpChunkAddress(file, slot->value.key.string);
+		fprintf(file, ", .sum = 0x%x }", slot->value.key.sum);
+	} break;
+	case XS_LIST_KIND: {
+		fprintf(file, "list = { .first = ");
+		fxDumpSlotAddress(file, slot->value.list.first);
+		fprintf(file, ", .last = ");
+		fxDumpSlotAddress(file, slot->value.list.last);
+		fprintf(file, " }");
+	} break;
+	case XS_PRIVATE_KIND: {
+		fprintf(file, "private = { .check = ");
+		fxDumpSlotAddress(file, slot->value.private.check);
+		fprintf(file, ", .first = ");
+		fxDumpSlotAddress(file, slot->value.private.first);
+		fprintf(file, " }");
+	} break;
+	case XS_STACK_KIND: {
+		fprintf(file, "stack = { .address = ");
+		fxDumpChunkAddress(file, slot->value.array.address);
+		fprintf(file, ", .length = %d }", (int)slot->value.array.length);
+	} break;
+	case XS_WEAK_ENTRY_KIND: {
+		fprintf(file, "weakEntry = { .check = ");
+		fxDumpSlotAddress(file, slot->value.weakEntry.check);
+		fprintf(file, ", .value = ");
+		fxDumpSlotAddress(file, slot->value.weakEntry.value);
+		fprintf(file, " }");
+	} break;
+	case XS_HOST_KIND: {
+		fprintf(file, "host = { .data = ");
+		fxDumpChunkAddress(file, slot->value.host.data);
+		fprintf(file, " }");
+	} break;
+	default:
+		break;
+	}
+}
+
+void fxDumpSlotAddress(FILE* file, void* address) 
+{
+	if (address)
+		fprintf(file, "[%8.8zu]", (size_t)address);
+	else
+		fprintf(file, "[        ]");
+}
+
+void fxDumpSlotTable(FILE* file, txByte* buffer, txSize size)
+{
+	txSize offset = 0;
+	txSlot** address = (txSlot**)buffer;
+	size /= sizeof(txSlot*);
+	while (offset < size) {
+		txSlot* slot = *((txSlot**)address);
+		if (offset % 8)
+			fprintf(file, " ");
+		else
+			fprintf(file, "\n\t");
+		fxDumpSlotAddress(file, slot);
+		offset++;
+		address++;
+	}
+}
+
+
+