/*

 * 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"

#if mx32bitID

#define mxSymbolBit 0x80000000

#define mxSymbolMask 0x7FFFFFFF

#else

#define mxSymbolBit 0x8000

#define mxSymbolMask 0x7FFF

#endif

typedef struct sxMarshallBuffer txMarshallBuffer; 

struct sxMarshallBuffer {

  txByte* base;

  txByte* current;

  txSlot* link;

  txID* symbolMap;

  txSize size;

  txID symbolCount;

  txSize symbolSize;

  txSlot* stack;

  c_jmp_buf jmp_buf;

  char error[128];

};

static void fxDemarshallChunk(txMachine* the, void* theData, void** theDataAddress);

static txID fxDemarshallKey(txMachine* the, txID id, txID* theSymbolMap, txBoolean alien);

static void fxDemarshallReference(txMachine* the, txSlot* theSlot, txSlot** theSlotAddress, txID* theSymbolMap, txBoolean alien);

static void fxDemarshallSlot(txMachine* the, txSlot* theSlot, txSlot* theResult, txID* theSymbolMap, txBoolean alien);

static void fxMarshallChunk(txMachine* the, void* theData, void** theDataAddress, txMarshallBuffer* theBuffer);

static txBoolean fxMarshallKey(txMachine* the, txSlot* slot, txMarshallBuffer* theBuffer, txBoolean alien);

static void fxMarshallReference(txMachine* the, txSlot* theSlot, txSlot** theSlotAddress, txMarshallBuffer* theBuffer, txBoolean alien);

static txBoolean fxMarshallSlot(txMachine* the, txSlot* theSlot, txSlot** theSlotAddress, txMarshallBuffer* theBuffer, txBoolean alien);

static void fxMeasureChunk(txMachine* the, void* theData, txMarshallBuffer* theBuffer);

static txBoolean fxMeasureKey(txMachine* the, txID theID, txMarshallBuffer* theBuffer, txBoolean alien);

static void fxMeasureReference(txMachine* the, txSlot* theSlot, txMarshallBuffer* theBuffer, txBoolean alien);

static void fxMeasureSlot(txMachine* the, txSlot* theSlot, txMarshallBuffer* theBuffer, txBoolean alien);

static void fxMeasureThrow(txMachine* the, txMarshallBuffer* theBuffer, txString message);

#define mxMarshallAlign(POINTER,SIZE) \

  if (((SIZE) &= ((sizeof(txNumber) - 1)))) (POINTER) += sizeof(txNumber) - (SIZE)

void fxDemarshall(txMachine* the, void* theData, txBoolean alien)

{

  txByte* p;

  txByte* q;

  txID aSymbolCount;

  txID aSymbolLength;

  txID* aSymbolMap;

  txID* aSymbolPointer;

  txSlot* aSlot;

  txChunk* aChunk;

  txIndex aLength;

  if (!theData) {

    the->stack->kind = XS_UNDEFINED_KIND;

    return;

  }

  p = (txByte*)theData;

  q = p + *((txSize*)(p));

  {

    mxTry(the) {

      p += sizeof(txSize);

      aSymbolCount = *((txID*)p);

      p += sizeof(txID);

      aSymbolMap = aSymbolPointer = (txID*)p;

      p += aSymbolCount * sizeof(txID);

      while (aSymbolCount) {

        txID id;

        aSymbolLength = *aSymbolPointer;

        mxPushStringC((char *)p);

        id = fxNewName(the, the->stack);

        mxPop();

        *aSymbolPointer++ = id;

        aSymbolCount--;

        p += aSymbolLength;

      }

      aLength = mxPtrDiff(p - (txByte*)theData);

      mxMarshallAlign(p, aLength);

      mxPushUndefined();

      fxDemarshallSlot(the, (txSlot*)p, the->stack, aSymbolMap, alien);

    }

    mxCatch(the) {

      the->stack->kind = XS_UNDEFINED_KIND;

      break;

    }

    while (p < q) {

      aSlot = (txSlot*)p;

      p += sizeof(txSlot);

      switch (aSlot->kind) {

      case XS_STRING_KIND:

      case XS_BIGINT_KIND:

        aChunk = (txChunk*)p;

        p += aChunk->size;

        mxMarshallAlign(p, aChunk->size);

        break;

      case XS_ARRAY_BUFFER_KIND:

        if (aSlot->value.arrayBuffer.address) {

          aChunk = (txChunk*)p;

          p += aChunk->size;

          mxMarshallAlign(p, aChunk->size);

        }

        break;

      case XS_REGEXP_KIND:

        if (aSlot->value.regexp.code) {

          aChunk = (txChunk*)p;

          p += aChunk->size;

          mxMarshallAlign(p, aChunk->size);

        }

        if (aSlot->value.regexp.data) {

          aChunk = (txChunk*)p;

          p += aChunk->size;

          mxMarshallAlign(p, aChunk->size);

        }

        break;

      case XS_KEY_KIND:

        if (aSlot->value.key.string) {

          aChunk = (txChunk*)p;

          p += aChunk->size;

          mxMarshallAlign(p, aChunk->size);

        }

      case XS_INSTANCE_KIND:

        aSlot->value.instance.garbage = C_NULL;

        break;

      }

    }

  }

}

void fxDemarshallChunk(txMachine* the, void* theData, void** theDataAddress)

{

  txSize aSize = ((txChunk*)(((txByte*)theData) - sizeof(txChunk)))->size - sizeof(txChunk);

  txByte* aResult = (txByte *)fxNewChunk(the, aSize);

  c_memcpy(aResult, theData, aSize);

  *theDataAddress = aResult;

}

txID fxDemarshallKey(txMachine* the, txID id, txID* theSymbolMap, txBoolean alien)

{

  if (id != XS_NO_ID) {

    if (alien)

      id = theSymbolMap[id - 1];

    else if (id >= the->keyOffset)

      id = theSymbolMap[id - the->keyOffset];

  }

  return id;

}

void fxDemarshallReference(txMachine* the, txSlot* theSlot, txSlot** theSlotAddress, txID* theSymbolMap, txBoolean alien)

{

  if (!alien && (theSlot->flag & XS_DONT_MARSHALL_FLAG))

    *theSlotAddress = theSlot;

  else if (theSlot->value.instance.garbage)

    *theSlotAddress = theSlot->value.instance.garbage;

  else {

    mxCheckCStack();

    *theSlotAddress = fxNewSlot(the);

    fxDemarshallSlot(the, theSlot, *theSlotAddress, theSymbolMap, alien);

  }

}

void fxDemarshallSlot(txMachine* the, txSlot* theSlot, txSlot* theResult, txID* theSymbolMap, txBoolean alien)

{

  txSlot* aSlot;

  txIndex index, offset;

  txSlot* aResult;

  txSlot** aSlotAddress;

  if (!(theSlot->flag & XS_INTERNAL_FLAG))

    theResult->ID = fxDemarshallKey(the, theSlot->ID, theSymbolMap, alien);

  else

    theResult->ID = theSlot->ID;

  theResult->flag = theSlot->flag;

  switch (theSlot->kind) {

  case XS_UNDEFINED_KIND:

  case XS_NULL_KIND:

  case XS_BOOLEAN_KIND:

  case XS_INTEGER_KIND:

  case XS_NUMBER_KIND:

  case XS_DATE_KIND:

  case XS_STRING_X_KIND:

  case XS_BIGINT_X_KIND:

  case XS_DATA_VIEW_KIND:

  case XS_KEY_X_KIND:

  case XS_BUFFER_INFO_KIND:

    theResult->value = theSlot->value;

    theResult->kind = theSlot->kind;

    break;

  case XS_STRING_KIND:

    fxDemarshallChunk(the, theSlot->value.string, (void **)&theResult->value.string);

    theResult->kind = theSlot->kind;

    break;

  case XS_BIGINT_KIND:

    fxDemarshallChunk(the, theSlot->value.bigint.data, (void **)&theResult->value.bigint.data);

    theResult->value.bigint.size = theSlot->value.bigint.size;

    theResult->value.bigint.sign = theSlot->value.bigint.sign;

    theResult->kind = theSlot->kind;

    break;

  case XS_ARRAY_BUFFER_KIND: 

    if (theSlot->value.arrayBuffer.address)

      fxDemarshallChunk(the, theSlot->value.arrayBuffer.address, (void **)&(theResult->value.arrayBuffer.address));

    else

      theResult->value.arrayBuffer.address = C_NULL;

    theResult->kind = theSlot->kind;

    break;

  case XS_REGEXP_KIND:

    theResult->value.regexp.code = C_NULL;

    theResult->value.regexp.data = C_NULL;

    theResult->kind = theSlot->kind;

    if (theSlot->value.regexp.code)

      fxDemarshallChunk(the, theSlot->value.regexp.code, (void**)&(theResult->value.regexp.code));

    if (theSlot->value.regexp.data)

      fxDemarshallChunk(the, theSlot->value.regexp.data, (void**)&(theResult->value.regexp.data));

    break;  

  case XS_KEY_KIND:

    if (theSlot->value.key.string)

      fxDemarshallChunk(the, theSlot->value.key.string, (void **)&theResult->value.key.string);

    else

      theResult->value.key.string = C_NULL;

    theResult->value.key.sum = theSlot->value.key.sum;

    theResult->kind = theSlot->kind;

    break;

  case XS_SYMBOL_KIND:

    theResult->value.symbol = fxDemarshallKey(the, theSlot->value.symbol, theSymbolMap, alien);

    theResult->kind = theSlot->kind;

    break;

  case XS_HOST_KIND:

    theResult->value.host.data = fxRetainSharedChunk(theSlot->value.host.data);

    theResult->value.host.variant.destructor = fxReleaseSharedChunk;

    theResult->kind = theSlot->kind;

    break;

  case XS_MAP_KIND:

  case XS_SET_KIND:

        theResult->value.table.length = theSlot->value.table.length;

    aSlotAddress = (txSlot**)fxNewChunk(the, theResult->value.table.length * sizeof(txSlot*));

    c_memset(aSlotAddress, 0, theResult->value.table.length * sizeof(txSlot*));

    theResult->value.table.address = aSlotAddress;

    theResult->kind = theSlot->kind;

    break;  

  case XS_TYPED_ARRAY_KIND:

    theResult->value.typedArray.dispatch = (txTypeDispatch*)&gxTypeDispatches[theSlot->value.integer];

    theResult->value.typedArray.atomics = (txTypeAtomics*)&gxTypeAtomics[theSlot->value.integer];

    theResult->kind = theSlot->kind;

    break;

  case XS_REFERENCE_KIND:

    theResult->value.error.info = C_NULL;

    theResult->kind = XS_ERROR_KIND;

    fxDemarshallReference(the, theSlot->value.reference, &(theResult->value.error.info), theSymbolMap, alien);

    theResult->value.reference = theResult->value.error.info;

    theResult->kind = XS_REFERENCE_KIND;

    break;

  case XS_INSTANCE_KIND:

    theSlot->value.instance.garbage = theResult;

    theResult->value.instance.garbage = C_NULL;

    theResult->kind = theSlot->kind;

    aSlot = theSlot->next;

    if (!alien && theSlot->value.instance.prototype) {

          theResult->value.instance.prototype = theSlot->value.instance.prototype;

    }

    else {

          theResult->value.instance.prototype = mxObjectPrototype.value.reference;

      if (aSlot) {

        if (aSlot->flag & XS_INTERNAL_FLAG) {

          if (aSlot->ID == XS_ARRAY_BEHAVIOR)

            theResult->value.instance.prototype = mxArrayPrototype.value.reference;

          else {

            switch (aSlot->kind) {

            case XS_ARRAY_BUFFER_KIND: theResult->value.instance.prototype = mxArrayBufferPrototype.value.reference; break;

            case XS_BOOLEAN_KIND: theResult->value.instance.prototype = mxBooleanPrototype.value.reference; break;

            case XS_DATA_VIEW_KIND: theResult->value.instance.prototype = mxDataViewPrototype.value.reference; break;

            case XS_DATE_KIND: theResult->value.instance.prototype = mxDatePrototype.value.reference; break;

            case XS_ERROR_KIND: theResult->value.instance.prototype = mxErrorPrototypes(aSlot->value.error.which).value.reference; break;

            case XS_HOST_KIND: theResult->value.instance.prototype = mxSharedArrayBufferPrototype.value.reference; break;

            case XS_MAP_KIND: theResult->value.instance.prototype = mxMapPrototype.value.reference; break;

            case XS_NUMBER_KIND: theResult->value.instance.prototype = mxNumberPrototype.value.reference; break;

            case XS_REGEXP_KIND: theResult->value.instance.prototype = mxRegExpPrototype.value.reference; break;

            case XS_SET_KIND: theResult->value.instance.prototype = mxSetPrototype.value.reference; break;

            case XS_STRING_KIND: theResult->value.instance.prototype = mxStringPrototype.value.reference; break;

            case XS_TYPED_ARRAY_KIND: {

              txTypeDispatch* dispatch = (txTypeDispatch*)&gxTypeDispatches[aSlot->value.integer];

              mxPush(the->stackIntrinsics[-1 - (txInteger)dispatch->constructorID]);

              mxGetID(mxID(_prototype));

              theResult->value.instance.prototype = the->stack->value.reference;

              mxPop();

              } break;

            }

          }

        }

      }

    }

    aSlotAddress = &(theResult->next);

    while (aSlot) {

      *aSlotAddress = fxNewSlot(the);

      fxDemarshallSlot(the, aSlot, *aSlotAddress, theSymbolMap, alien);

      aSlot = aSlot->next;

      aSlotAddress = &((*aSlotAddress)->next);

    }

    aSlot = theResult->next;

    if (aSlot) {

      if (aSlot->kind == XS_MAP_KIND) {

        txSlot* key = aSlot->next->value.list.first;

        while (key) {

          txSlot* value = key->next;

          txU4 sum = fxSumEntry(the, key);

          txU4 modulo = sum % aSlot->value.table.length;

          txSlot* entry = fxNewSlot(the);

          txSlot** address = &(aSlot->value.table.address[modulo]);

          entry->next = *address;

          entry->kind = XS_ENTRY_KIND;

          entry->value.entry.slot = key;

          entry->value.entry.sum = sum;

          *address = entry;

          key = value->next;

        }

      }

      else if (aSlot->kind == XS_SET_KIND) {

        txSlot* key = aSlot->next->value.list.first;

        while (key) {

          txU4 sum = fxSumEntry(the, key);

          txU4 modulo = sum % aSlot->value.table.length;

          txSlot* entry = fxNewSlot(the);

          txSlot** address = &(aSlot->value.table.address[modulo]);

          entry->next = *address;

          entry->kind = XS_ENTRY_KIND;

          entry->value.entry.slot = key;

          entry->value.entry.sum = sum;

          *address = entry;

          key = key->next;

        }

      }

    }

    break;  

  case XS_ARRAY_KIND:

    theResult->value.array.length = 0;

    theResult->value.array.address = C_NULL;

    theResult->kind = theSlot->kind;

    if ((index = theSlot->value.array.length)) {

      theResult->value.array.address = (txSlot *)fxNewChunk(the, index * sizeof(txSlot));

      c_memset(theResult->value.array.address, 0, index * sizeof(txSlot));

      aSlot = theSlot->value.array.address;

      index = 0;

      offset = 0;

      while (aSlot) {

        if (aSlot->kind == XS_AT_KIND)

          index = aSlot->value.at.index;

        else {

          mxPushUndefined();

          fxDemarshallSlot(the, aSlot, the->stack, theSymbolMap, alien);

          aResult = theResult->value.array.address + offset;

          aResult->value = the->stack->value;

          aResult->kind = the->stack->kind;

          mxPop();

          *((txIndex*)aResult) = index;

          index++;

          offset++;

          theResult->value.array.length = index;

        }

        aSlot = aSlot->next;

      }

    }

    break;

  case XS_ERROR_KIND:

    theResult->value.error.info = C_NULL;

    theResult->value.error.which = theSlot->value.error.which;

    theResult->kind = theSlot->kind;

    if (theSlot->value.error.info)

      fxDemarshallReference(the, theSlot->value.error.info, &theResult->value.error.info, theSymbolMap, alien);

    break;

  case XS_PROXY_KIND:

    theResult->value.proxy.handler = C_NULL;

    theResult->value.proxy.target = C_NULL;

    theResult->kind = theSlot->kind;

    if (theSlot->value.proxy.handler)

      fxDemarshallReference(the, theSlot->value.proxy.handler, &theResult->value.proxy.handler, theSymbolMap, alien);

    if (theSlot->value.proxy.target)

      fxDemarshallReference(the, theSlot->value.proxy.target, &theResult->value.proxy.target, theSymbolMap, alien);

    break;  

  case XS_LIST_KIND:

    theResult->value.list.first = C_NULL;

    theResult->value.list.last = C_NULL;

    theResult->kind = theSlot->kind;

    aSlot = theSlot->value.list.first;

    aSlotAddress = &(theResult->value.list.first);

    while (aSlot) {

      theResult->value.list.last = *aSlotAddress = fxNewSlot(the);

      fxDemarshallSlot(the, aSlot, *aSlotAddress, theSymbolMap, alien);

      aSlot = aSlot->next;

      aSlotAddress = &((*aSlotAddress)->next);

    }

    break;  

  case XS_PRIVATE_KIND:

    theResult->value.private.check = theSlot->value.private.check;

    theResult->value.private.first = C_NULL;

    theResult->kind = theSlot->kind;

    aSlot = theSlot->value.private.first;

    aSlotAddress = &(theResult->value.private.first);

    while (aSlot) {

      *aSlotAddress = fxNewSlot(the);

      fxDemarshallSlot(the, aSlot, *aSlotAddress, theSymbolMap, alien);

      aSlot = aSlot->next;

      aSlotAddress = &((*aSlotAddress)->next);

    }

    break;  

  default:

    break;

  }

}

void* fxMarshall(txMachine* the, txBoolean alien)

{

  txMarshallBuffer aBuffer;

  txSlot* aSlot;

  txSlot* bSlot;

  txSlot* cSlot;

  c_memset(&aBuffer, 0, sizeof(aBuffer));

  if (c_setjmp(aBuffer.jmp_buf) == 0) {

    size_t mapSize = alien ? the->keyIndex : (the->keyIndex - the->keyOffset);

    aBuffer.symbolSize = sizeof(txSize) + sizeof(txID);

    aBuffer.symbolMap = c_calloc(mapSize, sizeof(txID));

    if (mapSize && !aBuffer.symbolMap)

      fxMeasureThrow(the,  &aBuffer, "out of memory");

        the->stack->ID = XS_NO_ID;

        aBuffer.stack = the->stack;

    fxMeasureSlot(the, the->stack, &aBuffer, alien);

    aBuffer.size += aBuffer.symbolSize;

    mxMarshallAlign(aBuffer.size, aBuffer.symbolSize);

    aBuffer.base = aBuffer.current = (txByte *)c_malloc(aBuffer.size);

    if (!aBuffer.base)

      fxMeasureThrow(the,  &aBuffer, "out of memory");

    *((txSize*)(aBuffer.current)) = aBuffer.size;

    aBuffer.current += sizeof(txSize);

    *((txID*)(aBuffer.current)) = aBuffer.symbolCount;

    aBuffer.current += sizeof(txID);

    if (aBuffer.symbolCount) {

      txID* lengths = (txID*)aBuffer.current;

      txID* map = aBuffer.symbolMap;

      txID dstIndex = 1;

      txSlot** p;

      txSlot** q;

      txSlot* key;

      aBuffer.current += aBuffer.symbolCount * sizeof(txID);

      if (alien) {

        p = the->keyArrayHost;

        q = p + the->keyOffset;

        while (p < q) {

          txID length = *map;

          if (length) {

            *map = dstIndex;

            key = *p;

            mxCheck(the, (key->kind == XS_KEY_KIND) || (key->kind  == XS_KEY_X_KIND));

            *lengths++ = length;

            c_memcpy(aBuffer.current, key->value.key.string, length);

            aBuffer.current += length;

            dstIndex++;

          }

          map++;

          p++;

        }

      }

      else 

        dstIndex = the->keyOffset;

      p = the->keyArray;

      q = p + the->keyIndex - the->keyOffset;

      while (p < q) {

        txID length = *map;

        if (length) {

          *map = dstIndex;

          key = *p;

          mxCheck(the, (key->kind == XS_KEY_KIND) || (key->kind  == XS_KEY_X_KIND));

          *lengths++ = length;

          c_memcpy(aBuffer.current, key->value.key.string, length);

          aBuffer.current += length;

          dstIndex++;

        }

        map++;

        p++;

      }

    }

    mxMarshallAlign(aBuffer.current, aBuffer.symbolSize);

    fxMarshallSlot(the, the->stack, &aSlot, &aBuffer, alien);

    aSlot = aBuffer.link;

    while (aSlot) {

      bSlot = aSlot->value.instance.garbage;

      aSlot->flag &= ~XS_MARK_FLAG;

      aSlot->value.instance.garbage = C_NULL;

      aSlot = bSlot;

    }

    mxCheck(the, aBuffer.current == aBuffer.base + aBuffer.size);

  }

  else {

    aSlot = the->firstHeap;

    while (aSlot) {

      bSlot = aSlot + 1;

      cSlot = aSlot->value.reference;

      while (bSlot < cSlot) {

        bSlot->flag &= ~XS_MARK_FLAG; 

        bSlot++;

      }

      aSlot = aSlot->next;

    }

    if (aBuffer.base)

      c_free(aBuffer.base);

    if (aBuffer.symbolMap)

      c_free(aBuffer.symbolMap);

    mxUnknownError(aBuffer.error);  

  }

  mxPop();

  c_free(aBuffer.symbolMap);

  return aBuffer.base;

}

void fxMarshallChunk(txMachine* the, void* theData, void** theDataAddress, txMarshallBuffer* theBuffer)

{

  txChunk* aChunk = ((txChunk*)(((txByte*)theData) - sizeof(txChunk)));

  txSize aSize = aChunk->size & 0x7FFFFFFF;

  txByte* aResult = theBuffer->current;

  theBuffer->current += aSize;

  c_memcpy(aResult, aChunk, aSize);

  aChunk = (txChunk*)aResult;

  aChunk->size &= 0x7FFFFFFF;

  *theDataAddress = aResult + sizeof(txChunk);

  mxMarshallAlign(theBuffer->current, aSize);

}

txBoolean fxMarshallKey(txMachine* the, txSlot* slot, txMarshallBuffer* theBuffer, txBoolean alien)

{

  txID id = slot->ID;

  txSlot* result = (txSlot*)(theBuffer->current);

  txSlot* key;

  if ((id == XS_NO_ID) || (slot->flag & XS_INTERNAL_FLAG)) {

    result->ID = id;

    return 1;

  }

  if (alien) {

    key = fxGetKey(the, id);

    if (key->flag & XS_DONT_ENUM_FLAG) {

      result->ID = theBuffer->symbolMap[id];

      return 1;

    }

  }

  else if (id >= the->keyOffset) {

    key = fxGetKey(the, id);

    if (key->flag & XS_DONT_ENUM_FLAG) {

      result->ID = theBuffer->symbolMap[id - the->keyOffset];

      return 1;

    }

  }

  else {

    result->ID = id;

    return 1;

  }

  return 0;

}

void fxMarshallReference(txMachine* the, txSlot* theSlot, txSlot** theSlotAddress, txMarshallBuffer* theBuffer, txBoolean alien)

{

  if (!alien && (theSlot->flag & XS_DONT_MARSHALL_FLAG))

    *theSlotAddress = theSlot;

  else if (theSlot->value.instance.garbage)

    *theSlotAddress = theSlot->value.instance.garbage;

  else {

    mxCheckCStack();

    fxMarshallSlot(the, theSlot, theSlotAddress, theBuffer, alien);

  }

}

txBoolean fxMarshallSlot(txMachine* the, txSlot* theSlot, txSlot** theSlotAddress, txMarshallBuffer* theBuffer, txBoolean alien)

{

  txSlot* aResult;

  txSlot* aSlot;

  txSlot** aSlotAddress;

  if ((theSlot->kind == XS_PRIVATE_KIND) && (alien || ~(theSlot->value.private.check->flag & XS_DONT_MARSHALL_FLAG)))

    return 0;

  if (!fxMarshallKey(the, theSlot, theBuffer, alien))

    return 0;

  aResult = (txSlot*)(theBuffer->current);

  theBuffer->current += sizeof(txSlot);

  aResult->flag = theSlot->flag;

  aResult->kind = theSlot->kind;

  aResult->value = theSlot->value;

  *theSlotAddress = aResult;

  switch (theSlot->kind) {

  case XS_UNDEFINED_KIND:

  case XS_NULL_KIND:

  case XS_BOOLEAN_KIND:

  case XS_INTEGER_KIND:

  case XS_NUMBER_KIND:

  case XS_DATE_KIND:

  case XS_STRING_X_KIND:

  case XS_BIGINT_X_KIND:

  case XS_DATA_VIEW_KIND:

  case XS_KEY_X_KIND:

  case XS_BUFFER_INFO_KIND:

    break;

  case XS_STRING_KIND:

    fxMarshallChunk(the, theSlot->value.string, (void **)&(aResult->value.string), theBuffer);

    break;

  case XS_BIGINT_KIND:

    fxMarshallChunk(the, theSlot->value.bigint.data, (void **)&(aResult->value.bigint.data), theBuffer);

    break;

  case XS_ARRAY_BUFFER_KIND: 

    if (theSlot->value.arrayBuffer.address)

      fxMarshallChunk(the, theSlot->value.arrayBuffer.address, (void **) &(aResult->value.arrayBuffer.address), theBuffer);

    break;

  case XS_REGEXP_KIND:

    if (theSlot->value.regexp.code)

      fxMarshallChunk(the, theSlot->value.regexp.code, (void**)&(aResult->value.regexp.code), theBuffer);

    if (theSlot->value.regexp.data)

      fxMarshallChunk(the, theSlot->value.regexp.data, (void**)&(aResult->value.regexp.data), theBuffer);

    break;  

  case XS_KEY_KIND:

    if (theSlot->value.key.string)

      fxMarshallChunk(the, theSlot->value.key.string, (void **)&(aResult->value.key.string), theBuffer);

    break;

  case XS_SYMBOL_KIND:

    aResult->value.symbol = theSlot->value.symbol; //@@ only shared symbols remain

    break;

  case XS_HOST_KIND: 

    break;

  case XS_MAP_KIND:

  case XS_SET_KIND:

    aResult->value.table.address = C_NULL;

    break;  

  case XS_TYPED_ARRAY_KIND:

    aResult->value.integer = (txInteger)(theSlot->value.typedArray.dispatch - &gxTypeDispatches[0]);

    break;

  case XS_REFERENCE_KIND:

    fxMarshallReference(the, theSlot->value.reference, &aResult->value.reference,  theBuffer, alien);

    break;

  case XS_INSTANCE_KIND:

    aResult->value.instance.garbage = theBuffer->link;

    aResult->value.instance.prototype = C_NULL;

    aSlot = theSlot->value.instance.prototype;

    if (!alien && aSlot && (aSlot->flag & XS_DONT_MARSHALL_FLAG))

      aResult->value.instance.prototype = aSlot;

    theSlot->value.instance.garbage = aResult;

    theBuffer->link = theSlot;

    aSlotAddress = &(aResult->next);

    aSlot = theSlot->next;

    while (aSlot) {

      if (fxMarshallSlot(the, aSlot, aSlotAddress, theBuffer, alien))

        aSlotAddress = &((*aSlotAddress)->next);

      aSlot = aSlot->next;

    }

    *aSlotAddress = C_NULL;

    break;  

  case XS_ARRAY_KIND: {

    txIndex length = theSlot->value.array.length;

    txIndex size = fxGetIndexSize(the, theSlot);

    txSlot* slot = theSlot->value.array.address;

    txSlot* limit = slot + size;

    aResult->value.array.length = size;

    aSlotAddress = &(aResult->value.array.address);

    if (length == size) {

      while (slot < limit) {

        fxMarshallSlot(the, slot, aSlotAddress, theBuffer, alien);

        aSlotAddress = &((*aSlotAddress)->next);

        slot++;

      }

    }

    else {

      txSlot elision = { NULL, {.ID = XS_NO_ID, .flag = XS_NO_FLAG, .kind = XS_AT_KIND}, .value = { .at = { 0x0, XS_NO_ID } } };

      while (slot < limit) {

        txIndex index = *((txIndex*)slot);

        if (elision.value.at.index != index) {

          elision.value.at.index = index;

          fxMarshallSlot(the, &elision, aSlotAddress, theBuffer, alien);

          aSlotAddress = &((*aSlotAddress)->next);

        }

        fxMarshallSlot(the, slot, aSlotAddress, theBuffer, alien);

        aSlotAddress = &((*aSlotAddress)->next);

        elision.value.at.index = index + 1;

        slot++;

      }

    }

    *aSlotAddress = C_NULL;

    } break;

  case XS_ERROR_KIND:

    if (theSlot->value.error.info)

      fxMarshallReference(the, theSlot->value.error.info, &aResult->value.error.info, theBuffer, alien);

    break;  

  case XS_PROXY_KIND:

    if (theSlot->value.proxy.handler)

      fxMarshallReference(the, theSlot->value.proxy.handler, &aResult->value.proxy.handler, theBuffer, alien);

    if (theSlot->value.proxy.target)

      fxMarshallReference(the, theSlot->value.proxy.target, &aResult->value.proxy.target, theBuffer, alien);

    break;  

  case XS_LIST_KIND:

    aSlot = theSlot->value.list.first;

    aSlotAddress = &(aResult->value.list.first);

    while (aSlot) {

      fxMarshallSlot(the, aSlot, aSlotAddress, theBuffer, alien);

      aResult->value.list.last = *aSlotAddress;

      aSlot = aSlot->next;

      aSlotAddress = &((*aSlotAddress)->next);

    }

    *aSlotAddress = C_NULL;

    break;  

  case XS_PRIVATE_KIND:

    aSlot = theSlot->value.private.check;

    if (!alien && (aSlot->flag & XS_DONT_MARSHALL_FLAG)) {

      aSlot = theSlot->value.private.first;

      aSlotAddress = &(aResult->value.private.first);

      while (aSlot) {

        fxMarshallSlot(the, aSlot, aSlotAddress, theBuffer, alien);

        aSlot = aSlot->next;

        aSlotAddress = &((*aSlotAddress)->next);

      }

      *aSlotAddress = C_NULL;

    }

    else {

      theBuffer->current -= sizeof(txSlot);

      return 0;

    }

    break; 

  default:

    break;

  }

  return 1;

}

void fxMeasureChunk(txMachine* the, void* theData, txMarshallBuffer* theBuffer)

{

  txChunk* aChunk = ((txChunk*)(((txByte*)theData) - sizeof(txChunk)));

  txSize aSize = aChunk->size & 0x7FFFFFFF;

  theBuffer->size += aSize;

  if (theBuffer->size < 0)

    fxMeasureThrow(the, theBuffer, "too big");

  mxMarshallAlign(theBuffer->size, aSize);

}

txBoolean fxMeasureKey(txMachine* the, txID id, txMarshallBuffer* theBuffer, txBoolean alien)

{

  txSlot* key;

  txSize length;

  if (id == XS_NO_ID)

    return 1;

  if (alien) {

    if (theBuffer->symbolMap[id])

      return 1;

    key = fxGetKey(the, id);

    if (!(key->flag & XS_DONT_ENUM_FLAG))

      return 0;

  }

  else if (id >= the->keyOffset) {

    if (theBuffer->symbolMap[id - the->keyOffset])

      return 1;

    key = fxGetKey(the, id);

    if (!(key->flag & XS_DONT_ENUM_FLAG))

      return 0;

    id -= the->keyOffset;

  }

  else

    return 1;

  length = mxStringLength(key->value.key.string) + 1;  

  theBuffer->symbolMap[id] = (txID)length;

  theBuffer->symbolSize += sizeof(txID);

  theBuffer->symbolSize += length;

  theBuffer->symbolCount++;

  return 1;

}

void fxMeasureReference(txMachine* the, txSlot* theSlot, txMarshallBuffer* theBuffer, txBoolean alien)

{

  if (theSlot->flag & XS_DONT_MARSHALL_FLAG) {

    if (alien)

      if (theSlot->value.host.variant.destructor != fxReleaseSharedChunk)

        fxMeasureThrow(the, theBuffer, "read only object");

  }

  else if ((theSlot->flag & XS_MARK_FLAG) == 0) {

    mxCheckCStack();

    fxMeasureSlot(the, theSlot, theBuffer, alien);

  }

}

void fxMeasureSlot(txMachine* the, txSlot* theSlot, txMarshallBuffer* theBuffer, txBoolean alien)

{

  txSlot* aSlot;

  if (!(theSlot->flag & XS_INTERNAL_FLAG) && !fxMeasureKey(the, theSlot->ID, theBuffer, alien))

    return;

  theBuffer->size += sizeof(txSlot);

  if (theBuffer->size < 0)

    fxMeasureThrow(the, theBuffer, "too big");

  switch (theSlot->kind) {

  case XS_UNDEFINED_KIND:

  case XS_NULL_KIND:

  case XS_BOOLEAN_KIND:

  case XS_INTEGER_KIND:

  case XS_NUMBER_KIND:

  case XS_DATE_KIND:

  case XS_STRING_X_KIND: