/src/moddable/xs/sources/xsArray.c

Source
/*
 * Copyright (c) 2016-2025  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"

#define mxArraySize(ARRAY) (((ARRAY)->value.array.address) ? (((txChunk*)(((txByte*)((ARRAY)->value.array.address)) - sizeof(txChunk)))->size) / sizeof(txSlot) : 0)

static txIndex fxCheckArrayLength(txMachine* the, txSlot* slot);
static txBoolean fxCallThisItem(txMachine* the, txSlot* function, txIndex index, txSlot* item);
static txSlot* fxCheckArray(txMachine* the, txSlot* slot, txBoolean mutable);
static txSlot* fxCheckArrayItems(txMachine* the, txSlot* array, txIndex from, txIndex to);
static int fxCompareArrayItem(txMachine* the, txSlot* function, txSlot* array, txInteger i);
static txSlot* fxCreateArray(txMachine* the, txFlag flag, txIndex length);
static txSlot* fxCreateArraySpecies(txMachine* the, txNumber length);
static void fxFindThisItem(txMachine* the, txSlot* function, txNumber index, txSlot* item);
static txNumber fxGetArrayLength(txMachine* the, txSlot* reference);
static txIndex fxGetArrayLimit(txMachine* the, txSlot* reference);
static void fxMoveThisItem(txMachine* the, txNumber from, txNumber to);
static void fxReduceThisItem(txMachine* the, txSlot* function, txIndex index);
static txBoolean fxSetArrayLength(txMachine* the, txSlot* array, txIndex target);
static void fx_Array_from_aux(txMachine* the, txSlot* function, txSlot* value, txIndex index);
static txIndex fx_Array_prototype_flatAux(txMachine* the, txSlot* source, txIndex length, txIndex start, txIndex depth, txSlot* function);

static txBoolean fxArrayDefineOwnProperty(txMachine* the, txSlot* instance, txID id, txIndex index, txSlot* slot, txFlag mask);
static txBoolean fxArrayDeleteProperty(txMachine* the, txSlot* instance, txID id, txIndex index);
static txBoolean fxArrayGetOwnProperty(txMachine* the, txSlot* instance, txID id, txIndex index, txSlot* slot);
static txSlot* fxArrayGetProperty(txMachine* the, txSlot* instance, txID id, txIndex index, txFlag flag);
static txBoolean fxArrayHasProperty(txMachine* the, txSlot* instance, txID id, txIndex index);
static void fxArrayOwnKeys(txMachine* the, txSlot* instance, txFlag flag, txSlot* keys);
static txSlot* fxArraySetProperty(txMachine* the, txSlot* instance, txID id, txIndex index, txFlag flag);

const txBehavior ICACHE_FLASH_ATTR gxArrayBehavior = {
  fxArrayGetProperty,
  fxArraySetProperty,
  fxOrdinaryCall,
  fxOrdinaryConstruct,
  fxArrayDefineOwnProperty,
  fxArrayDeleteProperty,
  fxArrayGetOwnProperty,
  fxOrdinaryGetPropertyValue,
  fxOrdinaryGetPrototype,
  fxArrayHasProperty,
  fxOrdinaryIsExtensible,
  fxArrayOwnKeys,
  fxOrdinaryPreventExtensions,
  fxOrdinarySetPropertyValue,
  fxOrdinarySetPrototype,
};

void fxBuildArray(txMachine* the)
{
  txSlot* instance;
  txSlot* slot;
  txSlot* property;
  txSlot* unscopable;
  
  mxPush(mxObjectPrototype);
  instance = fxNewArrayInstance(the);

  fxNewHostFunction(the, mxCallback(fxArrayLengthGetter), 0, mxID(_length), XS_NO_ID);
  property = mxFunctionInstanceHome(the->stack->value.reference);
  property->value.home.object = instance;
  fxNewHostFunction(the, mxCallback(fxArrayLengthSetter), 1, mxID(_length), XS_NO_ID);
  property = mxFunctionInstanceHome(the->stack->value.reference);
  property->value.home.object = instance;
  mxPushUndefined();
  the->stack->flag = XS_DONT_DELETE_FLAG;
  the->stack->kind = XS_ACCESSOR_KIND;
  the->stack->value.accessor.getter = (the->stack + 2)->value.reference;
  the->stack->value.accessor.setter = (the->stack + 1)->value.reference;
  mxPull(mxArrayLengthAccessor);
  mxPop();
  mxPop();

  slot = fxLastProperty(the, instance);
  slot = fxNextHostFunctionProperty(the, slot, mxCallback(fx_Array_prototype_at), 1, mxID(_at), XS_DONT_ENUM_FLAG);
  slot = fxNextHostFunctionProperty(the, slot, mxCallback(fx_Array_prototype_concat), 1, mxID(_concat), XS_DONT_ENUM_FLAG);
  slot = fxNextHostFunctionProperty(the, slot, mxCallback(fx_Array_prototype_copyWithin), 2, mxID(_copyWithin), XS_DONT_ENUM_FLAG);
  slot = fxNextHostFunctionProperty(the, slot, mxCallback(fx_Array_prototype_entries), 0, mxID(_entries), XS_DONT_ENUM_FLAG);
  slot = fxNextHostFunctionProperty(the, slot, mxCallback(fx_Array_prototype_every), 1, mxID(_every), XS_DONT_ENUM_FLAG);
  slot = fxNextHostFunctionProperty(the, slot, mxCallback(fx_Array_prototype_fill), 1, mxID(_fill), XS_DONT_ENUM_FLAG);
  slot = fxNextHostFunctionProperty(the, slot, mxCallback(fx_Array_prototype_filter), 1, mxID(_filter), XS_DONT_ENUM_FLAG);
  slot = fxNextHostFunctionProperty(the, slot, mxCallback(fx_Array_prototype_find), 1, mxID(_find), XS_DONT_ENUM_FLAG);
  slot = fxNextHostFunctionProperty(the, slot, mxCallback(fx_Array_prototype_findIndex), 1, mxID(_findIndex), XS_DONT_ENUM_FLAG);
  slot = fxNextHostFunctionProperty(the, slot, mxCallback(fx_Array_prototype_findLast), 1, mxID(_findLast), XS_DONT_ENUM_FLAG);
  slot = fxNextHostFunctionProperty(the, slot, mxCallback(fx_Array_prototype_findLastIndex), 1, mxID(_findLastIndex), XS_DONT_ENUM_FLAG);
  slot = fxNextHostFunctionProperty(the, slot, mxCallback(fx_Array_prototype_flat), 0, mxID(_flat), XS_DONT_ENUM_FLAG);
  slot = fxNextHostFunctionProperty(the, slot, mxCallback(fx_Array_prototype_flatMap), 1, mxID(_flatMap), XS_DONT_ENUM_FLAG);
  slot = fxNextHostFunctionProperty(the, slot, mxCallback(fx_Array_prototype_forEach), 1, mxID(_forEach), XS_DONT_ENUM_FLAG);
  slot = fxNextHostFunctionProperty(the, slot, mxCallback(fx_Array_prototype_includes), 1, mxID(_includes), XS_DONT_ENUM_FLAG);
  slot = fxNextHostFunctionProperty(the, slot, mxCallback(fx_Array_prototype_indexOf), 1, mxID(_indexOf), XS_DONT_ENUM_FLAG);
  slot = fxNextHostFunctionProperty(the, slot, mxCallback(fx_Array_prototype_join), 1, mxID(_join), XS_DONT_ENUM_FLAG);
  slot = fxNextHostFunctionProperty(the, slot, mxCallback(fx_Array_prototype_keys), 0, mxID(_keys), XS_DONT_ENUM_FLAG);
  slot = fxNextHostFunctionProperty(the, slot, mxCallback(fx_Array_prototype_lastIndexOf), 1, mxID(_lastIndexOf), XS_DONT_ENUM_FLAG);
  slot = fxNextHostFunctionProperty(the, slot, mxCallback(fx_Array_prototype_map), 1, mxID(_map), XS_DONT_ENUM_FLAG);
  slot = fxNextHostFunctionProperty(the, slot, mxCallback(fx_Array_prototype_pop), 0, mxID(_pop), XS_DONT_ENUM_FLAG);
  slot = fxNextHostFunctionProperty(the, slot, mxCallback(fx_Array_prototype_push), 1, mxID(_push), XS_DONT_ENUM_FLAG);
  slot = fxNextHostFunctionProperty(the, slot, mxCallback(fx_Array_prototype_reduce), 1, mxID(_reduce), XS_DONT_ENUM_FLAG);
  slot = fxNextHostFunctionProperty(the, slot, mxCallback(fx_Array_prototype_reduceRight), 1, mxID(_reduceRight), XS_DONT_ENUM_FLAG);
  slot = fxNextHostFunctionProperty(the, slot, mxCallback(fx_Array_prototype_reverse), 0, mxID(_reverse), XS_DONT_ENUM_FLAG);
  slot = fxNextHostFunctionProperty(the, slot, mxCallback(fx_Array_prototype_shift), 0, mxID(_shift), XS_DONT_ENUM_FLAG);
  slot = fxNextHostFunctionProperty(the, slot, mxCallback(fx_Array_prototype_slice), 2, mxID(_slice), XS_DONT_ENUM_FLAG);
  slot = fxNextHostFunctionProperty(the, slot, mxCallback(fx_Array_prototype_some), 1, mxID(_some), XS_DONT_ENUM_FLAG);
  slot = fxNextHostFunctionProperty(the, slot, mxCallback(fx_Array_prototype_sort), 1, mxID(_sort), XS_DONT_ENUM_FLAG);
  slot = fxNextHostFunctionProperty(the, slot, mxCallback(fx_Array_prototype_splice), 2, mxID(_splice), XS_DONT_ENUM_FLAG);
  slot = fxNextHostFunctionProperty(the, slot, mxCallback(fx_Array_prototype_toLocaleString), 0, mxID(_toLocaleString), XS_DONT_ENUM_FLAG);
  slot = fxNextHostFunctionProperty(the, slot, mxCallback(fx_Array_prototype_toString), 0, mxID(_toString), XS_DONT_ENUM_FLAG);
  slot = fxNextHostFunctionProperty(the, slot, mxCallback(fx_Array_prototype_unshift), 1, mxID(_unshift), XS_DONT_ENUM_FLAG);
  property = slot = fxNextHostFunctionProperty(the, slot, mxCallback(fx_Array_prototype_values), 0, mxID(_values), XS_DONT_ENUM_FLAG);
  mxPushSlot(property);
  mxPull(mxArrayIteratorFunction);
  slot = fxNextSlotProperty(the, slot, property, mxID(_Symbol_iterator), XS_DONT_ENUM_FLAG);
  unscopable = fxLastProperty(the, fxNewInstance(the));
  unscopable = fxNextBooleanProperty(the, unscopable, 1, mxID(_copyWithin), XS_NO_FLAG);
  unscopable = fxNextBooleanProperty(the, unscopable, 1, mxID(_at), XS_NO_FLAG);
  unscopable = fxNextBooleanProperty(the, unscopable, 1, mxID(_entries), XS_NO_FLAG);
  unscopable = fxNextBooleanProperty(the, unscopable, 1, mxID(_fill), XS_NO_FLAG);
  unscopable = fxNextBooleanProperty(the, unscopable, 1, mxID(_find), XS_NO_FLAG);
  unscopable = fxNextBooleanProperty(the, unscopable, 1, mxID(_findIndex), XS_NO_FLAG);
  unscopable = fxNextBooleanProperty(the, unscopable, 1, mxID(_findLast), XS_NO_FLAG);
  unscopable = fxNextBooleanProperty(the, unscopable, 1, mxID(_findLastIndex), XS_NO_FLAG);
  unscopable = fxNextBooleanProperty(the, unscopable, 1, mxID(_flat), XS_NO_FLAG);
  unscopable = fxNextBooleanProperty(the, unscopable, 1, mxID(_flatMap), XS_NO_FLAG);
  unscopable = fxNextBooleanProperty(the, unscopable, 1, mxID(_includes), XS_NO_FLAG);
  unscopable = fxNextBooleanProperty(the, unscopable, 1, mxID(_keys), XS_NO_FLAG);
  unscopable = fxNextBooleanProperty(the, unscopable, 1, mxID(_values), XS_NO_FLAG);
#if mxECMAScript2023
  unscopable = fxNextBooleanProperty(the, unscopable, 1, mxID(_toReversed), XS_NO_FLAG);
  unscopable = fxNextBooleanProperty(the, unscopable, 1, mxID(_toSorted), XS_NO_FLAG);
  unscopable = fxNextBooleanProperty(the, unscopable, 1, mxID(_toSpliced), XS_NO_FLAG);
#endif
  slot = fxNextSlotProperty(the, slot, the->stack++, mxID(_Symbol_unscopables), XS_DONT_ENUM_FLAG | XS_DONT_SET_FLAG);
#if mxECMAScript2023
  slot = fxNextHostFunctionProperty(the, slot, mxCallback(fx_Array_prototype_toReversed), 0, mxID(_toReversed), XS_DONT_ENUM_FLAG);
  slot = fxNextHostFunctionProperty(the, slot, mxCallback(fx_Array_prototype_toSorted), 1, mxID(_toSorted), XS_DONT_ENUM_FLAG);
  slot = fxNextHostFunctionProperty(the, slot, mxCallback(fx_Array_prototype_toSpliced), 2, mxID(_toSpliced), XS_DONT_ENUM_FLAG);
  slot = fxNextHostFunctionProperty(the, slot, mxCallback(fx_Array_prototype_with), 2, mxID(_with), XS_DONT_ENUM_FLAG);
#endif
  mxArrayPrototype = *the->stack;
  slot = fxBuildHostConstructor(the, mxCallback(fx_Array), 1, mxID(_Array));
  mxArrayConstructor = *the->stack;
  slot = fxLastProperty(the, slot);
  slot = fxNextHostFunctionProperty(the, slot, mxCallback(fx_Array_from), 1, mxID(_from), XS_DONT_ENUM_FLAG);
  slot = fxNextHostFunctionProperty(the, slot, mxCallback(fx_Array_isArray), 1, mxID(_isArray), XS_DONT_ENUM_FLAG);
  slot = fxNextHostFunctionProperty(the, slot, mxCallback(fx_Array_of), 0, mxID(_of), XS_DONT_ENUM_FLAG);
  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_ArrayIterator_prototype_next), 0, mxID(_next), XS_DONT_ENUM_FLAG);
  slot = fxNextStringXProperty(the, slot, "Array Iterator", mxID(_Symbol_toStringTag), XS_DONT_ENUM_FLAG | XS_DONT_SET_FLAG);
  mxPull(mxArrayIteratorPrototype);
}

txNumber fxArgToIndex(txMachine* the, txInteger argi, txNumber index, txNumber length)
{
  if ((mxArgc > argi) && (mxArgv(argi)->kind != XS_UNDEFINED_KIND)) {
    txNumber i = c_trunc(fxToNumber(the, mxArgv(argi)));
    if (c_isnan(i) || (i == 0))
      i = 0;
    if (i < 0) {
      i = length + i;
      if (i < 0)
        i = 0;
    }
    else if (i > length)
      i = length;
    index = i;
  }
  return index;
}

txInteger fxArgToIndexInteger(txMachine* the, txInteger argi, txInteger index, txInteger length)
{
  if (mxArgc <= argi)
    return index;

  txSlot *slot = mxArgv(argi);
  if (slot->kind != XS_INTEGER_KIND)
    return fxArgToIndex(the, argi, index, length);

  index = slot->value.integer;
  if (index < 0) {
    index = length + index;
    if (index < 0)
      index = 0;
  }
  else if (index > length)
    index = length;

  return index;
}

txNumber fxArgToLastIndex(txMachine* the, txInteger argi, txNumber index, txNumber length)
{
  if (mxArgc > argi) {
    txNumber i = c_trunc(fxToNumber(the, mxArgv(argi)));
    if (c_isnan(i) || (i == 0))
      i = 0;
    if (i < 0) {
      i = length + i;
      if (i < 0)
        index = 0;
      else
        index = i + 1;
    }
    else if (i < length)
      index = i + 1;
  }
  return index;
}

txNumber fxArgToRange(txMachine* the, txInteger argi, txNumber index, txNumber min, txNumber max)
{
  if ((mxArgc > argi) && (mxArgv(argi)->kind != XS_UNDEFINED_KIND)) {
    txNumber i = c_trunc(fxToNumber(the, mxArgv(argi)));
    if (c_isnan(i))
      i = min;
    if (i <= min)
      i = min;
    else if (i > max)
      i = max;
    index = i;
  }
  return index;
}

txNumber fxArgToRelativeIndex(txMachine* the, txInteger argi, txNumber index, txNumber length)
{
  if ((mxArgc > argi) && (mxArgv(argi)->kind != XS_UNDEFINED_KIND)) {
    txNumber i = c_trunc(fxToNumber(the, mxArgv(argi)));
    if (c_isnan(i) || (i == 0))
      i = 0;
    if (i < 0)
      i = length + i;
    index = i;
  }
  return index;
}

void fxCacheArray(txMachine* the, txSlot* instance)
{
  txSlot* array = instance->next;
  txIndex length = array->value.array.length;
  if (length) {
    txSlot* address = (txSlot *)fxNewChunk(the, fxMultiplyChunkSizes(the, length, sizeof(txSlot)));
    txSlot* srcSlot = array->next;
    txSlot* dstSlot = address;
    txIndex index = 0;
    while (srcSlot) {
      dstSlot->next = C_NULL;
      *((txIndex*)dstSlot) = index; 
      dstSlot->ID = XS_NO_ID;
      dstSlot->flag = XS_NO_FLAG;
      dstSlot->kind = srcSlot->kind;
      dstSlot->value = srcSlot->value;
      srcSlot = srcSlot->next;
      dstSlot++;
      index++;
    }
    array->value.array.address = address;
    array->next = C_NULL;
  }
}

txBoolean fxCallThisItem(txMachine* the, txSlot* function, txIndex index, txSlot* item)
{
  mxPushSlot(mxThis);
  if (mxHasIndex(index)) {
    /* THIS */
    if (mxArgc > 1)
      mxPushSlot(mxArgv(1));
    else
      mxPushUndefined();
    /* FUNCTION */
    mxPushSlot(function);
    mxCall();
    /* ARGUMENTS */
    mxPushSlot(mxThis);
    mxGetIndex(index);
    if (item) {
      item->kind = the->stack->kind;
      item->value = the->stack->value;
    }
    mxPushUnsigned(index);
    mxPushSlot(mxThis);
    mxRunCount(3);
    return 1;
  }
  return 0;
}

