void fxParseJSONObject(txMachine* the, txJSONParser* theParser) { txSlot* anObject; txSlot* at; txSlot* aProperty; fxGetNextJSONToken(the, theParser); mxPush(mxObjectPrototype); anObject = fxNewObjectInstance(the); for (;;) { if (theParser->token == XS_JSON_TOKEN_RIGHT_BRACE) break; if (theParser->token != XS_JSON_TOKEN_STRING) { mxSyntaxError("missing name"); break; } mxPushString(theParser->string->value.string); at = fxAt(the, the->stack); if (theParser->reviver) mxPushString(theParser->string->value.string); fxGetNextJSONToken(the, theParser); if (theParser->token != XS_JSON_TOKEN_COLON) { mxSyntaxError("missing :"); break; } fxGetNextJSONToken(the, theParser); fxParseJSONValue(the, theParser); if (theParser->reviver) { mxPushInteger(2); mxPushReference(anObject); mxPushReference(theParser->reviver); fxCall(the); } if (the->stack->kind != XS_UNDEFINED_KIND) { aProperty = fxSetProperty(the, anObject, at->value.at.id, at->value.at.index, XS_OWN); aProperty->kind = the->stack->kind; aProperty->value = the->stack->value; } the->stack++; the->stack++; if (theParser->token != XS_JSON_TOKEN_COMMA) break; fxGetNextJSONToken(the, theParser); } if (theParser->token != XS_JSON_TOKEN_RIGHT_BRACE) mxSyntaxError("missing }"); fxGetNextJSONToken(the, theParser); }
void fxSetID(txMachine* the, txInteger theID) { txSlot* anInstance; txSlot* aProperty; txSlot* aFunction; fxToInstance(the, the->stack); anInstance = fxGetInstance(the, the->stack); if (!anInstance) mxDebugID(XS_TYPE_ERROR, "C: xsSet %s: shared instance", theID); aProperty = fxSetProperty(the, anInstance, theID, C_NULL); if (!aProperty) mxDebugID(XS_TYPE_ERROR, "C: xsSet %s: not extensible", theID); if (aProperty->kind == XS_ACCESSOR_KIND) { mxPushInteger(1); /* SWAP THIS */ the->scratch = *(the->stack); *(the->stack) = *(the->stack + 1); *(the->stack + 1) = the->scratch; /* FUNCTION */ aFunction = aProperty->value.accessor.setter; if (!mxIsFunction(aFunction)) mxDebugID(XS_TYPE_ERROR, "C: xsCall set %s: no function", theID); mxPushReference(aFunction); fxCall(the); } else { the->stack++; if (aProperty->flag & XS_DONT_SET_FLAG) mxDebugID(XS_TYPE_ERROR, "C: xsSet %s: no permission", theID); aProperty->kind = the->stack->kind; aProperty->value = the->stack->value; } }
txBoolean fxCallArrayItem(txMachine* the, txSlot* function, txSlot* array, txIndex index, txSlot* item) { txSlot* slot = array->value.array.address + index; if (slot->ID) { /* ARG0 */ mxPushSlot(slot); if (item) { item->kind = the->stack->kind; item->value = the->stack->value; } /* ARG1 */ mxPushUnsigned(index); /* ARG2 */ mxPushSlot(mxThis); /* ARGC */ mxPushInteger(3); /* THIS */ if (mxArgc > 1) mxPushSlot(mxArgv(1)); else mxPushUndefined(); /* FUNCTION */ mxPushReference(function); fxCall(the); return 1; } return 0; }
txSlot* fxNewInstance(txMachine* the) { txSlot* instance = fxNewSlot(the); instance->kind = XS_INSTANCE_KIND; instance->value.instance.garbage = C_NULL; instance->value.instance.prototype = C_NULL; mxPushReference(instance); return instance; }
int fxCompareArrayItem(txMachine* the, txSlot* function, txSlot* array, txInteger i) { txSlot* address = array->value.array.address; txSlot* a = address + i; txSlot* b = the->stack; int result; if (!(a->ID)) result = (!(b->ID)) ? 0 : 1; else if (!(b->ID)) result = -1; else if (a->kind == XS_UNDEFINED_KIND) result = (b->kind == XS_UNDEFINED_KIND) ? 0 : 1; else if (b->kind == XS_UNDEFINED_KIND) result = -1; else { mxPushSlot(a); mxPushSlot(b); if (function) { /* ARGC */ mxPushInteger(2); /* THIS */ mxPushSlot(mxThis); /* FUNCTION */ mxPushReference(function); fxCall(the); if (the->stack->kind == XS_INTEGER_KIND) result = the->stack->value.integer; else { txNumber number = fxToNumber(the, the->stack); result = (number < 0) ? -1 : (number > 0) ? 1 : 0; } the->stack++; } else { fxToString(the, the->stack + 1); fxToString(the, the->stack); result = c_strcmp((the->stack + 1)->value.string, the->stack->value.string); the->stack += 2; } } return result; }
void fxReduceArrayItem(txMachine* the, txSlot* function, txSlot* array, txIndex index) { txSlot* slot = array->value.array.address + index; if (slot->ID) { /* ARG0 */ mxPushSlot(mxResult); /* ARG1 */ mxPushSlot(slot); /* ARG2 */ mxPushUnsigned(index); /* ARG3 */ mxPushSlot(mxThis); /* ARGC */ mxPushInteger(4); /* THIS */ mxPushUndefined(); /* FUNCTION */ mxPushReference(function); fxCall(the); mxPullSlot(mxResult); } }
txSlot* fxCreateInstance(txMachine* the, txSlot* slot) { txSlot* prototype; mxPushUndefined(); prototype = the->stack; fxBeginHost(the); mxPushReference(slot); fxGetID(the, mxID(_prototype)); *prototype = *the->stack; fxEndHost(the); /* txSlot* prototype = mxFunctionInstancePrototype(slot); if (prototype->kind == XS_NULL_KIND) { if (prototype->flag & XS_DONT_SET_FLAG) mxTypeError("new.target: no constructor"); if (slot->flag & XS_SHARED_FLAG) mxTypeError("new.target: shared"); fxDefaultFunctionPrototype(the, slot, prototype); } mxPushSlot(prototype); */ fxNewInstanceOf(the); return the->stack->value.reference; }
void fxGetID(txMachine* the, txInteger theID) { txSlot* anInstance; txSlot* aProperty; txSlot* aFunction; fxToInstance(the, the->stack); anInstance = fxGetInstance(the, the->stack); aProperty = fxGetProperty(the, anInstance, theID); if (!aProperty) { the->stack->kind = XS_UNDEFINED_KIND; //mxDebugID(XS_NO_ERROR, "C: xsGet %s: no property", theID); } else if (aProperty->kind == XS_ACCESSOR_KIND) { aFunction = aProperty->value.accessor.getter; if (mxIsFunction(aFunction)) { mxPushInteger(0); /* SWAP THIS */ the->scratch = *(the->stack); *(the->stack) = *(the->stack + 1); *(the->stack + 1) = the->scratch; /* FUNCTION */ aFunction = aProperty->value.accessor.getter; if (!mxIsFunction(aFunction)) mxDebugID(XS_TYPE_ERROR, "C: xsCall get %s: no function", theID); mxPushReference(aFunction); fxCall(the); } else the->stack->kind = XS_UNDEFINED_KIND; } else { the->stack->kind = aProperty->kind; the->stack->value = aProperty->value; } }
void fx_Function_prototype_bind(txMachine* the) { txSlot* instance = fxToInstance(the, mxThis); txSize length; txSlot* slot; txID id; txSlot* arguments; txSlot* argument; txSize c = mxArgc, i; if (!fxIsFunction(the, instance)) mxTypeError("this is no Function instance"); if (fxHasOwnProperty(the, instance, mxID(_length))) { mxPushSlot(mxThis); fxGetID(the, mxID(_length)); length = fxToInteger(the, the->stack++); if (c > 1) length -= c - 1; if (length < 0) length = 0; mxPop(); } else length = 0; mxPushSlot(mxThis); fxGetID(the, mxID(_name)); mxPushStringC("bound "); fxConcatString(the, the->stack, the->stack + 1); slot = fxNewName(the, the->stack); id = slot->ID; mxPop(); mxPop(); mxPushReference(instance->value.instance.prototype); instance = fxNewFunctionInstance(the, id); mxPullSlot(mxResult); slot = mxFunctionInstanceCode(instance); slot->kind = XS_CALLBACK_KIND; slot->value.callback.address = fx_Function_prototype_bound; slot->value.callback.IDs = (txID*)mxIDs.value.code; slot = mxFunctionInstanceInfo(instance); slot->value.info.length = (txID)length; slot = fxLastProperty(the, instance); slot = fxNextSlotProperty(the, slot, mxThis, mxID(_boundFunction), XS_GET_ONLY); if (c > 0) slot = fxNextSlotProperty(the, slot, mxArgv(0), mxID(_boundThis), XS_GET_ONLY); else slot = fxNextUndefinedProperty(the, slot, mxID(_boundThis), XS_GET_ONLY); mxPush(mxArrayPrototype); arguments = fxNewArrayInstance(the); argument = arguments->next; for (i = 1; i < c; i++) { argument->next = fxNewSlot(the); argument = argument->next; argument->kind = mxArgv(i)->kind; argument->value = mxArgv(i)->value; } arguments->next->value.array.length = mxArgc - 1; fxCacheArray(the, arguments); slot = fxNextSlotProperty(the, slot, the->stack, mxID(_boundArguments), XS_GET_ONLY); mxPop(); }
void fxSerializeJSONProperty(txMachine* the, txJSONSerializer* theSerializer, txInteger* theFlag) { txSlot* aWrapper = the->stack + 2; txSlot* aValue = the->stack + 1; txSlot* aKey = the->stack; txSlot* anInstance; txSlot* aProperty; txInteger aFlag; txIndex aLength, anIndex; if (mxIsReference(aValue)) { anInstance = fxGetInstance(the, aValue); if (anInstance->flag & XS_LEVEL_FLAG) mxTypeError("cyclic value"); mxPushSlot(aKey); /* COUNT */ mxPushInteger(1); /* THIS */ mxPushSlot(aValue); /* FUNCTION */ mxPushSlot(aValue); fxGetID(the, mxID(_toJSON)); if (mxIsReference(the->stack) && mxIsFunction(the->stack->value.reference)) { fxCall(the); mxPullSlot(aValue); } else { the->stack = aKey; } } else anInstance = C_NULL; if (theSerializer->replacer) { mxPushSlot(aKey); mxPushSlot(aValue); /* COUNT */ mxPushInteger(2); /* THIS */ mxPushSlot(aWrapper); /* FUNCTION */ mxPushSlot(theSerializer->replacer); fxCall(the); mxPullSlot(aValue); } again: switch (aValue->kind) { case XS_NULL_KIND: fxSerializeJSONName(the, theSerializer, theFlag); fxSerializeJSONChars(the, theSerializer, "null"); break; case XS_BOOLEAN_KIND: fxSerializeJSONName(the, theSerializer, theFlag); fxSerializeJSONChars(the, theSerializer, aValue->value.boolean ? "true" : "false"); break; case XS_INTEGER_KIND: fxSerializeJSONName(the, theSerializer, theFlag); fxSerializeJSONInteger(the, theSerializer, aValue->value.integer); break; case XS_NUMBER_KIND: fxSerializeJSONName(the, theSerializer, theFlag); fxSerializeJSONNumber(the, theSerializer, aValue->value.number); break; case XS_STRING_KIND: case XS_STRING_X_KIND: fxSerializeJSONName(the, theSerializer, theFlag); fxSerializeJSONString(the, theSerializer, aValue->value.string); break; case XS_ARRAY_KIND: fxSerializeJSONName(the, theSerializer, theFlag); anInstance->flag |= XS_LEVEL_FLAG; fxSerializeJSONChar(the, theSerializer, '['); theSerializer->level++; fxSerializeJSONIndent(the, theSerializer); aFlag = 4; aLength = aValue->value.array.length; for (anIndex = 0; anIndex < aLength; anIndex++) { aProperty = aValue->value.array.address + anIndex; mxPushSlot(aProperty); mxPushInteger(anIndex); fxSerializeJSONProperty(the, theSerializer, &aFlag); } theSerializer->level--; fxSerializeJSONIndent(the, theSerializer); fxSerializeJSONChar(the, theSerializer, ']'); anInstance->flag &= ~XS_LEVEL_FLAG; break; case XS_REFERENCE_KIND: anInstance = fxGetInstance(the, aValue); aValue = anInstance->next; if (aValue && (aValue->flag & XS_INTERNAL_FLAG) && (aValue->kind != XS_PROXY_KIND)) { goto again; } fxSerializeJSONName(the, theSerializer, theFlag); anInstance->flag |= XS_LEVEL_FLAG; if (fxIsArray(the, anInstance)) { fxSerializeJSONChar(the, theSerializer, '['); theSerializer->level++; fxSerializeJSONIndent(the, theSerializer); aFlag = 4; mxPushReference(anInstance); fxGetID(the, mxID(_length)); aLength = fxToInteger(the, the->stack); mxPop(); for (anIndex = 0; anIndex < aLength; anIndex++) { mxPushReference(anInstance); fxGetID(the, anIndex); mxPushInteger(anIndex); fxSerializeJSONProperty(the, theSerializer, &aFlag); } theSerializer->level--; fxSerializeJSONIndent(the, theSerializer); fxSerializeJSONChar(the, theSerializer, ']'); } else { fxSerializeJSONChar(the, theSerializer, '{'); theSerializer->level++; fxSerializeJSONIndent(the, theSerializer); aFlag = 2; { txSlot aContext; aContext.value.regexp.code = theSerializer; aContext.value.regexp.offsets = &aFlag; fxEachInstanceProperty(the, anInstance, XS_EACH_ENUMERABLE_FLAG | XS_EACH_STRING_FLAG | XS_STEP_GET_FLAG, fxSerializeJSONOwnProperty, &aContext, anInstance); } theSerializer->level--; fxSerializeJSONIndent(the, theSerializer); fxSerializeJSONChar(the, theSerializer, '}'); } anInstance->flag &= ~XS_LEVEL_FLAG; break; default: if (*theFlag & 4) { if (*theFlag & 1) { fxSerializeJSONChars(the, theSerializer, ","); fxSerializeJSONIndent(the, theSerializer); } else *theFlag |= 1; fxSerializeJSONChars(the, theSerializer, "null"); } break; } the->stack++; // POP VALUE }
void fx_Array_from(txMachine* the) { txSlot* list = fxNewInstance(the); txSlot* item = list; txIndex count = 0; txIndex index; txSlot* function = C_NULL; txSlot* _this = C_NULL; txSlot* resultArray; txSlot* resultSlot; if (mxArgc > 2) _this = mxArgv(2); if (mxArgc > 1) { txSlot* slot = mxArgv(1); if (slot->kind == XS_REFERENCE_KIND) { slot = slot->value.reference; if ((slot->next->kind == XS_CODE_KIND) || (slot->next->kind == XS_CALLBACK_KIND)) function = slot; } } if (mxArgc > 0) { mxPushSlot(mxArgv(0)); if (fxHasID(the, mxID(_Symbol_iterator))) { txSlot* iterator; txSlot* result; mxPushInteger(0); mxPushSlot(mxArgv(0)); fxCallID(the, mxID(_Symbol_iterator)); iterator = the->stack; { mxTry(the) { count = 0; for(;;) { mxCallID(iterator, mxID(_next), 0); result = the->stack; mxGetID(result, mxID(_done)); if (fxToBoolean(the, the->stack)) break; the->stack++; mxGetID(result, mxID(_value)); if (function) { /* ARG1 */ mxPushInteger(count); /* ARGC */ mxPushInteger(2); /* THIS */ if (_this) mxPushSlot(_this); else mxPushUndefined(); /* FUNCTION */ mxPushReference(function); fxCall(the); } item = fxNextSlotProperty(the, item, the->stack, XS_NO_ID, XS_NO_FLAG); the->stack++; count++; } } mxCatch(the) { mxCallID(iterator, mxID(_return), 0); fxJump(the); } } the->stack++; } else {