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

package/moddable/xs/sources/xsMapSet.c

@@ -0,0 +1,1649 @@
+/*
+ * Copyright (c) 2016-2017  Moddable Tech, Inc.
+ *
+ *   This file is part of the Moddable SDK Runtime.
+ * 
+ *   The Moddable SDK Runtime is free software: you can redistribute it and/or modify
+ *   it under the terms of the GNU Lesser General Public License as published by
+ *   the Free Software Foundation, either version 3 of the License, or
+ *   (at your option) any later version.
+ * 
+ *   The Moddable SDK Runtime is distributed in the hope that it will be useful,
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *   GNU Lesser General Public License for more details.
+ * 
+ *   You should have received a copy of the GNU Lesser General Public License
+ *   along with the Moddable SDK Runtime.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * This file incorporates work covered by the following copyright and  
+ * permission notice:  
+ *
+ *       Copyright (C) 2010-2016 Marvell International Ltd.
+ *       Copyright (C) 2002-2010 Kinoma, Inc.
+ *
+ *       Licensed under the Apache License, Version 2.0 (the "License");
+ *       you may not use this file except in compliance with the License.
+ *       You may obtain a copy of the License at
+ *
+ *        http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *       Unless required by applicable law or agreed to in writing, software
+ *       distributed under the License is distributed on an "AS IS" BASIS,
+ *       WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *       See the License for the specific language governing permissions and
+ *       limitations under the License.
+ */
+
+#include "xsAll.h"
+
+#ifndef mxTableMinLength
+	#define mxTableMinLength (1)
+#endif
+#ifndef mxTableMaxLength
+	#define mxTableMaxLength (1024 * 1024)
+#endif
+#define mxTableThreshold(LENGTH) (((LENGTH) >> 1) + ((LENGTH) >> 2))
+
+static txSlot* fxCheckMapInstance(txMachine* the, txSlot* slot, txBoolean mutable);
+static txSlot* fxCheckMapKey(txMachine* the);
+static txSlot* fxNewMapIteratorInstance(txMachine* the, txSlot* iterable, txInteger kind);
+
+static txSlot* fxCheckSetInstance(txMachine* the, txSlot* slot, txBoolean mutable);
+static txSlot* fxCheckSetValue(txMachine* the);
+static txSlot* fxNewSetIteratorInstance(txMachine* the, txSlot* iterable, txInteger kind);
+
+static void fxClearEntries(txMachine* the, txSlot* table, txSlot* list, txBoolean paired);
+static txBoolean fxDeleteEntry(txMachine* the, txSlot* table, txSlot* list, txSlot* slot, txBoolean paired); 
+static txSlot* fxGetEntry(txMachine* the, txSlot* table, txSlot* slot);
+static void fxPurgeEntries(txMachine* the, txSlot* list);
+static void fxResizeEntries(txMachine* the, txSlot* table, txSlot* list);
+static void fxSetEntry(txMachine* the, txSlot* table, txSlot* list, txSlot* slot, txSlot* pair); 
+static txBoolean fxTestEntry(txMachine* the, txSlot* a, txSlot* b);
+
+static txSlot* fxCheckWeakMapInstance(txMachine* the, txSlot* slot, txBoolean mutable);
+static txSlot* fxCheckWeakMapKey(txMachine* the, txBoolean mutable);
+
+static txSlot* fxCheckWeakSetInstance(txMachine* the, txSlot* slot, txBoolean mutable);
+static txSlot* fxCheckWeakSetValue(txMachine* the, txBoolean mutable);
+
+static txBoolean fxDeleteWeakEntry(txMachine* the, txSlot* link, txSlot* slot); 
+static txSlot* fxGetWeakEntry(txMachine* the, txSlot* link, txSlot* slot);
+static void fxSetWeakEntry(txMachine* the, txSlot* link, txSlot* slot, txSlot* pair); 
+
+static void fxKeepDuringJobs(txMachine* the, txSlot* target);
+static txSlot* fxNewWeakRefInstance(txMachine* the);
+
+static void fx_FinalizationRegistryCleanup(txMachine* the, txSlot* registry, txSlot* callback);
+
+void fxBuildMapSet(txMachine* the)
+{
+	txSlot* slot;
+	txSlot* property;
+	
+	/* MAP */
+	mxPush(mxObjectPrototype);
+	slot = fxLastProperty(the, fxNewObjectInstance(the));
+	slot = fxNextHostAccessorProperty(the, slot, mxCallback(fx_Map_prototype_size), C_NULL, mxID(_size), XS_DONT_ENUM_FLAG);
+	slot = fxNextHostFunctionProperty(the, slot, mxCallback(fx_Map_prototype_clear), 0, mxID(_clear), XS_DONT_ENUM_FLAG);
+	slot = fxNextHostFunctionProperty(the, slot, mxCallback(fx_Map_prototype_delete), 1, mxID(_delete), XS_DONT_ENUM_FLAG);
+	property = slot = fxNextHostFunctionProperty(the, slot, mxCallback(fx_Map_prototype_entries), 0, mxID(_entries), XS_DONT_ENUM_FLAG);
+	slot = fxNextHostFunctionProperty(the, slot, mxCallback(fx_Map_prototype_forEach), 1, mxID(_forEach), XS_DONT_ENUM_FLAG);
+	slot = fxNextHostFunctionProperty(the, slot, mxCallback(fx_Map_prototype_get), 1, mxID(_get), XS_DONT_ENUM_FLAG);
+	slot = fxNextHostFunctionProperty(the, slot, mxCallback(fx_Map_prototype_has), 1, mxID(_has), XS_DONT_ENUM_FLAG);
+	slot = fxNextHostFunctionProperty(the, slot, mxCallback(fx_Map_prototype_keys), 0, mxID(_keys), XS_DONT_ENUM_FLAG);
+	slot = fxNextHostFunctionProperty(the, slot, mxCallback(fx_Map_prototype_set), 2, mxID(_set), XS_DONT_ENUM_FLAG);
+	slot = fxNextHostFunctionProperty(the, slot, mxCallback(fx_Map_prototype_values), 0, mxID(_values), XS_DONT_ENUM_FLAG);
+	slot = fxNextSlotProperty(the, slot, property, mxID(_Symbol_iterator), XS_DONT_ENUM_FLAG);
+	slot = fxNextStringXProperty(the, slot, "Map", mxID(_Symbol_toStringTag), XS_DONT_ENUM_FLAG | XS_DONT_SET_FLAG);
+	mxMapPrototype = *the->stack;
+	slot = fxBuildHostConstructor(the, mxCallback(fx_Map), 0, mxID(_Map));
+	mxMapConstructor = *the->stack;
+	slot = fxLastProperty(the, slot);
+	slot = fxNextHostAccessorProperty(the, slot, mxCallback(fx_species_get), C_NULL, mxID(_Symbol_species), XS_DONT_ENUM_FLAG);
+	mxPop();
+	
+	mxPush(mxIteratorPrototype);
+	slot = fxLastProperty(the, fxNewObjectInstance(the));
+	slot = fxNextHostFunctionProperty(the, slot, mxCallback(fx_MapIterator_prototype_next), 0, mxID(_next), XS_DONT_DELETE_FLAG | XS_DONT_ENUM_FLAG);
+	slot = fxNextStringXProperty(the, slot, "Map Iterator", mxID(_Symbol_toStringTag), XS_DONT_ENUM_FLAG | XS_DONT_SET_FLAG);
+	mxPull(mxMapIteratorPrototype);
+	
+	/* SET */
+	mxPush(mxObjectPrototype);
+	slot = fxLastProperty(the, fxNewObjectInstance(the));
+	slot = fxNextHostAccessorProperty(the, slot, mxCallback(fx_Set_prototype_size), C_NULL, mxID(_size), XS_DONT_ENUM_FLAG);
+	slot = fxNextHostFunctionProperty(the, slot, mxCallback(fx_Set_prototype_add), 1, mxID(_add), XS_DONT_ENUM_FLAG);
+	slot = fxNextHostFunctionProperty(the, slot, mxCallback(fx_Set_prototype_clear), 0, mxID(_clear), XS_DONT_ENUM_FLAG);
+	slot = fxNextHostFunctionProperty(the, slot, mxCallback(fx_Set_prototype_delete), 1, mxID(_delete), XS_DONT_ENUM_FLAG);
+	slot = fxNextHostFunctionProperty(the, slot, mxCallback(fx_Set_prototype_entries), 0, mxID(_entries), XS_DONT_ENUM_FLAG);
+	slot = fxNextHostFunctionProperty(the, slot, mxCallback(fx_Set_prototype_forEach), 1, mxID(_forEach), XS_DONT_ENUM_FLAG);
+	slot = fxNextHostFunctionProperty(the, slot, mxCallback(fx_Set_prototype_has), 1, mxID(_has), XS_DONT_ENUM_FLAG);
+	property = slot = fxNextHostFunctionProperty(the, slot, mxCallback(fx_Set_prototype_values), 0, mxID(_values), XS_DONT_ENUM_FLAG);
+	slot = fxNextSlotProperty(the, slot, property, mxID(_keys), XS_DONT_ENUM_FLAG);
+	slot = fxNextSlotProperty(the, slot, property, mxID(_Symbol_iterator), XS_DONT_ENUM_FLAG);
+	slot = fxNextStringXProperty(the, slot, "Set", mxID(_Symbol_toStringTag), XS_DONT_ENUM_FLAG | XS_DONT_SET_FLAG);
+	mxSetPrototype = *the->stack;
+	slot = fxBuildHostConstructor(the, mxCallback(fx_Set), 0, mxID(_Set));
+	mxSetConstructor = *the->stack;
+	slot = fxLastProperty(the, slot);
+	slot = fxNextHostAccessorProperty(the, slot, mxCallback(fx_species_get), C_NULL, mxID(_Symbol_species), XS_DONT_ENUM_FLAG);
+	mxPop();
+	
+	mxPush(mxIteratorPrototype);
+	slot = fxLastProperty(the, fxNewObjectInstance(the));
+	slot = fxNextHostFunctionProperty(the, slot, mxCallback(fx_SetIterator_prototype_next), 0, mxID(_next), XS_DONT_DELETE_FLAG | XS_DONT_ENUM_FLAG);
+	slot = fxNextStringXProperty(the, slot, "Set Iterator", mxID(_Symbol_toStringTag), XS_DONT_ENUM_FLAG | XS_DONT_SET_FLAG);
+	mxPull(mxSetIteratorPrototype);
+
+	/* WEAK MAP */
+	mxPush(mxObjectPrototype);
+	slot = fxLastProperty(the, fxNewObjectInstance(the));
+	slot = fxNextHostFunctionProperty(the, slot, mxCallback(fx_WeakMap_prototype_delete), 1, mxID(_delete), XS_DONT_ENUM_FLAG);
+	slot = fxNextHostFunctionProperty(the, slot, mxCallback(fx_WeakMap_prototype_get), 1, mxID(_get), XS_DONT_ENUM_FLAG);
+	slot = fxNextHostFunctionProperty(the, slot, mxCallback(fx_WeakMap_prototype_has), 1, mxID(_has), XS_DONT_ENUM_FLAG);
+	slot = fxNextHostFunctionProperty(the, slot, mxCallback(fx_WeakMap_prototype_set), 2, mxID(_set), XS_DONT_ENUM_FLAG);
+	slot = fxNextStringXProperty(the, slot, "WeakMap", mxID(_Symbol_toStringTag), XS_DONT_ENUM_FLAG | XS_DONT_SET_FLAG);
+	mxWeakMapPrototype = *the->stack;
+	slot = fxBuildHostConstructor(the, mxCallback(fx_WeakMap), 0, mxID(_WeakMap));
+	mxWeakMapConstructor = *the->stack;
+	mxPop();
+	
+	/* WEAK SET */
+	mxPush(mxObjectPrototype);
+	slot = fxLastProperty(the, fxNewObjectInstance(the));
+	slot = fxNextHostFunctionProperty(the, slot, mxCallback(fx_WeakSet_prototype_add), 1, mxID(_add), XS_DONT_ENUM_FLAG);
+	slot = fxNextHostFunctionProperty(the, slot, mxCallback(fx_WeakSet_prototype_delete), 1, mxID(_delete), XS_DONT_ENUM_FLAG);
+	slot = fxNextHostFunctionProperty(the, slot, mxCallback(fx_WeakSet_prototype_has), 1, mxID(_has), XS_DONT_ENUM_FLAG);
+	slot = fxNextStringXProperty(the, slot, "WeakSet", mxID(_Symbol_toStringTag), XS_DONT_ENUM_FLAG | XS_DONT_SET_FLAG);
+	mxWeakSetPrototype = *the->stack;
+	slot = fxBuildHostConstructor(the, mxCallback(fx_WeakSet), 0, mxID(_WeakSet));
+	mxWeakSetConstructor = *the->stack;
+	mxPop();
+	
+	/* WEAK REF */
+	mxPush(mxObjectPrototype);
+	slot = fxLastProperty(the, fxNewObjectInstance(the));
+	slot = fxNextHostFunctionProperty(the, slot, mxCallback(fx_WeakRef_prototype_deref), 0, mxID(_deref), XS_DONT_ENUM_FLAG);
+	slot = fxNextStringXProperty(the, slot, "WeakRef", mxID(_Symbol_toStringTag), XS_DONT_ENUM_FLAG | XS_DONT_SET_FLAG);
+	mxWeakRefPrototype = *the->stack;
+	slot = fxBuildHostConstructor(the, mxCallback(fx_WeakRef), 1, mxID(_WeakRef));
+	mxWeakRefConstructor = *the->stack;
+	mxPop();
+	
+	/* FINALIZATION REGISTRY */
+	mxPush(mxObjectPrototype);
+	slot = fxLastProperty(the, fxNewObjectInstance(the));
+//	slot = fxNextHostFunctionProperty(the, slot, mxCallback(fx_FinalizationRegistry_prototype_cleanupSome), 0, mxID(_cleanupSome), XS_DONT_ENUM_FLAG);
+	slot = fxNextHostFunctionProperty(the, slot, mxCallback(fx_FinalizationRegistry_prototype_register), 2, mxID(_register), XS_DONT_ENUM_FLAG);
+	slot = fxNextHostFunctionProperty(the, slot, mxCallback(fx_FinalizationRegistry_prototype_unregister), 1, mxID(_unregister), XS_DONT_ENUM_FLAG);
+	slot = fxNextStringXProperty(the, slot, "FinalizationRegistry", mxID(_Symbol_toStringTag), XS_DONT_ENUM_FLAG | XS_DONT_SET_FLAG);
+	mxFinalizationRegistryPrototype = *the->stack;
+	slot = fxBuildHostConstructor(the, mxCallback(fx_FinalizationRegistry), 1, mxID(_FinalizationRegistry));
+	mxFinalizationRegistryConstructor = *the->stack;
+	mxPop();
+}
+
+txSlot* fxCheckMapInstance(txMachine* the, txSlot* slot, txBoolean mutable)
+{
+	if (slot->kind == XS_REFERENCE_KIND) {
+		txSlot* instance = slot->value.reference;
+		if (((slot = instance->next)) && (slot->flag & XS_INTERNAL_FLAG) && (slot->kind == XS_MAP_KIND) && (instance != mxMapPrototype.value.reference)) {
+			if (mutable && (slot->flag & XS_DONT_SET_FLAG))
+				mxTypeError("Map instance is read-only");
+			return instance;
+		}
+	}
+	mxTypeError("this is no Map instance");
+	return C_NULL;
+}
+
+txSlot* fxCheckMapKey(txMachine* the)
+{
+	if (mxArgc > 0) {
+		txSlot* slot = mxArgv(0);
+		return slot;
+	}
+	mxTypeError("no key");
+	return C_NULL;
+}
+
+txSlot* fxNewMapInstance(txMachine* the)
+{
+	txSlot* map;
+	txSlot* table;
+	txSlot* list;
+	txSlot* size;
+	txSlot** address;
+	map = fxNewSlot(the);
+	map->kind = XS_INSTANCE_KIND;
+	map->value.instance.garbage = C_NULL;
+	map->value.instance.prototype = the->stack->value.reference;
+	the->stack->kind = XS_REFERENCE_KIND;
+	the->stack->value.reference = map;
+	table = map->next = fxNewSlot(the);
+	list = table->next = fxNewSlot(the);
+	size = list->next = fxNewSlot(the);
+	address = (txSlot**)fxNewChunk(the, mxTableMinLength * sizeof(txSlot*));
+	c_memset(address, 0, mxTableMinLength * sizeof(txSlot*));
+	/* TABLE */
+	table->flag = XS_INTERNAL_FLAG;
+	table->kind = XS_MAP_KIND;
+	table->value.table.address = address;
+	table->value.table.length = mxTableMinLength;
+	/* LIST */
+	list->flag = XS_INTERNAL_FLAG;
+	list->kind = XS_LIST_KIND;
+	list->value.list.first = C_NULL;
+	list->value.list.last = C_NULL;
+	/* SIZE */
+	size->flag = XS_INTERNAL_FLAG;
+	size->kind = XS_INTEGER_KIND;
+	size->value.integer = 0;
+ 	return map;
+}
+
+void fx_Map(txMachine* the)
+{
+	txSlot *function, *iterable, *iterator, *next, *value;
+	if (mxIsUndefined(mxTarget))
+		mxTypeError("call: Map");
+	mxPushSlot(mxTarget);
+	fxGetPrototypeFromConstructor(the, &mxMapPrototype);
+	fxNewMapInstance(the);
+	mxPullSlot(mxResult);
+	if (mxArgc < 1)
+		return;
+	iterable = mxArgv(0);
+	if ((iterable->kind == XS_UNDEFINED_KIND) || (iterable->kind == XS_NULL_KIND))
+		return;
+	mxPushSlot(mxResult);
+	mxGetID(mxID(_set));	
+	function = the->stack;	
+	if (!fxIsCallable(the, function))	
+		mxTypeError("set is no function");
+	mxTemporary(iterator);
+	mxTemporary(next);
+	fxGetIterator(the, iterable, iterator, next, 0);	
+	mxTemporary(value);
+	while (fxIteratorNext(the, iterator, next, value)) {
+		mxTry(the) {
+			if (value->kind != XS_REFERENCE_KIND)
+				mxTypeError("item is no object");
+			mxPushSlot(mxResult);
+			mxPushSlot(function);
+			mxCall();
+			mxPushSlot(value);
+			mxGetIndex(0);
+			mxPushSlot(value);
+			mxGetIndex(1);
+			mxRunCount(2);
+			mxPop();
+		}
+		mxCatch(the) {
+			fxIteratorReturn(the, iterator);
+			fxJump(the);
+		}
+	}
+}
+
+void fx_Map_prototype_clear(txMachine* the)
+{
+	txSlot* instance = fxCheckMapInstance(the, mxThis, XS_MUTABLE);
+	txSlot* table = instance->next;
+	txSlot* list = table->next;
+	fxClearEntries(the, table, list, 1);
+}
+
+void fx_Map_prototype_delete(txMachine* the)
+{
+	txSlot* instance = fxCheckMapInstance(the, mxThis, XS_MUTABLE);
+	txSlot* table = instance->next;
+	txSlot* list = table->next;
+	txSlot* key = fxCheckMapKey(the);
+	mxResult->value.boolean = fxDeleteEntry(the, table, list, key, 1);
+	mxResult->kind = XS_BOOLEAN_KIND;
+}
+
+void fx_Map_prototype_entries(txMachine* the)
+{
+	fxCheckMapInstance(the, mxThis, XS_IMMUTABLE);
+	fxNewMapIteratorInstance(the, mxThis, 2);
+}
+
+void fx_Map_prototype_forEach(txMachine* the)
+{
+	txSlot* instance = fxCheckMapInstance(the, mxThis, XS_IMMUTABLE);
+	txSlot* table = instance->next;
+	txSlot* list = table->next;
+	txSlot* function = fxArgToCallback(the, 0);
+	txSlot* key;
+	txSlot* value;
+	mxPushList();
+	key = the->stack->value.list.first = list->value.list.first;
+	while (key) {
+		value = key->next;
+		if (!(key->flag & XS_DONT_ENUM_FLAG)) {
+			/* THIS */
+			if (mxArgc > 1)
+				mxPushSlot(mxArgv(1));
+			else
+				mxPushUndefined();
+			/* FUNCTION */
+			mxPushSlot(function);
+			mxCall();
+			/* ARGUMENTS */
+			mxPushSlot(value);
+			mxPushSlot(key);
+			mxPushSlot(mxThis);
+			mxRunCount(3);
+			mxPop();
+		}
+		key = the->stack->value.list.first = value->next;
+	}
+	mxPop();
+}
+
+void fx_Map_prototype_get(txMachine* the)
+{
+	txSlot* instance = fxCheckMapInstance(the, mxThis, XS_IMMUTABLE);
+	txSlot* table = instance->next;
+	txSlot* key = fxCheckMapKey(the);
+	txSlot* result = fxGetEntry(the, table, key);
+	if (result) {
+		txSlot* value = result->next;
+		mxResult->kind = value->kind;
+		mxResult->value = value->value;
+	}
+}
+
+void fx_Map_prototype_has(txMachine* the)
+{
+	txSlot* instance = fxCheckMapInstance(the, mxThis, XS_IMMUTABLE);
+	txSlot* table = instance->next;
+	txSlot* key = fxCheckMapKey(the);
+	txSlot* result = fxGetEntry(the, table, key);
+	mxResult->kind = XS_BOOLEAN_KIND;
+	mxResult->value.boolean = (result) ? 1 : 0;
+}
+
+void fx_Map_prototype_keys(txMachine* the)
+{
+	fxCheckMapInstance(the, mxThis, XS_IMMUTABLE);
+	fxNewMapIteratorInstance(the, mxThis, 0);
+}
+
+void fx_Map_prototype_set(txMachine* the)
+{
+	txSlot* instance = fxCheckMapInstance(the, mxThis, XS_MUTABLE);
+	txSlot* table = instance->next;
+	txSlot* list = table->next;
+	txSlot* key = fxCheckMapKey(the);
+	fxSetEntry(the, table, list, key, (mxArgc > 1) ? mxArgv(1) : &mxUndefined);
+	*mxResult = *mxThis;
+}
+
+void fx_Map_prototype_size(txMachine* the)
+{
+	txSlot* instance = fxCheckMapInstance(the, mxThis, XS_IMMUTABLE);
+	txSlot* table = instance->next;
+	txSlot* list = table->next;
+	mxResult->kind = XS_INTEGER_KIND;
+	mxResult->value.integer = list->next->value.integer;
+}
+
+void fx_Map_prototype_values(txMachine* the)
+{
+	fxCheckMapInstance(the, mxThis, XS_IMMUTABLE);
+	fxNewMapIteratorInstance(the, mxThis, 1);
+}
+
+txSlot* fxNewMapIteratorInstance(txMachine* the, txSlot* iterable, txInteger kind) 
+{
+	txSlot* instance;
+	txSlot* property;
+	mxPush(mxMapIteratorPrototype);
+	instance = fxNewIteratorInstance(the, iterable, mxID(_Map));
+	property = fxLastProperty(the, instance);
+	property->kind = XS_LIST_KIND;
+	property->value.list.first = C_NULL;
+	property->value.list.last = C_NULL;
+	property = fxNextIntegerProperty(the, property, kind, XS_NO_ID, XS_INTERNAL_FLAG);
+	mxPullSlot(mxResult);
+	return instance;
+}
+
+void fx_MapIterator_prototype_next(txMachine* the)
+{
+	txSlot* iterator = fxCheckIteratorInstance(the, mxThis, mxID(_Map));
+	txSlot* result = iterator->next;
+	txSlot* iterable = result->next;
+	mxResult->kind = result->kind;
+	mxResult->value = result->value;
+	result = fxCheckIteratorResult(the, result);
+	if (result->next->value.boolean == 0) {
+		txSlot* list = iterable->next;
+		txInteger kind = list->next->value.integer;
+		txSlot* key = list->value.list.first;
+		if (key)
+			key = key->next->next;
+		else
+			key = iterable->value.reference->next->next->value.list.first;
+		while (key && (key->flag & XS_DONT_ENUM_FLAG))
+			key = key->next->next;
+		if (key) {
+			txSlot* value = key->next;
+			if (kind == 2) {
+				mxPushSlot(key);
+				mxPushSlot(value);
+				fxConstructArrayEntry(the, result);
+			}
+			else if (kind == 1) {
+				result->kind = value->kind;
+				result->value = value->value;
+			}
+			else {
+				result->kind = key->kind;
+				result->value = key->value;
+			}
+			list->value.list.first = key;
+		}
+		else {
+			result->kind = XS_UNDEFINED_KIND;
+			result->next->value.boolean = 1;
+			list->value.list.first = C_NULL;
+		}
+	}
+}
+
+txSlot* fxCheckSetInstance(txMachine* the, txSlot* slot, txBoolean mutable)
+{
+	if (slot->kind == XS_REFERENCE_KIND) {
+		txSlot* instance = slot->value.reference;
+		if (((slot = instance->next)) && (slot->flag & XS_INTERNAL_FLAG) && (slot->kind == XS_SET_KIND) && (instance != mxSetPrototype.value.reference)) {
+			if (mutable && (slot->flag & XS_DONT_SET_FLAG))
+				mxTypeError("Set instance is read-only");
+			return instance;
+		}
+	}
+	mxTypeError("this is no Set instance");
+	return C_NULL;
+}
+
+txSlot* fxCheckSetValue(txMachine* the)
+{
+	if (mxArgc > 0) {
+		txSlot* slot = mxArgv(0);
+		return slot;
+	}
+	mxTypeError("no value");
+	return C_NULL;
+}
+
+txSlot* fxNewSetInstance(txMachine* the)
+{
+	txSlot* set;
+	txSlot* table;
+	txSlot* list;
+	txSlot* size;
+	txSlot** address;
+	set = fxNewSlot(the);
+	set->kind = XS_INSTANCE_KIND;
+	set->value.instance.garbage = C_NULL;
+	set->value.instance.prototype = the->stack->value.reference;
+	the->stack->kind = XS_REFERENCE_KIND;
+	the->stack->value.reference = set;
+	table = set->next = fxNewSlot(the);
+	list = table->next = fxNewSlot(the);
+	size = list->next = fxNewSlot(the);
+	address = (txSlot**)fxNewChunk(the, mxTableMinLength * sizeof(txSlot*));
+	c_memset(address, 0, mxTableMinLength * sizeof(txSlot*));
+	/* TABLE */
+	table->flag = XS_INTERNAL_FLAG;
+	table->kind = XS_SET_KIND;
+	table->value.table.address = address;
+	table->value.table.length = mxTableMinLength;
+	/* LIST */
+	list->flag = XS_INTERNAL_FLAG;
+	list->kind = XS_LIST_KIND;
+	list->value.list.first = C_NULL;
+	list->value.list.last = C_NULL;
+	/* SIZE */
+	size->flag = XS_INTERNAL_FLAG;
+	size->kind = XS_INTEGER_KIND;
+	size->value.integer = 0;
+ 	return set;
+}
+
+void fx_Set(txMachine* the)
+{
+	txSlot *function, *iterable, *iterator, *next, *value;
+	if (mxIsUndefined(mxTarget))
+		mxTypeError("call: Set");
+	mxPushSlot(mxTarget);
+	fxGetPrototypeFromConstructor(the, &mxSetPrototype);
+	fxNewSetInstance(the);
+	mxPullSlot(mxResult);
+	if (mxArgc < 1)
+		return;
+	iterable = mxArgv(0);
+	if ((iterable->kind == XS_UNDEFINED_KIND) || (iterable->kind == XS_NULL_KIND))
+		return;
+	mxPushSlot(mxResult);
+	mxGetID(mxID(_add));	
+	function = the->stack;	
+	if (!fxIsCallable(the, function))	
+		mxTypeError("add is no function");
+	mxTemporary(iterator);
+	mxTemporary(next);
+	fxGetIterator(the, iterable, iterator, next, 0);	
+	mxTemporary(value);
+	while (fxIteratorNext(the, iterator, next, value)) {
+		mxTry(the) {
+			mxPushSlot(mxResult);
+			mxPushSlot(function);
+			mxCall();
+			mxPushSlot(value);
+			mxRunCount(1);
+			mxPop();
+		}
+		mxCatch(the) {
+			fxIteratorReturn(the, iterator);
+			fxJump(the);
+		}
+	}
+}
+
+void fx_Set_prototype_add(txMachine* the)
+{
+	txSlot* instance = fxCheckSetInstance(the, mxThis, XS_MUTABLE);
+	txSlot* table = instance->next;
+	txSlot* list = table->next;
+	txSlot* value = fxCheckSetValue(the);
+	fxSetEntry(the, table, list, value, C_NULL);
+	*mxResult = *mxThis;
+}
+
+void fx_Set_prototype_clear(txMachine* the)
+{
+	txSlot* instance = fxCheckSetInstance(the, mxThis, XS_MUTABLE);
+	txSlot* table = instance->next;
+	txSlot* list = table->next;
+	fxClearEntries(the, table, list, 0);
+}
+
+void fx_Set_prototype_delete(txMachine* the)
+{
+	txSlot* instance = fxCheckSetInstance(the, mxThis, XS_MUTABLE);
+	txSlot* table = instance->next;
+	txSlot* list = table->next;
+	txSlot* value = fxCheckSetValue(the);
+	mxResult->value.boolean = fxDeleteEntry(the, table, list, value, 0);
+	mxResult->kind = XS_BOOLEAN_KIND;
+}
+
+void fx_Set_prototype_entries(txMachine* the)
+{
+	fxCheckSetInstance(the, mxThis, XS_IMMUTABLE);
+	fxNewSetIteratorInstance(the, mxThis, 2);
+}
+
+void fx_Set_prototype_forEach(txMachine* the)
+{
+	txSlot* instance = fxCheckSetInstance(the, mxThis, XS_IMMUTABLE);
+	txSlot* table = instance->next;
+	txSlot* list = table->next;
+	txSlot* function = fxArgToCallback(the, 0);
+	txSlot* value;
+	mxPushList();
+	value = the->stack->value.list.first = list->value.list.first;
+	while (value) {
+		if (!(value->flag & XS_DONT_ENUM_FLAG)) {
+			/* THIS */
+			if (mxArgc > 1)
+				mxPushSlot(mxArgv(1));
+			else
+				mxPushUndefined();
+			/* FUNCTION */
+			mxPushSlot(function);
+			mxCall();
+			/* ARGUMENTS */
+			mxPushSlot(value);
+			mxPushSlot(value);
+			mxPushSlot(mxThis);
+			mxRunCount(3);
+			mxPop();
+		}
+		value = the->stack->value.list.first = value->next;
+	}
+	mxPop();
+}
+
+void fx_Set_prototype_has(txMachine* the)
+{
+	txSlot* instance = fxCheckSetInstance(the, mxThis, XS_IMMUTABLE);
+	txSlot* table = instance->next;
+	txSlot* value = fxCheckSetValue(the);
+	txSlot* result = fxGetEntry(the, table, value);
+	mxResult->kind = XS_BOOLEAN_KIND;
+	mxResult->value.boolean = (result) ? 1 : 0;
+}
+
+void fx_Set_prototype_size(txMachine* the)
+{
+	txSlot* instance = fxCheckSetInstance(the, mxThis, XS_IMMUTABLE);
+	txSlot* table = instance->next;
+	txSlot* list = table->next;
+	mxResult->kind = XS_INTEGER_KIND;
+	mxResult->value.integer = list->next->value.integer;
+}
+
+void fx_Set_prototype_values(txMachine* the)
+{
+	fxCheckSetInstance(the, mxThis, XS_IMMUTABLE);
+	fxNewSetIteratorInstance(the, mxThis, 1);
+}
+
+txSlot* fxNewSetIteratorInstance(txMachine* the, txSlot* iterable, txInteger kind) 
+{
+	txSlot* instance;
+	txSlot* property;
+	mxPush(mxSetIteratorPrototype);
+	instance = fxNewIteratorInstance(the, iterable, mxID(_Set));
+	property = fxLastProperty(the, instance);
+	property->kind = XS_LIST_KIND;
+	property->value.list.first = C_NULL;
+	property->value.list.last = C_NULL;
+	property = fxNextIntegerProperty(the, property, kind, XS_NO_ID, XS_INTERNAL_FLAG);
+	mxPullSlot(mxResult);
+	return instance;
+}
+
+void fx_SetIterator_prototype_next(txMachine* the)
+{
+	txSlot* iterator = fxCheckIteratorInstance(the, mxThis, mxID(_Set));
+	txSlot* result = iterator->next;
+	txSlot* iterable = result->next;
+	mxResult->kind = result->kind;
+	mxResult->value = result->value;
+	result = fxCheckIteratorResult(the, result);
+	if (result->next->value.boolean == 0) {
+		txSlot* list = iterable->next;
+		txInteger kind = list->next->value.integer;
+		txSlot* value = list->value.list.first;
+		if (value)
+			value = value->next;
+		else
+			value = iterable->value.reference->next->next->value.list.first;
+		while (value && (value->flag & XS_DONT_ENUM_FLAG))
+			value = value->next;
+		if (value) {
+			if (kind == 2) {
+				mxPushSlot(value);
+				mxPushSlot(value);
+				fxConstructArrayEntry(the, result);
+			}
+			else {
+				result->kind = value->kind;
+				result->value = value->value;
+			}
+			list->value.list.first = value;
+		}
+		else {
+			result->kind = XS_UNDEFINED_KIND;
+			result->next->value.boolean = 1;
+			list->value.list.first = C_NULL;
+		}
+	}
+}
+
+void fxClearEntries(txMachine* the, txSlot* table, txSlot* list, txBoolean paired)
+{
+	txSlot* slot = list->value.list.first;
+	while (slot) {
+		slot->flag = XS_DONT_ENUM_FLAG;
+		slot->kind = XS_UNDEFINED_KIND;
+		slot = slot->next;
+	}
+	c_memset(table->value.table.address, 0, table->value.table.length * sizeof(txSlot*));
+	list->next->value.integer = 0;
+	fxResizeEntries(the, table, list);
+	fxPurgeEntries(the, list);
+}
+
+txBoolean fxDeleteEntry(txMachine* the, txSlot* table, txSlot* list, txSlot* key, txBoolean paired) 
+{
+	txSlot* info = list->next;
+	txU4 sum = fxSumEntry(the, key);
+	txU4 index = sum & (table->value.table.length - 1);
+	txSlot** address = &(table->value.table.address[index]);
+	txSlot* entry;
+	txSlot* first;
+	txSlot* last;
+	while ((entry = *address)) {
+		if (entry->value.entry.sum == sum) {
+			first = entry->value.entry.slot;
+			if (fxTestEntry(the, first, key)) {
+				*address = entry->next;
+				entry->next = C_NULL;
+				first->flag = XS_DONT_ENUM_FLAG;
+				first->kind = XS_UNDEFINED_KIND;
+				if (paired) {
+					last = first->next;
+					last->flag = XS_DONT_ENUM_FLAG;
+					last->kind = XS_UNDEFINED_KIND;
+				}
+				info->value.integer--;
+				fxResizeEntries(the, table, list);
+				fxPurgeEntries(the, list);
+				return 1;
+			}
+		}
+		address = &entry->next;
+	}
+	return 0;
+}
+
+txSlot* fxGetEntry(txMachine* the, txSlot* table, txSlot* slot) 
+{
+	txU4 sum = fxSumEntry(the, slot);
+	txU4 index = sum & (table->value.table.length - 1);
+	txSlot* entry = table->value.table.address[index];
+	txSlot* result;
+	while (entry) {
+		if (entry->value.entry.sum == sum) {
+			result = entry->value.entry.slot;
+			if (fxTestEntry(the, result, slot))
+				return result;
+		}
+		entry = entry->next;
+	}
+	return C_NULL;
+}
+
+void fxPurgeEntries(txMachine* the, txSlot* list) 
+{
+	txSlot* former = C_NULL;
+	txSlot** address = &(list->value.list.first);
+	txSlot* slot;
+	while ((slot = *address)) {
+		if (slot->flag & XS_DONT_ENUM_FLAG) {
+			*address = slot->next;
+		}
+		else {
+			former = slot;
+			address = &slot->next;
+		}
+	}
+	list->value.list.last = former;
+}
+
+void fxResizeEntries(txMachine* the, txSlot* table, txSlot* list) 
+{
+	txSize size = list->next->value.integer;
+	txSize formerLength = table->value.table.length;
+	txSize currentLength = formerLength;
+	txSize high = mxTableThreshold(formerLength);
+	txSize low = mxTableThreshold(formerLength) >> 1;
+	if (high < size) {
+		currentLength = formerLength << 1;
+		if (currentLength > mxTableMaxLength)
+			currentLength = mxTableMaxLength;
+	}
+	else if (low >= size) {
+		currentLength = formerLength >> 1;
+		if (currentLength < mxTableMinLength)
+			currentLength = mxTableMinLength;
+	}
+	if (formerLength != currentLength) {
+		txSlot** currentAddress = (txSlot**)fxNewChunk(the, currentLength * sizeof(txSlot*));
+		if (currentAddress) {
+			txSlot** formerAddress = table->value.table.address;
+
+            txSize currentMask = currentLength - 1;
+			c_memset(currentAddress, 0, currentLength * sizeof(txSlot*));
+			while (formerLength) {
+				txSlot* entry;
+				while ((entry = *formerAddress)) {
+					txU4 index = entry->value.entry.sum & currentMask;
+					 *formerAddress = entry->next;
+					entry->next = currentAddress[index];
+					currentAddress[index] = entry;
+				}
+				formerLength--;
+				formerAddress++;
+			}
+			table->value.table.address = currentAddress;
+			table->value.table.length = currentLength;
+		}
+	}
+// 	{
+// 		txSize holes = 0;
+// 		txSize collisions = 0;
+// 		txSize i = 	0;
+// 		while (i < table->value.table.length) {
+// 			txSize j = 0;
+// 			txSlot* entry = table->value.table.address[i];
+// 			while (entry) {
+// 				j++;
+// 				entry = entry->next;
+// 			}
+// 			if (j == 0)
+// 				holes++;
+// 			else if (collisions < j)
+// 				collisions = j;
+// 			i++;
+// 		}
+// 		fprintf(stderr, "# size %d capacity %d holes %d collisions <%d\n", size, table->value.table.length, holes, collisions);
+// 	}
+}
+
+void fxSetEntry(txMachine* the, txSlot* table, txSlot* list, txSlot* key, txSlot* pair) 
+{
+	txU4 sum = fxSumEntry(the, key);
+	txU4 index = sum & (table->value.table.length - 1);
+	txSlot** address = &(table->value.table.address[index]);
+	txSlot* entry = *address;
+	txSlot* first;
+	txSlot* last;
+	while (entry) {
+		if (entry->value.entry.sum == sum) {
+			first = entry->value.entry.slot;
+			if (fxTestEntry(the, first, key)) {
+				if (pair) {
+					last = first->next;
+					last->kind = pair->kind;
+					last->value = pair->value;
+				}
+				return;
+			}
+		}
+		entry = entry->next;
+	}
+	first = fxNewSlot(the);
+	first->kind = key->kind;
+	first->value = key->value;
+	mxPushClosure(first);
+	if (pair) {
+		first->next = last = fxNewSlot(the);
+		last->kind = pair->kind;
+		last->value = pair->value;
+		mxPushClosure(last);
+	}
+	entry = fxNewSlot(the);
+	address = &(table->value.table.address[index]);
+	entry->next = *address;
+	entry->kind = XS_ENTRY_KIND;
+	entry->value.entry.slot = first;
+	entry->value.entry.sum = sum;
+	*address = entry;
+	if (list->value.list.last)
+		list->value.list.last->next = first;
+	else
+		list->value.list.first = first;
+	if (pair)
+		list->value.list.last = last;
+	else
+		list->value.list.last = first;
+	if (pair)
+		mxPop();
+	mxPop();
+	list->next->value.integer++;
+	fxResizeEntries(the, table, list);
+}
+
+txU4 fxSumEntry(txMachine* the, txSlot* slot) 
+{
+	txU1 kind = slot->kind;
+	txU8 sum;
+	
+	if ((XS_STRING_KIND == kind) || (XS_STRING_X_KIND == kind)) {
+		// Dan Bernstein: http://www.cse.yorku.ca/~oz/hash.html
+		txU1 *string = (txU1*)slot->value.string;
+		sum = 5381;
+		while ((kind = c_read8(string++))) {
+			sum = ((sum << 5) + sum) + kind;
+		}
+	}
+	else {
+		if (XS_REFERENCE_KIND == kind) {
+			txSlot* base = C_NULL;
+			sum = slot->value.reference - base;
+		}
+		else if (XS_INTEGER_KIND == kind) {
+			fxToNumber(the, slot);
+			sum = *((txU8*)&slot->value.number);
+		}
+		else if (XS_NUMBER_KIND == kind) {
+			if (slot->value.number == 0)
+				slot->value.number = 0;
+			else if (c_isnan(slot->value.number))
+				slot->value.number = C_NAN;
+			sum = *((txU8*)&slot->value.number);
+		}
+		else if ((XS_BIGINT_KIND == kind) || (XS_BIGINT_X_KIND == kind)) {
+			sum = fxToBigUint64(the, slot);
+		}
+		else if (XS_SYMBOL_KIND == kind) {
+			sum = slot->value.symbol;
+		}
+		else if (XS_BOOLEAN_KIND == kind) {
+			sum = slot->value.boolean;
+		}
+		else {
+			sum = 0;
+		}
+		// Thomas Wang: http://web.archive.org/web/20071223173210/http://www.concentric.net/~Ttwang/tech/inthash.htm
+		sum = (~sum) + (sum << 18); // sum = (sum << 18) - sum - 1;
+		sum = sum ^ (sum >> 31);
+		sum = sum * 21; // sum = (sum + (sum << 2)) + (sum << 4);
+		sum = sum ^ (sum >> 11);
+		sum = sum + (sum << 6);
+		sum = sum ^ (sum >> 22);
+	}
+	sum &= 0xFFFFFFFF;
+	return (txU4)sum;
+}
+
+txBoolean fxTestEntry(txMachine* the, txSlot* a, txSlot* b)
+{	
+	txBoolean result = 0;
+	if (a->kind == b->kind) {
+		if ((XS_UNDEFINED_KIND == a->kind) || (XS_NULL_KIND == a->kind))
+			result = 1;
+		else if (XS_BOOLEAN_KIND == a->kind)
+			result = a->value.boolean == b->value.boolean;
+		else if (XS_INTEGER_KIND == a->kind)
+			result = a->value.integer == b->value.integer;
+        else if (XS_NUMBER_KIND == a->kind)
+			result = ((c_isnan(a->value.number) && c_isnan(b->value.number)) || (a->value.number == b->value.number));
+		else if ((XS_STRING_KIND == a->kind) || (XS_STRING_X_KIND == a->kind))
+			result = c_strcmp(a->value.string, b->value.string) == 0;
+		else if (XS_SYMBOL_KIND == a->kind)
+			result = a->value.symbol == b->value.symbol;
+		else if ((XS_BIGINT_KIND == a->kind) || (XS_BIGINT_X_KIND == a->kind))
+			result = gxTypeBigInt.compare(the, 0, 1, 0, a, b);
+		else if (XS_REFERENCE_KIND == a->kind)
+			result = a->value.reference == b->value.reference;
+	}
+	else if ((XS_INTEGER_KIND == a->kind) && (XS_NUMBER_KIND == b->kind))
+		result = (!c_isnan(b->value.number)) && ((txNumber)(a->value.integer) == b->value.number);
+	else if ((XS_NUMBER_KIND == a->kind) && (XS_INTEGER_KIND == b->kind))
+		result = (!c_isnan(a->value.number)) && (a->value.number == (txNumber)(b->value.integer));
+	else if ((XS_STRING_KIND == a->kind) && (XS_STRING_X_KIND == b->kind))
+		result = c_strcmp(a->value.string, b->value.string) == 0;
+	else if ((XS_STRING_X_KIND == a->kind) && (XS_STRING_KIND == b->kind))
+		result = c_strcmp(a->value.string, b->value.string) == 0;
+	else if ((XS_BIGINT_KIND == a->kind) && (XS_BIGINT_X_KIND == b->kind))
+		result = gxTypeBigInt.compare(the, 0, 1, 0, a, b);
+	else if ((XS_BIGINT_X_KIND == a->kind) && (XS_BIGINT_KIND == b->kind))
+		result = gxTypeBigInt.compare(the, 0, 1, 0, a, b);
+	return result;
+}
+
+txSlot* fxCheckWeakMapInstance(txMachine* the, txSlot* slot, txBoolean mutable)
+{
+	if (slot->kind == XS_REFERENCE_KIND) {
+		txSlot* instance = slot->value.reference;
+		if (((slot = instance->next)) && (slot->flag & XS_INTERNAL_FLAG) && (slot->kind == XS_WEAK_MAP_KIND) && (instance != mxWeakMapPrototype.value.reference)) {
+			if (mutable && (slot->flag &  XS_DONT_SET_FLAG))
+				mxTypeError("WeakMap instance is read-only");
+			return instance;
+		}
+	}
+	mxTypeError("this is no WeakMap instance");
+	return C_NULL;
+}
+
+txSlot* fxCheckWeakMapKey(txMachine* the, txBoolean mutable)
+{
+	if (mxArgc > 0) {
+		txSlot* slot = mxArgv(0);
+		if (slot->kind == XS_REFERENCE_KIND) {
+			if (mutable && (slot->value.reference->flag & XS_MARK_FLAG))
+				mxTypeError("WeakMap key is read-only");
+			return slot;
+		}
+	}
+	return C_NULL;
+}
+
+txSlot* fxNewWeakMapInstance(txMachine* the)
+{
+	txSlot* map;
+	txSlot* list;
+	map = fxNewSlot(the);
+	map->kind = XS_INSTANCE_KIND;
+	map->value.instance.garbage = C_NULL;
+	map->value.instance.prototype = the->stack->value.reference;
+	the->stack->kind = XS_REFERENCE_KIND;
+	the->stack->value.reference = map;
+	/* LIST */
+	list = map->next = fxNewSlot(the);
+	list->flag = XS_INTERNAL_FLAG;
+	list->kind = XS_WEAK_MAP_KIND;
+	list->value.weakList.first = C_NULL;
+	list->value.weakList.link = the->firstWeakListLink;
+	the->firstWeakListLink = list;
+ 	return map;
+}
+
+void fx_WeakMap(txMachine* the)
+{
+	txSlot *function, *iterable, *iterator, *next, *value;
+	if (mxIsUndefined(mxTarget))
+		mxTypeError("call: WeakMap");
+	mxPushSlot(mxTarget);
+	fxGetPrototypeFromConstructor(the, &mxWeakMapPrototype);
+	fxNewWeakMapInstance(the);
+	mxPullSlot(mxResult);
+	if (mxArgc < 1)
+		return;
+	iterable = mxArgv(0);
+	if ((iterable->kind == XS_UNDEFINED_KIND) || (iterable->kind == XS_NULL_KIND))
+		return;
+	mxPushSlot(mxResult);
+	mxGetID(mxID(_set));	
+	function = the->stack;	
+	if (!fxIsCallable(the, function))	
+		mxTypeError("set is no function");
+	mxTemporary(iterator);
+	mxTemporary(next);
+	fxGetIterator(the, iterable, iterator, next, 0);	
+	mxTemporary(value);
+	while (fxIteratorNext(the, iterator, next, value)) {
+		mxTry(the) {
+			mxPushSlot(mxResult);
+			mxPushSlot(function);
+			mxCall();
+			if (value->kind != XS_REFERENCE_KIND)
+				mxTypeError("item is no object");
+			mxPushSlot(value);
+			mxGetIndex(0);
+			mxPushSlot(value);
+			mxGetIndex(1);
+			mxRunCount(2);
+			mxPop();
+		}
+		mxCatch(the) {
+			fxIteratorReturn(the, iterator);
+			fxJump(the);
+		}
+	}
+}
+
+void fx_WeakMap_prototype_delete(txMachine* the)
+{
+	txSlot* instance = fxCheckWeakMapInstance(the, mxThis, XS_MUTABLE);
+	txSlot* key = fxCheckWeakMapKey(the, XS_MUTABLE);
+	mxResult->value.boolean = (key) ? fxDeleteWeakEntry(the, instance->next, key->value.reference) : 0;
+	mxResult->kind = XS_BOOLEAN_KIND;
+}
+
+void fx_WeakMap_prototype_get(txMachine* the)
+{
+	txSlot* instance = fxCheckWeakMapInstance(the, mxThis, XS_IMMUTABLE);
+	txSlot* key = fxCheckWeakMapKey(the, XS_IMMUTABLE);
+	txSlot* result = (key) ? fxGetWeakEntry(the, instance->next, key->value.reference) : C_NULL;
+	if (result) {
+		txSlot* value = result->value.weakEntry.value;
+		mxResult->kind = value->kind;
+		mxResult->value = value->value;
+	}
+}
+
+void fx_WeakMap_prototype_has(txMachine* the)
+{
+	txSlot* instance = fxCheckWeakMapInstance(the, mxThis, XS_IMMUTABLE);
+	txSlot* key = fxCheckWeakMapKey(the, XS_IMMUTABLE);
+	txSlot* result = (key) ? fxGetWeakEntry(the, instance->next, key->value.reference) : C_NULL;
+	mxResult->kind = XS_BOOLEAN_KIND;
+	mxResult->value.boolean = (result) ? 1 : 0;
+}
+
+void fx_WeakMap_prototype_set(txMachine* the)
+{
+	txSlot* instance = fxCheckWeakMapInstance(the, mxThis, XS_MUTABLE);
+	txSlot* key = fxCheckWeakMapKey(the, XS_MUTABLE);
+	if (!key)
+		mxTypeError("key is no object");
+	fxSetWeakEntry(the, instance->next, key->value.reference, (mxArgc > 1) ? mxArgv(1) : &mxUndefined);
+	*mxResult = *mxThis;
+}
+
+txSlot* fxCheckWeakSetInstance(txMachine* the, txSlot* slot, txBoolean mutable)
+{
+	if (slot->kind == XS_REFERENCE_KIND) {
+		txSlot* instance = slot->value.reference;
+		if (((slot = instance->next)) && (slot->flag & XS_INTERNAL_FLAG) && (slot->kind == XS_WEAK_SET_KIND) && (instance != mxWeakSetPrototype.value.reference)) {
+			if (mutable && (slot->flag & XS_DONT_SET_FLAG))
+				mxTypeError("WeakSet instance is read-only");
+			return instance;
+		}
+	}
+	mxTypeError("this is no WeakSet instance");
+	return C_NULL;
+}
+
+txSlot* fxCheckWeakSetValue(txMachine* the, txBoolean mutable)
+{
+	if (mxArgc > 0) {
+		txSlot* slot = mxArgv(0);
+		if (slot->kind == XS_REFERENCE_KIND) {
+			if (mutable && (slot->value.reference->flag & XS_MARK_FLAG))
+				mxTypeError("WeakSet value is read-only");
+			return slot;
+		}
+	}
+	return C_NULL;
+}
+
+txSlot* fxNewWeakSetInstance(txMachine* the)
+{
+	txSlot* set;
+	txSlot* list;
+	set = fxNewSlot(the);
+	set->kind = XS_INSTANCE_KIND;
+	set->value.instance.garbage = C_NULL;
+	set->value.instance.prototype = the->stack->value.reference;
+	the->stack->kind = XS_REFERENCE_KIND;
+	the->stack->value.reference = set;
+	/* LIST */
+	list = set->next = fxNewSlot(the);
+	list->flag = XS_INTERNAL_FLAG;
+	list->kind = XS_WEAK_SET_KIND;
+	list->value.weakList.first = C_NULL;
+	list->value.weakList.link = the->firstWeakListLink;
+	the->firstWeakListLink = list;
+ 	return set;
+}
+
+void fx_WeakSet(txMachine* the)
+{
+	txSlot *function, *iterable, *iterator, *next, *value;
+	if (mxIsUndefined(mxTarget))
+		mxTypeError("call: WeakSet");
+	mxPushSlot(mxTarget);
+	fxGetPrototypeFromConstructor(the, &mxWeakSetPrototype);
+	fxNewWeakSetInstance(the);
+	mxPullSlot(mxResult);
+	if (mxArgc < 1)
+		return;
+	iterable = mxArgv(0);
+	if ((iterable->kind == XS_UNDEFINED_KIND) || (iterable->kind == XS_NULL_KIND))
+		return;
+	mxPushSlot(mxResult);
+	mxGetID(mxID(_add));	
+	function = the->stack;	
+	if (!fxIsCallable(the, function))	
+		mxTypeError("add is no function");
+	mxTemporary(iterator);
+	mxTemporary(next);
+	fxGetIterator(the, iterable, iterator, next, 0);	
+	mxTemporary(value);
+	while (fxIteratorNext(the, iterator, next, value)) {
+		mxTry(the) {
+			mxPushSlot(mxResult);
+			mxPushSlot(function);
+			mxCall();
+			mxPushSlot(value);
+			mxRunCount(1);
+			mxPop();
+		}
+		mxCatch(the) {
+			fxIteratorReturn(the, iterator);
+			fxJump(the);
+		}
+	}
+}
+
+void fx_WeakSet_prototype_add(txMachine* the)
+{
+	txSlot* instance = fxCheckWeakSetInstance(the, mxThis, XS_MUTABLE);
+	txSlot* value = fxCheckWeakSetValue(the, XS_MUTABLE);
+	if (!value)
+		mxTypeError("value is no object");
+	fxSetWeakEntry(the, instance->next, value->value.reference, &mxUndefined);
+	*mxResult = *mxThis;
+}
+
+void fx_WeakSet_prototype_has(txMachine* the)
+{
+	txSlot* instance = fxCheckWeakSetInstance(the, mxThis, XS_IMMUTABLE);
+	txSlot* value = fxCheckWeakSetValue(the, XS_IMMUTABLE);
+	txSlot* result = (value) ? fxGetWeakEntry(the, instance->next, value->value.reference) : C_NULL;
+	mxResult->kind = XS_BOOLEAN_KIND;
+	mxResult->value.boolean = (result) ? 1 : 0;
+}
+
+void fx_WeakSet_prototype_delete(txMachine* the)
+{
+	txSlot* instance = fxCheckWeakSetInstance(the, mxThis, XS_MUTABLE);
+	txSlot* value = fxCheckWeakSetValue(the, XS_MUTABLE);
+	mxResult->value.boolean = (value) ? fxDeleteWeakEntry(the, instance->next, value->value.reference) : 0;
+	mxResult->kind = XS_BOOLEAN_KIND;
+}
+
+txBoolean fxDeleteWeakEntry(txMachine* the, txSlot* list, txSlot* key) 
+{
+	txSlot* slot = (key->flag & XS_EXOTIC_FLAG) ? key->next : key;
+	txSlot** address = &slot->next;
+	while ((slot = *address)) {
+		if (!(slot->flag & XS_INTERNAL_FLAG))
+			break;
+		if ((slot->kind == XS_WEAK_ENTRY_KIND) && (slot->value.weakEntry.check == list)) {
+			slot->value.weakEntry.value->kind = XS_UNINITIALIZED_KIND;
+			*address = slot->next;
+			return 1;
+		}			
+		address = &slot->next;
+	}
+	return 0;
+}
+
+txSlot* fxGetWeakEntry(txMachine* the, txSlot* list, txSlot* key) 
+{
+	txSlot* slot = (key->flag & XS_EXOTIC_FLAG) ? key->next : key;
+    slot = slot->next;
+	while (slot) {
+		if (!(slot->flag & XS_INTERNAL_FLAG))
+			break;
+		if ((slot->kind == XS_WEAK_ENTRY_KIND) && (slot->value.weakEntry.check == list))
+			return slot;
+		slot = slot->next;
+	}
+	return C_NULL;
+}
+
+void fxSetWeakEntry(txMachine* the, txSlot* list, txSlot* key, txSlot* value) 
+{
+	txSlot* slot = (key->flag & XS_EXOTIC_FLAG) ? key->next : key;
+	txSlot** address = &slot->next;
+	txSlot* keyEntry;
+	txSlot* listEntry;
+	txSlot* closure;
+	while ((slot = *address)) {
+		if (!(slot->flag & XS_INTERNAL_FLAG))
+			break;
+		if ((slot->kind == XS_WEAK_ENTRY_KIND) && (slot->value.weakEntry.check == list)) {
+			slot = slot->value.weakEntry.value;
+			slot->kind = value->kind;
+			slot->value = value->value;
+			return;
+		}			
+		address = &slot->next;
+	}
+	
+	keyEntry = fxNewSlot(the);
+	mxPushClosure(keyEntry);
+	listEntry = fxNewSlot(the);
+	mxPushClosure(listEntry);
+	closure = fxNewSlot(the);
+	closure->kind = value->kind;
+	closure->value = value->value;
+	
+	slot = (key->flag & XS_EXOTIC_FLAG) ? key->next : key;
+	address = &slot->next;
+	while ((slot = *address)) {
+		if (!(slot->flag & XS_INTERNAL_FLAG))
+			break;
+		address = &slot->next;
+	}
+	
+	keyEntry->next = *address;
+	keyEntry->flag = XS_INTERNAL_FLAG;
+	keyEntry->kind = XS_WEAK_ENTRY_KIND;
+	keyEntry->value.weakEntry.check = list;
+	keyEntry->value.weakEntry.value = closure;
+	*address = keyEntry;
+	
+	listEntry->next = list->value.weakList.first;
+	listEntry->flag = XS_INTERNAL_FLAG;
+	listEntry->kind = XS_WEAK_ENTRY_KIND;
+	listEntry->value.weakEntry.check = key;
+	listEntry->value.weakEntry.value = closure;
+	list->value.weakList.first = listEntry;
+	
+	mxPop();
+	mxPop();
+}
+
+void fxKeepDuringJobs(txMachine* the, txSlot* target)
+{
+	txSlot* instance = mxDuringJobs.value.reference;
+	txSlot** address = &(instance->next);
+	txSlot* slot;
+	while ((slot = *address)) {
+		if (slot->value.reference == target)
+			return;
+		address = &(slot->next);
+	}
+	*address = slot = fxNewSlot(the);
+	slot->value.reference = target;
+	slot->kind = XS_REFERENCE_KIND;
+}
+
+txSlot* fxCheckWeakRefInstance(txMachine* the, txSlot* slot)
+{
+	if (slot->kind == XS_REFERENCE_KIND) {
+		txSlot* instance = slot->value.reference;
+		if (((slot = instance->next)) && (slot->flag & XS_INTERNAL_FLAG) && (slot->kind == XS_WEAK_REF_KIND))
+			return instance;
+	}
+	mxTypeError("this is no WeakRef instance");
+	return C_NULL;
+}
+
+txSlot* fxNewWeakRefInstance(txMachine* the)
+{
+	txSlot* slot;
+	txSlot* instance = fxNewSlot(the);
+	instance->kind = XS_INSTANCE_KIND;
+	instance->value.instance.garbage = C_NULL;
+	instance->value.instance.prototype = the->stack->value.reference;
+	the->stack->kind = XS_REFERENCE_KIND;
+	the->stack->value.reference = instance;
+	slot = instance->next = fxNewSlot(the);
+	slot->flag = XS_INTERNAL_FLAG;
+	slot->kind = XS_WEAK_REF_KIND;
+	slot->value.weakRef.target = C_NULL;
+	slot->value.weakRef.link = C_NULL;
+	return instance;
+}
+
+void fx_WeakRef(txMachine* the)
+{
+	txSlot* target;
+	txSlot* instance;
+	if (mxIsUndefined(mxTarget))
+		mxTypeError("call: WeakRef");
+	if (mxArgc < 1)
+		mxTypeError("new WeakRef: no target");
+	target = mxArgv(0);
+	if (!mxIsReference(target))
+		mxTypeError("new WeakRef: target is no object");
+	target = target->value.reference;
+	mxPushSlot(mxTarget);
+	fxGetPrototypeFromConstructor(the, &mxWeakRefPrototype);
+	instance = fxNewWeakRefInstance(the);
+	mxPullSlot(mxResult);
+	fxKeepDuringJobs(the, target);
+	instance->next->value.weakRef.target = target;
+}
+
+void fx_WeakRef_prototype_deref(txMachine* the)
+{
+	txSlot* instance = fxCheckWeakRefInstance(the, mxThis);
+	txSlot* target = instance->next->value.weakRef.target;
+	if (target) {
+		mxResult->value.reference = target;
+		mxResult->kind = XS_REFERENCE_KIND;
+		fxKeepDuringJobs(the, target);
+	}
+}
+
+txSlot* fxCheckFinalizationRegistryInstance(txMachine* the, txSlot* slot)
+{
+	if (slot->kind == XS_REFERENCE_KIND) {
+		txSlot* instance = slot->value.reference;
+		if (((slot = instance->next)) && (slot->flag & XS_INTERNAL_FLAG) && (slot->kind == XS_CLOSURE_KIND) && (slot->value.closure->kind == XS_FINALIZATION_REGISTRY_KIND)) {
+			if (slot->flag & XS_MARK_FLAG)
+				mxTypeError("FinalizationRegistry instance is read-only");
+			return instance;
+		}
+	}
+	mxTypeError("this is no FinalizationRegistry instance");
+	return C_NULL;
+}
+
+void fx_FinalizationRegistry(txMachine* the)
+{
+	txSlot* callback;
+	txSlot* instance;
+	txSlot* property;
+	txSlot* registry;
+	txSlot* slot;
+	if (mxIsUndefined(mxTarget))
+		mxTypeError("call: FinalizationRegistry");
+	if (mxArgc < 1)
+		mxTypeError("no callback");
+	callback = mxArgv(0);
+	if (!fxIsCallable(the, callback))
+		mxTypeError("callback is no function");
+	mxPushSlot(mxTarget);
+	fxGetPrototypeFromConstructor(the, &mxFinalizationRegistryPrototype);
+	instance = fxNewSlot(the);
+	instance->kind = XS_INSTANCE_KIND;
+	instance->value.instance.garbage = C_NULL;
+	instance->value.instance.prototype = the->stack->value.reference;
+	the->stack->kind = XS_REFERENCE_KIND;
+	the->stack->value.reference = instance;
+	mxPullSlot(mxResult);
+	property = instance->next = fxNewSlot(the);
+	property->flag = XS_INTERNAL_FLAG;
+	property->kind = XS_CLOSURE_KIND;
+	property->value.closure = C_NULL;
+	registry = fxNewSlot(the);
+	registry->kind = XS_FINALIZATION_REGISTRY_KIND;
+	registry->value.finalizationRegistry.callback = C_NULL;
+	registry->value.finalizationRegistry.flags = XS_NO_FLAG;
+	property->value.closure = registry;
+	slot = fxNewSlot(the);
+	slot->kind = callback->kind;
+	slot->value = callback->value;
+	registry->value.finalizationRegistry.callback = slot;
+}
+
+
+#if 0
+// removed from FinalizationRegistry specification
+void fx_FinalizationRegistry_prototype_cleanupSome(txMachine* the)
+{
+	txSlot* instance;
+	txSlot* registry;
+	txSlot* callback = C_NULL;
+	txSlot** address;
+	txSlot* slot;
+	if (!mxIsReference(mxThis))
+		mxTypeError("this is no object");
+	instance = fxCheckFinalizationRegistryInstance(the, mxThis);
+	registry = instance->next->value.closure;
+	if (mxArgc > 0) {
+		callback = mxArgv(0);
+		if (mxIsUndefined(callback))
+			callback = C_NULL;
+		else if (!fxIsCallable(the, callback))
+			mxTypeError("callback is no function");
+	}
+	fx_FinalizationRegistryCleanup(the, registry, callback);
+	callback = registry->value.finalizationRegistry.callback;
+	if (callback->next == C_NULL) {
+		address = &(mxFinalizationRegistries.value.reference->next);
+		while ((slot = *address)) {
+			if (slot->value.closure == registry) {
+				*address = slot->next;
+				return;
+			}
+			address = &(slot->next);
+		}
+	}
+}
+#endif
+
+void fx_FinalizationRegistry_prototype_register(txMachine* the)
+{
+	txSlot* instance;
+	txSlot* registry;
+	txSlot* target;
+	txSlot* token = C_NULL;
+	txSlot* callback;
+	txSlot** address;
+	txSlot* slot;
+	if (!mxIsReference(mxThis))
+		mxTypeError("this is no object");
+	instance = fxCheckFinalizationRegistryInstance(the, mxThis);
+	registry = instance->next->value.closure;
+	if (mxArgc < 1)
+		mxTypeError("no target");
+	target = mxArgv(0);
+	if (!mxIsReference(target))
+		mxTypeError("target is no object");
+	if (mxArgc > 1) {
+		if (fxIsSameValue(the, target, mxArgv(1), 1))
+			mxTypeError("target and holdings are the same");
+	}
+	target = target->value.reference;
+	if (mxArgc > 2) {
+		token = mxArgv(2);
+		if (mxIsUndefined(token))
+			token = C_NULL;
+		else if (mxIsReference(token))
+			token = token->value.reference;
+		else
+			mxTypeError("token is no object");
+	}
+	callback = registry->value.finalizationRegistry.callback;
+	address = &(callback->next);
+	while ((slot = *address))
+		address = &(slot->next);
+	slot = *address = fxNewSlot(the);
+	if (mxArgc > 1) {
+		slot->kind = mxArgv(1)->kind;
+		slot->value = mxArgv(1)->value;
+	}
+	slot = slot->next = fxNewSlot(the);
+	slot->kind = XS_FINALIZATION_CELL_KIND;
+	slot->value.finalizationCell.target = target;
+	slot->value.finalizationCell.token = token;
+	
+	address = &(mxFinalizationRegistries.value.reference->next);
+	while ((slot = *address)) {
+		if (slot->value.closure == registry)
+			return;
+		address = &(slot->next);
+	}
+	slot = *address = fxNewSlot(the);
+	slot->kind = XS_CLOSURE_KIND;
+	slot->value.closure = registry;
+}	
+
+void fx_FinalizationRegistry_prototype_unregister(txMachine* the)
+{
+	txSlot* instance;
+	txSlot* token;
+	txSlot* registry;
+	txSlot* callback;
+	txSlot** address;
+	txSlot* slot;
+	if (!mxIsReference(mxThis))
+		mxTypeError("this is no object");
+	instance = fxCheckFinalizationRegistryInstance(the, mxThis);
+	if (mxArgc < 1)
+		mxTypeError("no token");
+	token = mxArgv(0);
+	if (!mxIsReference(token))
+		mxTypeError("token is no object");
+	token = token->value.reference;
+	mxResult->kind = XS_BOOLEAN_KIND;
+	mxResult->value.boolean = 0;
+	registry = instance->next->value.closure;
+	callback = registry->value.finalizationRegistry.callback;
+	address = &(callback->next);
+	while ((slot = *address)) {
+		slot = slot->next;
+		if (slot->value.finalizationCell.token && fxIsSameInstance(the, slot->value.finalizationCell.token, token)) {
+			*address = slot->next;
+			mxResult->value.boolean = 1;
+		}
+		else
+			address = &(slot->next);
+	}
+	if (callback->next == C_NULL) {
+		address = &(mxFinalizationRegistries.value.reference->next);
+		while ((slot = *address)) {
+			if (slot->value.closure == registry) {
+				*address = slot->next;
+				return;
+			}
+			address = &(slot->next);
+		}
+	}
+}
+
+void fx_FinalizationRegistryCleanup(txMachine* the, txSlot* registry, txSlot* callback)
+{
+	txSlot* slot;
+	txUnsigned flags;
+	txSlot** address;
+	txSlot* value;
+
+	if (!(registry->value.finalizationRegistry.flags & XS_FINALIZATION_REGISTRY_CHANGED))
+		return;
+		
+	slot = registry->value.finalizationRegistry.callback->next;
+	flags = 0;
+	while (slot) {
+		slot = slot->next;
+		if (slot->value.finalizationCell.target == C_NULL) {
+			flags = 1;
+			break;
+		}
+		slot = slot->next;
+	}
+	if (!flags)
+		return;
+	if (!callback)
+		callback = registry->value.finalizationRegistry.callback;
+	flags = registry->value.finalizationRegistry.flags;
+	{
+		mxTry(the) {
+			address = &(registry->value.finalizationRegistry.callback->next);
+			while ((value = *address)) {
+				slot = value->next;
+				if (slot->value.finalizationCell.target == C_NULL) {
+					*address = slot->next;
+					mxPushUndefined();
+					mxPushSlot(callback);
+					mxCall();
+					mxPushSlot(value);
+					mxRunCount(1);
+					mxPop();
+				}
+				else
+					address = &(slot->next);
+			}
+			registry->value.finalizationRegistry.flags = flags;
+		}
+		mxCatch(the) {
+			registry->value.finalizationRegistry.flags = flags;
+			fxJump(the);
+		}
+	}
+	
+	slot = registry->value.finalizationRegistry.callback->next;
+	while (slot) {
+		slot = slot->next;
+		if (slot->value.finalizationCell.target == C_NULL)
+			break;
+		slot = slot->next;
+	}
+	if (!slot)
+		registry->value.finalizationRegistry.flags &= ~XS_FINALIZATION_REGISTRY_CHANGED;
+}
+
+void fxCleanupFinalizationRegistries(txMachine* the)
+{
+	txSlot** address = &(mxFinalizationRegistries.value.reference->next);
+	txSlot* closure;
+	while ((closure = *address)) {
+		txSlot* registry = closure->value.closure;
+		if (registry->value.finalizationRegistry.flags & XS_FINALIZATION_REGISTRY_CHANGED) {
+			fx_FinalizationRegistryCleanup(the, registry, C_NULL);
+			address = &(mxFinalizationRegistries.value.reference->next);
+		}
+		else
+			address = &(closure->next);
+	}
+}
+
+