txSlot* fxCheckArray(txMachine* the, txSlot* slot, txBoolean mutable)
{
  txSlot* instance = fxToInstance(the, slot);
  txSlot* array = instance->next;
  if (array && (array->kind == XS_ARRAY_KIND) && (array->ID == XS_ARRAY_BEHAVIOR)) {
#if mxAliasInstance
    if (instance->ID) {
      txSlot* alias = the->aliasArray[instance->ID];
      if (alias)
        array = alias->next;
      else if (mutable) {
        instance = fxAliasInstance(the, instance);
        array = instance->next;
      }
    }
#endif
    {
      txSlot* address = array->value.array.address;
      txIndex size = (address) ? (((txChunk*)(((txByte*)address) - sizeof(txChunk)))->size) / sizeof(txSlot) : 0;
      txSlot* prototype = instance->value.instance.prototype;
      if (array->value.array.length != size)
        return C_NULL;
      if (mutable && ((instance->flag & XS_DONT_PATCH_FLAG) || (array->flag & XS_DONT_SET_FLAG)))
        return C_NULL;
      while (prototype) {
        txSlot* property = prototype->next;
        while (property) {
          if (property->flag & XS_INTERNAL_FLAG) {
            if ((property->kind == XS_ARRAY_KIND) && (property->value.array.address != C_NULL)) 
              return C_NULL;
          }
          else 
            break;
          property = property->next;
        }
        prototype = prototype->value.instance.prototype;
      }        
      return array;
    }
  }
  return C_NULL;
}

txSlot* fxCheckArrayItems(txMachine* the, txSlot* array, txIndex from, txIndex to)
{
  txSlot* address = array->value.array.address;
  txIndex length = array->value.array.length;
  if (length < from)
    return C_NULL;
  if (length < to)
    return C_NULL;
  address += from;
  while (from < to) {
    if (address->flag)
      return C_NULL;
    if (address->kind == XS_ACCESSOR_KIND)
      return C_NULL;
    address++;
    from++;
  }
  return array;
}

txIndex fxCheckArrayLength(txMachine* the, txSlot* slot)
{
  if (slot->kind == XS_INTEGER_KIND) {
    if (slot->value.integer >= 0)
      return (txIndex)slot->value.integer;
  }
  else if (slot->kind == XS_NUMBER_KIND) {
    txIndex length = (txIndex)slot->value.number;
    txNumber check = length;
    if (slot->value.number == check)
      return length;
  }
  else {
    txUnsigned length;
    txNumber check;
    mxPushSlot(slot);
    length = fxToUnsigned(the, the->stack);
    mxPop();
    mxPushSlot(slot);
    check = fxToNumber(the, the->stack);
    mxPop();
    if (length == check)
      return length;
  }
  mxRangeError("invalid length");
  return 0;
}

int fxCompareArrayItem(txMachine* the, txSlot* function, txSlot* array, txInteger i)
{
  txSlot* address = array->value.array.address;
  txSlot* a = address + i;
  txSlot* b = the->stack;
  txSlot* ai = a->next;
  txSlot* bi = b->next;
  int result;
  
  if (a->kind == XS_UNDEFINED_KIND)
    result = (b->kind == XS_UNDEFINED_KIND) ? 0 : 1;
  else if (b->kind == XS_UNDEFINED_KIND)
    result = -1;
  else {
    if (function) {
      /* THIS */
      mxPushUndefined();
      /* FUNCTION */
      mxPushSlot(function);
      mxCall();
      /* ARGUMENTS */
      mxPushSlot(a);
      mxPushSlot(b);
      mxRunCount(2);
      if (the->stack->kind == XS_INTEGER_KIND)
        result = the->stack->value.integer;
      else {
        txNumber number = fxToNumber(the, the->stack);
        result = (number < 0) ? -1 :  (number > 0) ? 1 : 0;
      }
      mxPop();
    }
    else {
      mxPushSlot(a);
      mxPushSlot(b);
      fxToString(the, the->stack + 1);
      fxToString(the, the->stack);
      result = fxUTF8Compare((the->stack + 1)->value.string, the->stack->value.string);
      mxPop();
      mxPop();
      mxMeterSome(3);
    }
  }
  if (result == 0)
    result = (bi > ai) ? -1 : (bi < ai) ? 1 : 0;
  return result;
}

void fxConstructArrayEntry(txMachine* the, txSlot* entry)
{
  txSlot* value = the->stack;
  txSlot* key = the->stack + 1;
  txSlot* instance;
  txSlot* array;
  txSlot* item;
  mxPush(mxArrayPrototype);
  instance = fxNewArrayInstance(the);
  array = instance->next;
  fxSetIndexSize(the, array, 2, XS_CHUNK);
  item = array->value.array.address;
  *((txIndex*)item) = 0;
  item->ID = XS_NO_ID;
  item->kind = key->kind;
  item->value = key->value;
  item++;
  *((txIndex*)item) = 1;
  item->ID = XS_NO_ID;
  item->kind = value->kind;
  item->value = value->value;
  entry->kind = the->stack->kind;
  entry->value = the->stack->value;
  the->stack += 3;
}

txSlot* fxCreateArray(txMachine* the, txFlag flag, txIndex length)
{
  if (mxIsReference(mxThis) && mxIsConstructor(mxThis->value.reference))
    mxPushSlot(mxThis);
  else
    mxPush(mxArrayConstructor);
  mxNew();
  if (flag) {
    mxPushUnsigned(length);
    mxRunCount(1);
  }
  else
    mxRunCount(0);
  mxPullSlot(mxResult);
  return fxCheckArray(the, mxResult, XS_MUTABLE);
}

txSlot* fxCreateArraySpecies(txMachine* the, txNumber length)
{
  txSlot* instance = fxToInstance(the, mxThis);
  txFlag flag = 1;
  if (fxIsArray(the, instance)) {
    mxPushSlot(mxThis);
    mxGetID(mxID(_constructor));
    if (mxIsReference(the->stack)) {
      mxGetID(mxID(_Symbol_species));
      if (the->stack->kind == XS_NULL_KIND)
        the->stack->kind = XS_UNDEFINED_KIND;
    }
  }
  else
    mxPushUndefined();
    if (the->stack->kind == XS_UNDEFINED_KIND) {
    *the->stack = mxArrayConstructor;
        flag = 0;
    }
  else if (mxIsReference(the->stack) && mxIsConstructor(the->stack->value.reference)) {
    if (the->stack->value.reference != mxArrayConstructor.value.reference)
      flag = 0;
  }
  else
    mxTypeError("invalid constructor");
  mxNew();
  mxPushNumber(length);
  mxRunCount(1);
  mxPullSlot(mxResult);
  return (flag) ? mxResult->value.reference->next : C_NULL;
}

