/* * Copyright (c) 2016-2018 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 . * * 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. */ #ifndef __XSALL__ #define __XSALL__ #include "xsCommon.h" #ifdef __cplusplus extern "C" { #endif //#define mxFrequency 1 #ifndef mxBoundsCheck #ifdef mxDebug #define mxBoundsCheck 1 #else #define mxBoundsCheck 0 #endif #endif #ifndef mxRegExp #define mxRegExp 1 #endif #ifndef mxMachinePlatform #define mxMachinePlatform \ void* host; #endif typedef struct sxMachine txMachine; typedef struct sxSlot txSlot; typedef struct sxBlock txBlock; typedef struct sxChunk txChunk; typedef struct sxJump txJump; typedef struct sxProfileRecord txProfileRecord; typedef struct sxCreation txCreation; typedef struct sxPreparation txPreparation; typedef struct sxHostFunctionBuilder txHostFunctionBuilder; typedef struct sxHostHooks txHostHooks; typedef struct sxInspectorNameLink txInspectorNameLink; typedef struct sxInspectorNameList txInspectorNameList; typedef txBoolean (*txArchiveRead)(void* src, size_t offset, void* buffer, size_t size); typedef txBoolean (*txArchiveWrite)(void* dst, size_t offset, void* buffer, size_t size); typedef void (*txCallback)(txMachine*); typedef txCallback (*txCallbackAt)(txID index); typedef void (*txDestructor)(void*); typedef void (*txMarkRoot)(txMachine*, txSlot*); typedef void (*txMarker)(txMachine*, void*, txMarkRoot); typedef void (*txStep)(txMachine*, txSlot*, txID, txIndex, txSlot*); typedef void (*txSweepRoot)(txMachine*, txSlot*); typedef void (*txSweeper)(txMachine*, void*, txSweepRoot); typedef void (*txTypeCallback)(txMachine*, txSlot*, txInteger, txSlot*, int); typedef void (*txTypeCoerce)(txMachine*, txSlot*); typedef int (*txTypeCompare)(const void*, const void*); typedef void (*txTypeOperator)(txMachine*, txSlot*, txInteger, txSlot*, int, int); typedef txInteger (*txTypeWait)(txMachine* the, txSlot* host, txInteger offset, txSlot* slot, txNumber timeout); typedef void (*txBehaviorCall)(txMachine* the, txSlot* instance, txSlot* _this, txSlot* arguments); typedef void (*txBehaviorConstruct)(txMachine* the, txSlot* instance, txSlot* arguments, txSlot* target); typedef txBoolean (*txBehaviorDefineOwnProperty)(txMachine* the, txSlot* instance, txID id, txIndex index, txSlot* slot, txFlag mask); typedef txBoolean (*txBehaviorDeleteProperty)(txMachine* the, txSlot* instance, txID id, txIndex index); typedef txBoolean (*txBehaviorGetOwnProperty)(txMachine* the, txSlot* instance, txID id, txIndex index, txSlot* slot); typedef txSlot* (*txBehaviorGetProperty)(txMachine* the, txSlot* instance, txID id, txIndex index, txFlag flag); typedef txBoolean (*txBehaviorGetPropertyValue)(txMachine* the, txSlot* instance, txID id, txIndex index, txSlot* receiver, txSlot* value); typedef txBoolean (*txBehaviorGetPrototype)(txMachine* the, txSlot* instance, txSlot* result); typedef txBoolean (*txBehaviorHasProperty)(txMachine* the, txSlot* instance, txID id, txIndex index); typedef txBoolean (*txBehaviorIsExtensible)(txMachine* the, txSlot* instance); typedef void (*txBehaviorOwnKeys)(txMachine* the, txSlot* instance, txFlag flag, txSlot* keys); typedef txBoolean (*txBehaviorPreventExtensions)(txMachine* the, txSlot* instance); typedef txSlot* (*txBehaviorSetProperty)(txMachine* the, txSlot* instance, txID id, txIndex index, txFlag flag); typedef txBoolean (*txBehaviorSetPropertyValue)(txMachine* the, txSlot* instance, txID id, txIndex index, txSlot* value, txSlot* receiver); typedef txBoolean (*txBehaviorSetPrototype)(txMachine* the, txSlot* instance, txSlot* prototype); typedef struct { txSlot* (*newAsyncInstance)(txMachine*); void (*runAsync)(txMachine*, txSlot*); txSlot* (*newGeneratorInstance)(txMachine*); txSlot* (*newGeneratorFunctionInstance)(txMachine*, txID name); txSlot* (*newAsyncGeneratorInstance)(txMachine*); txSlot* (*newAsyncGeneratorFunctionInstance)(txMachine*, txID name); void (*runForAwaitOf)(txMachine*); txSlot* (*newArgumentsSloppyInstance)(txMachine*, txIndex count); txSlot* (*newArgumentsStrictInstance)(txMachine*, txIndex count); void (*runEval)(txMachine*); void (*runEvalEnvironment)(txMachine*); void (*runProgramEnvironment)(txMachine*); void (*initializeSharedCluster)(); void (*terminateSharedCluster)(); txSlot* (*newFunctionLength)(txMachine* the, txSlot* instance, txNumber length); txSlot* (*newFunctionName)(txMachine* the, txSlot* instance, txID id, txIndex index, txID former, txString prefix); void (*runImport)(txMachine* the, txSlot* realm, txID id); txBoolean (*definePrivateProperty)(txMachine* the, txSlot* instance, txSlot* check, txID id, txSlot* slot, txFlag mask); txSlot* (*getPrivateProperty)(txMachine* the, txSlot* instance, txSlot* check, txID id); txSlot* (*setPrivateProperty)(txMachine* the, txSlot* instance, txSlot* check, txID id); void (*cleanupFinalizationRegistries)(txMachine*); void (*captureErrorStack)(txMachine* the, txSlot* internal, txSlot* frame); } txDefaults; enum { XS_ORDINARY_BEHAVIOR = 0, XS_ARGUMENTS_SLOPPY_BEHAVIOR, XS_ARGUMENTS_STRICT_BEHAVIOR, XS_ARRAY_BEHAVIOR, XS_ENVIRONMENT_BEHAVIOR, XS_GLOBAL_BEHAVIOR, XS_MODULE_BEHAVIOR, XS_PROXY_BEHAVIOR, XS_STRING_BEHAVIOR, XS_TYPED_ARRAY_BEHAVIOR, XS_BEHAVIOR_COUNT }; typedef struct { txBehaviorGetProperty getProperty; txBehaviorSetProperty setProperty; txBehaviorCall call; txBehaviorConstruct construct; txBehaviorDefineOwnProperty defineOwnProperty; txBehaviorDeleteProperty deleteProperty; txBehaviorGetOwnProperty getOwnProperty; txBehaviorGetPropertyValue getPropertyValue; txBehaviorGetPrototype getPrototype; txBehaviorHasProperty hasProperty; txBehaviorIsExtensible isExtensible; txBehaviorOwnKeys ownKeys; txBehaviorPreventExtensions preventExtensions; txBehaviorSetPropertyValue setPropertyValue; txBehaviorSetPrototype setPrototype; } txBehavior; typedef struct { txInteger lo; txInteger hi; } txSortPartition; #define mxSortThreshold 4 #define mxSortPartitionCount 30 #define mxTypeArrayCount 11 typedef struct { txU2 size; txU2 shift; // (1 << shift) == size txTypeCallback getter; txTypeCallback setter; txTypeCoerce coerce; txTypeCompare compare; txID getID; txID setID; txID constructorID; } txTypeDispatch; typedef struct { txTypeCallback add; txTypeCallback and; txTypeCallback compareExchange; txTypeCallback exchange; txTypeCallback load; txTypeCallback or; txTypeCallback store; txTypeCallback sub; txTypeCallback xor; txTypeWait wait; } txTypeAtomics; typedef txBigInt* (*txBigIntBinary)(txMachine*, txBigInt* r, txBigInt* a, txBigInt* b); typedef txBoolean (*txBigIntCompare)(txMachine*, txBoolean less, txBoolean equal, txBoolean more, txSlot*, txSlot*); typedef void (*txBigIntDecode)(txMachine*, txSize); typedef void (*txBigIntToArrayBuffer)(txMachine* the, txSlot* slot, txU4 minBytes, txBoolean sign, int endian); typedef txSlot* (*txBigIntToInstance)(txMachine* the, txSlot* slot); typedef void (*txBigintToString)(txMachine* the, txSlot* slot, txU4 radix); typedef txNumber (*txBigIntToNumber)(txMachine* the, txSlot* slot); typedef txBigInt* (*txBigIntUnary)(txMachine*, txBigInt* r, txBigInt* a); typedef struct { txBigIntCompare compare; txBigIntDecode decode; txBigIntToArrayBuffer toArrayBuffer; txBigIntToInstance toInstance; txBigIntToNumber toNumber; txBigintToString toString; txBigIntBinary _add; txBigIntBinary _and; txBigIntUnary _dec; txBigIntBinary _div; txBigIntBinary _exp; txBigIntUnary _inc; txBigIntBinary _lsl; txBigIntBinary _lsr; txBigIntBinary _mul; txBigIntUnary _neg; txBigIntBinary _nop; txBigIntUnary _not; txBigIntBinary _or; txBigIntBinary _rem; txBigIntBinary _sub; txBigIntBinary _xor; } txTypeBigInt; struct sxHostHooks { txDestructor destructor; txMarker marker; txSweeper sweeper; }; typedef union { txBoolean boolean; txInteger integer; txNumber number; txString string; txID symbol; txBigInt bigint; txSlot* reference; txSlot* closure; struct { union { txSlot* reference; txInteger count; } variable; txInteger line; } environment; // id == file struct { txByte* code; txSlot* scope; } frame; struct { txSlot* garbage; txSlot* prototype; } instance; struct { txSlot* address; txIndex length; } array; struct { txByte* address; void* detachKey; } arrayBuffer; struct { txInteger length; txInteger maxLength; } bufferInfo; struct { txCallback address; txSlot* closures; } callback; struct { txByte* address; txSlot* closures; } code; struct { txInteger offset; txInteger size; } dataView; struct { txSlot* info; txError which; } error; struct { void* data; union { txDestructor destructor; txHostHooks* hooks; } variant; } host; struct { txSlot* handler; txSlot* target; } proxy; struct { txInteger* code; txInteger* data; } regexp; struct { txSlot* address; txIndex length; } stack; struct { txSlot** address; txSize length; } table; struct { txTypeDispatch* dispatch; txTypeAtomics* atomics; } typedArray; struct { txSlot* check; txSlot* value; } weakEntry; struct { txSlot* first; txSlot* link; } weakList; struct { txSlot* target; txSlot* link; } weakRef; struct { txSlot* callback; txUnsigned flags; } finalizationRegistry; struct { txSlot* target; txSlot* token; } finalizationCell; struct { txSlot* getter; txSlot* setter; } accessor; struct { txU4 index; txID id; } at; struct { txSlot* slot; txU4 sum; } entry; struct { txSlot* first; txIndex length; } errors; struct { txSlot* object; txSlot* module; } home; struct { txString string; txU4 sum; } key; struct { txSlot* first; txSlot* last; } list; struct { txSlot* realm; txID id; } module; #ifdef mxHostFunctionPrimitive struct { const txHostFunctionBuilder* builder; txID profileID; } hostFunction; #endif struct { txSlot* cache; txSlot* instance; } hostInspector; struct { txSlot* slot; txInspectorNameLink* link; } instanceInspector; struct { txSlot* closure; txSlot* module; } export; struct { txSlot* check; txSlot* first; } private; txID* IDs; } txValue; struct sxBlock { txBlock* nextBlock; txByte* current; txByte* limit; txByte* temporary; }; struct sxChunk { txSize size; #if INTPTR_MAX == INT64_MAX txS4 dummy; #endif txByte* temporary; }; struct sxJump { c_jmp_buf buffer; /* xs.h */ txJump* nextJump; /* xs.h */ txSlot* stack; /* xs.h */ txSlot* scope; /* xs.h */ txSlot* frame; /* xs.h */ txSlot* environment; /* xs.h */ txByte* code; /* xs.h */ txBoolean flag; /* xs.h */ }; struct sxSlot { txSlot* next; #if mx32bitID #if mxBigEndian union { struct { txID ID; txS2 dummy; txFlag flag; txKind kind; }; txS8 ID_FLAG_KIND; }; #else union { struct { txKind kind; txFlag flag; txS2 dummy; txID ID; }; txS8 KIND_FLAG_ID; }; #endif #else #if mxBigEndian union { struct { txID ID; txFlag flag; txKind kind; }; txS4 ID_FLAG_KIND; }; #else union { struct { txKind kind; txFlag flag; txID ID; }; txS4 KIND_FLAG_ID; }; #endif #if INTPTR_MAX == INT64_MAX txS4 dummy; #endif #endif txValue value; }; struct sxInspectorNameLink { txInspectorNameLink* previous; txInspectorNameLink* next; txString name; }; struct sxInspectorNameList { txInspectorNameLink *first; txInspectorNameLink* last; }; struct sxMachine { txSlot* stack; /* xs.h */ txSlot* scope; /* xs.h */ txSlot* frame; /* xs.h */ txByte* code; /* xs.h */ txSlot* stackBottom; /* xs.h */ txSlot* stackTop; /* xs.h */ txSlot* stackPrototypes; /* xs.h */ txJump* firstJump; /* xs.h */ void* context; /* xs.h */ void* archive; /* xs.h */ txSlot scratch; /* xs.h */ mxMachinePlatform /* xs.h */ txFlag status; txSlot* cRoot; txBlock* firstBlock; txSlot* freeHeap; txSlot* firstHeap; txSize nameModulo; txSlot** nameTable; txSize symbolModulo; txSlot** symbolTable; txID* colors; txSlot** keyArray; txID keyCount; txID keyDelta; txID keyIndex; txID keyOffset; txSlot** keyArrayHost; txID aliasCount; txID aliasIndex; txSlot** aliasArray; char* stackLimit; txSlot* firstWeakListLink; txSlot* firstWeakRefLink; txSize currentChunksSize; txSize peakChunksSize; txSize maximumChunksSize; txSize minimumChunksSize; txSize currentHeapCount; txSize peakHeapCount; txSize maximumHeapCount; txSize minimumHeapCount; txSize parserBufferSize; txSize parserTableModulo; txBoolean shared; txMachine* sharedMachine; txBoolean collectFlag; void* dtoa; void* preparation; txInteger tag; char nameBuffer[256]; #ifdef mxDebug txString name; txFlag breakOnExceptionsFlag; txFlag breakOnStartFlag; txFlag debugAttribute; txFlag debugExit; txFlag debugState; txFlag debugTag; txFlag nameIndex; txFlag pathIndex; txSlot* debugModule; size_t idValue; txInteger lineValue; char pathValue[256]; txSize debugOffset; char debugBuffer[256]; txSize echoOffset; char echoBuffer[256]; #endif #ifdef mxFrequency txNumber exits[XS_CODE_COUNT]; txNumber frequencies[XS_CODE_COUNT]; #endif #ifdef mxInstrument txU2 garbageCollectionCount; txU2 loadedModulesCount; txSize peakParserSize; txSlot* stackPeak; txSize floatingPointOps; void (*onBreak)(txMachine*, txU1 stop); #endif #ifdef mxMetering txBoolean (*meterCallback)(txMachine*, txU4); txU4 meterCount; txU4 meterIndex; txU4 meterInterval; #endif txID profileID; #if defined(mxInstrument) || defined(mxProfile) void* profiler; #endif }; struct sxCreation { txSize initialChunkSize; /* xs.h */ txSize incrementalChunkSize; /* xs.h */ txSize initialHeapCount; /* xs.h */ txSize incrementalHeapCount; /* xs.h */ txSize stackCount; /* xs.h */ txSize initialKeyCount; /* xs.h */ txSize incrementalKeyCount; /* xs.h */ txSize nameModulo; /* xs.h */ txSize symbolModulo; /* xs.h */ txSize parserBufferSize; /* xs.h */ txSize parserTableModulo; /* xs.h */ txSize staticSize; /* xs.h */ }; struct sxPreparation { txS1 version[4]; txSize aliasCount; txSize heapCount; txSlot* heap; txSize stackCount; txSlot* stack; txID* colors; txSize keyCount; txSlot** keys; txSize nameModulo; txSlot** names; txSize symbolModulo; txSlot** symbols; txSize scriptCount; txScript* scripts; txID profileID; txCreation creation; txString main; txU1 checksum[16]; }; struct sxHostFunctionBuilder { txCallback callback; txInteger length; txID id; }; typedef struct { txSlot* slot; txSize offset; txSize size; } txStringStream; typedef struct { txString buffer; txSize offset; txSize size; } txStringCStream; /* xsAPI.c */ mxExport txKind fxTypeOf(txMachine*, txSlot*); mxExport void fxUndefined(txMachine*, txSlot*); mxExport void fxNull(txMachine*, txSlot*); mxExport void fxBoolean(txMachine*, txSlot*, txS1); mxExport txBoolean fxToBoolean(txMachine*, txSlot*); mxExport void fxInteger(txMachine*, txSlot*, txInteger); mxExport txInteger fxToInteger(txMachine*, txSlot*); mxExport void fxNumber(txMachine*, txSlot*, txNumber); mxExport txNumber fxToNumber(txMachine*, txSlot*); mxExport void fxString(txMachine*, txSlot*, txString); mxExport void fxStringBuffer(txMachine* the, txSlot* theSlot, txString theValue, txSize theSize); mxExport txString fxToString(txMachine*, txSlot*); mxExport txString fxToStringBuffer(txMachine*, txSlot*, txString, txSize); mxExport txString fxToStringCopy(txMachine*, txSlot*); mxExport void fxStringX(txMachine* the, txSlot* theSlot, txString theValue); mxExport void fxUnsigned(txMachine*, txSlot*, txUnsigned); mxExport txUnsigned fxToUnsigned(txMachine*, txSlot*); mxExport void fxClosure(txMachine* the, txSlot* theSlot, txSlot* theClosure); mxExport txSlot* fxToClosure(txMachine* the, txSlot* theSlot); mxExport void fxReference(txMachine* the, txSlot* theSlot, txSlot* theReference); mxExport txSlot* fxToReference(txMachine* the, txSlot* theSlot); mxExport txSlot* fxNewArray(txMachine*, txInteger); mxExport txSlot* fxNewObject(txMachine*); mxExport txBoolean fxIsInstanceOf(txMachine*); mxExport void fxArrayCacheBegin(txMachine*, txSlot*); mxExport void fxArrayCacheEnd(txMachine*, txSlot*); mxExport void fxArrayCacheItem(txMachine*, txSlot*, txSlot*); mxExport void fxBuildHosts(txMachine*, txInteger, const txHostFunctionBuilder*); mxExport txSlot* fxNewHostConstructor(txMachine*, txCallback, txInteger, txInteger); mxExport txSlot* fxNewHostFunction(txMachine*, txCallback, txInteger, txInteger, txInteger); mxExport txSlot* fxNewHostInstance(txMachine* the); mxExport txSlot* fxNewHostObject(txMachine*, txDestructor); mxExport txInteger fxGetHostBufferLength(txMachine* the, txSlot* slot); mxExport void* fxGetHostChunk(txMachine*, txSlot*); mxExport void* fxGetHostChunkIf(txMachine*, txSlot*); mxExport void* fxGetHostData(txMachine*, txSlot*); mxExport void* fxGetHostDataIf(txMachine*, txSlot*); mxExport void* fxGetHostHandle(txMachine*, txSlot*); mxExport txDestructor fxGetHostDestructor(txMachine*, txSlot*); mxExport txHostHooks* fxGetHostHooks(txMachine*, txSlot*); mxExport void fxPetrifyHostBuffer(txMachine* the, txSlot* slot); mxExport void fxSetHostBuffer(txMachine* the, txSlot* slot, void* theData, txSize theSize); mxExport void *fxSetHostChunk(txMachine* the, txSlot* slot, void* theValue, txSize theSize); mxExport void fxSetHostData(txMachine*, txSlot*, void*); mxExport void fxSetHostDestructor(txMachine*, txSlot*, txDestructor); mxExport void fxSetHostHooks(txMachine*, txSlot*, const txHostHooks*); mxExport void* fxToHostHandle(txMachine* the, txSlot* slot); mxExport txID fxID(txMachine*, txString); mxExport txID fxFindID(txMachine* the, txString theName); mxExport txS1 fxIsID(txMachine*, txString); mxExport txID fxToID(txMachine* the, txSlot* theSlot); mxExport txString fxName(txMachine*, txID); mxExport void fxEnumerate(txMachine* the); mxExport txBoolean fxHasAll(txMachine* the, txID id, txIndex index); mxExport txBoolean fxHasAt(txMachine* the); mxExport txBoolean fxHasID(txMachine*, txID); mxExport txBoolean fxHasIndex(txMachine* the, txIndex index); mxExport void fxGetAll(txMachine* the, txID id, txIndex index); mxExport void fxGetAt(txMachine*); mxExport void fxGetID(txMachine*, txID); mxExport void fxGetIndex(txMachine*, txIndex); mxExport void fxSetAll(txMachine* the, txID id, txIndex index); mxExport void fxSetAt(txMachine*); mxExport void fxSetID(txMachine*, txID); mxExport void fxSetIndex(txMachine*, txIndex); mxExport void fxDefineAll(txMachine* the, txID id, txIndex index, txFlag flag, txFlag mask); mxExport void fxDefineAt(txMachine* the, txFlag flag, txFlag mask); mxExport void fxDefineID(txMachine* the, txID id, txFlag flag, txFlag mask); mxExport void fxDefineIndex(txMachine* the, txIndex index, txFlag flag, txFlag mask); mxExport void fxDeleteAll(txMachine*, txID, txIndex); mxExport void fxDeleteAt(txMachine*); mxExport void fxDeleteID(txMachine*, txID); mxExport void fxDeleteIndex(txMachine*, txIndex); mxExport void fxCall(txMachine*); mxExport void fxCallID(txMachine*, txID); mxExport void fxNew(txMachine*); mxExport void fxNewID(txMachine*, txID); mxExport void fxRunCount(txMachine*, txInteger); mxExport txBoolean fxRunTest(txMachine* the); mxExport void fxCallFrame(txMachine*); mxExport void fxNewFrame(txMachine* the); mxExport void fxVars(txMachine*, txInteger); mxExport txInteger fxCheckArg(txMachine*, txInteger); mxExport txInteger fxCheckVar(txMachine*, txInteger); mxExport void fxOverflow(txMachine*, txInteger, txString thePath, txInteger theLine); mxExport void fxThrow(txMachine* the, txString thePath, txInteger theLine) XS_FUNCTION_NORETURN; mxExport void fxThrowMessage(txMachine* the, txString thePath, txInteger theLine, txError theError, txString theMessage, ...) XS_FUNCTION_NORETURN; mxExport void fxDebugger(txMachine* the, txString thePath, txInteger theLine); mxExport const txByte gxNoCode[] ICACHE_FLASH_ATTR; mxExport txMachine* fxCreateMachine(txCreation* theCreation, txString theName, void* theContext, txID profileID); mxExport void fxDeleteMachine(txMachine*); mxExport txMachine* fxCloneMachine(txCreation* theCreation, txMachine* theMachine, txString theName, void* theContext); mxExport txMachine* fxPrepareMachine(txCreation* creation, txPreparation* preparation, txString name, void* context, void* archive); mxExport void fxShareMachine(txMachine* the); mxExport txMachine* fxBeginHost(txMachine*); mxExport void fxEndHost(txMachine*); mxExport void fxEndJob(txMachine* the); mxExport void fxExitToHost(txMachine*) XS_FUNCTION_NORETURN; mxExport void fxCollectGarbage(txMachine*); mxExport void fxEnableGarbageCollection(txMachine* the, txBoolean enableIt); mxExport void fxRemember(txMachine*, txSlot*); mxExport void fxForget(txMachine*, txSlot*); mxExport void fxAccess(txMachine*, txSlot*); mxExport void fxDemarshall(txMachine* the, void* theData, txBoolean alien); mxExport void* fxMarshall(txMachine* the, txBoolean alien); mxExport void fxBuildArchiveKeys(txMachine* the); mxExport void* fxGetArchiveCode(txMachine* the, void* archive, txString path, size_t* size); mxExport txInteger fxGetArchiveCodeCount(txMachine* the, void* archive); mxExport void* fxGetArchiveCodeName(txMachine* the, void* archive, txInteger index); mxExport void* fxGetArchiveData(txMachine* the, void* archive, txString path, size_t* size); mxExport txInteger fxGetArchiveDataCount(txMachine* the, void* archive); mxExport void* fxGetArchiveDataName(txMachine* the, void* archive, txInteger index); mxExport void* fxGetArchiveName(txMachine* the, void* archive); mxExport void* fxMapArchive(txMachine* the, txPreparation* preparation, void* archive, size_t bufferSize, txArchiveRead read, txArchiveWrite write); mxExport txBoolean fxIsProfiling(txMachine* the); mxExport void fxStartProfiling(txMachine* the); mxExport void fxStopProfiling(txMachine* the, void* stream); mxExport void fxAwaitImport(txMachine*, txBoolean defaultFlag); #ifdef mxMetering mxExport void fxBeginMetering(txMachine* the, txBoolean (*callback)(txMachine*, txU4), txU4 interval); mxExport void fxCheckMetering(txMachine* the); mxExport void fxEndMetering(txMachine* the); #endif /* xsmc.c */ mxExport void _xsNewArray(txMachine *the, txSlot *res, txInteger length); mxExport void _xsNewObject(txMachine *the, txSlot *res); mxExport void _xsNewHostInstance(txMachine*, txSlot*, txSlot*); mxExport txBoolean _xsIsInstanceOf(txMachine*, txSlot*, txSlot*); mxExport txBoolean _xsHas(txMachine*, txSlot*, txID); mxExport txBoolean _xsHasIndex(txMachine*, txSlot*, txIndex); mxExport void _xsGet(txMachine*, txSlot*, txSlot*, txID); mxExport void _xsGetAt(txMachine*, txSlot*, txSlot*, txSlot*); mxExport void _xsGetIndex(txMachine*, txSlot*, txSlot*, txIndex); mxExport void _xsSet(txMachine*, txSlot*, txID, txSlot*); mxExport void _xsSetAt(txMachine*, txSlot*, txSlot*, txSlot*); mxExport void _xsSetIndex(txMachine*, txSlot*, txIndex, txSlot*); mxExport void _xsDelete(txMachine*, txSlot*, txID); mxExport void _xsDeleteAt(txMachine*, txSlot*, txSlot*); mxExport void _xsCall(txMachine*, txSlot*, txSlot*, txUnsigned, ...); mxExport void _xsNew(txMachine*, txSlot*, txSlot*, txUnsigned, ...); mxExport txBoolean _xsTest(txMachine*, txSlot*); mxExport txInteger fxIncrementalVars(txMachine*, txInteger); /* xsPlatforms.c */ extern void* fxAllocateChunks(txMachine* the, txSize theSize); extern txSlot* fxAllocateSlots(txMachine* the, txSize theCount); extern void fxBuildKeys(txMachine* the); extern void fxCreateMachinePlatform(txMachine* the); extern void fxDeleteMachinePlatform(txMachine* the); extern void fxFreeChunks(txMachine* the, void* theChunks); extern void fxFreeSlots(txMachine* the, void* theSlots); extern txID fxFindModule(txMachine* the, txSlot* realm, txID moduleID, txSlot* slot); extern void fxLoadModule(txMachine* the, txSlot* module, txID moduleID); extern txScript* fxParseScript(txMachine* the, void* stream, txGetter getter, txUnsigned flags); extern void fxQueuePromiseJobs(txMachine* the); extern void fxInitializeSharedCluster(); extern void fxTerminateSharedCluster(); extern void* fxCreateSharedChunk(txInteger byteLength); extern void fxLockSharedChunk(void* data); extern void fxLinkSharedChunk(txMachine* the); extern txInteger fxMeasureSharedChunk(void* data); extern txInteger fxNotifySharedChunk(txMachine* the, void* data, txInteger offset, txInteger count); extern void fxReleaseSharedChunk(void* data); extern void* fxRetainSharedChunk(void* data); extern void fxUnlinkSharedChunk(txMachine* the); extern void fxUnlockSharedChunk(void* data); extern txInteger fxWaitSharedChunk(txMachine* the, void* address, txNumber timeout); extern void fxAbort(txMachine* the, int status); #ifdef mxDebug extern void fxConnect(txMachine* the); extern void fxDisconnect(txMachine* the); extern txBoolean fxIsConnected(txMachine* the); extern txBoolean fxIsReadable(txMachine* the); extern void fxReceive(txMachine* the); extern void fxSend(txMachine* the, txBoolean more); #endif /* xsDefaults.c */ extern const txDefaults gxDefaults; extern const txBehavior* gxBehaviors[]; extern const txTypeBigInt gxTypeBigInt; /* xsAll.c */ extern txString fxAdornStringC(txMachine* the, txString prefix, txSlot* string, txString suffix); extern txSlot* fxArgToCallback(txMachine* the, txInteger argi); extern void fxBufferFrameName(txMachine* the, txString buffer, txSize size, txSlot* frame, txString suffix); extern void fxBufferFunctionName(txMachine* the, txString buffer, txSize size, txSlot* function, txString suffix); extern void fxBufferObjectName(txMachine* the, txString buffer, txSize size, txSlot* object, txString suffix); extern txString fxConcatString(txMachine* the, txSlot* a, txSlot* b); extern txString fxConcatStringC(txMachine* the, txSlot* a, txString b); extern txString fxCopyString(txMachine* the, txSlot* a, txSlot* b); extern txString fxCopyStringC(txMachine* the, txSlot* a, txString b); extern txBoolean fxIsCanonicalIndex(txMachine* the, txID id); extern int fxStringGetter(void*); extern int fxStringCGetter(void*); extern void fxJump(txMachine*) XS_FUNCTION_NORETURN; /* xsRun.c */ extern void fxRunEval(txMachine* the); extern void fxRunForAwaitOf(txMachine* the); extern void fxRunID(txMachine* the, txSlot* generator, txInteger count); extern void fxRunScript(txMachine* the, txScript* script, txSlot* _this, txSlot* _target, txSlot* environment, txSlot* object, txSlot* module); extern txBoolean fxIsSameReference(txMachine* the, txSlot* a, txSlot* b); extern txBoolean fxIsSameSlot(txMachine* the, txSlot* a, txSlot* b); extern txBoolean fxIsSameValue(txMachine* the, txSlot* a, txSlot* b, txBoolean zero); /* xsMemory.c */ extern txSize fxAddChunkSizes(txMachine* the, txSize a, txSize b); extern void fxCheckCStack(txMachine* the); extern void fxAllocate(txMachine* the, txCreation* theCreation); extern void fxCollect(txMachine* the, txFlag theFlag); mxExport txSlot* fxDuplicateSlot(txMachine* the, txSlot* theSlot); extern void fxFree(txMachine* the); extern void fxGrowKeys(txMachine* the, txID theCount); extern txSize fxMultiplyChunkSizes(txMachine* the, txSize a, txSize b); mxExport void* fxNewChunk(txMachine* the, txSize theSize); mxExport void* fxNewGrowableChunk(txMachine* the, txSize size, txSize overflow); extern txSlot* fxNewSlot(txMachine* the); mxExport void* fxRenewChunk(txMachine* the, void* theData, txSize theSize); extern void fxShare(txMachine* the); /* xsDebug.c */ #ifdef mxDebug mxExport void fxCheck(txMachine* the, txString thePath, txInteger theLine); extern void fxDebugCommand(txMachine* the); extern void fxDebugLine(txMachine* the, txID id, txInteger line); extern void fxDebugLoop(txMachine* the, txString thePath, txInteger theLine, txString message); extern void fxDebugThrow(txMachine* the, txString thePath, txInteger theLine, txString message); mxExport void fxLogin(txMachine* the); mxExport void fxLogout(txMachine* the); #endif mxExport void fxBubble(txMachine* the, txInteger flags, void* message, txInteger length, txString conversation); mxExport void fxFileEvalString(txMachine* the, txString string, txString tag); mxExport void fxReport(txMachine* the, txString theFormat, ...); mxExport void fxReportError(txMachine* the, txString thePath, txInteger theLine, txString theFormat, ...); mxExport void fxReportWarning(txMachine* the, txString thePath, txInteger theLine, txString theFormat, ...); #ifdef mxInstrument extern void fxDescribeInstrumentation(txMachine* the, txInteger count, txString* names, txString* units); extern void fxSampleInstrumentation(txMachine* the, txInteger count, txInteger* values); extern void fxCheckProfiler(txMachine* the, txSlot* frame); extern void fxCreateProfiler(txMachine* the); extern void fxDeleteProfiler(txMachine* the, void* stream); extern void fxResumeProfiler(txMachine* the); extern void fxSuspendProfiler(txMachine* the); #define mxFloatingPointOp(operation) \ /* fprintf(stderr, "float: %s\n", operation); */ \ the->floatingPointOps += 1 #else #define mxFloatingPointOp(operation) #endif /* xsType.c */ extern txSlot* fxAliasInstance(txMachine* the, txSlot* instance); extern txSlot* fxDuplicateInstance(txMachine* the, txSlot* instance); extern txSlot* fxGetInstance(txMachine* the, txSlot* theSlot); extern txSlot* fxGetPrototype(txMachine* the, txSlot* instance); extern txBoolean fxIsSameInstance(txMachine* the, txSlot* a, txSlot* b); extern txSlot* fxNewInstance(txMachine* the); extern txSlot* fxToInstance(txMachine* the, txSlot* theSlot); extern void fxToPrimitive(txMachine* the, txSlot* theSlot, txBoolean theHint); extern void fxToSpeciesConstructor(txMachine* the, txSlot* constructor); extern txFlag fxDescriptorToSlot(txMachine* the, txSlot* descriptor); extern void fxDescribeProperty(txMachine* the, txSlot* property, txFlag mask); extern txBoolean fxIsPropertyCompatible(txMachine* the, txSlot* property, txSlot* slot, txFlag mask); mxExport void fx_species_get(txMachine* the); extern const txBehavior gxOrdinaryBehavior; extern void fxOrdinaryCall(txMachine* the, txSlot* instance, txSlot* _this, txSlot* arguments); extern void fxOrdinaryConstruct(txMachine* the, txSlot* instance, txSlot* arguments, txSlot* target); extern txBoolean fxOrdinaryDefineOwnProperty(txMachine* the, txSlot* instance, txID id, txIndex index, txSlot* slot, txFlag mask); extern txBoolean fxOrdinaryDeleteProperty(txMachine* the, txSlot* instance, txID id, txIndex index); extern txBoolean fxOrdinaryGetOwnProperty(txMachine* the, txSlot* instance, txID id, txIndex index, txSlot* slot); extern txSlot* fxOrdinaryGetProperty(txMachine* the, txSlot* instance, txID id, txIndex index, txFlag flag); extern txBoolean fxOrdinaryGetPropertyValue(txMachine* the, txSlot* instance, txID id, txIndex index, txSlot* receiver, txSlot* value); extern txBoolean fxOrdinaryGetPrototype(txMachine* the, txSlot* instance, txSlot* result); extern txBoolean fxOrdinaryHasProperty(txMachine* the, txSlot* instance, txID id, txIndex index); extern txSlot* fxOrdinarySetProperty(txMachine* the, txSlot* instance, txID id, txIndex index, txFlag flag); extern txBoolean fxOrdinarySetPropertyValue(txMachine* the, txSlot* instance, txID id, txIndex index, txSlot* value, txSlot* receiver); extern txBoolean fxOrdinaryIsExtensible(txMachine* the, txSlot* instance); extern void fxOrdinaryOwnKeys(txMachine* the, txSlot* target, txFlag flag, txSlot* keys); extern txBoolean fxOrdinaryPreventExtensions(txMachine* the, txSlot* instance); extern txBoolean fxOrdinarySetPrototype(txMachine* the, txSlot* instance, txSlot* prototype); mxExport void fxOrdinaryToPrimitive(txMachine* the); extern const txBehavior gxEnvironmentBehavior; extern txSlot* fxNewEnvironmentInstance(txMachine* the, txSlot* environment); extern void fxRunEvalEnvironment(txMachine* the); extern void fxRunProgramEnvironment(txMachine* the); extern txSlot* fxNewRealmInstance(txMachine* the); extern txSlot* fxNewProgramInstance(txMachine* the); /* xsProperty.c */ extern txSlot* fxNextHostAccessorProperty(txMachine* the, txSlot* property, txCallback get, txCallback set, txID id, txFlag flag); extern txSlot* fxNextHostFunctionProperty(txMachine* the, txSlot* property, txCallback call, txInteger length, txID id, txFlag flag); extern txSlot* fxLastProperty(txMachine* the, txSlot* slot); extern txSlot* fxNextUndefinedProperty(txMachine* the, txSlot* property, txID id, txFlag flag); extern txSlot* fxNextNullProperty(txMachine* the, txSlot* property, txID id, txFlag flag); extern txSlot* fxNextBooleanProperty(txMachine* the, txSlot* property, txBoolean boolean, txID id, txFlag flag); extern txSlot* fxNextIntegerProperty(txMachine* the, txSlot* property, txInteger integer, txID id, txFlag flag); extern txSlot* fxNextNumberProperty(txMachine* the, txSlot* property, txNumber number, txID id, txFlag flag); extern txSlot* fxNextReferenceProperty(txMachine* the, txSlot* property, txSlot* slot, txID id, txFlag flag); extern txSlot* fxNextSlotProperty(txMachine* the, txSlot* property, txSlot* slot, txID id, txFlag flag); extern txSlot* fxNextStringProperty(txMachine* the, txSlot* property, txString string, txID id, txFlag flag); extern txSlot* fxNextStringXProperty(txMachine* the, txSlot* property, txString string, txID id, txFlag flag); extern txSlot* fxNextSymbolProperty(txMachine* the, txSlot* property, txID symbol, txID id, txFlag flag); extern txSlot* fxNextTypeDispatchProperty(txMachine* the, txSlot* property, txTypeDispatch* dispatch, txTypeAtomics* atomics, txID id, txFlag flag); extern txSlot* fxQueueIDKeys(txMachine* the, txSlot* first, txFlag flag, txSlot* keys); extern txSlot* fxQueueIndexKeys(txMachine* the, txSlot* array, txFlag flag, txSlot* keys); extern txSlot* fxQueueKey(txMachine* the, txID id, txIndex index, txSlot* keys); extern txBoolean fxDeleteIndexProperty(txMachine* the, txSlot* array, txIndex index); extern txSlot* fxGetIndexProperty(txMachine* the, txSlot* array, txIndex index); extern txIndex fxGetIndexSize(txMachine* the, txSlot* array); extern txSlot* fxSetIndexProperty(txMachine* the, txSlot* instance, txSlot* array, txIndex index); extern void fxSetIndexSize(txMachine* the, txSlot* array, txIndex target, txBoolean growable); extern txBoolean fxDefinePrivateProperty(txMachine* the, txSlot* instance, txSlot* check, txID id, txSlot* slot, txFlag mask); extern txSlot* fxGetPrivateProperty(txMachine* the, txSlot* instance, txSlot* check, txID id); extern txSlot* fxSetPrivateProperty(txMachine* the, txSlot* instance, txSlot* check, txID id); /* xsGlobal.c */ extern const txBehavior gxGlobalBehavior; extern void fxBuildGlobal(txMachine* the); extern txSlot* fxNewGlobalInstance(txMachine* the); extern txBoolean fxGlobalDeleteProperty(txMachine* the, txSlot* instance, txID id, txIndex index); extern txSlot* fxGlobalGetProperty(txMachine* the, txSlot* instance, txID id, txIndex index, txFlag flag); extern txSlot* fxGlobalSetProperty(txMachine* the, txSlot* instance, txID id, txIndex index, txFlag flag); mxExport void fx_Iterator_iterator(txMachine* the); mxExport void fx_Enumerator(txMachine* the); mxExport void fx_Enumerator_next(txMachine* the); mxExport void fx_decodeURI(txMachine* the); mxExport void fx_decodeURIComponent(txMachine* the); mxExport void fx_encodeURI(txMachine* the); mxExport void fx_encodeURIComponent(txMachine* the); mxExport void fx_escape(txMachine* the); mxExport void fx_eval(txMachine* the); mxExport void fx_trace(txMachine* the); mxExport void fx_trace_center(txMachine* the); mxExport void fx_trace_left(txMachine* the); mxExport void fx_trace_right(txMachine* the); mxExport void fx_unescape(txMachine* the); extern txSlot* fxCheckIteratorInstance(txMachine* the, txSlot* slot, txID id); extern txSlot* fxCheckIteratorResult(txMachine* the, txSlot* result); extern txBoolean fxGetIterator(txMachine* the, txSlot* iterable, txSlot* iterator, txSlot* next, txBoolean optional); extern txBoolean fxIteratorNext(txMachine* the, txSlot* iterator, txSlot* next, txSlot* value); extern void fxIteratorReturn(txMachine* the, txSlot* iterator); extern txSlot* fxNewIteratorInstance(txMachine* the, txSlot* iterable, txID id); mxExport void fxDecodeURI(txMachine* the, txString theSet); mxExport void fxEncodeURI(txMachine* the, txString theSet); /* xsObject.c */ mxExport void fx_Object(txMachine* the); mxExport void fx_Object_prototype___proto__get(txMachine* the); mxExport void fx_Object_prototype___proto__set(txMachine* the); mxExport void fx_Object_prototype___defineGetter__(txMachine* the); mxExport void fx_Object_prototype___defineSetter__(txMachine* the); mxExport void fx_Object_prototype___lookupGetter__(txMachine* the); mxExport void fx_Object_prototype___lookupSetter__(txMachine* the); mxExport void fx_Object_prototype_hasOwnProperty(txMachine* the); mxExport void fx_Object_prototype_isPrototypeOf(txMachine* the); mxExport void fx_Object_prototype_propertyIsEnumerable(txMachine* the); mxExport void fx_Object_prototype_toLocaleString(txMachine* the); mxExport void fx_Object_prototype_toString(txMachine* the); mxExport void fx_Object_prototype_valueOf(txMachine* the); mxExport void fx_Object_assign(txMachine* the); mxExport void fx_Object_copy(txMachine* the); mxExport void fx_Object_create(txMachine* the); mxExport void fx_Object_defineProperties(txMachine* the); mxExport void fx_Object_defineProperty(txMachine* the); mxExport void fx_Object_entries(txMachine* the); mxExport void fx_Object_freeze(txMachine* the); mxExport void fx_Object_fromEntries(txMachine* the); mxExport void fx_Object_getOwnPropertyDescriptor(txMachine* the); mxExport void fx_Object_getOwnPropertyDescriptors(txMachine* the); mxExport void fx_Object_getOwnPropertyNames(txMachine* the); mxExport void fx_Object_getOwnPropertySymbols(txMachine* the); mxExport void fx_Object_getPrototypeOf(txMachine* the); mxExport void fx_Object_hasOwn(txMachine* the); mxExport void fx_Object_is(txMachine* the); mxExport void fx_Object_isExtensible(txMachine* the); mxExport void fx_Object_isFrozen(txMachine* the); mxExport void fx_Object_isSealed(txMachine* the); mxExport void fx_Object_keys(txMachine* the); mxExport void fx_Object_preventExtensions(txMachine* the); mxExport void fx_Object_seal(txMachine* the); mxExport void fx_Object_setPrototypeOf(txMachine* the); mxExport void fx_Object_values(txMachine* the); extern void fxBuildObject(txMachine* the); extern txSlot* fxNewObjectInstance(txMachine* the); extern void fxFreezePropertyStep(txMachine* the, txSlot* context, txID id, txIndex index, txSlot* property); extern void fxIsPropertyFrozenStep(txMachine* the, txSlot* context, txID id, txIndex index, txSlot* property); /* xsFunction.c */ mxExport void fx_Function(txMachine* the); mxExport void fx_Function_prototype_apply(txMachine* the); mxExport void fx_Function_prototype_bind(txMachine* the); mxExport void fx_Function_prototype_bound(txMachine* the); mxExport void fx_Function_prototype_call(txMachine* the); mxExport void fx_Function_prototype_hasInstance(txMachine* the); mxExport void fx_Function_prototype_toString(txMachine* the); extern void fxBuildFunction(txMachine* the); extern void fxDefaultFunctionPrototype(txMachine* the); extern txSlot* fxGetPrototypeFromConstructor(txMachine* the, txSlot* defaultPrototype); mxExport txBoolean fxIsCallable(txMachine* the, txSlot* slot); extern txBoolean fxIsFunction(txMachine* the, txSlot* slot); extern txSlot* fxNewFunctionInstance(txMachine* the, txID name); extern txSlot* fxNewFunctionLength(txMachine* the, txSlot* instance, txNumber length); extern txSlot* fxNewFunctionName(txMachine* the, txSlot* instance, txID id, txIndex index, txID former, txString prefix); extern void fxRenameFunction(txMachine* the, txSlot* function, txID id, txIndex index, txID former, txString prefix); mxExport void fx_AsyncFunction(txMachine* the); extern txSlot* fxNewAsyncInstance(txMachine* the); extern void fxResolveAwait(txMachine* the); extern void fxRejectAwait(txMachine* the); extern void fxRunAsync(txMachine* the, txSlot* instance); /* xsBoolean.c */ mxExport void fx_Boolean(txMachine* the); mxExport void fx_Boolean_prototype_toString(txMachine* the); mxExport void fx_Boolean_prototype_valueOf(txMachine* the); extern void fxBuildBoolean(txMachine* the); extern txSlot* fxNewBooleanInstance(txMachine* the); /* xsSymbol.c */ mxExport void fx_Symbol(txMachine* the); mxExport void fx_Symbol_for(txMachine* the); mxExport void fx_Symbol_keyFor(txMachine* the); mxExport void fx_Symbol_prototype_get_description(txMachine* the); mxExport void fx_Symbol_prototype_toPrimitive(txMachine* the); mxExport void fx_Symbol_prototype_toString(txMachine* the); mxExport void fx_Symbol_prototype_valueOf(txMachine* the); extern void fxBuildSymbol(txMachine* the); extern txSlot* fxNewSymbolInstance(txMachine* the); extern void fxSymbolToString(txMachine* the, txSlot* slot); extern txSlot* fxGetKey(txMachine* the, txID theID); extern char* fxGetKeyName(txMachine* the, txID theID); extern txID fxFindName(txMachine* the, txString theString); extern txBoolean fxIsKeyName(txMachine* the, txID theID); extern txBoolean fxIsKeySymbol(txMachine* the, txID theID); extern txID fxNewName(txMachine* the, txSlot* theSlot); extern txID fxNewNameC(txMachine* the, txString theString); extern txID fxNewNameX(txMachine* the, txString theString); extern txSlot* fxAt(txMachine* the, txSlot* slot); extern void fxKeyAt(txMachine* the, txID id, txIndex index, txSlot* slot); extern void fxIDToString(txMachine* the, txID id, txString theBuffer, txSize theSize); /* xsError.c */ mxExport void fx_Error(txMachine* the); mxExport void fx_Error_toString(txMachine* the); mxExport void fx_AggregateError(txMachine* the); mxExport void fx_EvalError(txMachine* the); mxExport void fx_RangeError(txMachine* the); mxExport void fx_ReferenceError(txMachine* the); mxExport void fx_SyntaxError(txMachine* the); mxExport void fx_TypeError(txMachine* the); mxExport void fx_URIError(txMachine* the); mxExport void fx_Error_prototype_get_stack(txMachine* the); extern void fxBuildError(txMachine* the); extern void fxCaptureErrorStack(txMachine* the, txSlot* internal, txSlot* frame); /* xsNumber.c */ mxExport void fx_isFinite(txMachine* the); mxExport void fx_isNaN(txMachine* the); mxExport void fx_parseFloat(txMachine* the); mxExport void fx_parseInt(txMachine* the); mxExport void fx_Number(txMachine* the); mxExport void fx_Number_isFinite(txMachine* the); mxExport void fx_Number_isInteger(txMachine* the); mxExport void fx_Number_isNaN(txMachine* the); mxExport void fx_Number_isSafeInteger(txMachine* the); mxExport void fx_Number_prototype_toExponential(txMachine* the); mxExport void fx_Number_prototype_toFixed(txMachine* the); mxExport void fx_Number_prototype_toLocaleString(txMachine* the); mxExport void fx_Number_prototype_toPrecision(txMachine* the); mxExport void fx_Number_prototype_toString(txMachine* the); mxExport void fx_Number_prototype_valueOf(txMachine* the); extern void fxBuildNumber(txMachine* the); extern txSlot* fxNewNumberInstance(txMachine* the); extern void fxNumberCoerce(txMachine* the, txSlot* slot); extern void fxIntCoerce(txMachine* the, txSlot* slot); extern void fxUintCoerce(txMachine* the, txSlot* slot); /* xsMath.c */ mxExport void fx_Math_abs(txMachine* the); mxExport void fx_Math_acos(txMachine* the); mxExport void fx_Math_acosh(txMachine* the); mxExport void fx_Math_asin(txMachine* the); mxExport void fx_Math_asinh(txMachine* the); mxExport void fx_Math_atan(txMachine* the); mxExport void fx_Math_atanh(txMachine* the); mxExport void fx_Math_atan2(txMachine* the); mxExport void fx_Math_cbrt(txMachine* the); mxExport void fx_Math_ceil(txMachine* the); mxExport void fx_Math_clz32(txMachine* the); mxExport void fx_Math_cos(txMachine* the); mxExport void fx_Math_cosh(txMachine* the); mxExport void fx_Math_exp(txMachine* the); mxExport void fx_Math_expm1(txMachine* the); mxExport void fx_Math_floor(txMachine* the); mxExport void fx_Math_fround(txMachine* the); mxExport void fx_Math_hypot(txMachine* the); mxExport void fx_Math_idiv(txMachine* the); mxExport void fx_Math_idivmod(txMachine* the); mxExport void fx_Math_imod(txMachine* the); mxExport void fx_Math_imul(txMachine* the); mxExport void fx_Math_imuldiv(txMachine* the); mxExport void fx_Math_irem(txMachine* the); mxExport void fx_Math_log(txMachine* the); mxExport void fx_Math_log1p(txMachine* the); mxExport void fx_Math_log10(txMachine* the); mxExport void fx_Math_log2(txMachine* the); mxExport void fx_Math_max(txMachine* the); mxExport void fx_Math_min(txMachine* the); mxExport void fx_Math_mod(txMachine* the); mxExport void fx_Math_pow(txMachine* the); mxExport void fx_Math_random(txMachine* the); mxExport void fx_Math_random_secure(txMachine* the); mxExport void fx_Math_round(txMachine* the); mxExport void fx_Math_sign(txMachine* the); mxExport void fx_Math_sin(txMachine* the); mxExport void fx_Math_sinh(txMachine* the); mxExport void fx_Math_sqrt(txMachine* the); mxExport void fx_Math_tan(txMachine* the); mxExport void fx_Math_tanh(txMachine* the); mxExport void fx_Math_trunc(txMachine* the); mxExport void fx_Math_toInteger(txMachine* the); extern void fxBuildMath(txMachine* the); extern txNumber fx_pow(txNumber x, txNumber y); /* xsBigInt.c */ mxExport void fx_BigInt(txMachine* the); mxExport void fx_BigInt_asIntN(txMachine* the); mxExport void fx_BigInt_asUintN(txMachine* the); mxExport void fx_BigInt_bitLength(txMachine* the); mxExport void fx_BigInt_fromArrayBuffer(txMachine* the); mxExport void fx_BigInt_prototype_toString(txMachine* the); mxExport void fx_BigInt_prototype_valueOf(txMachine* the); extern void fxBuildBigInt(txMachine* the); extern void fxBigIntCoerce(txMachine* the, txSlot* slot); extern txBoolean fxBigIntCompare(txMachine* the, txBoolean less, txBoolean equal, txBoolean more, txSlot* left, txSlot* right); extern void fxBigIntDecode(txMachine* the, txSize size); extern void fxBigintToArrayBuffer(txMachine* the, txSlot* slot, txU4 minBytes, txBoolean sign, int endian); extern txSlot* fxBigIntToInstance(txMachine* the, txSlot* slot); extern txNumber fxBigIntToNumber(txMachine* the, txSlot* slot); extern void fxBigintToString(txMachine* the, txSlot* slot, txU4 radix); extern txS8 fxToBigInt64(txMachine* the, txSlot* slot); extern txU8 fxToBigUint64(txMachine* the, txSlot* slot); mxExport void fxBigInt(txMachine* the, txSlot* slot, txU1 sign, txU2 size, txU4* data); mxExport void fxBigIntX(txMachine* the, txSlot* slot, txU1 sign, txU2 size, txU4* data); mxExport txBigInt* fxToBigInt(txMachine* the, txSlot* slot, txFlag strict); mxExport void fxFromBigInt64(txMachine* the, txSlot* slot, txS8 value); mxExport void fxFromBigUint64(txMachine* the, txSlot* slot, txU8 value); mxExport txBigInt* fxBigInt_add(txMachine* the, txBigInt* r, txBigInt* a, txBigInt* b); mxExport txBigInt* fxBigInt_and(txMachine* the, txBigInt* r, txBigInt* a, txBigInt* b); mxExport txBigInt* fxBigInt_dec(txMachine* the, txBigInt* r, txBigInt* a); mxExport txBigInt* fxBigInt_div(txMachine* the, txBigInt* r, txBigInt* a, txBigInt* b); mxExport txBigInt* fxBigInt_exp(txMachine* the, txBigInt* r, txBigInt* a, txBigInt* b); mxExport txBigInt* fxBigInt_inc(txMachine* the, txBigInt* r, txBigInt* a); mxExport txBigInt* fxBigInt_lsl(txMachine* the, txBigInt* r, txBigInt* a, txBigInt* b); mxExport txBigInt* fxBigInt_lsr(txMachine* the, txBigInt* r, txBigInt* a, txBigInt* b); mxExport txBigInt* fxBigInt_mul(txMachine* the, txBigInt* r, txBigInt* a, txBigInt* b); mxExport txBigInt* fxBigInt_neg(txMachine* the, txBigInt* r, txBigInt* a); mxExport txBigInt* fxBigInt_nop(txMachine* the, txBigInt* r, txBigInt* a, txBigInt* b); mxExport txBigInt* fxBigInt_not(txMachine* the, txBigInt* r, txBigInt* a); mxExport txBigInt* fxBigInt_or(txMachine* the, txBigInt* r, txBigInt* a, txBigInt* b); mxExport txBigInt* fxBigInt_rem(txMachine* the, txBigInt* r, txBigInt* a, txBigInt* b); mxExport txBigInt* fxBigInt_sub(txMachine* the, txBigInt* r, txBigInt* a, txBigInt* b); mxExport txBigInt* fxBigInt_xor(txMachine* the, txBigInt* r, txBigInt* a, txBigInt* b); mxExport txBigInt *fxBigInt_alloc(txMachine* the, txU4 size); mxExport void fxBigInt_free(txMachine* the, txBigInt*); mxExport int fxBigInt_comp(txBigInt* a, txBigInt* b); mxExport void fxBigInt_copy(txBigInt* a, txBigInt* b); mxExport txBigInt* fxBigInt_mod(txMachine* the, txBigInt* r, txBigInt* a, txBigInt* b); mxExport txBigInt* fxBigInt_sqr(txMachine* the, txBigInt* r, txBigInt* a); mxExport int fxBigInt_iszero(txBigInt *a); mxExport txBigInt *fxBigInt_dup(txMachine* the, txBigInt *a); mxExport int fxBigInt_bitsize(txBigInt *e); mxExport int fxBigInt_ucomp(txBigInt *a, txBigInt *b); mxExport txBigInt *fxBigInt_uand(txMachine* the, txBigInt *r, txBigInt *a, txBigInt *b); mxExport txBigInt *fxBigInt_uor(txMachine* the, txBigInt *r, txBigInt *a, txBigInt *b); mxExport txBigInt *fxBigInt_uxor(txMachine* the, txBigInt *r, txBigInt *a, txBigInt *b); mxExport txBigInt *fxBigInt_ulsl1(txMachine* the, txBigInt *r, txBigInt *a, txU4 sw); mxExport txBigInt *fxBigInt_ulsr1(txMachine* the, txBigInt *r, txBigInt *a, txU4 sw); mxExport txBigInt *fxBigInt_uadd(txMachine* the, txBigInt *rr, txBigInt *aa, txBigInt *bb); mxExport txBigInt *fxBigInt_usub(txMachine* the, txBigInt *rr, txBigInt *aa, txBigInt *bb); mxExport txBigInt *fxBigInt_umul(txMachine* the, txBigInt *rr, txBigInt *aa, txBigInt *bb); mxExport txBigInt *fxBigInt_umul1(txMachine* the, txBigInt *r, txBigInt *a, txU4 b); mxExport txBigInt *fxBigInt_udiv(txMachine* the, txBigInt *q, txBigInt *a, txBigInt *b, txBigInt **r); mxExport int fxBigInt_isset(txBigInt *e, txU4 i); mxExport void fxBigInt_fill0(txBigInt *r); /* xsDate.c */ mxExport void fx_Date(txMachine* the); mxExport void fx_Date_secure(txMachine* the); mxExport void fx_Date_now(txMachine* the); mxExport void fx_Date_now_secure(txMachine* the); mxExport void fx_Date_parse(txMachine* the); mxExport void fx_Date_UTC(txMachine* the); mxExport void fx_Date_prototype_getMilliseconds(txMachine* the); mxExport void fx_Date_prototype_getSeconds(txMachine* the); mxExport void fx_Date_prototype_getMinutes(txMachine* the); mxExport void fx_Date_prototype_getHours(txMachine* the); mxExport void fx_Date_prototype_getDay(txMachine* the); mxExport void fx_Date_prototype_getDate(txMachine* the); mxExport void fx_Date_prototype_getMonth(txMachine* the); mxExport void fx_Date_prototype_getYear(txMachine* the); mxExport void fx_Date_prototype_getFullYear(txMachine* the); mxExport void fx_Date_prototype_getUTCMilliseconds(txMachine* the); mxExport void fx_Date_prototype_getUTCSeconds(txMachine* the); mxExport void fx_Date_prototype_getUTCMinutes(txMachine* the); mxExport void fx_Date_prototype_getUTCHours(txMachine* the); mxExport void fx_Date_prototype_getUTCDay(txMachine* the); mxExport void fx_Date_prototype_getUTCDate(txMachine* the); mxExport void fx_Date_prototype_getUTCMonth(txMachine* the); mxExport void fx_Date_prototype_getUTCFullYear(txMachine* the); mxExport void fx_Date_prototype_getTimezoneOffset(txMachine* the); mxExport void fx_Date_prototype_setMilliseconds(txMachine* the); mxExport void fx_Date_prototype_setSeconds(txMachine* the); mxExport void fx_Date_prototype_setMinutes(txMachine* the); mxExport void fx_Date_prototype_setHours(txMachine* the); mxExport void fx_Date_prototype_setDate(txMachine* the); mxExport void fx_Date_prototype_setMonth(txMachine* the); mxExport void fx_Date_prototype_setYear(txMachine* the); mxExport void fx_Date_prototype_setFullYear(txMachine* the); mxExport void fx_Date_prototype_setTime(txMachine* the); mxExport void fx_Date_prototype_setUTCMilliseconds(txMachine* the); mxExport void fx_Date_prototype_setUTCSeconds(txMachine* the); mxExport void fx_Date_prototype_setUTCMinutes(txMachine* the); mxExport void fx_Date_prototype_setUTCHours(txMachine* the); mxExport void fx_Date_prototype_setUTCDate(txMachine* the); mxExport void fx_Date_prototype_setUTCMonth(txMachine* the); mxExport void fx_Date_prototype_setUTCFullYear(txMachine* the); mxExport void fx_Date_prototype_toDateString(txMachine* the); mxExport void fx_Date_prototype_toISOString(txMachine* the); mxExport void fx_Date_prototype_toJSON(txMachine* the); mxExport void fx_Date_prototype_toPrimitive(txMachine* the); mxExport void fx_Date_prototype_toString(txMachine* the); mxExport void fx_Date_prototype_toTimeString(txMachine* the); mxExport void fx_Date_prototype_toUTCString(txMachine* the); mxExport void fx_Date_prototype_valueOf(txMachine* the); extern void fxBuildDate(txMachine* the); extern txNumber fxDateNow(); /* xsString.c */ extern const txBehavior gxStringBehavior; mxExport void fx_String(txMachine* the); #ifndef mxCESU8 mxExport void fx_String_fromArrayBuffer(txMachine* the); #endif mxExport void fx_String_fromCharCode(txMachine* the); mxExport void fx_String_fromCodePoint(txMachine* the); mxExport void fx_String_raw(txMachine* the); mxExport void fx_String_prototype_at(txMachine* the); mxExport void fx_String_prototype_charAt(txMachine* the); mxExport void fx_String_prototype_charCodeAt(txMachine* the); mxExport void fx_String_prototype_codePointAt(txMachine* the); mxExport void fx_String_prototype_compare(txMachine* the); mxExport void fx_String_prototype_concat(txMachine* the); mxExport void fx_String_prototype_endsWith(txMachine* the); mxExport void fx_String_prototype_includes(txMachine* the); mxExport void fx_String_prototype_indexOf(txMachine* the); mxExport void fx_String_prototype_lastIndexOf(txMachine* the); mxExport void fx_String_prototype_localeCompare(txMachine* the); mxExport void fx_String_prototype_match(txMachine* the); mxExport void fx_String_prototype_matchAll(txMachine* the); mxExport void fx_String_prototype_normalize(txMachine* the); mxExport void fx_String_prototype_padEnd(txMachine* the); mxExport void fx_String_prototype_padStart(txMachine* the); mxExport void fx_String_prototype_repeat(txMachine* the); mxExport void fx_String_prototype_replace(txMachine* the); mxExport void fx_String_prototype_replaceAll(txMachine* the); mxExport void fx_String_prototype_search(txMachine* the); mxExport void fx_String_prototype_slice(txMachine* the); mxExport void fx_String_prototype_split(txMachine* the); mxExport void fx_String_prototype_startsWith(txMachine* the); mxExport void fx_String_prototype_substr(txMachine* the); mxExport void fx_String_prototype_substring(txMachine* the); mxExport void fx_String_prototype_toLowerCase(txMachine* the); mxExport void fx_String_prototype_toUpperCase(txMachine* the); mxExport void fx_String_prototype_trim(txMachine* the); mxExport void fx_String_prototype_trimEnd(txMachine* the); mxExport void fx_String_prototype_trimStart(txMachine* the); mxExport void fx_String_prototype_valueOf(txMachine* the); mxExport void fx_String_prototype_iterator(txMachine* the); mxExport void fx_String_prototype_iterator_next(txMachine* the); mxExport void fxStringAccessorGetter(txMachine* the); mxExport void fxStringAccessorSetter(txMachine* the); extern void fxBuildString(txMachine* the); extern txSlot* fxNewStringInstance(txMachine* the); extern txSlot* fxAccessStringProperty(txMachine* the, txSlot* instance, txInteger index); extern void fxPushSubstitutionString(txMachine* the, txSlot* string, txInteger size, txInteger offset, txSlot* match, txInteger length, txInteger count, txSlot* captures, txSlot* groups, txSlot* replace); /* xsRegExp.c */ mxExport void fx_RegExp(txMachine* the); mxExport void fx_RegExp_prototype_get_dotAll(txMachine* the); mxExport void fx_RegExp_prototype_get_flags(txMachine* the); mxExport void fx_RegExp_prototype_get_global(txMachine* the); mxExport void fx_RegExp_prototype_get_hasIndices(txMachine* the); mxExport void fx_RegExp_prototype_get_ignoreCase(txMachine* the); mxExport void fx_RegExp_prototype_get_multiline(txMachine* the); mxExport void fx_RegExp_prototype_get_source(txMachine* the); mxExport void fx_RegExp_prototype_get_sticky(txMachine* the); mxExport void fx_RegExp_prototype_get_unicode(txMachine* the); mxExport void fx_RegExp_prototype_compile(txMachine* the); mxExport void fx_RegExp_prototype_exec(txMachine* the); mxExport void fx_RegExp_prototype_match(txMachine* the); mxExport void fx_RegExp_prototype_matchAll(txMachine* the); mxExport void fx_RegExp_prototype_matchAll_next(txMachine* the); mxExport void fx_RegExp_prototype_replace(txMachine* the); mxExport void fx_RegExp_prototype_search(txMachine* the); mxExport void fx_RegExp_prototype_split(txMachine* the); mxExport void fx_RegExp_prototype_test(txMachine* the); mxExport void fx_RegExp_prototype_toString(txMachine* the); mxExport void fxInitializeRegExp(txMachine* the); extern void fxBuildRegExp(txMachine* the); extern txBoolean fxIsRegExp(txMachine* the, txSlot* slot); extern txSlot* fxNewRegExpInstance(txMachine* the); extern void fx_String_prototype_toCase(txMachine* the, txBoolean flag); /* xsArguments.c */ extern const txBehavior gxArgumentsSloppyBehavior; extern void fxBuildArguments(txMachine* the); extern txSlot* fxNewArgumentsSloppyInstance(txMachine* the, txIndex count); extern txSlot* fxNewArgumentsStrictInstance(txMachine* the, txIndex count); mxExport void fxThrowTypeError(txMachine* the); /* xsArray.c */ extern const txBehavior gxArrayBehavior; extern void fxBuildArray(txMachine* the); mxExport void fxArrayLengthGetter(txMachine* the); mxExport void fxArrayLengthSetter(txMachine* the); mxExport void fx_Array(txMachine* the); mxExport void fx_Array_from(txMachine* the); mxExport void fx_Array_isArray(txMachine* the); mxExport void fx_Array_of(txMachine* the); mxExport void fx_Array_prototype_at(txMachine* the); mxExport void fx_Array_prototype_concat(txMachine* the); mxExport void fx_Array_prototype_copyWithin(txMachine* the); mxExport void fx_Array_prototype_entries(txMachine* the); mxExport void fx_Array_prototype_every(txMachine* the); mxExport void fx_Array_prototype_fill(txMachine* the); mxExport void fx_Array_prototype_filter(txMachine* the); mxExport void fx_Array_prototype_find(txMachine* the); mxExport void fx_Array_prototype_findIndex(txMachine* the); mxExport void fx_Array_prototype_findLast(txMachine* the); mxExport void fx_Array_prototype_findLastIndex(txMachine* the); mxExport void fx_Array_prototype_flat(txMachine* the); mxExport void fx_Array_prototype_flatMap(txMachine* the); mxExport void fx_Array_prototype_forEach(txMachine* the); mxExport void fx_Array_prototype_includes(txMachine* the); mxExport void fx_Array_prototype_indexOf(txMachine* the); mxExport void fx_Array_prototype_join(txMachine* the); mxExport void fx_Array_prototype_keys(txMachine* the); mxExport void fx_Array_prototype_lastIndexOf(txMachine* the); mxExport void fx_Array_prototype_map(txMachine* the); mxExport void fx_Array_prototype_pop(txMachine* the); mxExport void fx_Array_prototype_push(txMachine* the); mxExport void fx_Array_prototype_reduce(txMachine* the); mxExport void fx_Array_prototype_reduceRight(txMachine* the); mxExport void fx_Array_prototype_reverse(txMachine* the); mxExport void fx_Array_prototype_shift(txMachine* the); mxExport void fx_Array_prototype_slice(txMachine* the); mxExport void fx_Array_prototype_some(txMachine* the); mxExport void fx_Array_prototype_sort(txMachine* the); mxExport void fx_Array_prototype_splice(txMachine* the); mxExport void fx_Array_prototype_toLocaleString(txMachine* the); mxExport void fx_Array_prototype_toString(txMachine* the); mxExport void fx_Array_prototype_unshift(txMachine* the); mxExport void fx_Array_prototype_values(txMachine* the); mxExport void fx_ArrayIterator_prototype_next(txMachine* the); extern txNumber fxArgToIndex(txMachine* the, txInteger argi, txNumber index, txNumber length); extern txNumber fxArgToLastIndex(txMachine* the, txInteger argi, txNumber index, txNumber length); extern txNumber fxArgToRange(txMachine* the, txInteger argi, txNumber index, txNumber min, txNumber max); extern void fxCacheArray(txMachine* the, txSlot* theArray); extern void fxConstructArrayEntry(txMachine* the, txSlot* entry); extern txBoolean fxIsArray(txMachine* the, txSlot* instance); extern txSlot* fxNewArrayInstance(txMachine* the); extern void fxSortArrayItems(txMachine* the, txSlot* function, txSlot* array, txNumber LENGTH); extern txNumber fxToLength(txMachine* the, txSlot* slot); /* xsDataView.c */ enum { EndianNative = 0, EndianLittle = 1, EndianBig = 2 }; extern int fxBigInt64Compare(const void* p, const void* q); extern void fxBigInt64Getter(txMachine* the, txSlot* data, txInteger offset, txSlot* slot, int endian); extern void fxBigInt64Setter(txMachine* the, txSlot* data, txInteger offset, txSlot* slot, int endian); extern int fxBigUint64Compare(const void* p, const void* q); extern void fxBigUint64Getter(txMachine* the, txSlot* data, txInteger offset, txSlot* slot, int endian); extern void fxBigUint64Setter(txMachine* the, txSlot* data, txInteger offset, txSlot* slot, int endian); extern int fxFloat32Compare(const void* p, const void* q); extern void fxFloat32Getter(txMachine* the, txSlot* data, txInteger offset, txSlot* slot, int endian); extern void fxFloat32Setter(txMachine* the, txSlot* data, txInteger offset, txSlot* slot, int endian); extern int fxFloat64Compare(const void* p, const void* q); extern void fxFloat64Getter(txMachine* the, txSlot* data, txInteger offset, txSlot* slot, int endian); extern void fxFloat64Setter(txMachine* the, txSlot* data, txInteger offset, txSlot* slot, int endian); extern int fxInt8Compare(const void* p, const void* q); extern void fxInt8Getter(txMachine* the, txSlot* data, txInteger offset, txSlot* slot, int endian); extern void fxInt8Setter(txMachine* the, txSlot* data, txInteger offset, txSlot* slot, int endian); extern int fxInt16Compare(const void* p, const void* q); extern void fxInt16Getter(txMachine* the, txSlot* data, txInteger offset, txSlot* slot, int endian); extern void fxInt16Setter(txMachine* the, txSlot* data, txInteger offset, txSlot* slot, int endian); extern int fxInt32Compare(const void* p, const void* q); extern void fxInt32Getter(txMachine* the, txSlot* data, txInteger offset, txSlot* slot, int endian); extern void fxInt32Setter(txMachine* the, txSlot* data, txInteger offset, txSlot* slot, int endian); extern int fxUint8Compare(const void* p, const void* q); extern void fxUint8Getter(txMachine* the, txSlot* data, txInteger offset, txSlot* slot, int endian); extern void fxUint8Setter(txMachine* the, txSlot* data, txInteger offset, txSlot* slot, int endian); extern int fxUint16Compare(const void* p, const void* q); extern void fxUint16Getter(txMachine* the, txSlot* data, txInteger offset, txSlot* slot, int endian); extern void fxUint16Setter(txMachine* the, txSlot* data, txInteger offset, txSlot* slot, int endian); extern int fxUint32Compare(const void* p, const void* q); extern void fxUint32Getter(txMachine* the, txSlot* data, txInteger offset, txSlot* slot, int endian); extern void fxUint32Setter(txMachine* the, txSlot* data, txInteger offset, txSlot* slot, int endian); extern void fxUint8ClampedSetter(txMachine* the, txSlot* data, txInteger offset, txSlot* slot, int endian); mxExport void *fxArrayBuffer(txMachine* the, txSlot* slot, void* data, txInteger byteLength, txInteger maxByteLength); mxExport void fxGetArrayBufferData(txMachine* the, txSlot* slot, txInteger byteOffset, void* data, txInteger byteLength); mxExport txInteger fxGetArrayBufferLength(txMachine* the, txSlot* slot); mxExport txInteger fxGetArrayBufferMaxLength(txMachine* the, txSlot* slot); mxExport void fxSetArrayBufferData(txMachine* the, txSlot* slot, txInteger byteOffset, void* data, txInteger byteLength); mxExport void fxSetArrayBufferLength(txMachine* the, txSlot* slot, txInteger byteLength); mxExport void* fxToArrayBuffer(txMachine* the, txSlot* slot); mxExport void fx_ArrayBuffer(txMachine* the); mxExport void fx_ArrayBuffer_fromBigInt(txMachine* the); #ifndef mxCESU8 mxExport void fx_ArrayBuffer_fromString(txMachine* the); #endif mxExport void fx_ArrayBuffer_isView(txMachine* the); mxExport void fx_ArrayBuffer_prototype_get_byteLength(txMachine* the); mxExport void fx_ArrayBuffer_prototype_get_maxByteLength(txMachine* the); mxExport void fx_ArrayBuffer_prototype_get_resizable(txMachine* the); mxExport void fx_ArrayBuffer_prototype_concat(txMachine* the); mxExport void fx_ArrayBuffer_prototype_resize(txMachine* the); mxExport void fx_ArrayBuffer_prototype_slice(txMachine* the); mxExport void fx_ArrayBuffer_prototype_transfer(txMachine* the); mxExport void fx_DataView(txMachine* the); mxExport void fx_DataView_prototype_buffer_get(txMachine* the); mxExport void fx_DataView_prototype_byteLength_get(txMachine* the); mxExport void fx_DataView_prototype_byteOffset_get(txMachine* the); mxExport void fx_DataView_prototype_getBigInt64(txMachine* the); mxExport void fx_DataView_prototype_getBigUint64(txMachine* the); mxExport void fx_DataView_prototype_getFloat32(txMachine* the); mxExport void fx_DataView_prototype_getFloat64(txMachine* the); mxExport void fx_DataView_prototype_getInt8(txMachine* the); mxExport void fx_DataView_prototype_getInt16(txMachine* the); mxExport void fx_DataView_prototype_getInt32(txMachine* the); mxExport void fx_DataView_prototype_getUint8(txMachine* the); mxExport void fx_DataView_prototype_getUint16(txMachine* the); mxExport void fx_DataView_prototype_getUint32(txMachine* the); mxExport void fx_DataView_prototype_setBigInt64(txMachine* the); mxExport void fx_DataView_prototype_setBigUint64(txMachine* the); mxExport void fx_DataView_prototype_setFloat32(txMachine* the); mxExport void fx_DataView_prototype_setFloat64(txMachine* the); mxExport void fx_DataView_prototype_setInt8(txMachine* the); mxExport void fx_DataView_prototype_setInt16(txMachine* the); mxExport void fx_DataView_prototype_setInt32(txMachine* the); mxExport void fx_DataView_prototype_setUint8(txMachine* the); mxExport void fx_DataView_prototype_setUint16(txMachine* the); mxExport void fx_DataView_prototype_setUint32(txMachine* the); mxExport const txTypeDispatch gxTypeDispatches[]; mxExport const txBehavior gxTypedArrayBehavior; mxExport void fxTypedArrayGetter(txMachine* the); mxExport void fxTypedArraySetter(txMachine* the); mxExport void fx_TypedArray(txMachine* the); mxExport void fx_TypedArray_from(txMachine* the); mxExport void fx_TypedArray_of(txMachine* the); mxExport void fx_TypedArray_prototype_at(txMachine* the); mxExport void fx_TypedArray_prototype_buffer_get(txMachine* the); mxExport void fx_TypedArray_prototype_byteLength_get(txMachine* the); mxExport void fx_TypedArray_prototype_byteOffset_get(txMachine* the); mxExport void fx_TypedArray_prototype_copyWithin(txMachine* the); mxExport void fx_TypedArray_prototype_entries(txMachine* the); mxExport void fx_TypedArray_prototype_every(txMachine* the); mxExport void fx_TypedArray_prototype_fill(txMachine* the); mxExport void fx_TypedArray_prototype_filter(txMachine* the); mxExport void fx_TypedArray_prototype_find(txMachine* the); mxExport void fx_TypedArray_prototype_findIndex(txMachine* the); mxExport void fx_TypedArray_prototype_findLast(txMachine* the); mxExport void fx_TypedArray_prototype_findLastIndex(txMachine* the); mxExport void fx_TypedArray_prototype_forEach(txMachine* the); mxExport void fx_TypedArray_prototype_includes(txMachine* the); mxExport void fx_TypedArray_prototype_indexOf(txMachine* the); mxExport void fx_TypedArray_prototype_join(txMachine* the); mxExport void fx_TypedArray_prototype_keys(txMachine* the); mxExport void fx_TypedArray_prototype_lastIndexOf(txMachine* the); mxExport void fx_TypedArray_prototype_length_get(txMachine* the); mxExport void fx_TypedArray_prototype_map(txMachine* the); mxExport void fx_TypedArray_prototype_reduce(txMachine* the); mxExport void fx_TypedArray_prototype_reduceRight(txMachine* the); mxExport void fx_TypedArray_prototype_reverse(txMachine* the); mxExport void fx_TypedArray_prototype_set(txMachine* the); mxExport void fx_TypedArray_prototype_slice(txMachine* the); mxExport void fx_TypedArray_prototype_some(txMachine* the); mxExport void fx_TypedArray_prototype_sort(txMachine* the); mxExport void fx_TypedArray_prototype_subarray(txMachine* the); mxExport void fx_TypedArray_prototype_toLocaleString(txMachine* the); mxExport void fx_TypedArray_prototype_toStringTag_get(txMachine* the); mxExport void fx_TypedArray_prototype_values(txMachine* the); extern void fxBuildDataView(txMachine* the); extern void fxConstructArrayBufferResult(txMachine* the, txSlot* constructor, txInteger length); extern txInteger fxArgToByteLength(txMachine* the, txInteger argi, txInteger length); extern txInteger fxGetDataViewSize(txMachine* the, txSlot* view, txSlot* buffer); /* xsAtomics.c */ extern void fxInt8Add(txMachine* the, txSlot* host, txInteger offset, txSlot* slot, int endian); extern void fxInt16Add(txMachine* the, txSlot* host, txInteger offset, txSlot* slot, int endian); extern void fxInt32Add(txMachine* the, txSlot* host, txInteger offset, txSlot* slot, int endian); extern void fxInt64Add(txMachine* the, txSlot* host, txInteger offset, txSlot* slot, int endian); extern void fxUint8Add(txMachine* the, txSlot* host, txInteger offset, txSlot* slot, int endian); extern void fxUint16Add(txMachine* the, txSlot* host, txInteger offset, txSlot* slot, int endian); extern void fxUint32Add(txMachine* the, txSlot* host, txInteger offset, txSlot* slot, int endian); extern void fxUint64Add(txMachine* the, txSlot* host, txInteger offset, txSlot* slot, int endian); extern void fxInt8And(txMachine* the, txSlot* host, txInteger offset, txSlot* slot, int endian); extern void fxInt16And(txMachine* the, txSlot* host, txInteger offset, txSlot* slot, int endian); extern void fxInt32And(txMachine* the, txSlot* host, txInteger offset, txSlot* slot, int endian); extern void fxInt64And(txMachine* the, txSlot* host, txInteger offset, txSlot* slot, int endian); extern void fxUint8And(txMachine* the, txSlot* host, txInteger offset, txSlot* slot, int endian); extern void fxUint16And(txMachine* the, txSlot* host, txInteger offset, txSlot* slot, int endian); extern void fxUint32And(txMachine* the, txSlot* host, txInteger offset, txSlot* slot, int endian); extern void fxUint64And(txMachine* the, txSlot* host, txInteger offset, txSlot* slot, int endian); extern void fxInt8CompareExchange(txMachine* the, txSlot* host, txInteger offset, txSlot* slot, int endian); extern void fxInt16CompareExchange(txMachine* the, txSlot* host, txInteger offset, txSlot* slot, int endian); extern void fxInt32CompareExchange(txMachine* the, txSlot* host, txInteger offset, txSlot* slot, int endian); extern void fxInt64CompareExchange(txMachine* the, txSlot* host, txInteger offset, txSlot* slot, int endian); extern void fxUint8CompareExchange(txMachine* the, txSlot* host, txInteger offset, txSlot* slot, int endian); extern void fxUint16CompareExchange(txMachine* the, txSlot* host, txInteger offset, txSlot* slot, int endian); extern void fxUint32CompareExchange(txMachine* the, txSlot* host, txInteger offset, txSlot* slot, int endian); extern void fxUint64CompareExchange(txMachine* the, txSlot* host, txInteger offset, txSlot* slot, int endian); extern void fxInt8Exchange(txMachine* the, txSlot* host, txInteger offset, txSlot* slot, int endian); extern void fxInt16Exchange(txMachine* the, txSlot* host, txInteger offset, txSlot* slot, int endian); extern void fxInt32Exchange(txMachine* the, txSlot* host, txInteger offset, txSlot* slot, int endian); extern void fxInt64Exchange(txMachine* the, txSlot* host, txInteger offset, txSlot* slot, int endian); extern void fxUint8Exchange(txMachine* the, txSlot* host, txInteger offset, txSlot* slot, int endian); extern void fxUint16Exchange(txMachine* the, txSlot* host, txInteger offset, txSlot* slot, int endian); extern void fxUint32Exchange(txMachine* the, txSlot* host, txInteger offset, txSlot* slot, int endian); extern void fxUint64Exchange(txMachine* the, txSlot* host, txInteger offset, txSlot* slot, int endian); extern void fxInt8Load(txMachine* the, txSlot* host, txInteger offset, txSlot* slot, int endian); extern void fxInt16Load(txMachine* the, txSlot* host, txInteger offset, txSlot* slot, int endian); extern void fxInt32Load(txMachine* the, txSlot* host, txInteger offset, txSlot* slot, int endian); extern void fxInt64Load(txMachine* the, txSlot* host, txInteger offset, txSlot* slot, int endian); extern void fxUint8Load(txMachine* the, txSlot* host, txInteger offset, txSlot* slot, int endian); extern void fxUint16Load(txMachine* the, txSlot* host, txInteger offset, txSlot* slot, int endian); extern void fxUint32Load(txMachine* the, txSlot* host, txInteger offset, txSlot* slot, int endian); extern void fxUint64Load(txMachine* the, txSlot* host, txInteger offset, txSlot* slot, int endian); extern void fxInt8Or(txMachine* the, txSlot* host, txInteger offset, txSlot* slot, int endian); extern void fxInt16Or(txMachine* the, txSlot* host, txInteger offset, txSlot* slot, int endian); extern void fxInt32Or(txMachine* the, txSlot* host, txInteger offset, txSlot* slot, int endian); extern void fxInt64Or(txMachine* the, txSlot* host, txInteger offset, txSlot* slot, int endian); extern void fxUint8Or(txMachine* the, txSlot* host, txInteger offset, txSlot* slot, int endian); extern void fxUint16Or(txMachine* the, txSlot* host, txInteger offset, txSlot* slot, int endian); extern void fxUint32Or(txMachine* the, txSlot* host, txInteger offset, txSlot* slot, int endian); extern void fxUint64Or(txMachine* the, txSlot* host, txInteger offset, txSlot* slot, int endian); extern void fxInt8Store(txMachine* the, txSlot* host, txInteger offset, txSlot* slot, int endian); extern void fxInt16Store(txMachine* the, txSlot* host, txInteger offset, txSlot* slot, int endian); extern void fxInt32Store(txMachine* the, txSlot* host, txInteger offset, txSlot* slot, int endian); extern void fxInt64Store(txMachine* the, txSlot* host, txInteger offset, txSlot* slot, int endian); extern void fxUint8Store(txMachine* the, txSlot* host, txInteger offset, txSlot* slot, int endian); extern void fxUint16Store(txMachine* the, txSlot* host, txInteger offset, txSlot* slot, int endian); extern void fxUint32Store(txMachine* the, txSlot* host, txInteger offset, txSlot* slot, int endian); extern void fxUint64Store(txMachine* the, txSlot* host, txInteger offset, txSlot* slot, int endian); extern void fxInt8Sub(txMachine* the, txSlot* host, txInteger offset, txSlot* slot, int endian); extern void fxInt16Sub(txMachine* the, txSlot* host, txInteger offset, txSlot* slot, int endian); extern void fxInt32Sub(txMachine* the, txSlot* host, txInteger offset, txSlot* slot, int endian); extern void fxInt64Sub(txMachine* the, txSlot* host, txInteger offset, txSlot* slot, int endian); extern void fxUint8Sub(txMachine* the, txSlot* host, txInteger offset, txSlot* slot, int endian); extern void fxUint16Sub(txMachine* the, txSlot* host, txInteger offset, txSlot* slot, int endian); extern void fxUint32Sub(txMachine* the, txSlot* host, txInteger offset, txSlot* slot, int endian); extern void fxUint64Sub(txMachine* the, txSlot* host, txInteger offset, txSlot* slot, int endian); extern void fxInt8Xor(txMachine* the, txSlot* host, txInteger offset, txSlot* slot, int endian); extern void fxInt16Xor(txMachine* the, txSlot* host, txInteger offset, txSlot* slot, int endian); extern void fxInt32Xor(txMachine* the, txSlot* host, txInteger offset, txSlot* slot, int endian); extern void fxInt64Xor(txMachine* the, txSlot* host, txInteger offset, txSlot* slot, int endian); extern void fxUint8Xor(txMachine* the, txSlot* host, txInteger offset, txSlot* slot, int endian); extern void fxUint16Xor(txMachine* the, txSlot* host, txInteger offset, txSlot* slot, int endian); extern void fxUint32Xor(txMachine* the, txSlot* host, txInteger offset, txSlot* slot, int endian); extern void fxUint64Xor(txMachine* the, txSlot* host, txInteger offset, txSlot* slot, int endian); extern txInteger fxInt32Wait(txMachine* the, txSlot* host, txInteger offset, txSlot* slot, txNumber timeout); extern txInteger fxInt64Wait(txMachine* the, txSlot* host, txInteger offset, txSlot* slot, txNumber timeout); mxExport const txTypeAtomics gxTypeAtomics[]; extern void fxBuildAtomics(txMachine* the); mxExport void fx_SharedArrayBuffer(txMachine* the); mxExport void fx_SharedArrayBuffer_prototype_get_byteLength(txMachine* the); mxExport void fx_SharedArrayBuffer_prototype_get_growable(txMachine* the); mxExport void fx_SharedArrayBuffer_prototype_get_maxByteLength(txMachine* the); mxExport void fx_SharedArrayBuffer_prototype_grow(txMachine* the); mxExport void fx_SharedArrayBuffer_prototype_slice(txMachine* the); mxExport void fx_Atomics_add(txMachine* the); mxExport void fx_Atomics_and(txMachine* the); mxExport void fx_Atomics_compareExchange(txMachine* the); mxExport void fx_Atomics_exchange(txMachine* the); mxExport void fx_Atomics_isLockFree(txMachine* the); mxExport void fx_Atomics_load(txMachine* the); mxExport void fx_Atomics_or(txMachine* the); mxExport void fx_Atomics_notify(txMachine* the); mxExport void fx_Atomics_store(txMachine* the); mxExport void fx_Atomics_sub(txMachine* the); mxExport void fx_Atomics_wait(txMachine* the); mxExport void fx_Atomics_xor(txMachine* the); /* xsMapSet.c */ mxExport void fx_Map(txMachine* the); mxExport void fx_Map_prototype_clear(txMachine* the); mxExport void fx_Map_prototype_delete(txMachine* the); mxExport void fx_Map_prototype_entries(txMachine* the); mxExport void fx_Map_prototype_forEach(txMachine* the); mxExport void fx_Map_prototype_get(txMachine* the); mxExport void fx_Map_prototype_has(txMachine* the); mxExport void fx_Map_prototype_keys(txMachine* the); mxExport void fx_Map_prototype_set(txMachine* the); mxExport void fx_Map_prototype_size(txMachine* the); mxExport void fx_Map_prototype_values(txMachine* the); mxExport void fx_MapIterator_prototype_next(txMachine* the); mxExport void fx_Set(txMachine* the); mxExport void fx_Set_prototype_add(txMachine* the); mxExport void fx_Set_prototype_clear(txMachine* the); mxExport void fx_Set_prototype_delete(txMachine* the); mxExport void fx_Set_prototype_entries(txMachine* the); mxExport void fx_Set_prototype_forEach(txMachine* the); mxExport void fx_Set_prototype_has(txMachine* the); mxExport void fx_Set_prototype_size(txMachine* the); mxExport void fx_Set_prototype_values(txMachine* the); mxExport void fx_SetIterator_prototype_next(txMachine* the); mxExport void fx_WeakMap(txMachine* the); mxExport void fx_WeakMap_prototype_delete(txMachine* the); mxExport void fx_WeakMap_prototype_get(txMachine* the); mxExport void fx_WeakMap_prototype_has(txMachine* the); mxExport void fx_WeakMap_prototype_set(txMachine* the); mxExport void fx_WeakSet(txMachine* the); mxExport void fx_WeakSet_prototype_add(txMachine* the); mxExport void fx_WeakSet_prototype_delete(txMachine* the); mxExport void fx_WeakSet_prototype_has(txMachine* the); mxExport void fx_WeakRef(txMachine* the); mxExport void fx_WeakRef_prototype_deref(txMachine* the); mxExport void fx_FinalizationRegistry(txMachine* the); //mxExport void fx_FinalizationRegistry_prototype_cleanupSome(txMachine* the); mxExport void fx_FinalizationRegistry_prototype_register(txMachine* the); mxExport void fx_FinalizationRegistry_prototype_unregister(txMachine* the); extern void fxBuildMapSet(txMachine* the); extern txSlot* fxNewMapInstance(txMachine* the); extern txSlot* fxNewSetInstance(txMachine* the); extern txSlot* fxNewWeakMapInstance(txMachine* the); extern txSlot* fxNewWeakSetInstance(txMachine* the); extern void fxCleanupFinalizationRegistries(txMachine* the); extern txU4 fxSumEntry(txMachine* the, txSlot* slot); /* xsJSON.c */ mxExport void fx_JSON_parse(txMachine* the); mxExport void fx_JSON_stringify(txMachine* the); extern void fxBuildJSON(txMachine* the); /* xsGenerator.c */ mxExport void fx_Generator(txMachine* the); mxExport void fx_Generator_prototype_next(txMachine* the); mxExport void fx_Generator_prototype_return(txMachine* the); mxExport void fx_Generator_prototype_throw(txMachine* the); mxExport void fx_GeneratorFunction(txMachine* the); mxExport void fx_AsyncGenerator(txMachine* the); mxExport void fx_AsyncGenerator_prototype_next(txMachine* the); mxExport void fx_AsyncGenerator_prototype_return(txMachine* the); mxExport void fx_AsyncGenerator_prototype_throw(txMachine* the); mxExport void fx_AsyncGeneratorFunction(txMachine* the); mxExport void fx_AsyncIterator_asyncIterator(txMachine* the); mxExport void fx_AsyncFromSyncIterator_prototype_next(txMachine* the); mxExport void fx_AsyncFromSyncIterator_prototype_return(txMachine* the); mxExport void fx_AsyncFromSyncIterator_prototype_throw(txMachine* the); extern void fxBuildGenerator(txMachine* the); extern txSlot* fxNewGeneratorInstance(txMachine* the); extern txSlot* fxNewGeneratorFunctionInstance(txMachine* the, txID name); extern txSlot* fxNewAsyncGeneratorInstance(txMachine* the); extern txSlot* fxNewAsyncGeneratorFunctionInstance(txMachine* the, txID name); extern txSlot* fxNewAsyncFromSyncIteratorInstance(txMachine* the); extern void fxAsyncGeneratorRejectAwait(txMachine* the); extern void fxAsyncGeneratorRejectYield(txMachine* the); extern void fxAsyncGeneratorResolveAwait(txMachine* the); extern void fxAsyncGeneratorResolveYield(txMachine* the); extern void fxAsyncFromSyncIteratorDone(txMachine* the); /* xsPromise.c */ mxExport void fx_Promise(txMachine* the); mxExport void fx_Promise_all(txMachine* the); mxExport void fx_Promise_allSettled(txMachine* the); mxExport void fx_Promise_any(txMachine* the); mxExport void fx_Promise_race(txMachine* the); mxExport void fx_Promise_reject(txMachine* the); mxExport void fx_Promise_resolve(txMachine* the); mxExport void fx_Promise_prototype_catch(txMachine* the); mxExport void fx_Promise_prototype_finally(txMachine* the); mxExport void fx_Promise_prototype_then(txMachine* the); mxExport void fxOnRejectedPromise(txMachine* the); mxExport void fxOnResolvedPromise(txMachine* the); mxExport void fxOnThenable(txMachine* the); extern void fx_Promise_resolveAux(txMachine* the); extern void fx_Promise_prototype_finallyAux(txMachine* the); extern void fx_Promise_prototype_finallyReturn(txMachine* the); extern void fx_Promise_prototype_finallyThrow(txMachine* the); extern void fxBuildPromise(txMachine* the); extern void fxCheckUnhandledRejections(txMachine* the, txBoolean atExit); extern void fxCombinePromisesCallback(txMachine* the); extern txSlot* fxNewPromiseCapability(txMachine* the, txSlot* resolveFunction, txSlot* rejectFunction); extern void fxNewPromiseCapabilityCallback(txMachine* the); extern txSlot* fxNewPromiseInstance(txMachine* the); extern void fxPromiseThen(txMachine* the, txSlot* promise, txSlot* onFullfilled, txSlot* onRejected, txSlot* resolveFunction, txSlot* rejectFunction); extern void fxPushPromiseFunctions(txMachine* the, txSlot* promise); extern void fxQueueJob(txMachine* the, txInteger count, txSlot* promise); extern void fxRejectException(txMachine* the, txSlot* rejectFunction); extern void fxRejectPromise(txMachine* the); extern void fxResolvePromise(txMachine* the); extern void fxRunPromiseJobs(txMachine* the); /* xsProxy.c */ extern void fxBuildProxy(txMachine* the); mxExport const txBehavior gxProxyBehavior; mxExport void fxProxyGetter(txMachine* the); mxExport void fxProxySetter(txMachine* the); mxExport void fx_Proxy(txMachine* the); mxExport void fx_Proxy_revocable(txMachine* the); mxExport void fx_Proxy_revoke(txMachine* the); mxExport void fx_Reflect_apply(txMachine* the); mxExport void fx_Reflect_construct(txMachine* the); mxExport void fx_Reflect_defineProperty(txMachine* the); mxExport void fx_Reflect_deleteProperty(txMachine* the); mxExport void fx_Reflect_get(txMachine* the); mxExport void fx_Reflect_getOwnPropertyDescriptor(txMachine* the); mxExport void fx_Reflect_getPrototypeOf(txMachine* the); mxExport void fx_Reflect_has(txMachine* the); mxExport void fx_Reflect_isExtensible(txMachine* the); mxExport void fx_Reflect_ownKeys(txMachine* the); mxExport void fx_Reflect_preventExtensions(txMachine* the); mxExport void fx_Reflect_set(txMachine* the); mxExport void fx_Reflect_setPrototypeOf(txMachine* the); /* xsModule.c */ extern const txBehavior gxModuleBehavior; extern void fxBuildModule(txMachine* the); extern txBoolean fxIsLoadingModule(txMachine* the, txSlot* realm, txID moduleID); extern void fxRunModule(txMachine* the, txSlot* realm, txID moduleID, txScript* script); extern void fxExecuteModulesFulfilled(txMachine* the); extern void fxExecuteModulesRejected(txMachine* the); extern void fxLoadModulesFulfilled(txMachine* the); extern void fxLoadModulesRejected(txMachine* the); extern void fxPrepareModule(txMachine* the, txFlag flag); extern void fxPrepareTransfer(txMachine* the); extern void fxResolveModule(txMachine* the, txSlot* module, txID moduleID, txScript* script, void* data, txDestructor destructor); extern void fxRunImport(txMachine* the, txSlot* realm, txID id); mxExport void fxModuleGetter(txMachine* the); mxExport void fx_Compartment(txMachine* the); mxExport void fx_Compartment_prototype_get_globalThis(txMachine* the); mxExport void fx_Compartment_prototype_evaluate(txMachine* the); mxExport void fx_Compartment_prototype_import(txMachine* the); mxExport void fx_Compartment_prototype_importNow(txMachine* the); mxExport void fx_ModuleSource(txMachine* the); mxExport void fx_ModuleSource_prototype_get_bindings(txMachine* the); mxExport void fx_ModuleSource_prototype_get_needsImport(txMachine* the); mxExport void fx_ModuleSource_prototype_get_needsImportMeta(txMachine* the); mxExport void fxExecuteVirtualModuleSource(txMachine* the); mxExport void fxExecuteVirtualModuleSourceImport(txMachine* the); /* xsLockdown.c */ #ifdef mxLockdown mxExport void fx_harden(txMachine* the); mxExport void fx_lockdown(txMachine* the); mxExport void fx_petrify(txMachine* the); mxExport void fx_mutabilities(txMachine* the); #endif /* xsProfile.c */ #ifdef mxProfile extern void fxCheckProfiler(txMachine* the, txSlot* frame); extern void fxCreateProfiler(txMachine* the); extern void fxDeleteProfiler(txMachine* the, void* stream); extern void fxResumeProfiler(txMachine* the); extern void fxSuspendProfiler(txMachine* the); #endif enum { XS_NO_ERROR = 0, XS_UNKNOWN_ERROR, XS_EVAL_ERROR, XS_RANGE_ERROR, XS_REFERENCE_ERROR, XS_SYNTAX_ERROR, XS_TYPE_ERROR, XS_URI_ERROR, XS_AGGREGATE_ERROR, XS_ERROR_COUNT }; enum { XS_IMMUTABLE = 0, XS_MUTABLE = 1, }; enum { XS_CHUNK = 0, XS_GROWABLE_CHUNK = 1, }; enum { XS_NO_STATUS = 0, XS_RETURN_STATUS = 1, XS_THROW_STATUS = 2, XS_NO_HINT = 0, XS_NUMBER_HINT = 1, XS_STRING_HINT = 2, XS_NO_FLAG = 0, XS_ASYNC_FLAG = 1, XS_IMPORT_NAMESPACE = 0, XS_IMPORT_DEFAULT = 1, XS_IMPORT_PREFLIGHT = 2, XS_IMPORT_ASYNC = 4, XS_OWN = 0, XS_ANY = 1, /* frame flags */ /* ? = 1, */ XS_C_FLAG = 2, XS_FIELD_FLAG = 4, XS_STEP_INTO_FLAG = 8, XS_STEP_OVER_FLAG = 16, XS_STRICT_FLAG = 32, XS_DEBUG_FLAG = 64, XS_MARK_FLAG = 128, /* instance flags */ XS_EXOTIC_FLAG = 1, XS_CAN_CALL_FLAG = 2, XS_CAN_CONSTRUCT_FLAG = 4, XS_DONT_MODIFY_FLAG = 8, XS_DONT_PATCH_FLAG = 16, XS_LEVEL_FLAG = 32, XS_DONT_MARSHALL_FLAG = 64, /* XS_MARK_FLAG = 128, */ /* property flags */ XS_INTERNAL_FLAG = 1, /* XS_DONT_DELETE_FLAG = 2, */ /* XS_DONT_ENUM_FLAG = 4, */ /* XS_DONT_SET_FLAG = 8 , */ XS_INSPECTOR_FLAG = 16, XS_BASE_FLAG = 32, XS_DERIVED_FLAG = 64, /* XS_MARK_FLAG = 128, */ /* mxBehaviorOwnKeys flags */ XS_EACH_NAME_FLAG = 1, XS_EACH_SYMBOL_FLAG = 2, /* mxBehaviorDefineOwnProperty flags */ /* XS_NAME_FLAG = 1, */ /* XS_DONT_DELETE_FLAG = 2, */ /* XS_DONT_ENUM_FLAG = 4, */ /* XS_DONT_SET_FLAG = 8, */ /* XS_METHOD_FLAG = 16, */ /* XS_GETTER_FLAG = 32, */ /* XS_SETTER_FLAG = 64, */ XS_ACCESSOR_FLAG = XS_GETTER_FLAG | XS_SETTER_FLAG, XS_GET_ONLY = XS_DONT_DELETE_FLAG | XS_DONT_ENUM_FLAG | XS_DONT_SET_FLAG, /* collect flags */ XS_COMPACT_FLAG = 1, XS_ORGANIC_FLAG = 2, XS_COLLECTING_FLAG = 4, XS_TRASHING_FLAG = 8, XS_SKIPPED_COLLECT_FLAG = 16, XS_HOST_CHUNK_FLAG = 32, XS_HOST_HOOKS_FLAG = 64, /* finalization registry flags */ XS_FINALIZATION_REGISTRY_CHANGED = 1, /* bubble flags */ XS_BUBBLE_LEFT = 1, XS_BUBBLE_RIGHT = 2, XS_BUBBLE_BINARY = 4, }; enum { XS_UNINITIALIZED_KIND = -1, XS_UNDEFINED_KIND = 0, XS_NULL_KIND, XS_BOOLEAN_KIND, XS_INTEGER_KIND, XS_NUMBER_KIND, XS_STRING_KIND, // 5 XS_STRING_X_KIND, XS_SYMBOL_KIND, XS_BIGINT_KIND, XS_BIGINT_X_KIND, XS_REFERENCE_KIND, //10 XS_CLOSURE_KIND, XS_FRAME_KIND, XS_INSTANCE_KIND, XS_ARGUMENTS_SLOPPY_KIND, XS_ARGUMENTS_STRICT_KIND, // 15 XS_ARRAY_KIND, XS_ARRAY_BUFFER_KIND, XS_CALLBACK_KIND, XS_CODE_KIND, XS_CODE_X_KIND, // 20 XS_DATE_KIND, XS_DATA_VIEW_KIND, XS_FINALIZATION_CELL_KIND, XS_FINALIZATION_REGISTRY_KIND, XS_GLOBAL_KIND, // 25 XS_HOST_KIND, XS_MAP_KIND, XS_MODULE_KIND, XS_PROGRAM_KIND, XS_PROMISE_KIND, // 30 XS_PROXY_KIND, XS_REGEXP_KIND, XS_SET_KIND, XS_TYPED_ARRAY_KIND, XS_WEAK_MAP_KIND, // 35 XS_WEAK_REF_KIND, XS_WEAK_SET_KIND, XS_ACCESSOR_KIND, XS_AT_KIND, XS_ENTRY_KIND, //40 XS_ERROR_KIND, XS_HOME_KIND, XS_KEY_KIND, XS_KEY_X_KIND, XS_LIST_KIND, // 45 XS_PRIVATE_KIND, XS_STACK_KIND, XS_VAR_KIND, XS_CALLBACK_X_KIND, #ifdef mxHostFunctionPrimitive XS_HOST_FUNCTION_KIND, #endif XS_HOST_INSPECTOR_KIND, XS_INSTANCE_INSPECTOR_KIND, XS_EXPORT_KIND, XS_WEAK_ENTRY_KIND, XS_BUFFER_INFO_KIND, XS_MODULE_SOURCE_KIND, XS_IDS_KIND, }; enum { XS_DEBUGGER_EXIT = 0, XS_NOT_ENOUGH_MEMORY_EXIT, XS_STACK_OVERFLOW_EXIT, XS_FATAL_CHECK_EXIT, XS_DEAD_STRIP_EXIT, XS_UNHANDLED_EXCEPTION_EXIT, XS_NO_MORE_KEYS_EXIT, XS_TOO_MUCH_COMPUTATION_EXIT, XS_UNHANDLED_REJECTION_EXIT, }; #if mxBigEndian #define mxInitSlotKind(SLOT,KIND) ((SLOT)->ID_FLAG_KIND = (uint8_t)(KIND)) #else #define mxInitSlotKind(SLOT,KIND) ((SLOT)->KIND_FLAG_ID = (uint8_t)(KIND)) #endif #define mxTry(THE_MACHINE) \ txJump __JUMP__; \ __JUMP__.nextJump = (THE_MACHINE)->firstJump; \ __JUMP__.stack = the->stack; \ __JUMP__.scope = the->scope; \ __JUMP__.frame = the->frame; \ __JUMP__.code = the->code; \ __JUMP__.flag = 0; \ (THE_MACHINE)->firstJump = &__JUMP__; \ if (c_setjmp(__JUMP__.buffer) == 0) { #define mxCatch(THE_MACHINE) \ (THE_MACHINE)->firstJump = __JUMP__.nextJump; \ } \ else for ( \ the->stack = __JUMP__.stack, \ the->scope = __JUMP__.scope, \ the->frame = __JUMP__.frame, \ the->code = __JUMP__.code, \ (THE_MACHINE)->firstJump = __JUMP__.nextJump; \ (__JUMP__.stack); \ __JUMP__.stack = NULL) #ifdef mxDebug #define mxCheck(THE, THE_ASSERTION) \ if (!(THE_ASSERTION)) \ fxCheck(THE, __FILE__,__LINE__) #else #define mxCheck(THE, THE_ASSERTION) #endif #define mxThrowMessage(_CODE,...) fxThrowMessage(the, C_NULL, 0, _CODE, __VA_ARGS__) #ifdef mxDebug #define mxUnknownError(...) fxThrowMessage(the, NULL, 0, XS_UNKNOWN_ERROR, __VA_ARGS__) #define mxEvalError(...) fxThrowMessage(the, NULL, 0, XS_EVAL_ERROR, __VA_ARGS__) #define mxRangeError(...) fxThrowMessage(the, NULL, 0, XS_RANGE_ERROR, __VA_ARGS__) #define mxReferenceError(...) fxThrowMessage(the, NULL, 0, XS_REFERENCE_ERROR, __VA_ARGS__) #define mxSyntaxError(...) fxThrowMessage(the, NULL, 0, XS_SYNTAX_ERROR, __VA_ARGS__) #define mxTypeError(...) fxThrowMessage(the, NULL, 0, XS_TYPE_ERROR, __VA_ARGS__) #define mxURIError(...) fxThrowMessage(the, NULL, 0, XS_URI_ERROR, __VA_ARGS__) #define mxDebugID(THE_ERROR, THE_FORMAT, THE_ID) ( \ fxIDToString(the, THE_ID, the->nameBuffer, sizeof(the->nameBuffer)), \ fxThrowMessage(the, NULL, 0, THE_ERROR, THE_FORMAT, the->nameBuffer) \ ) #else #define mxUnknownError(...) fxThrowMessage(the, NULL, 0, XS_UNKNOWN_ERROR, __VA_ARGS__) #define mxEvalError(...) fxThrowMessage(the, NULL, 0, XS_EVAL_ERROR, __VA_ARGS__) #define mxRangeError(...) fxThrowMessage(the, NULL, 0, XS_RANGE_ERROR, __VA_ARGS__) #define mxReferenceError(...) fxThrowMessage(the, NULL, 0, XS_REFERENCE_ERROR, __VA_ARGS__) #define mxSyntaxError(...) fxThrowMessage(the, NULL, 0, XS_SYNTAX_ERROR, __VA_ARGS__) #define mxTypeError(...) fxThrowMessage(the, NULL, 0, XS_TYPE_ERROR, __VA_ARGS__) #define mxURIError(...) fxThrowMessage(the, NULL, 0, XS_URI_ERROR, __VA_ARGS__) #define mxDebugID(THE_ERROR, THE_FORMAT, THE_ID) ( \ fxIDToString(the, THE_ID, the->nameBuffer, sizeof(the->nameBuffer)), \ fxThrowMessage(the, NULL, 0, THE_ERROR, THE_FORMAT, the->nameBuffer) \ ) #endif #define mxIsUndefined(THE_SLOT) \ ((THE_SLOT)->kind == XS_UNDEFINED_KIND) #define mxIsNull(THE_SLOT) \ ((THE_SLOT)->kind == XS_NULL_KIND) #define mxIsBigInt(THE_SLOT) \ (((THE_SLOT)->kind == XS_BIGINT_KIND) || ((THE_SLOT)->kind == XS_BIGINT_X_KIND)) #define mxIsReference(THE_SLOT) \ ((THE_SLOT)->kind == XS_REFERENCE_KIND) #define mxIsFunction(THE_SLOT) \ ( (THE_SLOT) && ((THE_SLOT)->next) && ((THE_SLOT)->next->flag & XS_INTERNAL_FLAG) && (((THE_SLOT)->next->kind == XS_CALLBACK_KIND) || ((THE_SLOT)->next->kind == XS_CALLBACK_X_KIND) || ((THE_SLOT)->next->kind == XS_CODE_KIND) || ((THE_SLOT)->next->kind == XS_CODE_X_KIND))) #define mxIsString(THE_SLOT) \ (/* (THE_SLOT) && */ ((THE_SLOT)->next) && ((THE_SLOT)->next->flag & XS_INTERNAL_FLAG) && (((THE_SLOT)->next->kind == XS_STRING_KIND) || ((THE_SLOT)->next->kind == XS_STRING_X_KIND))) #define mxIsBoolean(THE_SLOT) \ (/* (THE_SLOT) && */ ((THE_SLOT)->next) && ((THE_SLOT)->next->flag & XS_INTERNAL_FLAG) && ((THE_SLOT)->next->kind == XS_BOOLEAN_KIND)) #define mxIsNumber(THE_SLOT) \ (/* (THE_SLOT) && */ ((THE_SLOT)->next) && ((THE_SLOT)->next->flag & XS_INTERNAL_FLAG) && ((THE_SLOT)->next->kind == XS_NUMBER_KIND)) #define mxIsDate(THE_SLOT) \ (/* (THE_SLOT) && */ ((THE_SLOT)->next) && ((THE_SLOT)->next->flag & XS_INTERNAL_FLAG) && ((THE_SLOT)->next->kind == XS_DATE_KIND)) #define mxIsRegExp(THE_SLOT) \ (/* (THE_SLOT) && */ ((THE_SLOT)->next) && ((THE_SLOT)->next->flag & XS_INTERNAL_FLAG) && ((THE_SLOT)->next->kind == XS_REGEXP_KIND)) #define mxIsSymbol(THE_SLOT) \ (/* (THE_SLOT) && */ ((THE_SLOT)->next) && ((THE_SLOT)->next->flag & XS_INTERNAL_FLAG) && ((THE_SLOT)->next->kind == XS_SYMBOL_KIND)) #define mxIsHost(THE_SLOT) \ (/* (THE_SLOT) && */ ((THE_SLOT)->next) && ((THE_SLOT)->next->flag & XS_INTERNAL_FLAG) && ((THE_SLOT)->next->kind == XS_HOST_KIND)) #define mxIsPromise(THE_SLOT) \ ((THE_SLOT) && ((THE_SLOT)->next) && ((THE_SLOT)->next->flag & XS_INTERNAL_FLAG) && ((THE_SLOT)->next->kind == XS_PROMISE_KIND) && (THE_SLOT != mxPromisePrototype.value.reference)) #define mxIsProxy(THE_SLOT) \ (/* (THE_SLOT) && */ ((THE_SLOT)->next) && ((THE_SLOT)->next->flag & XS_INTERNAL_FLAG) && ((THE_SLOT)->next->kind == XS_PROXY_KIND)) #define mxIsCallable(THE_SLOT) \ ( (THE_SLOT) && ((THE_SLOT)->next) && (((THE_SLOT)->next->kind == XS_CALLBACK_KIND) || ((THE_SLOT)->next->kind == XS_CALLBACK_X_KIND) || ((THE_SLOT)->next->kind == XS_CODE_KIND) || ((THE_SLOT)->next->kind == XS_CODE_X_KIND) || ((THE_SLOT)->next->kind == XS_PROXY_KIND))) #define mxIsConstructor(THE_SLOT) \ ((THE_SLOT) && ((THE_SLOT)->flag & XS_CAN_CONSTRUCT_FLAG)) #define mxIsStringPrimitive(THE_SLOT) \ (((THE_SLOT)->kind == XS_STRING_KIND) || ((THE_SLOT)->kind == XS_STRING_X_KIND)) #ifdef mxMetering #define mxMeterOne() \ (the->meterIndex++) #define mxMeterSome(_COUNT) \ (the->meterIndex += _COUNT) #else #define mxMeterOne() \ ((void)0) #define mxMeterSome(_COUNT) \ ((void)0) #endif #if mxBoundsCheck #define mxCheckCStack() \ (fxCheckCStack(the)) #define mxOverflow(_COUNT) \ (mxMeterOne(), fxOverflow(the,_COUNT,C_NULL, 0)) #else #define mxCheckCStack() \ ((void)0) #define mxOverflow(_COUNT) \ ((void)0) #endif #define mxCall() \ (mxOverflow(-4), \ fxCall(the)) #define mxDefineAll(ID, INDEX, FLAG, MASK) \ (mxMeterOne(), fxDefineAll(the, ID, INDEX, FLAG, MASK)) #define mxDefineAt(FLAG, MASK) \ (mxMeterOne(), fxDefineAt(the, FLAG, MASK)) #define mxDefineID(ID, FLAG, MASK) \ (mxMeterOne(), fxDefineAll(the, ID, 0, FLAG, MASK)) #define mxDefineIndex(INDEX, FLAG, MASK) \ (mxMeterOne(), fxDefineAll(the, XS_NO_ID, INDEX, FLAG, MASK)) #define mxDeleteAll(ID, INDEX) \ (mxMeterOne(), fxDeleteAll(the, ID, INDEX)) #define mxDeleteAt() \ (mxMeterOne(), fxDeleteAt(the)) #define mxDeleteID(ID) \ (mxMeterOne(), fxDeleteAll(the, ID, 0)) #define mxDeleteIndex(INDEX) \ (mxMeterOne(), fxDeleteAll(the, XS_NO_ID, INDEX)) #define mxDub() \ (mxOverflow(-1), \ ((--the->stack)->next = C_NULL, \ the->stack->flag = XS_NO_FLAG, \ mxInitSlotKind(the->stack, (the->stack + 1)->kind), \ the->stack->value = (the->stack + 1)->value)) #define mxGetAll(ID, INDEX) \ (mxMeterOne(), fxGetAll(the, ID, INDEX)) #define mxGetAt() \ (mxMeterOne(), fxGetAt(the)) #define mxGetID(ID) \ (mxMeterOne(), fxGetAll(the, ID, 0)) #define mxGetIndex(INDEX) \ (mxMeterOne(), fxGetAll(the, XS_NO_ID, INDEX)) #define mxHasAll(ID, INDEX) \ (mxMeterOne(), fxHasAll(the, ID, INDEX)) #define mxHasAt() \ (mxMeterOne(), fxHasAt(the)) #define mxHasID(ID) \ (mxMeterOne(), fxHasAll(the, ID, 0)) #define mxHasIndex(INDEX) \ (mxMeterOne(), fxHasAll(the, XS_NO_ID, INDEX)) #define mxNew() \ (mxOverflow(-5), \ fxNew(the)) #define mxRunCount(_COUNT) \ (mxMeterOne(), fxRunID(the, C_NULL, _COUNT)) #define mxSetAll(ID, INDEX) \ (mxMeterOne(), fxSetAll(the, ID, INDEX)) #define mxSetAt() \ (mxMeterOne(), fxSetAt(the)) #define mxSetID(ID) \ (mxMeterOne(), fxSetAll(the, ID, 0)) #define mxSetIndex(INDEX) \ (mxMeterOne(), fxSetAll(the, XS_NO_ID, INDEX)) #define mxPush(THE_SLOT) \ (mxOverflow(-1), \ (--the->stack)->next = C_NULL, \ mxInitSlotKind(the->stack, (THE_SLOT).kind), \ the->stack->value = (THE_SLOT).value) #define mxPushSlot(THE_SLOT) \ (mxOverflow(-1), \ (--the->stack)->next = C_NULL, \ mxInitSlotKind(the->stack, (THE_SLOT)->kind), \ the->stack->value = (THE_SLOT)->value) #define mxPushAt(ID,INDEX) \ (mxOverflow(-1), \ (--the->stack)->next = C_NULL, \ mxInitSlotKind(the->stack, XS_AT_KIND), \ the->stack->value.at.index = (INDEX), \ the->stack->value.at.id = (ID)) #define mxPushBigInt(THE_BIGINT) \ (mxOverflow(-1), \ (--the->stack)->next = C_NULL, \ mxInitSlotKind(the->stack, XS_BIGINT_KIND), \ the->stack->value.bigint = (THE_BIGINT)) #define mxPushBoolean(THE_BOOLEAN) \ (mxOverflow(-1), \ (--the->stack)->next = C_NULL, \ mxInitSlotKind(the->stack, XS_BOOLEAN_KIND), \ the->stack->value.boolean = (THE_BOOLEAN)) #define mxPushClosure(THE_SLOT) \ (mxOverflow(-1), \ (--the->stack)->next = C_NULL, \ mxInitSlotKind(the->stack, XS_CLOSURE_KIND), \ the->stack->value.closure = (THE_SLOT)) #define mxPushInteger(THE_NUMBER) \ (mxOverflow(-1), \ (--the->stack)->next = C_NULL, \ mxInitSlotKind(the->stack, XS_INTEGER_KIND), \ the->stack->value.integer = (THE_NUMBER)) #define mxPushList() \ (mxOverflow(-1), \ (--the->stack)->next = C_NULL, \ mxInitSlotKind(the->stack, XS_LIST_KIND), \ the->stack->value.list.first = C_NULL, \ the->stack->value.list.last = C_NULL) #define mxPushNull() \ (mxOverflow(-1), \ (--the->stack)->next = C_NULL, \ mxInitSlotKind(the->stack, XS_NULL_KIND)) #define mxPushNumber(THE_NUMBER) \ (mxOverflow(-1), \ (--the->stack)->next = C_NULL, \ mxInitSlotKind(the->stack, XS_NUMBER_KIND), \ the->stack->value.number = (THE_NUMBER)) #define mxPushReference(THE_SLOT) \ (mxOverflow(-1), \ (--the->stack)->next = C_NULL, \ mxInitSlotKind(the->stack, XS_REFERENCE_KIND), \ the->stack->value.reference = (THE_SLOT)) #define mxPushString(THE_STRING) \ (mxOverflow(-1), \ (--the->stack)->next = C_NULL, \ mxInitSlotKind(the->stack, XS_STRING_KIND), \ the->stack->value.string = (THE_STRING)) #define mxPushStringC(THE_STRING) \ (mxOverflow(-1), \ (--the->stack)->next = C_NULL, \ mxInitSlotKind(the->stack, XS_UNDEFINED_KIND), \ fxCopyStringC(the, the->stack, THE_STRING)) #ifdef mxSnapshot #define mxPushStringX(THE_STRING) \ (mxOverflow(-1), \ (--the->stack)->next = C_NULL, \ mxInitSlotKind(the->stack, XS_UNDEFINED_KIND), \ fxCopyStringC(the, the->stack, THE_STRING)) #else #define mxPushStringX(THE_STRING) \ (mxOverflow(-1), \ (--the->stack)->next = C_NULL, \ mxInitSlotKind(the->stack, XS_STRING_X_KIND), \ the->stack->value.string = (THE_STRING)) #endif #define mxPushSymbol(THE_SYMBOL) \ (mxOverflow(-1), \ (--the->stack)->next = C_NULL, \ mxInitSlotKind(the->stack, XS_SYMBOL_KIND), \ the->stack->value.symbol = (THE_SYMBOL)) #define mxPushUndefined() \ (mxOverflow(-1), \ (--the->stack)->next = C_NULL, \ mxInitSlotKind(the->stack, XS_UNDEFINED_KIND)) #define mxPushUninitialized() \ (mxOverflow(-1), \ (--the->stack)->next = C_NULL, \ mxInitSlotKind(the->stack, XS_UNINITIALIZED_KIND)) #define mxPushUnsigned(THE_NUMBER) \ (mxOverflow(-1), \ (--the->stack)->next = C_NULL, \ (THE_NUMBER < 0x7FFFFFFF) ? \ (mxInitSlotKind(the->stack, XS_INTEGER_KIND), \ the->stack->value.integer = (txInteger)(THE_NUMBER)) \ : \ (mxInitSlotKind(the->stack, XS_NUMBER_KIND), \ the->stack->value.number = (txNumber)(THE_NUMBER)) \ ) #define mxTemporary(_SLOT) \ (mxOverflow(-1), \ _SLOT = --the->stack, \ mxInitSlotKind(the->stack, XS_UNDEFINED_KIND)) #define mxPop() \ (mxMeterOne(), the->stack++) #define mxPull(THE_SLOT) \ (mxMeterOne(), \ (THE_SLOT).value = the->stack->value, \ (THE_SLOT).kind = (the->stack++)->kind) #define mxPullSlot(THE_SLOT) \ (mxMeterOne(), \ (THE_SLOT)->value = the->stack->value, \ (THE_SLOT)->kind = (the->stack++)->kind) #define mxThis (the->frame + 4) #define mxFunction (the->frame + 3) #define mxTarget (the->frame + 2) #define mxResult (the->frame + 1) #define mxArgc ((the->frame - 1)->value.integer) #define mxArgv(THE_INDEX) (the->frame - 2 - (THE_INDEX)) #define mxVarc (the->scope->value.environment.variable.count) #define mxVarv(THE_INDEX) (the->scope - 1 - (THE_INDEX)) #define mxFrameToEnvironment(FRAME) ((FRAME) - 1 - ((FRAME) - 1)->value.integer - 1) #define mxFunctionInstanceCode(INSTANCE) ((INSTANCE)->next) #define mxFunctionInstanceHome(INSTANCE) ((INSTANCE)->next->next) #define mxRealmGlobal(REALM) ((REALM)->next) #define mxRealmClosures(REALM) ((REALM)->next->next) #define mxRealmTemplateCache(REALM) ((REALM)->next->next->next) #define mxOwnModules(REALM) ((REALM)->next->next->next->next) #define mxResolveHook(REALM) ((REALM)->next->next->next->next->next) #define mxModuleMap(REALM) ((REALM)->next->next->next->next->next->next) #define mxModuleMapHook(REALM) ((REALM)->next->next->next->next->next->next->next) #define mxLoadHook(REALM) ((REALM)->next->next->next->next->next->next->next->next) #define mxLoadNowHook(REALM) ((REALM)->next->next->next->next->next->next->next->next->next) #define mxImportMetaHook(REALM) ((REALM)->next->next->next->next->next->next->next->next->next->next) #define mxRealmParent(REALM) ((REALM)->next->next->next->next->next->next->next->next->next->next->next) #define mxModuleInstanceInternal(MODULE) ((MODULE)->next) #define mxModuleInstanceExports(MODULE) ((MODULE)->next->next) #define mxModuleInstanceMeta(MODULE) ((MODULE)->next->next->next) #define mxModuleInstanceTransfers(MODULE) ((MODULE)->next->next->next->next) #define mxModuleInstanceInitialize(MODULE) ((MODULE)->next->next->next->next->next) #define mxModuleInstanceExecute(MODULE) ((MODULE)->next->next->next->next->next->next) #define mxModuleInstanceHosts(MODULE) ((MODULE)->next->next->next->next->next->next->next) #define mxModuleInstanceLoader(MODULE) ((MODULE)->next->next->next->next->next->next->next->next) #define mxModuleInstanceFulfill(MODULE) ((MODULE)->next->next->next->next->next->next->next->next->next) #define mxModuleInstanceReject(MODULE) ((MODULE)->next->next->next->next->next->next->next->next->next->next) #define mxModuleInternal(MODULE) mxModuleInstanceInternal((MODULE)->value.reference) #define mxModuleExports(MODULE) mxModuleInstanceExports((MODULE)->value.reference) #define mxModuleMeta(MODULE) mxModuleInstanceMeta((MODULE)->value.reference) #define mxModuleTransfers(MODULE) mxModuleInstanceTransfers((MODULE)->value.reference) #define mxModuleInitialize(MODULE) mxModuleInstanceInitialize((MODULE)->value.reference) #define mxModuleExecute(MODULE) mxModuleInstanceExecute((MODULE)->value.reference) #define mxModuleHosts(MODULE) mxModuleInstanceHosts((MODULE)->value.reference) #define mxModuleLoader(MODULE) mxModuleInstanceLoader((MODULE)->value.reference) #define mxModuleFulfill(MODULE) mxModuleInstanceFulfill((MODULE)->value.reference) #define mxModuleReject(MODULE) mxModuleInstanceReject((MODULE)->value.reference) #define mxTransferLocal(TRANSFER) (TRANSFER)->value.reference->next #define mxTransferFrom(TRANSFER) (TRANSFER)->value.reference->next->next #define mxTransferImport(TRANSFER) (TRANSFER)->value.reference->next->next->next #define mxTransferAliases(TRANSFER) (TRANSFER)->value.reference->next->next->next->next #define mxTransferClosure(TRANSFER) (TRANSFER)->value.reference->next->next->next->next->next #define mxPromiseStatus(INSTANCE) ((INSTANCE)->next) #define mxPromiseThens(INSTANCE) ((INSTANCE)->next->next) #define mxPromiseResult(INSTANCE) ((INSTANCE)->next->next->next) #define mxPromiseEnvironment(INSTANCE) ((INSTANCE)->next->next->next->next) enum { mxUndefinedStatus, mxPendingStatus, mxFulfilledStatus, mxRejectedStatus }; #define mxBehavior(INSTANCE) (gxBehaviors[((INSTANCE)->flag & XS_EXOTIC_FLAG) ? (INSTANCE)->next->ID : 0]) #define mxBehaviorCall(THE, INSTANCE, THIS, ARGUMENTS) \ (*mxBehavior(INSTANCE)->call)(THE, INSTANCE, THIS, ARGUMENTS) #define mxBehaviorConstruct(THE, INSTANCE, ARGUMENTS, TARGET) \ (*mxBehavior(INSTANCE)->construct)(THE, INSTANCE, ARGUMENTS, TARGET) #define mxBehaviorDefineOwnProperty(THE, INSTANCE, ID, INDEX, VALUE, MASK) \ (*mxBehavior(INSTANCE)->defineOwnProperty)(THE, INSTANCE, ID, INDEX, VALUE, MASK) #define mxBehaviorDeleteProperty(THE, INSTANCE, ID, INDEX) \ (*mxBehavior(INSTANCE)->deleteProperty)(THE, INSTANCE, ID, INDEX) #define mxBehaviorGetOwnProperty(THE, INSTANCE, ID, INDEX, VALUE) \ (*mxBehavior(INSTANCE)->getOwnProperty)(THE, INSTANCE, ID, INDEX, VALUE) #define mxBehaviorGetProperty(THE, INSTANCE, ID, INDEX, FLAG) \ (*mxBehavior(INSTANCE)->getProperty)(THE, INSTANCE, ID, INDEX, FLAG) #define mxBehaviorGetPropertyValue(THE, INSTANCE, ID, INDEX, RECEIVER, VALUE) \ (*mxBehavior(INSTANCE)->getPropertyValue)(THE, INSTANCE, ID, INDEX, RECEIVER, VALUE) #define mxBehaviorGetPrototype(THE, INSTANCE, PROTOTYPE) \ (*mxBehavior(INSTANCE)->getPrototype)(THE, INSTANCE, PROTOTYPE) #define mxBehaviorHasProperty(THE, INSTANCE, ID, INDEX) \ (*mxBehavior(INSTANCE)->hasProperty)(THE, INSTANCE, ID, INDEX) #define mxBehaviorIsExtensible(THE, INSTANCE) \ (*mxBehavior(INSTANCE)->isExtensible)(THE, INSTANCE) #define mxBehaviorOwnKeys(THE, INSTANCE, FLAG, KEYS) \ (*mxBehavior(INSTANCE)->ownKeys)(THE, INSTANCE, FLAG, KEYS) #define mxBehaviorPreventExtensions(THE, INSTANCE) \ (*mxBehavior(INSTANCE)->preventExtensions)(THE, INSTANCE) #define mxBehaviorSetProperty(THE, INSTANCE, ID, INDEX, FLAG) \ (*mxBehavior(INSTANCE)->setProperty)(THE, INSTANCE, ID, INDEX, FLAG) #define mxBehaviorSetPropertyValue(THE, INSTANCE, ID, INDEX, VALUE, RECEIVER) \ (*mxBehavior(INSTANCE)->setPropertyValue)(THE, INSTANCE, ID, INDEX, VALUE, RECEIVER) #define mxBehaviorSetPrototype(THE, INSTANCE, PROTOTYPE) \ (*mxBehavior(INSTANCE)->setPrototype)(THE, INSTANCE, PROTOTYPE) enum { mxGlobalStackIndex, mxExceptionStackIndex, mxProgramStackIndex, mxHostsStackIndex, mxModuleQueueStackIndex, mxUnhandledPromisesStackIndex, mxDuringJobsStackIndex, mxFinalizationRegistriesStackIndex, mxPendingJobsStackIndex, mxRunningJobsStackIndex, mxBreakpointsStackIndex, mxHostInspectorsStackIndex, mxInstanceInspectorsStackIndex, mxObjectPrototypeStackIndex = XS_INTRINSICS_COUNT, mxFunctionPrototypeStackIndex, mxArrayPrototypeStackIndex, mxStringPrototypeStackIndex, mxBooleanPrototypeStackIndex, mxNumberPrototypeStackIndex, mxDatePrototypeStackIndex, mxRegExpPrototypeStackIndex, mxHostPrototypeStackIndex, mxErrorPrototypeStackIndex, mxEvalErrorPrototypeStackIndex, mxRangeErrorPrototypeStackIndex, mxReferenceErrorPrototypeStackIndex, mxSyntaxErrorPrototypeStackIndex, mxTypeErrorPrototypeStackIndex, mxURIErrorPrototypeStackIndex, mxAggregateErrorPrototypeStackIndex, mxSymbolPrototypeStackIndex, mxArrayBufferPrototypeStackIndex, mxDataViewPrototypeStackIndex, mxTypedArrayPrototypeStackIndex, mxMapPrototypeStackIndex, mxSetPrototypeStackIndex, mxWeakMapPrototypeStackIndex, mxWeakSetPrototypeStackIndex, mxPromisePrototypeStackIndex, mxProxyPrototypeStackIndex, mxSharedArrayBufferPrototypeStackIndex, mxBigIntPrototypeStackIndex, mxCompartmentPrototypeStackIndex, mxModuleSourcePrototypeStackIndex, mxWeakRefPrototypeStackIndex, mxFinalizationRegistryPrototypeStackIndex, mxEnumeratorFunctionStackIndex, mxAssignObjectFunctionStackIndex, mxCopyObjectFunctionStackIndex, mxAsyncFunctionPrototypeStackIndex, mxGeneratorPrototypeStackIndex, mxGeneratorFunctionPrototypeStackIndex, mxModulePrototypeStackIndex, mxTransferPrototypeStackIndex, mxOnRejectedPromiseFunctionStackIndex, mxOnResolvedPromiseFunctionStackIndex, mxOnThenableFunctionStackIndex, mxArrayLengthAccessorStackIndex, mxModuleAccessorStackIndex, mxProxyAccessorStackIndex, mxStringAccessorStackIndex, mxTypedArrayAccessorStackIndex, mxIteratorPrototypeStackIndex, mxArrayIteratorPrototypeStackIndex, mxMapIteratorPrototypeStackIndex, mxRegExpStringIteratorPrototypeStackIndex, mxSetIteratorPrototypeStackIndex, mxStringIteratorPrototypeStackIndex, mxAsyncIteratorPrototypeStackIndex, mxAsyncFromSyncIteratorPrototypeStackIndex, mxAsyncGeneratorPrototypeStackIndex, mxAsyncGeneratorFunctionPrototypeStackIndex, mxArgumentsSloppyPrototypeStackIndex, mxArgumentsStrictPrototypeStackIndex, mxThrowTypeErrorFunctionStackIndex, mxHookInstanceIndex, mxExecuteRegExpFunctionIndex, mxInitializeRegExpFunctionIndex, mxArrayIteratorFunctionIndex, mxOrdinaryToPrimitiveFunctionStackIndex, mxCompartmentGlobalStackIndex, mxEmptyCodeStackIndex, mxEmptyStringStackIndex, mxEmptyRegExpStackIndex, mxBigIntStringStackIndex, mxBooleanStringStackIndex, mxDefaultStringStackIndex, mxFunctionStringStackIndex, mxNumberStringStackIndex, mxObjectStringStackIndex, mxStringStringStackIndex, mxSymbolStringStackIndex, mxUndefinedStringStackIndex, mxStackIndexCount }; #define mxGlobal the->stackTop[-1 - mxGlobalStackIndex] #define mxException the->stackTop[-1 - mxExceptionStackIndex] #define mxProgram the->stackTop[-1 - mxProgramStackIndex] #define mxHosts the->stackTop[-1 - mxHostsStackIndex] #define mxModuleQueue the->stackTop[-1 - mxModuleQueueStackIndex] #define mxUnhandledPromises the->stackTop[-1 - mxUnhandledPromisesStackIndex] #define mxDuringJobs the->stackTop[-1 - mxDuringJobsStackIndex] #define mxFinalizationRegistries the->stackTop[-1 - mxFinalizationRegistriesStackIndex] #define mxPendingJobs the->stackTop[-1 - mxPendingJobsStackIndex] #define mxRunningJobs the->stackTop[-1 - mxRunningJobsStackIndex] #define mxBreakpoints the->stackTop[-1 - mxBreakpointsStackIndex] #define mxHostInspectors the->stackTop[-1 - mxHostInspectorsStackIndex] #define mxInstanceInspectors the->stackTop[-1 - mxInstanceInspectorsStackIndex] #define mxAggregateErrorConstructor the->stackPrototypes[-1 - _AggregateError] #define mxArrayConstructor the->stackPrototypes[-1 - _Array] #define mxArrayBufferConstructor the->stackPrototypes[-1 - _ArrayBuffer] #define mxAtomicsObject the->stackPrototypes[-1 - _Atomics] #define mxBigIntConstructor the->stackPrototypes[-1 - _BigInt] #define mxBigInt64ArrayConstructor the->stackPrototypes[-1 - _BigInt64Array] #define mxBigUint64ArrayConstructor the->stackPrototypes[-1 - _BigUint64Array] #define mxBooleanConstructor the->stackPrototypes[-1 - _Boolean] #define mxCompartmentConstructor the->stackPrototypes[-1 - _Compartment] #define mxDataViewConstructor the->stackPrototypes[-1 - _DataView] #define mxDateConstructor the->stackPrototypes[-1 - _Date] #define mxErrorConstructor the->stackPrototypes[-1 - _Error] #define mxEvalErrorConstructor the->stackPrototypes[-1 - _EvalError] #define mxFinalizationRegistryConstructor the->stackPrototypes[-1 - _FinalizationRegistry] #define mxFloat32ArrayConstructor the->stackPrototypes[-1 - _Float32Array] #define mxFloat64ArrayConstructor the->stackPrototypes[-1 - _Float64Array] #define mxFunctionConstructor the->stackPrototypes[-1 - _Function] #define mxInfinity the->stackPrototypes[-1 - _Infinity] #define mxInt16ArrayConstructor the->stackPrototypes[-1 - _Int16Array] #define mxInt32ArrayConstructor the->stackPrototypes[-1 - _Int32Array] #define mxInt8ArrayConstructor the->stackPrototypes[-1 - _Int8Array] #define mxJSONObject the->stackPrototypes[-1 - _JSON] #define mxMapConstructor the->stackPrototypes[-1 - _Map] #define mxMathObject the->stackPrototypes[-1 - _Math] #define mxNaN the->stackPrototypes[-1 - _NaN] #define mxNumberConstructor the->stackPrototypes[-1 - _Number] #define mxObjectConstructor the->stackPrototypes[-1 - _Object] #define mxPromiseConstructor the->stackPrototypes[-1 - _Promise] #define mxProxyConstructor the->stackPrototypes[-1 - _Proxy] #define mxRangeErrorConstructor the->stackPrototypes[-1 - _RangeError] #define mxReferenceErrorConstructor the->stackPrototypes[-1 - _ReferenceError] #define mxReflectObject the->stackPrototypes[-1 - _Reflect] #define mxRegExpConstructor the->stackPrototypes[-1 - _RegExp] #define mxSetConstructor the->stackPrototypes[-1 - _Set] #define mxSharedArrayBufferConstructor the->stackPrototypes[-1 - _SharedArrayBuffer] #define mxModuleSourceConstructor the->stackPrototypes[-1 - _ModuleSource] #define mxStringConstructor the->stackPrototypes[-1 - _String] #define mxSymbolConstructor the->stackPrototypes[-1 - _Symbol] #define mxSyntaxErrorConstructor the->stackPrototypes[-1 - _SyntaxError] #define mxTypeErrorConstructor the->stackPrototypes[-1 - _TypeError] #define mxTypedArrayConstructor the->stackPrototypes[-1 - _TypedArray] #define mxURIErrorConstructor the->stackPrototypes[-1 - _URIError] #define mxUint16ArrayConstructor the->stackPrototypes[-1 - _Uint16Array] #define mxUint32ArrayConstructor the->stackPrototypes[-1 - _Uint32Array] #define mxUint8ArrayConstructor the->stackPrototypes[-1 - _Uint8Array] #define mxUint8ClampedArrayConstructor the->stackPrototypes[-1 - _Uint8ClampedArray] #define mxWeakMapConstructor the->stackPrototypes[-1 - _WeakMap] #define mxWeakRefConstructor the->stackPrototypes[-1 - _WeakRef] #define mxWeakSetConstructor the->stackPrototypes[-1 - _WeakSet] #define mxDecodeURIFunction the->stackPrototypes[-1 - _decodeURI] #define mxDecodeURIComponentFunction the->stackPrototypes[-1 - _decodeURIComponent] #define mxEncodeURIFunction the->stackPrototypes[-1 - _encodeURI] #define mxEncodeURIComponentFunction the->stackPrototypes[-1 - _encodeURIComponent] #define mxEscapeFunction the->stackPrototypes[-1 - _escape] #define mxEvalFunction the->stackPrototypes[-1 - _eval] #define mxIsFiniteFunction the->stackPrototypes[-1 - _isFinite] #define mxIsNaNFunction the->stackPrototypes[-1 - _isNaN] #define mxParseFloatFunction the->stackPrototypes[-1 - _parseFloat] #define mxParseIntFunction the->stackPrototypes[-1 - _parseInt] #define mxTraceFunction the->stackPrototypes[-1 - _trace] #define mxUndefined the->stackPrototypes[-1 - _undefined] #define mxUnescapeFunction the->stackPrototypes[-1 - _unescape] #define mxObjectPrototype the->stackPrototypes[-1 - mxObjectPrototypeStackIndex] #define mxFunctionPrototype the->stackPrototypes[-1 - mxFunctionPrototypeStackIndex] #define mxArrayPrototype the->stackPrototypes[-1 - mxArrayPrototypeStackIndex] #define mxStringPrototype the->stackPrototypes[-1 - mxStringPrototypeStackIndex] #define mxBooleanPrototype the->stackPrototypes[-1 - mxBooleanPrototypeStackIndex] #define mxNumberPrototype the->stackPrototypes[-1 - mxNumberPrototypeStackIndex] #define mxDatePrototype the->stackPrototypes[-1 - mxDatePrototypeStackIndex] #define mxRegExpPrototype the->stackPrototypes[-1 - mxRegExpPrototypeStackIndex] #define mxHostPrototype the->stackPrototypes[-1 - mxHostPrototypeStackIndex] #define mxErrorPrototypes(THE_ERROR) (the->stackPrototypes[-mxErrorPrototypeStackIndex-(THE_ERROR)]) #define mxErrorPrototype the->stackPrototypes[-1 - mxErrorPrototypeStackIndex] #define mxEvalErrorPrototype the->stackPrototypes[-1 - mxEvalErrorPrototypeStackIndex] #define mxRangeErrorPrototype the->stackPrototypes[-1 - mxRangeErrorPrototypeStackIndex] #define mxReferenceErrorPrototype the->stackPrototypes[-1 - mxReferenceErrorPrototypeStackIndex] #define mxSyntaxErrorPrototype the->stackPrototypes[-1 - mxSyntaxErrorPrototypeStackIndex] #define mxTypeErrorPrototype the->stackPrototypes[-1 - mxTypeErrorPrototypeStackIndex] #define mxURIErrorPrototype the->stackPrototypes[-1 - mxURIErrorPrototypeStackIndex] #define mxAggregateErrorPrototype the->stackPrototypes[-1 - mxAggregateErrorPrototypeStackIndex] #define mxSymbolPrototype the->stackPrototypes[-1 - mxSymbolPrototypeStackIndex] #define mxArrayBufferPrototype the->stackPrototypes[-1 - mxArrayBufferPrototypeStackIndex] #define mxDataViewPrototype the->stackPrototypes[-1 - mxDataViewPrototypeStackIndex] #define mxTypedArrayPrototype the->stackPrototypes[-1 - mxTypedArrayPrototypeStackIndex] #define mxMapPrototype the->stackPrototypes[-1 - mxMapPrototypeStackIndex] #define mxSetPrototype the->stackPrototypes[-1 - mxSetPrototypeStackIndex] #define mxWeakMapPrototype the->stackPrototypes[-1 - mxWeakMapPrototypeStackIndex] #define mxWeakSetPrototype the->stackPrototypes[-1 - mxWeakSetPrototypeStackIndex] #define mxPromisePrototype the->stackPrototypes[-1 - mxPromisePrototypeStackIndex] #define mxProxyPrototype the->stackPrototypes[-1 - mxProxyPrototypeStackIndex] #define mxSharedArrayBufferPrototype the->stackPrototypes[-1 - mxSharedArrayBufferPrototypeStackIndex] #define mxBigIntPrototype the->stackPrototypes[-1 - mxBigIntPrototypeStackIndex] #define mxCompartmentPrototype the->stackPrototypes[-1 - mxCompartmentPrototypeStackIndex] #define mxModuleSourcePrototype the->stackPrototypes[-1 - mxModuleSourcePrototypeStackIndex] #define mxWeakRefPrototype the->stackPrototypes[-1 - mxWeakRefPrototypeStackIndex] #define mxFinalizationRegistryPrototype the->stackPrototypes[-1 - mxFinalizationRegistryPrototypeStackIndex] #define mxEmptyCode the->stackPrototypes[-1 - mxEmptyCodeStackIndex] #define mxEmptyString the->stackPrototypes[-1 - mxEmptyStringStackIndex] #define mxEmptyRegExp the->stackPrototypes[-1 - mxEmptyRegExpStackIndex] #define mxBigIntString the->stackPrototypes[-1 - mxBigIntStringStackIndex] #define mxBooleanString the->stackPrototypes[-1 - mxBooleanStringStackIndex] #define mxDefaultString the->stackPrototypes[-1 - mxDefaultStringStackIndex] #define mxFunctionString the->stackPrototypes[-1 - mxFunctionStringStackIndex] #define mxNumberString the->stackPrototypes[-1 - mxNumberStringStackIndex] #define mxObjectString the->stackPrototypes[-1 - mxObjectStringStackIndex] #define mxStringString the->stackPrototypes[-1 - mxStringStringStackIndex] #define mxSymbolString the->stackPrototypes[-1 - mxSymbolStringStackIndex] #define mxUndefinedString the->stackPrototypes[-1 - mxUndefinedStringStackIndex] #define mxEnumeratorFunction the->stackPrototypes[-1 - mxEnumeratorFunctionStackIndex] #define mxAssignObjectFunction the->stackPrototypes[-1 - mxAssignObjectFunctionStackIndex] #define mxCopyObjectFunction the->stackPrototypes[-1 - mxCopyObjectFunctionStackIndex] #define mxAsyncFunctionPrototype the->stackPrototypes[-1 - mxAsyncFunctionPrototypeStackIndex] #define mxGeneratorPrototype the->stackPrototypes[-1 - mxGeneratorPrototypeStackIndex] #define mxGeneratorFunctionPrototype the->stackPrototypes[-1 - mxGeneratorFunctionPrototypeStackIndex] #define mxModulePrototype the->stackPrototypes[-1 - mxModulePrototypeStackIndex] #define mxTransferPrototype the->stackPrototypes[-1 - mxTransferPrototypeStackIndex] #define mxOnRejectedPromiseFunction the->stackPrototypes[-1 - mxOnRejectedPromiseFunctionStackIndex] #define mxOnResolvedPromiseFunction the->stackPrototypes[-1 - mxOnResolvedPromiseFunctionStackIndex] #define mxOnThenableFunction the->stackPrototypes[-1 - mxOnThenableFunctionStackIndex] #define mxArrayLengthAccessor the->stackPrototypes[-1 - mxArrayLengthAccessorStackIndex] #define mxModuleAccessor the->stackPrototypes[-1 - mxModuleAccessorStackIndex] #define mxProxyAccessor the->stackPrototypes[-1 - mxProxyAccessorStackIndex] #define mxStringAccessor the->stackPrototypes[-1 - mxStringAccessorStackIndex] #define mxTypedArrayAccessor the->stackPrototypes[-1 - mxTypedArrayAccessorStackIndex] #define mxIteratorPrototype the->stackPrototypes[-1 - mxIteratorPrototypeStackIndex] #define mxArrayIteratorPrototype the->stackPrototypes[-1 - mxArrayIteratorPrototypeStackIndex] #define mxMapIteratorPrototype the->stackPrototypes[-1 - mxMapIteratorPrototypeStackIndex] #define mxRegExpStringIteratorPrototype the->stackPrototypes[-1 - mxRegExpStringIteratorPrototypeStackIndex] #define mxSetIteratorPrototype the->stackPrototypes[-1 - mxSetIteratorPrototypeStackIndex] #define mxStringIteratorPrototype the->stackPrototypes[-1 - mxStringIteratorPrototypeStackIndex] #define mxAsyncIteratorPrototype the->stackPrototypes[-1 - mxAsyncIteratorPrototypeStackIndex] #define mxAsyncFromSyncIteratorPrototype the->stackPrototypes[-1 - mxAsyncFromSyncIteratorPrototypeStackIndex] #define mxAsyncGeneratorPrototype the->stackPrototypes[-1 - mxAsyncGeneratorPrototypeStackIndex] #define mxAsyncGeneratorFunctionPrototype the->stackPrototypes[-1 - mxAsyncGeneratorFunctionPrototypeStackIndex] #define mxArgumentsSloppyPrototype the->stackPrototypes[-1 - mxArgumentsSloppyPrototypeStackIndex] #define mxArgumentsStrictPrototype the->stackPrototypes[-1 - mxArgumentsStrictPrototypeStackIndex] #define mxThrowTypeErrorFunction the->stackPrototypes[-1 - mxThrowTypeErrorFunctionStackIndex] #define mxHookInstance the->stackPrototypes[-1 - mxHookInstanceIndex] #define mxExecuteRegExpFunction the->stackPrototypes[-1 - mxExecuteRegExpFunctionIndex] #define mxInitializeRegExpFunction the->stackPrototypes[-1 - mxInitializeRegExpFunctionIndex] #define mxArrayIteratorFunction the->stackPrototypes[-1 - mxArrayIteratorFunctionIndex] #define mxOrdinaryToPrimitiveFunction the->stackPrototypes[-1 - mxOrdinaryToPrimitiveFunctionStackIndex] #define mxCompartmentGlobal the->stackPrototypes[-1 - mxCompartmentGlobalStackIndex] #define mxID(ID) ((txID)(ID)) #ifdef mxLink extern txCallback fxNewLinkerCallback(txMachine*, txCallback, txString); #define mxCallback(CALLBACK) fxNewLinkerCallback(the, CALLBACK, #CALLBACK) extern txSlot* fxBuildHostConstructor(txMachine* the, txCallback theCallback, txInteger theLength, txInteger name); extern txSlot* fxBuildHostFunction(txMachine* the, txCallback theCallback, txInteger theLength, txInteger name); #else #define mxCallback(CALLBACK) CALLBACK #define fxBuildHostConstructor(THE, CALLBACK, LENGTH, NAME) fxNewHostConstructor(THE, CALLBACK, LENGTH, NAME) #define fxBuildHostFunction(THE, CALLBACK, LENGTH, NAME) fxNewHostFunction(THE, CALLBACK, LENGTH, NAME, XS_NO_ID) #endif enum { mxHostProfileID, mxGarbageCollectorProfileID, mx_Promise_prototype_finallyAuxProfileID, mx_Promise_prototype_finallyReturnProfileID, mx_Promise_prototype_finallyThrowProfileID, mx_Proxy_revokeProfileID, mxAsyncGeneratorRejectAwaitProfileID, mxAsyncGeneratorRejectYieldProfileID, mxAsyncGeneratorResolveAwaitProfileID, mxAsyncGeneratorResolveYieldProfileID, mxAsyncFromSyncIteratorDoneProfileID, mxCombinePromisesCallbackProfileID, mxExecuteModulesFulfilledProfileID, mxExecuteModulesRejectedProfileID, mxExecuteVirtualModuleSourceProfileID, mxExecuteVirtualModuleSourceImportProfileID, mxLoadModulesFulfilledProfileID, mxLoadModulesRejectedProfileID, mxNewPromiseCapabilityCallbackProfileID, mxRejectAwaitProfileID, mxRejectPromiseProfileID, mxResolveAwaitProfileID, mxResolvePromiseProfileID, mxBaseProfileID }; #ifdef __cplusplus } #endif #endif /* __XSALL__ */