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 {