void fxFindThisItem(txMachine* the, txSlot* function, txNumber index, txSlot* item)
{
  /* THIS */
  if (mxArgc > 1)
    mxPushSlot(mxArgv(1));
  else
    mxPushUndefined();
  /* FUNCTION */
  mxPushSlot(function);
  mxCall();
  /* ARGUMENTS */
  mxPushSlot(mxThis);
  mxGetIndex((txIndex)index);
  if (item) {
    item->kind = the->stack->kind;
    item->value = the->stack->value;
  }
  mxPushNumber(index);
  mxPushSlot(mxThis);
  /* ARGC */
  mxRunCount(3);
}

txNumber fxGetArrayLength(txMachine* the, txSlot* reference)
{
  txNumber length;
  txSlot* instance = fxToInstance(the, reference);
  mxPushReference(instance);
  mxGetID(mxID(_length));
  length = fxToLength(the, the->stack);
  mxPop();
  return length;
}

txIndex fxGetArrayLimit(txMachine* the, txSlot* reference)
{
  txNumber length;
  txSlot* instance = fxToInstance(the, reference);
  txSlot* array = instance->next;
  if (array && (array->kind == XS_ARRAY_KIND) && (array->ID == XS_ARRAY_BEHAVIOR)) {
#if mxAliasInstance
    if (instance->ID) {
      txSlot* alias = the->aliasArray[instance->ID];
      if (alias)
        array = alias->next;
    }
#endif
    return array->value.array.length;
  }
  if (array && (array->kind == XS_TYPED_ARRAY_KIND) && (array->ID == XS_TYPED_ARRAY_BEHAVIOR)) {
    txSlot* view = array->next;
    txSlot* buffer = view->next;
    if (mxThis->value.reference != instance) { // iterator
      if (fxIsDataViewOutOfBound(the, view, buffer))
        mxTypeError("out of bound buffer");
    }
    return fxGetDataViewSize(the, view, buffer) >> array->value.typedArray.dispatch->shift;
  }
  mxPushReference(instance);
  mxGetID(mxID(_length));
  length = fxToLength(the, the->stack);
  mxPop();
  if (length > 0xFFFFFFFF) { // @@ practical limit for iterations
    txSlot* result = instance->next;
    length = 0;
    while (result && (result->flag & XS_INTERNAL_FLAG)) {
      if (result->kind == XS_ARRAY_KIND) {
        length = result->value.array.length;
        break;
      }
      result = result->next;
    }
  }
  return (txIndex)length;
}

void fxIndexArray(txMachine* the, txSlot* array) 
{
  txSlot* address = array->value.array.address;
  if (address) {
    txIndex size = (((txChunk*)(((txByte*)address) - sizeof(txChunk)))->size) / sizeof(txSlot);
    txIndex index = 0;
    while (index < size) {
      *((txIndex*)address) = index; 
      address->flag = XS_NO_FLAG;
      address++;
      index++;
    }
  }
}

txBoolean fxIsArray(txMachine* the, txSlot* instance) 
{
again:
  if (instance) {
    txSlot* internal = instance->next;
    if (internal && (internal->flag & XS_INTERNAL_FLAG)) {
      if ((internal->kind == XS_ARRAY_KIND) && (internal->ID == XS_ARRAY_BEHAVIOR))
        return 1;
      if (internal->kind == XS_PROXY_KIND) {
        instance = internal->value.proxy.target;
        if (instance)
          goto again;
        mxTypeError("revoked proxy");

      }
    }
  }
  return 0;
}

void fxMoveThisItem(txMachine* the, txNumber from, txNumber to)
{
  mxPushSlot(mxThis);
  mxPushNumber(from);
  if (mxHasAt()) {
    mxPushSlot(mxThis);
    mxPushNumber(from);
    mxGetAt();
    mxPushSlot(mxThis);
    mxPushNumber(to);
    mxSetAt();
    mxPop();
  }
  else {
    mxPushSlot(mxThis);
    mxPushNumber(to);
    mxDeleteAt();
    mxPop();
  }
}

txSlot* fxNewArrayInstance(txMachine* the)
{
  txSlot* instance;
  txSlot* property;
  instance = fxNewObjectInstance(the);
  instance->flag |= XS_EXOTIC_FLAG;
  property = instance->next = fxNewSlot(the);
  property->flag = XS_INTERNAL_FLAG | XS_DONT_DELETE_FLAG | XS_DONT_ENUM_FLAG;
  property->ID = XS_ARRAY_BEHAVIOR;
  property->kind = XS_ARRAY_KIND;
  property->value.array.length = 0;
  property->value.array.address = C_NULL;
  return instance;
}

void fxReduceThisItem(txMachine* the, txSlot* function, txIndex index)
{
  mxPushSlot(mxThis);
  if (fxHasIndex(the, index)) {
    /* THIS */
    mxPushUndefined();
    /* FUNCTION */
    mxPushSlot(function);
    mxCall();
    /* ARGUMENTS */
    mxPushSlot(mxResult);
    mxPushSlot(mxThis);
    mxGetIndex(index);
    mxPushUnsigned(index);
    mxPushSlot(mxThis);
    mxRunCount(4);
    mxPullSlot(mxResult);
  }
}

txBoolean fxSetArrayLength(txMachine* the, txSlot* array, txIndex length)
{
  txSlot* address = array->value.array.address;
  txSlot* chunk = address;
  txBoolean success = 1;
  if (address) {
    txSize size = (((txChunk*)(((txByte*)chunk) - sizeof(txChunk)))->size) / sizeof(txSlot);
    txSlot* result = address + size;
    txSlot* limit = result;
    txIndex at;
    while (result > address) {
      result--;
      at = *((txIndex*)result);
      if (length > at) {
        result++;
        break;
      }
      else if (result->flag & XS_DONT_DELETE_FLAG) {
        result++;
        length = at + 1;
        success = 0;
        break;
      }
    }
    if (result < limit) {
      if (result > address) {
        size = mxPtrDiff(result - address);
        chunk = (txSlot*)fxNewChunk(the, fxMultiplyChunkSizes(the, size, sizeof(txSlot)));
        address = array->value.array.address;
        c_memcpy(chunk, address, size * sizeof(txSlot));
      }
      else
        chunk = C_NULL;
    } 
  }
  array->value.array.length = length;
  array->value.array.address = chunk;
  return success;
}

void fxSortArrayItems(txMachine* the, txSlot* function, txSlot* array, txNumber LENGTH, txSlot* target)
{
  txBoolean flag = mxThis->value.reference != target->value.reference;
  txSlot* instance = C_NULL;
  txIndex index;
    txSlot* item;
  txIndex length;
  txIndex size;
again:
  if (!array) {
    LENGTH = fxGetArrayLength(the, mxThis);
    if (LENGTH > 0xFFFFFFFF)
      mxRangeError("array overflow");
    mxPush(mxArrayPrototype);
    instance = fxNewArrayInstance(the);
    array = instance->next;
    item = array;
        index = 0;
    while (index < LENGTH) {
      mxPushSlot(mxThis);
      if (flag || fxHasIndex(the, index)) {
        item->next = fxNewSlot(the);
        item = item->next;
        array->value.array.length++;
        mxPushSlot(mxThis);
        mxGetIndex(index);
        mxPullSlot(item);
      }
      index++;
    }
    fxCacheArray(the, instance);
  }
  length = array->value.array.length;
  size = mxArraySize(array);
  /* like GCC qsort */
  #define CHECK \
    if (size != mxArraySize(array)) { \
      array = C_NULL; \
      goto again; \
    }
  #define COMPARE(INDEX) \
    fxCompareArrayItem(the, function, array, INDEX)
  #define COPY \
    to->next = from->next; \
    to->ID = from->ID; \
    to->kind = from->kind; \
    to->value = from->value
  #define MOVE(FROM,TO) \
    from = array->value.array.address + (FROM); \
    to = array->value.array.address + (TO); \
    COPY
  #define PUSH(INDEX) \
    from = array->value.array.address + (INDEX); \
    mxPushUndefined(); \
    to = the->stack; \
    COPY
  #define PULL(INDEX) \
    from = the->stack++; \
    to = array->value.array.address + (INDEX); \
    COPY
  if (length > 0) {
    txIndex i, j;
    txSlot* from;
    txSlot* to;
    if (length > mxSortThreshold) {
      txIndex lo = 0, hi = length - 1;
      txSortPartition stack[mxSortPartitionCount];
      txSortPartition *top = stack + 1;
      while (stack < top) {
        txIndex mid = lo + ((hi - lo) >> 1);
        PUSH(mid);
        if (COMPARE(lo) > 0) {
          CHECK;
          MOVE(lo, mid);
          PULL(lo);
          PUSH(mid);
        }
        else
          CHECK;
        if (COMPARE(hi) < 0) {
          CHECK;
          MOVE(hi, mid);
          PULL(hi);
          PUSH(mid);
          if (COMPARE(lo) > 0) {
            CHECK;
            MOVE(lo, mid);
            PULL(lo);
            PUSH(mid);
          }
          else
            CHECK;
        }
        else
          CHECK;
        i = lo + 1;
        j = hi - 1;
        do {
          while ((COMPARE(i) < 0) && (i <= j)) { CHECK; i++; }
                    CHECK;
          while ((COMPARE(j) > 0) && (i <= j)) { CHECK; j--; }
          CHECK;
          if (i < j) {
            PUSH(i);
            MOVE(j, i);
            PULL(j);
            i++;
            j--;
          }
          else if (i == j) {
            i++;
            j--;
            break;
          }
        } while (i <= j);
        if ((j - lo) <= mxSortThreshold) {
          if ((hi - i) <= mxSortThreshold) {
            top--;
            lo = top->lo; 
            hi = top->hi;
          }
          else {
            lo = i;
          }
        }
        else if ((hi - i) <= mxSortThreshold) {
          hi = j;
        }
        else if ((j - lo) > (hi - i)) {
          top->lo = lo;
          top->hi = j; 
          top++;
          lo = i;
        }
        else {
          top->lo = i;
          top->hi = hi; 
          top++;
          hi = j;
        }
        mxPop();
      }
    }
    for (i = 1; i < length; i++) {
      PUSH(i);
      for (j = i; (j > 0) && (COMPARE(j - 1) > 0); j--) {
        CHECK;
        MOVE(j - 1, j);
      }
            CHECK;
      PULL(j);
    }
  }
  if (instance) {
    index = 0;
    while (index < length) {
      item = array->value.array.address + index;
      mxPushSlot(item);
      mxPushSlot(target);
      if (flag)
        mxDefineIndex(index, 0, XS_GET_ONLY);
      else
        mxSetIndex(index);
      mxPop();
      index++;
    }
    while (index < LENGTH) {
      mxPushSlot(target);
      mxDeleteIndex(index);
      index++;
    }
    mxPop();
  }
  else
    fxIndexArray(the, array);
}

txNumber fxToLength(txMachine* the, txSlot* slot)
{
again:
  if (slot->kind == XS_INTEGER_KIND) {
    txInteger length = slot->value.integer;
    if (length < 0)
      length = 0;
    slot->value.number = (txNumber)length;
    slot->kind = XS_NUMBER_KIND;
    return (txNumber)length;
  }
  if (slot->kind == XS_NUMBER_KIND) {
    txNumber length = slot->value.number;
    if (c_isnan(length))
      length = 0;
    else if (length <= 0)
      length = 0;
    else if (length > C_MAX_SAFE_INTEGER)
      length = C_MAX_SAFE_INTEGER;
    else
      length = c_trunc(length);
    slot->value.number = length;
    return length;
  }
  fxToNumber(the, slot);
  goto again;
}

