@agoric/xsnap 0.14.3-u14.0 → 0.14.3-u16.1

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

@@ -0,0 +1,717 @@
+#include "xsnap.h"
+
+#define SNAPSHOT_SIGNATURE "xsnap 1"
+
+extern void fxDumpSnapshot(xsMachine* the, xsSnapshot* snapshot);
+
+static void xsBuildAgent(xsMachine* the);
+static void xsPrintUsage();
+static void xsReplay(xsMachine* machine);
+
+//static void xs_clearTimer(xsMachine* the);
+static void xs_currentMeterLimit(xsMachine* the);
+static void xs_gc(xsMachine* the);
+static void xs_issueCommand(xsMachine* the);
+//static void xs_lockdown(xsMachine *the);
+static void xs_performance_now(xsMachine* the);
+static void xs_print(xsMachine* the);
+static void xs_resetMeter(xsMachine* the);
+static void xs_setImmediate(xsMachine* the);
+//static void xs_setInterval(xsMachine* the);
+//static void xs_setTimeout(xsMachine* the);
+
+extern void xs_textdecoder(xsMachine *the);
+extern void xs_textdecoder_decode(xsMachine *the);
+extern void xs_textdecoder_get_encoding(xsMachine *the);
+extern void xs_textdecoder_get_ignoreBOM(xsMachine *the);
+extern void xs_textdecoder_get_fatal(xsMachine *the);
+
+extern void xs_textencoder(xsMachine *the);
+extern void xs_textencoder_encode(xsMachine *the);
+extern void xs_textencoder_encodeInto(xsMachine *the);
+
+extern void modInstallTextDecoder(xsMachine *the);
+extern void modInstallTextEncoder(xsMachine *the);
+
+extern void xs_base64_encode(xsMachine *the);
+extern void xs_base64_decode(xsMachine *the);
+extern void modInstallBase64(xsMachine *the);
+
+// The order of the callbacks materially affects how they are introduced to
+// code that runs from a snapshot, so must be consistent in the face of
+// upgrade.
+#define mxSnapshotCallbackCount 18
+xsCallback gxSnapshotCallbacks[mxSnapshotCallbackCount] = {
+	xs_issueCommand, // 0
+	xs_print, // 1
+	xs_setImmediate, // 2
+	xs_gc, // 3
+	xs_performance_now, // 4
+	xs_currentMeterLimit, // 5
+	xs_resetMeter, // 6
+
+	xs_textdecoder, // 7
+	xs_textdecoder_decode, // 8
+	xs_textdecoder_get_encoding, // 9
+	xs_textdecoder_get_ignoreBOM, // 10
+	xs_textdecoder_get_fatal, // 11
+
+	xs_textencoder, // 12
+	xs_textencoder_encode, // 13
+	xs_textencoder_encodeInto, // 14
+
+	xs_base64_encode, // 15
+	xs_base64_decode, // 16
+
+	fx_harden, // 17
+	// fx_setInterval,
+	// fx_setTimeout,
+	// fx_clearTimer,
+};
+
+static int xsSnapshopRead(void* stream, void* address, size_t size)
+{
+	return (fread(address, size, 1, stream) == 1) ? 0 : errno;
+}
+
+static int xsSnapshopWrite(void* stream, void* address, size_t size)
+{
+	return (fwrite(address, size, 1, stream) == 1) ? 0 : errno;
+}
+	
+static xsUnsignedValue gxCurrentMeter = 0;
+static xsBooleanValue gxMeteringPrint = 0;
+static xsUnsignedValue gxMeteringLimit = 0;
+#ifdef mxMetering
+static xsBooleanValue xsMeteringCallback(xsMachine* the, xsUnsignedValue index)
+{
+	if (index > gxMeteringLimit) {
+// 		fprintf(stderr, "too much computation\n");
+		return 0;
+	}
+// 	fprintf(stderr, "%d\n", index);
+	return 1;
+}
+#endif
+
+int main(int argc, char* argv[]) 
+{
+	int argi;
+	int argd = 0;
+	int argp = 0;
+	int argr = 0;
+	int argw = 0;
+	int error = 0;
+	int interval = 0;
+	int option = 0;
+	int parserBufferSize = 8192 * 1024;
+	int profiling = 0;
+	xsCreation _creation = {
+		32 * 1024 * 1024,	/* initialChunkSize */
+		4 * 1024 * 1024,	/* incrementalChunkSize */
+		256 * 1024,			/* initialHeapCount */
+		128 * 1024,			/* incrementalHeapCount */
+		4096,				/* stackCount */
+		32000, 				/* initialKeyCount */
+		8000,				/* incrementalKeyCount */
+		1993,				/* nameModulo */
+		127,				/* symbolModulo */
+		parserBufferSize,	/* parserBufferSize */
+		1993,				/* parserTableModulo */
+	};
+	xsCreation* creation = &_creation;
+	xsSnapshot snapshot = {
+		SNAPSHOT_SIGNATURE,
+		sizeof(SNAPSHOT_SIGNATURE) - 1,
+		gxSnapshotCallbacks,
+		mxSnapshotCallbackCount,
+		xsSnapshopRead,
+		xsSnapshopWrite,
+		NULL,
+		0,
+		NULL,
+		NULL,
+		NULL,
+		0,
+		NULL,
+	};
+	xsMachine* machine;
+	char path[C_PATH_MAX];
+	char* dot;
+
+	if (argc == 1) {
+		xsPrintUsage();
+		return 0;
+	}
+	for (argi = 1; argi < argc; argi++) {
+		if (argv[argi][0] != '-')
+			continue;
+		if (!strcmp(argv[argi], "-d")) {
+			argi++;
+			if (argi < argc)
+				argd = argi;
+			else {
+				xsPrintUsage();
+				return 1;
+			}
+			option = 5;
+		}
+		else if (!strcmp(argv[argi], "-e"))
+			option = 1;
+		else if (!strcmp(argv[argi], "-h"))
+			xsPrintUsage();
+		else if (!strcmp(argv[argi], "-i")) {
+			argi++;
+			if (argi < argc)
+				interval = atoi(argv[argi]);
+			else {
+				xsPrintUsage();
+				return 1;
+			}
+		}
+		else if (!strcmp(argv[argi], "-l")) {
+			argi++;
+			if (argi < argc)
+				gxMeteringLimit = atoi(argv[argi]);
+			else {
+				xsPrintUsage();
+				return 1;
+			}
+		}
+		else if (!strcmp(argv[argi], "-m"))
+			option = 2;
+		else if (!strcmp(argv[argi], "-p")) {
+			profiling = 1;
+			argi++;
+			if ((argi < argc) && (argv[argi][0] != '-'))
+				argp = argi;
+			else
+				argi--;
+		}
+		else if (!strcmp(argv[argi], "-q"))
+			gxMeteringPrint = 1;
+		else if (!strcmp(argv[argi], "-r")) {
+			argi++;
+			if (argi < argc)
+				argr = argi;
+			else {
+				xsPrintUsage();
+				return 1;
+			}
+		}
+		else if (!strcmp(argv[argi], "-s"))
+			option = 3;
+		else if (!strcmp(argv[argi], "-t"))
+			option = 4;
+		else if (!strcmp(argv[argi], "-v")) {
+			xsVersion(path, sizeof(path));
+			printf("XS %s\n", path);
+		}
+		else if (!strcmp(argv[argi], "-w")) {
+			argi++;
+			if (argi < argc)
+				argw = argi;
+			else {
+				xsPrintUsage();
+				return 1;
+			}
+		}
+		else {
+			xsPrintUsage();
+			return 1;
+		}
+	}
+	if (gxMeteringLimit) {
+		if (interval == 0)
+			interval = 1;
+	}
+	xsInitializeSharedCluster();
+	if (argr) {
+		snapshot.stream = fopen(argv[argr], "rb");
+		if (snapshot.stream) {
+			machine = xsReadSnapshot(&snapshot, "xsnap", NULL);
+			fclose(snapshot.stream);
+		}
+		else
+			snapshot.error = errno;
+		if (snapshot.error) {
+			fprintf(stderr, "cannot read snapshot %s: %s\n", argv[argr], strerror(snapshot.error));
+			return 1;
+		}
+	}
+	else {
+		machine = xsCreateMachine(creation, "xsnap", NULL);
+		xsBuildAgent(machine);
+	}
+	if (profiling)
+		fxStartProfiling(machine);
+	xsBeginMetering(machine, xsMeteringCallback, interval);
+	{
+		if (option == 5) {
+			snapshot.stream = fopen(argv[argd], "rb");
+			if (snapshot.stream) {
+				fxDumpSnapshot(machine, &snapshot);
+				fclose(snapshot.stream);
+			}
+			else
+				snapshot.error = errno;
+			if (snapshot.error) {
+				fprintf(stderr, "cannot dump snapshot %s: %s\n", argv[argr], strerror(snapshot.error));
+				return 1;
+			}
+		}
+		else if (option == 4) {
+			fprintf(stderr, "%p\n", machine);
+			xsReplay(machine);
+		}
+		else {
+			xsBeginHost(machine);
+			{
+				xsVars(1);
+				for (argi = 1; argi < argc; argi++) {
+					if (!strcmp(argv[argi], "-i")) {
+						argi++;
+						continue;
+					}
+					if (!strcmp(argv[argi], "-l")) {
+						argi++;
+						continue;
+					}
+					if (argv[argi][0] == '-')
+						continue;
+					if (argi == argp)
+						continue;
+					if (argi == argr)
+						continue;
+					if (argi == argw)
+						continue;
+					if (option == 1) {
+						xsResult = xsString(argv[argi]);
+						xsCall1(xsGlobal, xsID("eval"), xsResult);
+					}
+					else {	
+						if (!c_realpath(argv[argi], path))
+							xsURIError("file not found: %s", argv[argi]);
+						dot = strrchr(path, '.');
+						if (((option == 0) && dot && !c_strcmp(dot, ".mjs")) || (option == 2))
+							xsRunModuleFile(path);
+						else
+							xsRunProgramFile(path);
+					}
+				}
+			}
+			xsRunLoop(machine);
+			xsEndHost(machine);
+			if (argw) {
+				snapshot.stream = fopen(argv[argw], "wb");
+				if (snapshot.stream) {
+					xsWriteSnapshot(machine, &snapshot);
+					fclose(snapshot.stream);
+				}
+				else
+					snapshot.error = errno;
+				if (snapshot.error) {
+					fprintf(stderr, "cannot write snapshot %s: %s\n", argv[argw], strerror(snapshot.error));
+				}
+			}
+		}
+	}
+	xsEndMetering(machine);
+	if (profiling) {
+		if (argp) {
+			FILE* stream = fopen(argv[argp], "w");
+			if (stream)
+				fxStopProfiling(machine, stream);
+			else
+				fprintf(stderr, "cannot write profile %s: %s\n", argv[argp], strerror(errno));
+		}
+		else
+			fxStopProfiling(machine, C_NULL);
+	}
+	if (machine->abortStatus)
+		error = machine->abortStatus;
+	xsDeleteMachine(machine);
+	xsTerminateSharedCluster();
+	return error;
+}
+
+void xsBuildAgent(xsMachine* machine) 
+{
+	xsBeginHost(machine);
+	xsVars(1);
+	
+// 	xsResult = xsNewHostFunction(xs_clearTimer, 1);
+// 	xsDefine(xsGlobal, xsID("clearImmediate"), xsResult, xsDontEnum);
+	xsResult = xsNewHostFunction(xs_setImmediate, 1);
+	xsDefine(xsGlobal, xsID("setImmediate"), xsResult, xsDontEnum);
+	
+// 	xsResult = xsNewHostFunction(xs_clearTimer, 1);
+// 	xsDefine(xsGlobal, xsID("clearInterval"), xsResult, xsDontEnum);
+// 	xsResult = xsNewHostFunction(xs_setInterval, 1);
+// 	xsDefine(xsGlobal, xsID("setInterval"), xsResult, xsDontEnum);
+
+// 	xsResult = xsNewHostFunction(xs_clearTimer, 1);
+// 	xsDefine(xsGlobal, xsID("clearTimeout"), xsResult, xsDontEnum);
+// 	xsResult = xsNewHostFunction(xs_setTimeout, 1);
+// 	xsDefine(xsGlobal, xsID("setTimeout"), xsResult, xsDontEnum);
+	
+	xsResult = xsNewHostFunction(xs_gc, 1);
+	xsDefine(xsGlobal, xsID("gc"), xsResult, xsDontEnum);
+	xsResult = xsNewHostFunction(xs_print, 1);
+	xsDefine(xsGlobal, xsID("print"), xsResult, xsDontEnum);
+	
+	xsResult = xsNewHostFunction(xs_issueCommand, 1);
+	xsDefine(xsGlobal, xsID("issueCommand"), xsResult, xsDontEnum);
+	
+	xsResult = xsNewObject();
+	xsVar(0) = xsNewHostFunction(xs_performance_now, 0);
+	xsDefine(xsResult, xsID("now"), xsVar(0), xsDontEnum);
+	xsDefine(xsGlobal, xsID("performance"), xsResult, xsDontEnum);
+	
+	xsResult = xsNewHostFunction(xs_currentMeterLimit, 1);
+	xsDefine(xsGlobal, xsID("currentMeterLimit"), xsResult, xsDontEnum);
+	xsResult = xsNewHostFunction(xs_resetMeter, 1);
+	xsDefine(xsGlobal, xsID("resetMeter"), xsResult, xsDontEnum);
+
+	modInstallTextDecoder(the);
+	modInstallTextEncoder(the);
+	modInstallBase64(the);
+// 	
+ 	xsResult = xsNewHostFunction(fx_harden, 1);
+ 	xsDefine(xsGlobal, xsID("harden"), xsResult, xsDontEnum);
+// 	xsResult = xsNewHostFunction(xs_lockdown, 0);
+// 	xsDefine(xsGlobal, xsID("lockdown"), xsResult, xsDontEnum);
+// 	xsResult = xsNewHostFunction(fx_petrify, 1);
+// 	xsDefine(xsGlobal, xsID("petrify"), xsResult, xsDontEnum);
+// 	xsResult = xsNewHostFunction(fx_mutabilities, 1);
+// 	xsDefine(xsGlobal, xsID("mutabilities"), xsResult, xsDontEnum);
+
+	xsEndHost(machine);
+}
+
+void xsPrintUsage()
+{
+	printf("xsnap [-h] [-e] [i <interval] [l <limit] [-m] [-r <snapshot>] [-s] [-v] [-w <snapshot>] strings...\n");
+	printf("\t-d <snapshot>: dump snapshot to stderr\n");
+	printf("\t-e: eval strings\n");
+	printf("\t-h: print this help message\n");
+	printf("\t-i <interval>: metering interval (default to 1)\n");
+	printf("\t-l <limit>: metering limit (default to none)\n");
+	printf("\t-m: strings are paths to modules\n");
+	printf("\t-r <snapshot>: read snapshot to create the XS machine\n");
+	printf("\t-s: strings are paths to scripts\n");
+	printf("\t-v: print XS version\n");
+	printf("\t-w <snapshot>: write snapshot of the XS machine at exit\n");
+	printf("without -e, -m, -s:\n");
+	printf("\tif the extension is .mjs, strings are paths to modules\n");
+	printf("\telse strings are paths to scripts\n");
+}
+
+static int gxStep = 0;
+
+void xsReplay(xsMachine* machine)
+{
+	char path[C_PATH_MAX];
+	char* names[6] = { "-evaluate.dat", "-issueCommand.dat", "-snapshot.dat", "-command.dat", "-reply.dat", "-options.json", };
+	for (;;) {
+		int which;
+		for (which = 0; which < 6; which++) {
+			sprintf(path, "%05d%s", gxStep, names[which]);
+			{
+			#if mxWindows
+				DWORD attributes = GetFileAttributes(path);
+				if ((attributes != 0xFFFFFFFF) && (!(attributes & FILE_ATTRIBUTE_DIRECTORY)))
+			#else
+				struct stat a_stat;
+				if ((stat(path, &a_stat) == 0) && (S_ISREG(a_stat.st_mode)))
+			#endif
+				{
+					gxStep++;
+					fprintf(stderr, "### %s\n", path);
+					FILE* file = fopen(path, "rb");
+					if (file) {
+						size_t length;
+						fseek(file, 0, SEEK_END);
+						length = ftell(file);
+						fseek(file, 0, SEEK_SET);
+						if (which == 0) {
+							xsBeginHost(machine);
+							xsStringValue string;
+							xsResult = xsStringBuffer(NULL, (xsIntegerValue)length);
+							string = xsToString(xsResult);
+							length = fread(string, 1, length, file);
+							string[length] = 0;
+							fclose(file);
+							xsCall1(xsGlobal, xsID("eval"), xsResult);
+							fxRunLoop(machine);
+							xsEndHost(machine);
+						}
+						else if (which == 1) {
+							xsBeginHost(machine);
+							xsResult = xsArrayBuffer(NULL, (xsIntegerValue)length);
+							length = fread(xsToArrayBuffer(xsResult), 1, length, file);	
+							fclose(file);
+							xsCall1(xsGlobal, xsID("handleCommand"), xsResult);
+							fxRunLoop(machine);
+							xsEndHost(machine);
+						}
+						else if (which == 2) {
+// 							xsBeginHost(machine);
+// 							xsCollectGarbage();
+// 							xsEndHost(machine);
+// 							fclose(file);
+							char buffer[1024];
+							char* slash;
+							xsSnapshot snapshot = {
+								SNAPSHOT_SIGNATURE,
+								sizeof(SNAPSHOT_SIGNATURE) - 1,
+								gxSnapshotCallbacks,
+								mxSnapshotCallbackCount,
+								xsSnapshopRead,
+								xsSnapshopWrite,
+								NULL,
+								0,
+								NULL,
+								NULL,
+								NULL,
+								0,
+								NULL
+							};
+							length = fread(buffer, 1, length, file);
+							buffer[length] = 0;
+							fclose(file);
+							slash = c_strrchr(buffer, '/');
+							if (slash) slash++;
+							else slash = buffer;
+							snapshot.stream = fopen(slash, "wb");
+							if (snapshot.stream) {
+								xsWriteSnapshot(machine, &snapshot);
+								fclose(snapshot.stream);
+							}
+						}
+						else
+							fclose(file);
+					}
+					break;
+				}
+			}
+		}
+		if (which == 6)
+			break;
+	}
+}
+
+void xs_clearTimer(xsMachine* the)
+{
+	xsClearTimer();
+}
+
+void xs_currentMeterLimit(xsMachine* the)
+{
+#if mxMetering
+	xsResult = xsInteger(gxCurrentMeter);
+#endif
+}
+
+void xs_gc(xsMachine* the)
+{
+	xsCollectGarbage();
+}
+
+void xs_issueCommand(xsMachine* the)
+{
+	char path[C_PATH_MAX];
+	FILE* file;
+	size_t length;
+	void* data;
+	size_t argLength;
+	void* argData;
+	
+	sprintf(path, "%05d-command.dat", gxStep);
+	gxStep++;
+	
+	file = fopen(path, "rb");
+	if (!file) xsUnknownError("cannot open %s", path);
+	fseek(file, 0, SEEK_END);
+	length = ftell(file);
+	fseek(file, 0, SEEK_SET);
+	data = c_malloc(length);
+	length = fread(data, 1, length, file);	
+	fclose(file);
+	
+	argLength = xsGetArrayBufferLength(xsArg(0));
+	argData = xsToArrayBuffer(xsArg(0));
+	
+	if ((length != argLength) || c_memcmp(data, argData, length)) {
+		fprintf(stderr, "### %s %.*s\n", path, (int)argLength, (char*)argData);
+// 		fprintf(stderr, "@@@ %s %.*s\n", path, (int)length, (char*)data);
+	}
+	else
+		fprintf(stderr, "### %s\n", path);
+	c_free(data);
+	
+	sprintf(path, "%05d-reply.dat", gxStep);
+	fprintf(stderr, "### %s\n", path);
+	gxStep++;
+	file = fopen(path, "rb");
+	if (!file) xsUnknownError("cannot open %s", path);
+	fseek(file, 0, SEEK_END);
+	length = ftell(file);
+	fseek(file, 0, SEEK_SET);
+	xsResult = xsArrayBuffer(NULL, (xsIntegerValue)length);
+	data = xsToArrayBuffer(xsResult);
+	length = fread(data, 1, length, file);	
+	fclose(file);
+}
+
+#if 0
+void xs_lockdown(xsMachine *the)
+{
+	fx_lockdown(the);
+	
+	xsResult = xsGet(xsGlobal, xsID("Base64"));
+	xsCall1(xsGlobal, xsID("harden"), xsResult);
+	xsResult = xsGet(xsGlobal, xsID("TextDecoder"));
+	xsCall1(xsGlobal, xsID("harden"), xsResult);
+	xsResult = xsGet(xsGlobal, xsID("TextEncoder"));
+	xsCall1(xsGlobal, xsID("harden"), xsResult);
+	
+// 	xsResult = xsGet(xsGlobal, xsID("clearImmediate"));
+// 	xsCall1(xsGlobal, xsID("harden"), xsResult);
+// 	xsResult = xsGet(xsGlobal, xsID("clearInterval"));
+// 	xsCall1(xsGlobal, xsID("harden"), xsResult);
+// 	xsResult = xsGet(xsGlobal, xsID("clearTimeout"));
+// 	xsCall1(xsGlobal, xsID("harden"), xsResult);
+	xsResult = xsGet(xsGlobal, xsID("currentMeterLimit"));
+	xsCall1(xsGlobal, xsID("harden"), xsResult);
+	xsResult = xsGet(xsGlobal, xsID("gc"));
+	xsCall1(xsGlobal, xsID("harden"), xsResult);
+	xsResult = xsGet(xsGlobal, xsID("harden"));
+	xsCall1(xsGlobal, xsID("harden"), xsResult);
+	xsResult = xsGet(xsGlobal, xsID("issueCommand"));
+	xsCall1(xsGlobal, xsID("harden"), xsResult);
+	xsResult = xsGet(xsGlobal, xsID("lockdown"));
+	xsCall1(xsGlobal, xsID("harden"), xsResult);
+	xsResult = xsGet(xsGlobal, xsID("mutabilities"));
+	xsCall1(xsGlobal, xsID("harden"), xsResult);
+	xsResult = xsGet(xsGlobal, xsID("performance"));
+	xsCall1(xsGlobal, xsID("harden"), xsResult);
+	xsResult = xsGet(xsGlobal, xsID("petrify"));
+	xsCall1(xsGlobal, xsID("harden"), xsResult);
+	xsResult = xsGet(xsGlobal, xsID("print"));
+	xsCall1(xsGlobal, xsID("harden"), xsResult);
+	xsResult = xsGet(xsGlobal, xsID("resetMeter"));
+	xsCall1(xsGlobal, xsID("harden"), xsResult);
+	xsResult = xsGet(xsGlobal, xsID("setImmediate"));
+	xsCall1(xsGlobal, xsID("harden"), xsResult);
+// 	xsResult = xsGet(xsGlobal, xsID("setInterval"));
+// 	xsCall1(xsGlobal, xsID("harden"), xsResult);
+// 	xsResult = xsGet(xsGlobal, xsID("setTimeout"));
+// 	xsCall1(xsGlobal, xsID("harden"), xsResult);
+}
+#endif
+
+void xs_performance_now(xsMachine *the)
+{
+	c_timeval tv;
+	c_gettimeofday(&tv, NULL);
+	xsResult = xsNumber((double)(tv.tv_sec * 1000.0) + ((double)(tv.tv_usec) / 1000.0));
+}
+
+void xs_print(xsMachine* the)
+{
+	xsIntegerValue c = xsToInteger(xsArgc), i;
+	xsStringValue string, p, q;
+	xsVars(1);
+	xsVar(0) = xsGet(xsGlobal, xsID("String"));
+	for (i = 0; i < c; i++) {
+		xsArg(i) = xsCallFunction1(xsVar(0), xsUndefined, xsArg(i));
+	}
+#ifdef mxMetering
+	if (gxMeteringPrint)
+		fprintf(stdout, "[%u] ", xsGetCurrentMeter(the));
+#endif
+	for (i = 0; i < c; i++) {
+		if (i)
+			fprintf(stdout, " ");
+		xsArg(i) = xsCallFunction1(xsVar(0), xsUndefined, xsArg(i));
+		p = string = xsToString(xsArg(i));
+	#if mxCESU8
+		for (;;) {
+			xsIntegerValue character;
+			q = fxUTF8Decode(p, &character);
+		again:
+			if (character == C_EOF)
+				break;
+			if (character == 0) {
+				if (p > string) {
+					char c = *p;
+					*p = 0;
+					fprintf(stdout, "%s", string);
+					*p = c;
+				}
+				string = q;
+			}
+			else if ((0x0000D800 <= character) && (character <= 0x0000DBFF)) {
+				xsStringValue r = q;
+				xsIntegerValue surrogate;
+				q = fxUTF8Decode(r, &surrogate);
+				if ((0x0000DC00 <= surrogate) && (surrogate <= 0x0000DFFF)) {
+					char buffer[5];
+					character = (xsIntegerValue)(0x00010000 + ((character & 0x03FF) << 10) + (surrogate & 0x03FF));
+					if (p > string) {
+						char c = *p;
+						*p = 0;
+						fprintf(stdout, "%s", string);
+						*p = c;
+					}
+					p = fxUTF8Encode(buffer, character);
+					*p = 0;
+					fprintf(stdout, "%s", buffer);
+					string = q;
+				}
+				else {
+					p = r;
+					character = surrogate;
+					goto again;
+				}
+			}
+			p = q;
+		}
+	#endif	
+		fprintf(stdout, "%s", string);
+	}
+	fprintf(stdout, "\n");
+}
+
+void xs_resetMeter(xsMachine* the)
+{
+#if mxMetering
+	xsIntegerValue argc = xsToInteger(xsArgc);
+	if (argc < 2) {
+		xsTypeError("expected newMeterLimit, newMeterIndex");
+	}
+	xsResult = xsInteger(xsGetCurrentMeter(the));
+	gxCurrentMeter = xsToInteger(xsArg(0));
+	xsSetCurrentMeter(the, xsToInteger(xsArg(1)));
+#endif
+}
+
+void xs_setImmediate(xsMachine* the)
+{
+	xsSetTimer(0, 0);
+}
+
+void xs_setInterval(xsMachine* the)
+{
+	xsSetTimer(xsToNumber(xsArg(1)), 1);
+}
+
+void xs_setTimeout(xsMachine* the)
+{
+	xsSetTimer(xsToNumber(xsArg(1)), 0);
+}
+
+
+
+