void fxArrayLengthGetter(txMachine* the)
{
  txSlot* instance = fxToInstance(the, mxThis);
  txSlot* array;
  while (instance) {
    if (instance->flag & XS_EXOTIC_FLAG) {
      array = instance->next;
      if ((array->kind == XS_ARRAY_KIND) && (array->ID == XS_ARRAY_BEHAVIOR))
        break;
    }
    instance = fxGetPrototype(the, instance);
  }
  if (!instance)
    return;
#if mxAliasInstance
  if (instance->ID) {
    txSlot* alias = the->aliasArray[instance->ID];
    if (alias)
      array = alias->next;
  }
#endif
  if (((txInteger)array->value.array.length) < 0) {
    mxResult->value.number = array->value.array.length;
    mxResult->kind = XS_NUMBER_KIND;
  }
  else {
    mxResult->value.integer = (txInteger)array->value.array.length;
    mxResult->kind = XS_INTEGER_KIND;
  }
}

void fxArrayLengthSetter(txMachine* the)
{
  txSlot* instance = fxToInstance(the, mxThis);
  txSlot* array;
  txIndex length;
  while (instance) {
    if (instance->flag & XS_EXOTIC_FLAG) {
      array = instance->next;
      if (array->ID == XS_ARRAY_BEHAVIOR)
        break;
    }
    instance = fxGetPrototype(the, instance);
  }
  if (!instance)
    return;
#if mxAliasInstance
  if (instance->ID) {
    txSlot* alias = the->aliasArray[instance->ID];
    if (!alias)
      alias = fxAliasInstance(the, instance);
    array = alias->next;
  }
#endif
  length = fxCheckArrayLength(the, mxArgv(0));
  if (array->flag & XS_DONT_SET_FLAG) {
    if (the->frame->next->flag & XS_STRICT_FLAG)
      mxTypeError("set length: not writable");
    else
      return;
  }
  fxSetArrayLength(the, array, length);
}

txBoolean fxArrayDefineOwnProperty(txMachine* the, txSlot* instance, txID id, txIndex index, txSlot* descriptor, txFlag mask) 
{
  if (id == mxID(_length)) {
    txSlot* array = instance->next;
    txSlot slot;
    txBoolean result = 1;
        txIndex length = ((descriptor->kind != XS_UNINITIALIZED_KIND) && (descriptor->kind != XS_ACCESSOR_KIND)) ? fxCheckArrayLength(the, descriptor) : 0;
        slot.flag = array->flag;
    slot.ID = id;
    slot.kind = XS_NUMBER_KIND;
    slot.value.number = array->value.array.length;
    if (!fxIsPropertyCompatible(the, &slot, descriptor, mask))
      return 0;
#if mxAliasInstance
    if (instance->ID) {
      txSlot* alias = the->aliasArray[instance->ID];
      if (!alias) {
        alias = fxAliasInstance(the, instance);
        array = alias->next;
      }
    }
#endif
    if (descriptor->kind != XS_UNINITIALIZED_KIND) {
      if (array->value.array.length != length)
        result = fxSetArrayLength(the, array, length);
    }
    if ((mask & XS_DONT_SET_FLAG) && (descriptor->flag & XS_DONT_SET_FLAG) && !(array->flag & XS_DONT_SET_FLAG))
      array->flag |= XS_DONT_SET_FLAG;
    return result;
  }
  return fxOrdinaryDefineOwnProperty(the, instance, id, index, descriptor, mask);
}

txBoolean fxArrayDeleteProperty(txMachine* the, txSlot* instance, txID id, txIndex index)
{
  if (id == mxID(_length))
    return 0;
  return fxOrdinaryDeleteProperty(the, instance, id, index);
}

txBoolean fxArrayGetOwnProperty(txMachine* the, txSlot* instance, txID id, txIndex index, txSlot* descriptor)
{
  if (id == mxID(_length)) {
    txSlot* array = instance->next;
    descriptor->flag = array->flag;
    descriptor->ID = id;
    descriptor->kind = XS_NUMBER_KIND;
    descriptor->value.number = array->value.array.length;
    return 1;
  }
  return fxOrdinaryGetOwnProperty(the, instance, id, index, descriptor);
}

txSlot* fxArrayGetProperty(txMachine* the, txSlot* instance, txID id, txIndex index, txFlag flag)
{
  if (id == mxID(_length))
    return &mxArrayLengthAccessor;
  return fxOrdinaryGetProperty(the, instance, id, index, flag);
}

txBoolean fxArrayHasProperty(txMachine* the, txSlot* instance, txID id, txIndex index) 
{
  if (id == mxID(_length))
    return 1;
  return fxOrdinaryHasProperty(the, instance, id, index);
}

void fxArrayOwnKeys(txMachine* the, txSlot* instance, txFlag flag, txSlot* keys)
{
  txSlot* property = instance->next;
  keys = fxQueueIndexKeys(the, property, flag, keys);
  if (flag & XS_EACH_NAME_FLAG)
    keys = fxQueueKey(the, mxID(_length), 0, keys);
  property = property->next;
  fxQueueIDKeys(the, property, flag, keys);
}

txSlot* fxArraySetProperty(txMachine* the, txSlot* instance, txID id, txIndex index, txFlag flag)
{
  if (id == mxID(_length)) {
    txSlot* array = instance->next;
    if (array->flag & XS_DONT_SET_FLAG)
      return array;
    return &mxArrayLengthAccessor;
  }
  return fxOrdinarySetProperty(the, instance, id, index, flag);
}

void fx_Array(txMachine* the)
{
  txSlot* instance;
  txSlot* array;
  txSlot* argument;
  txIndex count = (txIndex)mxArgc;
  txBoolean flag = 0;
  txIndex index = 0;
  txSlot* slot;
  
  if (mxIsUndefined(mxTarget))
    mxPushSlot(mxFunction);
  else
    mxPushSlot(mxTarget);
  fxGetPrototypeFromConstructor(the, &mxArrayPrototype);
  instance = fxNewArrayInstance(the);
  mxPullSlot(mxResult);
  array = instance->next; 
  
  if (count == 1) {
    argument = mxArgv(0);
    if ((argument->kind == XS_INTEGER_KIND) || (argument->kind == XS_NUMBER_KIND)) {
      count = fxCheckArrayLength(the, mxArgv(0));
      flag = 1;
    }
  }
  if (array) {
    if (flag)
      fxSetArrayLength(the, array, count);
    else {
      fxSetIndexSize(the, array, count, XS_CHUNK);
      slot = array->value.array.address;
      while (index < count) {
        argument = mxArgv(index);
        *((txIndex*)slot) = index;
        slot->ID = XS_NO_ID;
        slot->kind = argument->kind;
        slot->value = argument->value;
        slot++;
        index++;
      }
    }
  }
  else {
    mxPushNumber(count);
    mxPushSlot(mxThis);
    mxSetID(mxID(_length));
    mxPop();
    if (!flag) {
      while (index < count) {
        mxPushSlot(mxArgv(index));
        mxPushSlot(mxThis);
        mxDefineIndex(index, 0, XS_GET_ONLY);
        mxPop();
        index++;
      }
    }
  }
}

void fx_Array_from(txMachine* the)
{
  txSlot* function = (mxArgc > 1) ? fxArgToCallback(the, 1) : C_NULL;
  txIndex length = 0;
  txSlot* iterator;
  txSlot* next;
  txSlot* value;
  if (mxArgc > 0) {
    mxPushSlot(mxArgv(0));
    mxGetID(mxID(_Symbol_iterator));
    if (mxIsUndefined(the->stack) || mxIsNull(the->stack)) {
      txIndex index = 0;
      mxPushSlot(mxArgv(0));
      mxGetID(mxID(_length));
      if (mxIsUndefined(the->stack))
        length = 0;
      else
        length = fxCheckArrayLength(the, the->stack);
      mxPop();
      fxCreateArray(the, 1, length);
      while (index < length) {
        mxPushSlot(mxArgv(0));
        mxGetIndex(index);
        fx_Array_from_aux(the, function, the->stack, index);
        mxPop();
        index++;
      }
    }
    else {
      fxCreateArray(the, 0, 0);
      mxTemporary(iterator);
      mxTemporary(next);
      fxGetIterator(the, mxArgv(0), iterator, next, 0);
      mxTemporary(value);
      length = 0;
      while (fxIteratorNext(the, iterator, next, value)) {
        mxTry(the) {
          fx_Array_from_aux(the, function, value, length);
          length++;
        }
        mxCatch(the) {
          fxIteratorReturn(the, iterator, 1);
          fxJump(the);
        }
      }
      mxPop();
    }
  }
  else {
    fxCreateArray(the, 1, 0);
  }
  mxPushUnsigned(length);
  mxPushSlot(mxResult);
  mxSetID(mxID(_length));
  mxPop();
}

void fx_Array_from_aux(txMachine* the, txSlot* function, txSlot* value, txIndex index)
{
  if (function) {
    /* THIS */
    if (mxArgc > 2)
      mxPushSlot(mxArgv(2));
    else
      mxPushUndefined();
    /* FUNCTION */
    mxPushSlot(function);
    mxCall();
    /* ARGUMENTS */
    mxPushSlot(value);
    mxPushInteger(index);
    mxRunCount(2);
  }
  else
    mxPushSlot(value);
  mxPushSlot(mxResult);
  mxDefineIndex(index, 0, XS_GET_ONLY);
  mxPop();
}

void fx_Array_isArray(txMachine* the)
{
  mxResult->kind = XS_BOOLEAN_KIND;
  mxResult->value.boolean = (mxArgc > 0) ? fxIsArray(the, fxGetInstance(the, mxArgv(0))) : 0;
}

void fx_Array_of(txMachine* the)
{
  txIndex count = (txIndex)mxArgc, index = 0;
  txSlot* array = fxCreateArray(the, 1, count);
  if (array) {
    txSlot* slot;
    fxSetIndexSize(the, array, count, XS_CHUNK);
    slot = array->value.array.address;
    while (index < count) {
      txSlot* argument = mxArgv(index);
      *((txIndex*)slot) = index;
      slot->ID = XS_NO_ID;
      slot->kind = argument->kind;
      slot->value = argument->value;
      slot++;
      mxMeterSome(4);
      index++;
    }
    mxMeterSome(4);
  }
  else {
    while (index < count) {
      mxPushSlot(mxArgv(index));
      mxPushSlot(mxResult);
      mxDefineIndex(index, 0, XS_GET_ONLY);
      mxPop();
      index++;
    }
    mxPushInteger(count);
    mxPushSlot(mxResult);
    mxSetID(mxID(_length));
    mxPop();
  }
}

void fx_Array_prototype_at(txMachine* the)
{
  txSlot* array = fxCheckArray(the, mxThis, XS_IMMUTABLE);
  txNumber length = (array) ? array->value.array.length : fxGetArrayLength(the, mxThis);
  txNumber index = (mxArgc > 0) ? c_trunc(fxToNumber(the, mxArgv(0))) : C_NAN;
  if (c_isnan(index) || (index == 0))
    index = 0;
  if (index < 0)
    index = length + index;
  if ((0 <= index) && (index < length)) {
    mxPushSlot(mxThis);
    mxPushNumber(index);
    mxGetAt();
    mxPullSlot(mxResult);
  }
}

void fx_Array_prototype_concat(txMachine* the)
{
  txSlot* resultArray = fxCreateArraySpecies(the, 0);
  txIndex resultLength = 0;
  txInteger c = mxArgc;
  txInteger i = -1;
  if (resultArray) {
    txSlot* list = fxNewInstance(the);
    txSlot* slot = list;
    txSlot* resultSlot;
    txIndex holeCount = 0;
    mxPushSlot(mxThis);
    for (;;) {
      txSlot* argument = the->stack;
      txBoolean flag = 0;
      if (mxIsReference(argument)) {
        mxPushSlot(argument);
        mxGetID(mxID(_Symbol_isConcatSpreadable));
        if (mxIsUndefined(the->stack))
          flag = fxIsArray(the, argument->value.reference);
        else
          flag = fxToBoolean(the, the->stack);
        mxPop();
      }
      if (flag) { 
        txIndex length, index;
        mxPushSlot(argument);
        mxGetID(mxID(_length));
        length = (txIndex)fxToLength(the, the->stack);
        mxPop();
                if (resultLength + length < resultLength)
                    mxTypeError("array overflow");
        index = 0;
        while (index < length) {
          mxPushSlot(argument);
          if (fxHasIndex(the, index)) {
            mxPushSlot(argument);
            mxGetIndex(index);
            slot = fxNextSlotProperty(the, slot, the->stack, XS_NO_ID, XS_NO_FLAG);
            mxMeterSome(2);
            mxPop();
          }
          else {
            slot = slot->next = fxNewSlot(the);
            slot->kind = XS_UNINITIALIZED_KIND;
            holeCount++;
          }
          index++;
          resultLength++;
        }
      }
      else {
        slot = fxNextSlotProperty(the, slot, argument, XS_NO_ID, XS_NO_FLAG);
        mxMeterSome(4);
        resultLength++;
        if (resultLength == 0)
          mxTypeError("array overflow");
      }
      mxPop();
      i++;
      if (i == c)
        break;
      mxPushSlot(mxArgv(i));
    }
    fxSetIndexSize(the, resultArray, resultLength - holeCount, XS_CHUNK);
    resultArray->value.array.length = resultLength;
    resultSlot = resultArray->value.array.address;
    slot = list->next;
    resultLength = 0;
    while (slot) {
      if (slot->kind != XS_UNINITIALIZED_KIND) {
        *((txIndex*)resultSlot) = resultLength;
        resultSlot->ID = XS_NO_ID;
        resultSlot->kind = slot->kind;
        resultSlot->value = slot->value;
        resultSlot++;
      }
      slot = slot->next;
      resultLength++;
    }
    mxMeterSome(3);
    mxPop();
  }
  else {
    mxPushSlot(mxThis);
    for (;;) {
      txSlot* argument = the->stack;
      txBoolean flag = 0;
      if (mxIsReference(argument)) {
        mxPushSlot(argument);
        mxGetID(mxID(_Symbol_isConcatSpreadable));
        if (mxIsUndefined(the->stack))
          flag = fxIsArray(the, argument->value.reference);
        else
          flag = fxToBoolean(the, the->stack);
        mxPop();
      }
      if (flag) { 
        txIndex length, index;
        mxPushSlot(argument);
        mxGetID(mxID(_length));
        length = (txIndex)fxToLength(the, the->stack);
        mxPop();
        index = 0;
        while (index < length) {
          mxPushSlot(argument);
          if (fxHasIndex(the, index)) {
            mxPushSlot(argument);
            mxGetIndex(index);
            mxPushSlot(mxResult);
            mxDefineIndex(resultLength, 0, XS_GET_ONLY);
            mxPop();
          }
          index++;
          resultLength++;
        }
      }
      else {
        mxPushSlot(argument);
        mxPushSlot(mxResult);
        mxDefineIndex(resultLength, 0, XS_GET_ONLY);
        mxPop();
        resultLength++;
      }
      mxPop();
      i++;
      if (i == c)
        break;
      mxPushSlot(mxArgv(i));
    }
    mxPushInteger(resultLength);
    mxPushSlot(mxResult);
    mxSetID(mxID(_length));
    mxPop();
  }
}

void fx_Array_prototype_copyWithin(txMachine* the)
{
  txNumber length = fxGetArrayLength(the, mxThis);
  txNumber to = fxArgToIndex(the, 0, 0, length);
  txNumber from = fxArgToIndex(the, 1, 0, length);
  txNumber final = fxArgToIndex(the, 2, length, length);
  txNumber count = (final > from) ? final - from : 0;
  txSlot* array = fxCheckArray(the, mxThis, XS_MUTABLE);
  if (count > length - to)
    count = length - to;
  if (array) {
    if (count > 0) {
      if (from < to)
        array = fxCheckArrayItems(the, array, (txIndex)from, (txIndex)(to + count));
      else
        array = fxCheckArrayItems(the, array, (txIndex)to, (txIndex)(from + count));
    }
  }
  if (array) {
    if (count > 0) {
      c_memmove(array->value.array.address + (txIndex)to, array->value.array.address + (txIndex)from, (txIndex)count * sizeof(txSlot));
      fxIndexArray(the, array);
      mxMeterSome((txU4)count * 10);
    }
  }
  else {
    txNumber direction;
    if ((from < to) && (to < from + count)) {
      direction = -1;
      from += count - 1;
      to += count - 1;
    }
    else
      direction = 1;
    while (count > 0) {
      fxMoveThisItem(the, from, to);
      from += direction;
      to += direction;
      count--;
      mxCheckMetering();
    } 
  } 
  mxResult->kind = mxThis->kind;
  mxResult->value = mxThis->value;
}

void fx_Array_prototype_entries(txMachine* the)
{
  txSlot* property;
  fxToInstance(the, mxThis);
  mxPush(mxArrayIteratorPrototype);
  property = fxLastProperty(the, fxNewIteratorInstance(the, mxThis, mxID(_Array)));
  property = fxNextIntegerProperty(the, property, 2, XS_NO_ID, XS_INTERNAL_FLAG);
  mxPullSlot(mxResult);
}

void fx_Array_prototype_every(txMachine* the)
{
  txIndex length = fxGetArrayLimit(the, mxThis);
  txIndex index = 0;
  txSlot* function = fxArgToCallback(the, 0);
  mxResult->kind = XS_BOOLEAN_KIND;
  mxResult->value.boolean = 1;
  while (index < length) {
    if (fxCallThisItem(the, function, index, C_NULL)) {
      mxResult->value.boolean = fxToBoolean(the, the->stack);
      mxPop();
      if (!mxResult->value.boolean)
        break;
    }
    index++;
    mxCheckMetering();
  }
}

void fx_Array_prototype_fill(txMachine* the)
{
  txSlot* value;
  txSlot* array;
  if (mxArgc > 0)
    mxPushSlot(mxArgv(0));
  else
    mxPushUndefined();
  value = the->stack;
  array = fxCheckArray(the, mxThis, XS_MUTABLE);
  if (array)
    array = fxCheckArrayItems(the, array, 0, array->value.array.length);
  if (array) {
    txIndex length = array->value.array.length;
    txIndex start = (txIndex)fxArgToIndex(the, 1, 0, length);
    txIndex end = (txIndex)fxArgToIndex(the, 2, length, length);
    txSlot* address;
    txIndex size;
    if ((start == 0) && (end == length)) {
      fxSetIndexSize(the, array, length, XS_CHUNK);
      fxIndexArray(the, array);
    }
    address = array->value.array.address;
    size = (address) ? (((txChunk*)(((txByte*)address) - sizeof(txChunk)))->size) / sizeof(txSlot) : 0;
    if (length == size) {
      while (start < end) {
        txSlot* slot = array->value.array.address + start;
        if (slot->flag) {
          mxPushSlot(value);
          mxPushSlot(mxThis);
          mxSetIndex(start);
          mxPop();
          mxMeterSome(1);
        }
        else {
          slot->ID = XS_NO_ID;
          slot->kind = value->kind;
          slot->value = value->value;
          mxMeterSome(5);
        }
        start++;
        mxCheckMetering();
      }
      
    }
    else {
      while (start < end) {
        mxPushSlot(value);
        mxPushSlot(mxThis);
        mxSetIndex(start);
        mxPop();
        mxMeterSome(1);
        start++;
        mxCheckMetering();
      }
    }
  }
  else {
    txNumber length = fxGetArrayLength(the, mxThis);
    txNumber start = fxArgToIndex(the, 1, 0, length);
    txNumber end = fxArgToIndex(the, 2, length, length);
    txSlot* value = the->stack;
    while (start < end) {
      mxPushSlot(value);
      mxPushSlot(mxThis);
      mxPushNumber(start);
      mxSetAt();
      mxPop();
      start++;
      mxCheckMetering();
    }
  }
  mxPop();
  mxResult->kind = mxThis->kind;
  mxResult->value = mxThis->value;
}

void fx_Array_prototype_filter(txMachine* the)
{
  txIndex length = fxGetArrayLimit(the, mxThis);
  txIndex index = 0;
  txSlot* function = fxArgToCallback(the, 0);
  txSlot* resultArray = fxCreateArraySpecies(the, 0);
  txIndex resultLength = 0;
  txSlot* item;
  mxPushUndefined();
  item = the->stack;
  if (resultArray) {
    txSlot* list = fxNewInstance(the);
    txSlot* slot = list;
    txSlot* resultSlot;
    while (index < length) {
      if (fxCallThisItem(the, function, index, item)) {
        if (fxToBoolean(the, the->stack)) {
          slot = fxNextSlotProperty(the, slot, item, XS_NO_ID, XS_NO_FLAG);
          mxMeterSome(4);
          resultLength++;
        }
        mxPop();
      }
      index++;
      mxCheckMetering();
    }
    fxSetIndexSize(the, resultArray, resultLength, XS_CHUNK);
    resultSlot = resultArray->value.array.address;
    slot = list->next;
    index = 0;
    while (slot) {
      *((txIndex*)resultSlot) = index;
      resultSlot->ID = XS_NO_ID;
      resultSlot->kind = slot->kind;
      resultSlot->value = slot->value;
      resultSlot++;
      slot = slot->next;
      index++;
    }
    mxPop();
    mxMeterSome(-1);
  }
  else {
    while (index < length) {
      if (fxCallThisItem(the, function, index, item)) {
        if (fxToBoolean(the, the->stack)) {
          mxPushSlot(item);
          mxPushSlot(mxResult);
          mxDefineIndex(resultLength, 0, XS_GET_ONLY);
          mxPop();
          resultLength++;
        }
        mxPop();
      }
      index++;
      mxCheckMetering();
    }
  }
  mxPop();
}

void fx_Array_prototype_find(txMachine* the)
{
  txIndex length = fxGetArrayLimit(the, mxThis);
  txIndex index = 0;
  txSlot* function = fxArgToCallback(the, 0);
  txSlot* item;
  mxPushUndefined();
  item = the->stack;
  while (index < length) {
    fxFindThisItem(the, function, index, item);
    if (fxToBoolean(the, the->stack++)) {
      mxResult->kind = item->kind;
      mxResult->value = item->value;
      break;
    }
    index++;
  }
  mxPop();
}

void fx_Array_prototype_findIndex(txMachine* the)
{
  txIndex length = fxGetArrayLimit(the, mxThis);
  txIndex index = 0;
  txSlot* function = fxArgToCallback(the, 0);
  fxInteger(the, mxResult, -1);
  while (index < length) {
    fxFindThisItem(the, function, index, C_NULL);
    if (fxToBoolean(the, the->stack++)) {
      fxUnsigned(the, mxResult, index);
      break;
    }
    index++;
  }
}

void fx_Array_prototype_findLast(txMachine* the)
{
  txNumber index = fxGetArrayLength(the, mxThis);
  txSlot* function = fxArgToCallback(the, 0);
  txSlot* item;
  mxPushUndefined();
  item = the->stack;
  while (index > 0) {
    index--;
    fxFindThisItem(the, function, index, item);
    if (fxToBoolean(the, the->stack++)) {
      mxResult->kind = item->kind;
      mxResult->value = item->value;
      break;
    }
  }
  mxPop();
}

void fx_Array_prototype_findLastIndex(txMachine* the)
{
  txNumber index = fxGetArrayLength(the, mxThis);
  txSlot* function = fxArgToCallback(the, 0);
  fxInteger(the, mxResult, -1);
  while (index > 0) {
    index--;
    fxFindThisItem(the, function, index, C_NULL);
    if (fxToBoolean(the, the->stack++)) {
      fxUnsigned(the, mxResult, (txUnsigned)index);
      break;
    }
  }
}

void fx_Array_prototype_flat(txMachine* the)
{
  txIndex length, depth = 1;
  mxPushSlot(mxThis);
  mxGetID(mxID(_length));
  length = (txIndex)fxToLength(the, the->stack);
  mxPop();
  if ((mxArgc > 0) && !mxIsUndefined(mxArgv(0)))
    depth = (txIndex)fxToLength(the, mxArgv(0));
  fxCreateArraySpecies(the, 0);
  fx_Array_prototype_flatAux(the, mxThis, length, 0, depth, C_NULL);
}

txIndex fx_Array_prototype_flatAux(txMachine* the, txSlot* source, txIndex length, txIndex start, txIndex depth, txSlot* function)
{
  txSlot* item;
  txIndex index = 0;
  while (index < length) {
    mxPushSlot(source);
    if (fxHasIndex(the, index)) {
      if (function) {
        /* THIS */
        if (mxArgc > 1)
          mxPushSlot(mxArgv(1));
        else
          mxPushUndefined();
        /* FUNCTION */
        mxPushSlot(function);
        mxCall();
        /* ARGUMENTS */
        mxPushSlot(source);
        mxGetIndex(index);
        mxPushUnsigned(index);
        mxPushSlot(mxThis);
        mxRunCount(3);
      }
      else {
        mxPushSlot(source);
        mxGetIndex(index);
      }
      item = the->stack;
      if ((depth > 0) && mxIsReference(item) && fxIsArray(the, fxToInstance(the, item))) {
        txIndex itemLength;
        mxPushSlot(item);
        mxGetID(mxID(_length));
        itemLength = (txIndex)fxToLength(the, the->stack);
        mxPop();
        start = fx_Array_prototype_flatAux(the, item, itemLength, start, depth - 1, C_NULL);
      }
      else {
        mxPushSlot(mxResult);
        mxDefineIndex(start, 0, XS_GET_ONLY);
        start++;
      }
    }
    index++;
  }
  return start;
}

void fx_Array_prototype_flatMap(txMachine* the)
{
  txIndex length = (txIndex)fxGetArrayLength(the, mxThis);
  txSlot* function = fxArgToCallback(the, 0);
  fxCreateArraySpecies(the, 0);
  fx_Array_prototype_flatAux(the, mxThis, length, 0, 1, function);
}

void fx_Array_prototype_forEach(txMachine* the)
{
  txIndex length = fxGetArrayLimit(the, mxThis);
  txIndex index = 0;
  txSlot* function = fxArgToCallback(the, 0);
  while (index < length) {
    if (fxCallThisItem(the, function, index, C_NULL))
      mxPop();
    index++;
    mxCheckMetering();
  }
}

void fx_Array_prototype_includes(txMachine* the)
{
  txSlot* array = fxCheckArray(the, mxThis, XS_IMMUTABLE);
  txSlot* argument;
  if (mxArgc > 0)
    mxPushSlot(mxArgv(0));
  else
    mxPushUndefined();
  argument = the->stack;
  fxBoolean(the, mxResult, 0);
  if (array) {
    txIndex length = array->value.array.length;
    if (length) {
      txIndex index = (txIndex)fxArgToIndex(the, 1, 0, length);
      while (index < length) {
        mxPushSlot(mxThis);
        mxGetIndex(index);
        if (fxIsSameValue(the, the->stack++, argument, 1)) {
          mxResult->value.boolean = 1;
          break;
        }
        index++;
        mxCheckMetering();
      }
    }
  }
  else {
    txNumber length = fxGetArrayLength(the, mxThis);
    if (length) {
      txNumber index = fxArgToIndex(the, 1, 0, length);
      while (index < length) {
        mxPushSlot(mxThis);
        mxPushNumber(index);
        mxGetAt();
        if (fxIsSameValue(the, the->stack++, argument, 1)) {
          mxResult->value.boolean = 1;
          break;
        }
        index++;
        mxCheckMetering();
      }
    }
  }
  mxPop();
}

void fx_Array_prototype_indexOf(txMachine* the)
{
  txSlot* array = fxCheckArray(the, mxThis, XS_IMMUTABLE);
  txSlot* argument;
  if (mxArgc > 0)
    mxPushSlot(mxArgv(0));
  else
    mxPushUndefined();
  argument = the->stack;
  fxInteger(the, mxResult, -1);
  if (array) {
    txIndex length = array->value.array.length;
    if (length) {
      txIndex index = (txIndex)fxArgToIndex(the, 1, 0, length);
      while (index < length) {
        mxPushSlot(mxThis);
        if (fxHasIndex(the, index)) {
          mxPushSlot(mxThis);
          mxGetIndex(index);
          if (fxIsSameSlot(the, the->stack++, argument)) {
            fxUnsigned(the, mxResult, index);
            break;
          }
        }
        index++;
        mxCheckMetering();
      }
    }
  }
  else {
    txNumber length = fxGetArrayLength(the, mxThis);
    if (length) {
      txNumber index = fxArgToIndex(the, 1, 0, length);
      while (index < length) {
        mxPushSlot(mxThis);
        mxPushNumber(index);
        if (mxHasAt()) {
          mxPushSlot(mxThis);
          mxPushNumber(index);
          mxGetAt();
          if (fxIsSameSlot(the, the->stack++, argument)) {
            fxNumber(the, mxResult, index);
            break;
          }
        }
        index++;
        mxCheckMetering();
      }
    }
  }
  mxPop();
}

void fx_Array_prototype_join(txMachine* the)
{
  txIndex length = fxGetArrayLimit(the, mxThis);
  txIndex index = 0;
  txString string;
  txSlot* list = fxNewInstance(the);
  txSlot* slot = list;
  txBoolean comma = 0;
  txInteger size = 0;
  if ((mxArgc > 0) && (mxArgv(0)->kind != XS_UNDEFINED_KIND)) {
    mxPushSlot(mxArgv(0));
    string = fxToString(the, the->stack);
    the->stack->kind += XS_KEY_KIND - XS_STRING_KIND;
    the->stack->value.key.sum = mxStringLength(string);
  }
  else {
    mxPushStringX(",");
    the->stack->kind += XS_KEY_KIND - XS_STRING_KIND;
    the->stack->value.key.sum = 1;
  }
  while (index < length) {
    if (comma) {
      slot = fxNextSlotProperty(the, slot, the->stack, XS_NO_ID, XS_NO_FLAG);
      size = fxAddChunkSizes(the, size, slot->value.key.sum);
    }
    else
      comma = 1;
    mxPushSlot(mxThis);
    mxGetIndex(index);
    if ((the->stack->kind != XS_UNDEFINED_KIND) && (the->stack->kind != XS_NULL_KIND)) {
      slot = fxNextSlotProperty(the, slot, the->stack, XS_NO_ID, XS_NO_FLAG);
      string = fxToString(the, slot);
      slot->kind += XS_KEY_KIND - XS_STRING_KIND;
      slot->value.key.sum = mxStringLength(string);
      size = fxAddChunkSizes(the, size, slot->value.key.sum);
    }
    mxPop();
    index++;

    mxCheckMetering();
  }
  mxPop();
  string = mxResult->value.string = fxNewChunk(the, fxAddChunkSizes(the, size, 1));
  slot = list->next;
  while (slot) {
    c_memcpy(string, slot->value.key.string, slot->value.key.sum);
    string += slot->value.key.sum;
    slot = slot->next;
  }
  *string = 0;
  mxResult->kind = XS_STRING_KIND;
  mxPop();
}

void fx_Array_prototype_keys(txMachine* the)
{
  txSlot* property;
  fxToInstance(the, mxThis);
  mxPush(mxArrayIteratorPrototype);
  property = fxLastProperty(the, fxNewIteratorInstance(the, mxThis, mxID(_Array)));
  property = fxNextIntegerProperty(the, property, 1, XS_NO_ID, XS_INTERNAL_FLAG);
  mxPullSlot(mxResult);
}

void fx_Array_prototype_lastIndexOf(txMachine* the)
{
  txSlot* array = fxCheckArray(the, mxThis, XS_IMMUTABLE);
  txSlot* argument;
  if (mxArgc > 0)
    mxPushSlot(mxArgv(0));
  else
    mxPushUndefined();
  argument = the->stack;
  fxInteger(the, mxResult, -1);
  if (array) {
    txIndex length = array->value.array.length;
    if (length) {
      txIndex index = (txIndex)fxArgToLastIndex(the, 1, length, length);
      while (index > 0) {
        index--;
        mxPushSlot(mxThis);
        if (fxHasIndex(the, index)) {
          mxPushSlot(mxThis);
          mxGetIndex(index);
          if (fxIsSameSlot(the, the->stack++, argument)) {
            fxUnsigned(the, mxResult, index);
            break;
          }
        }
        mxCheckMetering();
      }
    }
  }
  else {
    txNumber length = fxGetArrayLength(the, mxThis);
    if (length) {
      txNumber index = fxArgToLastIndex(the, 1, length, length);
      while (index > 0) {
        index--;
        mxPushSlot(mxThis);
        mxPushNumber(index);
        if (mxHasAt()) {
          mxPushSlot(mxThis);
          mxPushNumber(index);
          mxGetAt();
          if (fxIsSameSlot(the, the->stack++, argument)) {
            fxNumber(the, mxResult, index);
            break;
          }
        }
        mxCheckMetering();
      }
    }
  }
  mxPop();
}

void fx_Array_prototype_map(txMachine* the)
{
  txNumber LENGTH = fxGetArrayLength(the, mxThis);
  txSlot* function = fxArgToCallback(the, 0);
  txSlot* resultArray = fxCreateArraySpecies(the, LENGTH);
  txIndex length = (txIndex)LENGTH;
  txIndex index = 0;
  if (resultArray) {
    txIndex resultLength = 0;
    fxSetIndexSize(the, resultArray, length, XS_CHUNK);
    while (index < length) {
      if (fxCallThisItem(the, function, index, C_NULL)) {
        txSlot* slot = resultArray->value.array.address + resultLength;
        *((txIndex*)slot) = index;
        slot->ID = XS_NO_ID;
        slot->kind = the->stack->kind;
        slot->value = the->stack->value;
        resultLength++;
        mxMeterSome(2);
        mxPop();
      }
      index++;
      mxCheckMetering();
    }
    if (resultLength < length) {
      fxSetIndexSize(the, resultArray, resultLength, XS_CHUNK);
      resultArray->value.array.length = length;
    }
  }
  else {
    while (index < length) {
      if (fxCallThisItem(the, function, index, C_NULL)) {
        mxPushSlot(mxResult);
        mxDefineIndex(index, 0, XS_GET_ONLY);
        mxPop();
      }
      index++;
      mxCheckMetering();
    }
  }
}

void fx_Array_prototype_pop(txMachine* the)
{
  txSlot* array = fxCheckArray(the, mxThis, XS_MUTABLE);
  if (array) {
    txIndex length = array->value.array.length;
    if (length > 0)
      array = fxCheckArrayItems(the, array, length - 1, length);
  }
  if (array) {
    txIndex length = array->value.array.length;
    txSlot* address;
    mxMeterSome(2);
    if (length > 0) {
      length--;
      address = array->value.array.address + length;
      mxResult->kind = address->kind;
      mxResult->value = address->value;
      fxSetIndexSize(the, array, length, XS_CHUNK);
      mxMeterSome(8);
    }
    mxMeterSome(4);
  }
  else {
    txNumber length = fxGetArrayLength(the, mxThis);
    if (length > 0) {
      length--;
      mxPushSlot(mxThis);
      mxPushNumber(length);
      mxGetAt();
      mxPullSlot(mxResult);
      mxPushSlot(mxThis);
      mxPushNumber(length);
      mxDeleteAt();
      mxPop();
    }
    mxPushNumber(length);
    mxPushSlot(mxThis);
    mxSetID(mxID(_length));
    mxPop();
  }
}

void fx_Array_prototype_push(txMachine* the)
{
  txIndex c = mxArgc, i = 0;
  txSlot* array = fxCheckArray(the, mxThis, XS_MUTABLE);
  if (array) {
    txIndex length = array->value.array.length;
    txSlot* address;
    mxMeterSome(2);
    if (length + c < length)
      mxRangeError("array overflow");
    fxSetIndexSize(the, array, length + c, XS_GROWABLE_CHUNK);
    address = array->value.array.address + length;
    while (i < c) {
      txSlot* argument = mxArgv(i);
      *((txIndex*)address) = length + i;
      address->ID = XS_NO_ID;
      address->kind = argument->kind;
      address->value = argument->value;
      address++;
      mxMeterSome(5);
      i++;
    }
    mxPushUnsigned(length + c);
    mxMeterSome(2);
  }
  else {
    txNumber length = fxGetArrayLength(the, mxThis);
    if (length + c > C_MAX_SAFE_INTEGER)
      mxTypeError("unsafe integer");
    while (i < c) {
      mxPushSlot(mxArgv(i));
      mxPushSlot(mxThis);
      mxPushNumber(length + i);
      mxSetAt();
      mxPop();
      i++;
    }
    mxPushNumber(length + c);
    mxPushSlot(mxThis);
    mxSetID(mxID(_length));
  }
  mxPullSlot(mxResult);
}

void fx_Array_prototype_reduce(txMachine* the)
{
  txIndex length = fxGetArrayLimit(the, mxThis);
  txIndex index = 0;
  txSlot* function = fxArgToCallback(the, 0);
  if (mxArgc > 1)
    *mxResult = *mxArgv(1);
  else {
    txBoolean flag = 0;
    while (!flag && (index < length)) {
      mxPushSlot(mxThis);
      if (fxHasIndex(the, index)) {
        mxPushSlot(mxThis);
        mxGetIndex(index);
        mxPullSlot(mxResult);
        flag = 1;
      }
      index++;
    }
    if (!flag)
      mxTypeError("no initial value");
  }
  while (index < length) {
    fxReduceThisItem(the, function, index);
    index++;
  }
}

void fx_Array_prototype_reduceRight(txMachine* the)
{
  txIndex length = fxGetArrayLimit(the, mxThis);
  txIndex index = length;
  txSlot* function = fxArgToCallback(the, 0);
  if (mxArgc > 1)
    *mxResult = *mxArgv(1);
  else {
    txBoolean flag = 0;
    while (!flag && (index > 0)) {
      index--;
      mxPushSlot(mxThis);
      if (fxHasIndex(the, index)) {
        mxPushSlot(mxThis);
        mxGetIndex(index);
        mxPullSlot(mxResult);
        flag = 1;
      }
    }
    if (!flag)
      mxTypeError("no initial value");
  }
  while (index > 0) {
    index--;
    fxReduceThisItem(the, function, index);
  }
}

void fx_Array_prototype_reverse(txMachine* the)
{
  txSlot* lowerSlot;
  txSlot* upperSlot;
  txNumber length = fxGetArrayLength(the, mxThis);
  txNumber middle = c_trunc(length / 2);
  txNumber lower = 0;
  while (lower != middle) {
    txNumber upper = length - lower - 1;
    mxPushSlot(mxThis);
    mxPushNumber(lower);
    if (mxHasAt()) {
      mxPushSlot(mxThis);
      mxPushNumber(lower);
      mxGetAt();
      lowerSlot = the->stack;
    }
    else
      lowerSlot = C_NULL;
    mxPushSlot(mxThis);
    mxPushNumber(upper);
    if (mxHasAt()) {
      mxPushSlot(mxThis);
      mxPushNumber(upper);
      mxGetAt();
      upperSlot = the->stack;
    }
    else
      upperSlot = C_NULL;
    if (upperSlot && lowerSlot) {
      mxPushSlot(upperSlot);
      mxPushSlot(mxThis);
      mxPushNumber(lower);
      mxSetAt();
      mxPop();
      mxPushSlot(lowerSlot);
      mxPushSlot(mxThis);
      mxPushNumber(upper);
      mxSetAt();
      mxPop();
      mxPop();
      mxPop();
    }
    else if (upperSlot) {
      mxPushSlot(upperSlot);
      mxPushSlot(mxThis);
      mxPushNumber(lower);
      mxSetAt();
      mxPop();
      mxPushSlot(mxThis);
      mxPushNumber(upper);
      mxDeleteAt();
      mxPop();
      mxPop();
    }
    else if (lowerSlot) {
      mxPushSlot(mxThis);
      mxPushNumber(lower);
      mxDeleteAt();
      mxPop();
      mxPushSlot(lowerSlot);
      mxPushSlot(mxThis);
      mxPushNumber(upper);
      mxSetAt();
      mxPop();
      mxPop();
    }
    lower++;
    mxCheckMetering();
  }
  *mxResult = *mxThis;
}

void fx_Array_prototype_shift(txMachine* the)
{
  txSlot* array = fxCheckArray(the, mxThis, XS_MUTABLE);
  if (array)
    array = fxCheckArrayItems(the, array, 0, array->value.array.length);
  if (array) {
    txIndex length = array->value.array.length;
    txSlot* address;
    mxMeterSome(2);
    if (length > 0) {
      mxMeterSome(3);
      address = array->value.array.address;
      length--;
      mxResult->kind = address->kind;
      mxResult->value = address->value;
      c_memmove(address, address + 1, length * sizeof(txSlot));
      fxSetIndexSize(the, array, length, XS_CHUNK);
      fxIndexArray(the, array);
      mxMeterSome(length * 10);
      mxMeterSome(3);
    }
    mxMeterSome(4);
  }
  else {
    txNumber length = fxGetArrayLength(the, mxThis);
    if (length > 0) {
      txNumber index = 1;
      mxPushSlot(mxThis);
      mxGetIndex(0);
      mxPullSlot(mxResult);
      while (index < length) {
        mxPushSlot(mxThis);
        mxPushNumber(index);
        if (mxHasAt()) {
          mxPushSlot(mxThis);
          mxPushNumber(index);
          mxGetAt();
          mxPushSlot(mxThis);
          mxPushNumber(index - 1);
          mxSetAt();
          mxPop();
        }
        else {
          mxPushSlot(mxThis);
          mxPushNumber(index - 1);
          mxDeleteAt();
          mxPop();
        }
        index++;
        mxCheckMetering();
      }
      length--;
      mxPushSlot(mxThis);
      mxDeleteIndex((txIndex)length);
      mxPop();
    }
    mxPushNumber(length);
    mxPushSlot(mxThis);
    mxSetID(mxID(_length));
    mxPop();
  }
}

void fx_Array_prototype_slice(txMachine* the)
{
  txNumber LENGTH = fxGetArrayLength(the, mxThis);
  txNumber START = fxArgToIndex(the, 0, 0, LENGTH);
  txNumber END = fxArgToIndex(the, 1, LENGTH, LENGTH);
  txNumber COUNT = (END > START) ? END - START : 0;
  txSlot* resultArray = fxCreateArraySpecies(the, COUNT);
  txSlot* array = C_NULL;
  if (resultArray)
    array = fxCheckArray(the, mxThis, XS_IMMUTABLE);
  if (array)
    array = fxCheckArrayItems(the, array, (txIndex)START, (txIndex)(START + COUNT));
  if (array) {
    txIndex start = (txIndex)START;
    txIndex count = (txIndex)COUNT;
    if (count) {
      fxSetIndexSize(the, resultArray, count, XS_CHUNK);
      c_memcpy(resultArray->value.array.address, array->value.array.address + start, count * sizeof(txSlot));
      fxIndexArray(the, resultArray);
      mxMeterSome(count * 10);
    }
    mxMeterSome(3);
  }
  else {
    txNumber INDEX = 0;
    while (START < END) {
      mxPushSlot(mxThis);
      mxPushNumber(START);
      if (mxHasAt()) {
        mxPushSlot(mxThis);
        mxPushNumber(START);
        mxGetAt();
        mxPushSlot(mxResult);
        mxPushNumber(INDEX);
        mxDefineAt(0, XS_GET_ONLY);
        mxPop();
      }
      INDEX++;
      START++;
      mxCheckMetering();
    }
    mxPushNumber(COUNT);
    mxPushSlot(mxResult);
    mxSetID(mxID(_length));
  }
}

void fx_Array_prototype_some(txMachine* the)
{
  txIndex length = fxGetArrayLimit(the, mxThis);
  txIndex index = 0;
  txSlot* function = fxArgToCallback(the, 0);
  mxResult->kind = XS_BOOLEAN_KIND;
  mxResult->value.boolean = 0;
  while (index < length) {
    if (fxCallThisItem(the, function, index, C_NULL)) {
      mxResult->value.boolean = fxToBoolean(the, the->stack);
      mxPop();
      if (mxResult->value.boolean)
        break;
    }
    index++;
    mxCheckMetering();
  }
}


void fx_Array_prototype_sort(txMachine* the)
{
  txSlot* function = C_NULL;
  /*txSlot* array =*/ fxCheckArray(the, mxThis, XS_MUTABLE);
  if (mxArgc > 0) {
    txSlot* slot = mxArgv(0);
    if (slot->kind != XS_UNDEFINED_KIND) {
      if (fxIsCallable(the, slot))
        function = slot;
      else
        mxTypeError("compare: not a function");
    }
  }
//  if (function)
    fxSortArrayItems(the, function, C_NULL, fxGetArrayLength(the, mxThis), mxThis);
//  else {
//    if (array)
//      array = fxCheckArrayItems(the, array, 0, array->value.array.length);
//    fxSortArrayItems(the, function, array, fxGetArrayLength(the, mxThis), mxThis);
//  }
  mxResult->kind = mxThis->kind;
  mxResult->value = mxThis->value;
}

void fx_Array_prototype_splice(txMachine* the)
{
  txIndex c = (txIndex)mxArgc;
  txNumber LENGTH = fxGetArrayLength(the, mxThis);
  txNumber START = fxArgToIndex(the, 0, 0, LENGTH);
  txNumber INSERTIONS, DELETIONS;
  txSlot* resultArray;
  txSlot* array = C_NULL;
  if (c == 0) {
    INSERTIONS = 0;
    DELETIONS = 0;
  }
  else if (c == 1) {
    INSERTIONS = 0;
    DELETIONS = LENGTH - START;
  }
  else {
    INSERTIONS = c - 2;
    DELETIONS = fxArgToRange(the, 1, 0, 0, LENGTH - START);
  }
  if (LENGTH + INSERTIONS - DELETIONS > C_MAX_SAFE_INTEGER)
    mxTypeError("unsafe integer");
  resultArray = fxCreateArraySpecies(the, DELETIONS);
  if (resultArray)
    array = fxCheckArray(the, mxThis, XS_MUTABLE);
  if (array) {
    if (INSERTIONS == DELETIONS)
      array = fxCheckArrayItems(the, array, (txIndex)START, (txIndex)(START + DELETIONS));
    else
      array = fxCheckArrayItems(the, array, (txIndex)START, (txIndex)LENGTH);
  }
  if (array) {
    txSlot* address;
    txIndex length = (txIndex)LENGTH;
    txIndex start = (txIndex)START;
    txIndex insertions = (txIndex)INSERTIONS;
    txIndex deletions = (txIndex)DELETIONS;
    txIndex index;
    if (LENGTH + INSERTIONS - DELETIONS > 0xFFFFFFFF)
      mxTypeError("array overflow");
    fxSetIndexSize(the, resultArray, deletions, XS_CHUNK);
    c_memcpy(resultArray->value.array.address, array->value.array.address + start, deletions * sizeof(txSlot));
    fxIndexArray(the, resultArray);
    mxMeterSome(deletions * 10);
    mxMeterSome(4);
    if (insertions < deletions) {
      c_memmove(array->value.array.address + start + insertions, array->value.array.address + start + deletions, (length - (start + deletions)) * sizeof(txSlot));
      fxSetIndexSize(the, array, length - (deletions - insertions), XS_CHUNK);
      mxMeterSome((length - (start + deletions)) * 10);
      mxMeterSome((deletions - insertions) * 4);
    }
    else if (insertions > deletions) {
      fxSetIndexSize(the, array, length + (insertions - deletions), XS_CHUNK);
      c_memmove(array->value.array.address + start + insertions, array->value.array.address + start + deletions, (length - (start + deletions)) * sizeof(txSlot));
      mxMeterSome((length - (start + deletions)) * 10);
    }
    address = array->value.array.address + start;
    index = 2;
    while (index < c) {
      txSlot* argument = mxArgv(index);
      address->ID = XS_NO_ID;
      address->kind = argument->kind;
      address->value = argument->value;
      address++;
      mxMeterSome(5);
      index++;
      mxCheckMetering();
    }
    fxIndexArray(the, array);
    mxMeterSome(4);
  }
  else { 
    txNumber INDEX = 0;
    while (INDEX < DELETIONS) {
      txNumber FROM = START + INDEX;
      mxPushSlot(mxThis);
      mxPushNumber(FROM);
      if (mxHasAt()) {
        mxPushSlot(mxThis);
        mxPushNumber(FROM);
        mxGetAt();
        mxPushSlot(mxResult);
        mxPushNumber(INDEX);
        mxDefineAt(0, XS_GET_ONLY);
        mxPop();
      }
      INDEX++;
      mxCheckMetering();
    }
    mxPushNumber(DELETIONS);
    mxPushSlot(mxResult);
    mxSetID(mxID(_length));
    mxPop();
    if (INSERTIONS < DELETIONS) {
      INDEX = START;
      while (INDEX < (LENGTH - DELETIONS)) {
        fxMoveThisItem(the, INDEX + DELETIONS, INDEX + INSERTIONS);
        INDEX++;
        mxCheckMetering();
      }
      INDEX = LENGTH;
      while (INDEX > (LENGTH - DELETIONS + INSERTIONS)) {
        mxPushSlot(mxThis);
        mxPushNumber(INDEX - 1);
        mxDeleteAt();
        mxPop();
        INDEX--;
        mxCheckMetering();
      }
    }
    else if (INSERTIONS > DELETIONS) {
      INDEX = LENGTH - DELETIONS;
      while (INDEX > START) {
        fxMoveThisItem(the, INDEX + DELETIONS - 1, INDEX + INSERTIONS - 1);
        INDEX--;
        mxCheckMetering();
      }
    }
    INDEX = 0;
    while (INDEX < INSERTIONS) {
      mxPushSlot(mxArgv(2 + (txInteger)INDEX));
      mxPushSlot(mxThis);
      mxPushNumber(START + INDEX);
      mxSetAt();
      mxPop();
      INDEX++;
      mxCheckMetering();
    }
    mxPushNumber(LENGTH - DELETIONS + INSERTIONS);
    mxPushSlot(mxThis);
    mxSetID(mxID(_length));
    mxPop();
  }
}

void fx_Array_prototype_toLocaleString(txMachine* the)
{
  txIndex length = fxGetArrayLimit(the, mxThis);
  txIndex index = 0;
  txString string;
  txSlot* list = fxNewInstance(the);
  txSlot* slot = list;
  txBoolean comma = 0;
  txInteger size = 0;
    
  mxPushStringX(",");
  the->stack->kind += XS_KEY_KIND - XS_STRING_KIND;
  the->stack->value.key.sum = 1;
  while (index < length) {
    if (comma) {
      slot = fxNextSlotProperty(the, slot, the->stack, XS_NO_ID, XS_NO_FLAG);
      size = fxAddChunkSizes(the, size, slot->value.key.sum);
    }
    else
      comma = 1;
    mxPushSlot(mxThis);
    mxGetIndex(index);
    if ((the->stack->kind != XS_UNDEFINED_KIND) && (the->stack->kind != XS_NULL_KIND)) {
      mxDub();
      mxGetID(mxID(_toLocaleString));
      mxCall();
      mxRunCount(0);
      slot = fxNextSlotProperty(the, slot, the->stack, XS_NO_ID, XS_NO_FLAG);
      string = fxToString(the, slot);
      slot->kind += XS_KEY_KIND - XS_STRING_KIND;
      slot->value.key.sum = mxStringLength(string);
      size = fxAddChunkSizes(the, size, slot->value.key.sum);
    }
    mxPop();
    index++;
    
    mxCheckMetering();
  }
  string = mxResult->value.string = fxNewChunk(the, fxAddChunkSizes(the, size, 1));
  slot = list->next;
  while (slot) {
    c_memcpy(string, slot->value.key.string, slot->value.key.sum);
    string += slot->value.key.sum;
    slot = slot->next;
  }
  *string = 0;
  mxResult->kind = XS_STRING_KIND;
  mxPop();
}

void fx_Array_prototype_toReversed(txMachine* the)
{
  txNumber LENGTH = fxGetArrayLength(the, mxThis);
  txIndex length, to, from;
  if (LENGTH > 0xFFFFFFFF)
    mxRangeError("array overflow");
  length = (txIndex)LENGTH;
  fxNewArray(the, length);
  mxPullSlot(mxResult);
  from = length - 1;
  to = 0;
  while (to < length) {
    mxPushSlot(mxThis);
    mxPushUnsigned(from);
    mxGetAt();
    mxPushSlot(mxResult);
    mxPushUnsigned(to);
    mxDefineAt(0, XS_GET_ONLY);
    mxPop();
    from--;
    to++;
    mxCheckMetering();
  }
}

void fx_Array_prototype_toSorted(txMachine* the)
{
  txSlot* function = C_NULL;
  txNumber LENGTH;
  if (mxArgc > 0) {
    txSlot* slot = mxArgv(0);
    if (slot->kind != XS_UNDEFINED_KIND) {
      if (fxIsCallable(the, slot))
        function = slot;
      else
        mxTypeError("compare: not a function");
    }
  }
  LENGTH = fxGetArrayLength(the, mxThis);
  if (LENGTH > 0xFFFFFFFF)
    mxRangeError("array overflow");
  fxNewArray(the, (txIndex)LENGTH);
  mxPullSlot(mxResult);
  fxSortArrayItems(the, function, C_NULL, LENGTH, mxResult);
}

void fx_Array_prototype_toSpliced(txMachine* the)
{
  txIndex c = (txIndex)mxArgc, i;
  txNumber LENGTH = fxGetArrayLength(the, mxThis);
  txNumber START = fxArgToIndex(the, 0, 0, LENGTH);
  txNumber INSERTIONS, SKIP, RESULT_LENGTH;
  txSlot* array = C_NULL;
  if (c == 0) {
    INSERTIONS = 0;
    SKIP = 0;
  }
  else if (c == 1) {
    INSERTIONS = 0;
    SKIP = LENGTH - START;
  }
  else {
    INSERTIONS = c - 2;
    SKIP = fxArgToRange(the, 1, 0, 0, LENGTH - START);
  }
  RESULT_LENGTH = LENGTH + INSERTIONS - SKIP;
  if (RESULT_LENGTH > C_MAX_SAFE_INTEGER)
    mxTypeError("unsafe integer");
  if (RESULT_LENGTH > 0xFFFFFFFF)
    mxRangeError("array overflow");
  array = fxCheckArray(the, mxThis, XS_IMMUTABLE);
  if (array)
    array = fxCheckArrayItems(the, array, (txIndex)0, (txIndex)START);
  if (array)
    array = fxCheckArrayItems(the, array, (txIndex)(START + SKIP), (txIndex)LENGTH);
  if (array) {
    txIndex length = (txIndex)LENGTH;
    txIndex start = (txIndex)START;
    txIndex skip = (txIndex)SKIP;
    txIndex rest = length - (start + skip);
    txSlot* resultArray;
    txSlot* resultAddress;
    txSlot* address;
    fxNewArray(the, (txIndex)RESULT_LENGTH);
    mxPullSlot(mxResult);
    resultArray = mxResult->value.reference->next;
    resultAddress = resultArray->value.array.address;
    address = array->value.array.address;
    if (start > 0) {
      c_memcpy(resultAddress, address, start * sizeof(txSlot));
      mxMeterSome(start * 10);
      resultAddress += start;
      address += start;
    }
    for (i = 2; i < c; i++) {
      txSlot* argument = mxArgv(i);
      resultAddress->ID = XS_NO_ID;
      resultAddress->kind = argument->kind;
      resultAddress->value = argument->value;
      resultAddress++;
      mxMeterSome(5);
      mxCheckMetering();
    }
    address += skip;
    if (rest > 0) {
      c_memcpy(resultAddress, address, rest * sizeof(txSlot));
      mxMeterSome(rest * 10);
    }
    fxIndexArray(the, resultArray);
    mxMeterSome(4);
  }
  else {
    txNumber from = 0;
    txNumber to = 0;
    fxNewArray(the, 0);
    mxPullSlot(mxResult);
    while (from < START) {
      mxPushSlot(mxThis);
      mxPushUnsigned(from);
      mxGetAt();
      mxPushSlot(mxResult);
      mxPushUnsigned(to);
      mxDefineAt(0, XS_GET_ONLY);
      mxPop();
      from++;
      to++;
      mxCheckMetering();
    }
    for (i = 2; i < c; i++) {
      mxPushSlot(mxArgv(i));
      mxPushSlot(mxResult);
      mxPushNumber(to);
      mxDefineAt(0, XS_GET_ONLY);
      mxPop();
      to++;
      mxCheckMetering();
    }
    from += SKIP;
    while (from < LENGTH) {
      mxPushSlot(mxThis);
      mxPushUnsigned(from);
      mxGetAt();
      mxPushSlot(mxResult);
      mxPushUnsigned(to);
      mxDefineAt(0, XS_GET_ONLY);
      mxPop();
      from++;
      to++;
      mxCheckMetering();
    }
  }
}

void fx_Array_prototype_toString(txMachine* the)
{
  mxPushSlot(mxThis);
  mxDub();
  mxGetID(mxID(_join));
  if (fxIsCallable(the, the->stack)) {
    mxCall();
    mxRunCount(0);
    mxPullSlot(mxResult);
  }
  else {
    mxPop();
    mxPop();
    fx_Object_prototype_toString(the);
  }
}

void fx_Array_prototype_unshift(txMachine* the)
{
  txIndex c = mxArgc, i;
  txSlot* array = fxCheckArray(the, mxThis, XS_MUTABLE);
  if (array)
    array = fxCheckArrayItems(the, array, 0, array->value.array.length);
  if (array) {
    txSlot* address;
    txIndex length = array->value.array.length;
    if (length + c < length)
      mxRangeError("array overflow");
    if (c > 0) {
      fxSetIndexSize(the, array, length + c, XS_GROWABLE_CHUNK);
      address = array->value.array.address;
      c_memmove(address + c, address, length * sizeof(txSlot));
      mxMeterSome(length * 10);
      i = 0;
      while (i < c) {
        txSlot* argument = mxArgv(i);
        address->ID = XS_NO_ID;
        address->kind = argument->kind;
        address->value = argument->value;
        address++;
        mxMeterSome(4);
        i++;
        mxCheckMetering();
      }
      fxIndexArray(the, array);
    }
    mxPushUnsigned(length + c);
    mxMeterSome(2);
  }
  else {
    txNumber length = fxGetArrayLength(the, mxThis);
    txNumber index = length;
    if (c > 0) {
      if (length + c > C_MAX_SAFE_INTEGER)
        mxTypeError("unsafe integer");
      while (index > 0) {
        fxMoveThisItem(the, index - 1, index + c - 1);
        index--;
        mxCheckMetering();
      }
      i = 0;
      while (i < c) {
        mxPushSlot(mxArgv(i));
        mxPushSlot(mxThis);
        mxSetIndex(i);
        mxPop();
        i++;
        mxCheckMetering();
      }
    }
    mxPushNumber(length + c);
    mxPushSlot(mxThis);
    mxSetID(mxID(_length));
  }
  mxPullSlot(mxResult);
}

void fx_Array_prototype_values(txMachine* the)
{
  txSlot* property;
  fxToInstance(the, mxThis);
  mxPush(mxArrayIteratorPrototype);
  property = fxLastProperty(the, fxNewIteratorInstance(the, mxThis, mxID(_Array)));
  property = fxNextIntegerProperty(the, property, 0, XS_NO_ID, XS_INTERNAL_FLAG);
  mxPullSlot(mxResult);
}

void fx_Array_prototype_with(txMachine* the)
{
  txNumber LENGTH = fxGetArrayLength(the, mxThis), INDEX;
  txIndex length, index, i;
  if (LENGTH > 0xFFFFFFFF)
    mxRangeError("array overflow");
  INDEX = fxArgToRelativeIndex(the, 0, 0, LENGTH);
  if ((INDEX < 0) || (LENGTH <= INDEX))
    mxRangeError("invalid index");
  length = (txIndex)LENGTH;
  fxNewArray(the, length);
  mxPullSlot(mxResult);
  index = (txIndex)INDEX;
  i = 0;
  while (i < index) {
    mxPushSlot(mxThis);
    mxPushUnsigned(i);
    mxGetAt();
    mxPushSlot(mxResult);
    mxPushUnsigned(i);
    mxDefineAt(0, XS_GET_ONLY);
    mxPop();
    i++;
    mxCheckMetering();
  }
  if (mxArgc > 1)
    mxPushSlot(mxArgv(1));
  else
    mxPushUndefined();
  mxPushSlot(mxResult);
  mxPushUnsigned(i);
  mxDefineAt(0, XS_GET_ONLY);
  mxPop();
  i++;
  while (i < length) {
    mxPushSlot(mxThis);
    mxPushUnsigned(i);
    mxGetAt();
    mxPushSlot(mxResult);
    mxPushUnsigned(i);
    mxDefineAt(0, XS_GET_ONLY);
    mxPop();
    i++;
    mxCheckMetering();
  }
}

void fx_ArrayIterator_prototype_next(txMachine* the)
{
  txSlot* iterator = fxCheckIteratorInstance(the, mxThis, mxID(_Array));
  txSlot* result = iterator->next;
  txSlot* iterable = result->next;
  txSlot* index = iterable->next;
  txSlot* value = fxCheckIteratorResult(the, result);
  txSlot* done = value->next;
  if (!done->value.boolean) {
    txInteger kind = index->next->value.integer;
    txIndex length = fxGetArrayLimit(the, iterable);
    txIndex i = (txIndex)index->value.integer;
    if (i < length) {
      switch(kind) {
      case 0: 
        mxPushSlot(iterable);
        mxGetIndex(i);
        mxPullSlot(value);
        break;
      case 1:
        mxPushUnsigned(i);
        mxPullSlot(value);
        break;
      case 2:
        mxPushUnsigned(i);
        mxPushSlot(iterable);
        mxGetIndex(i);
        fxConstructArrayEntry(the, value);
        break;
      }
            index->value.integer = i + 1;
    }
    else {
      value->kind = XS_UNDEFINED_KIND;
      done->value.boolean = 1;
    }
  }
  mxResult->kind = result->kind;
  mxResult->value = result->value;
}


Coverage Report

Created: 2025-11-24 06:36