void fx_Function_prototype_apply(txMachine* the)
{
txInteger c, i;
if ((mxArgc < 2) || (mxArgv(1)->kind == XS_UNDEFINED_KIND) || (mxArgv(1)->kind == XS_NULL_KIND))
c = 0;
else {
fxToInstance(the, mxArgv(1));
mxPushSlot(mxArgv(1));
fxGetID(the, mxID(_length));
c = fxToInteger(the, the->stack);
the->stack++;
for (i = 0; i < c; i++) {
mxPushSlot(mxArgv(1));
fxGetID(the, (txID)i);
}
}
/* ARGC */
mxPushInteger(c);
/* THIS */
if (mxArgc < 1)
mxPushUndefined();
else
mxPushSlot(mxArgv(0));
/* FUNCTION */
mxPushSlot(mxThis);
fxCall(the);
mxPullSlot(mxResult);
}
void fx_Function_prototype_bound(txMachine* the)
{
txSlot* boundArguments;
txInteger c, i;
txSlot* argument;
mxPush(*mxFunction);
fxGetID(the, mxID(_boundArguments));
boundArguments = fxGetInstance(the, the->stack);
the->stack++;
c = boundArguments->next->value.array.length;
argument = boundArguments->next->value.array.address;
for (i = 0; i < c; i++) {
mxPushSlot(argument);
argument++;
}
for (i = 0; i < mxArgc; i++) {
mxPushSlot(mxArgv(i));
}
/* ARGC */
mxPushInteger(c + mxArgc);
/* THIS */
mxPushSlot(mxFunction);
fxGetID(the, mxID(_boundThis));
/* FUNCTION */
mxPushSlot(mxFunction);
fxGetID(the, mxID(_boundFunction));
fxCall(the);
mxPullSlot(mxResult);
}
void fxCallID(txMachine* the, txInteger theID)
{
mxPushUndefined();
*the->stack = *(the->stack + 1);
fxGetID(the, theID);
fxCall(the);
}
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;
}
void fxEnumerate(txMachine* the)
{
mxPushInteger(0);
/* SWAP THIS */
the->scratch = *(the->stack);
*(the->stack) = *(the->stack + 1);
*(the->stack + 1) = the->scratch;
/* FUNCTION */
mxPush(mxEnumeratorFunction);
fxCall(the);
}
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 fx_setTimeoutCallback(CFRunLoopTimerRef timer, void *info)
{
txTimeoutData* data = info;
txMachine* the = data->the;
fxBeginHost(the);
{
mxPush(data->argument);
/* ARGC */
mxPushInteger(1);
/* THIS */
mxPushUndefined();
/* FUNCTION */
mxPush(data->function);
fxCall(the);
the->stack++;
}
fxEndHost(the);
}
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 fx_Function_prototype_call(txMachine* the)
{
txInteger c, i;
c = mxArgc;
i = 1;
while (i < c) {
mxPushSlot(mxArgv(i));
i++;
}
/* ARGC */
mxPushInteger(i - 1);
/* THIS */
if (mxArgc < 1)
mxPushUndefined();
else
mxPushSlot(mxArgv(0));
/* FUNCTION */
mxPushSlot(mxThis);
fxCall(the);
mxPullSlot(mxResult);
}
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);
}
}
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 console_log(xsMachine* the)
{
xsIntegerValue c = xsToInteger(xsArgc), i;
xsBooleanValue space = 0;
xsVars(4);
console_log_depth++;
for (i = 0; i < c; i++) {
if (space)
fprintf(stdout, " ");
else
space = 1;
switch (xsTypeOf(xsArg(i))) {
case xsUndefinedType:
case xsNullType:
case xsBooleanType:
case xsIntegerType:
case xsNumberType:
fprintf(stdout, "%s", xsToString(xsArg(i)));
break;
case xsSymbolType:
xsResult = xsCall1(xsGlobal, xsID("String"), xsArg(i));
fprintf(stdout, "%s", xsToString(xsResult));
break;
case xsStringType:
case xsStringXType:
if ((console_log_depth == 1) && (i == 0))
fprintf(stdout, "%s", xsToString(xsArg(i)));
else
fprintf(stdout, "'%s'", xsToString(xsArg(i)));
break;
case xsReferenceType:
if (console_log_depth < 3) {
xsBooleanValue comma = 0;
if (xsHas(xsArg(i), xsID("length"))) {
xsIntegerValue length = xsToInteger(xsGet(xsArg(i), xsID("length"))), index;
fprintf(stdout, "[");
for (index = 0; index < length; index++) {
if (comma)
fprintf(stdout, ",");
else
comma = 1;
fprintf(stdout, " ");
if (xsHas(xsArg(i), (xsIndex)index)) {
xsVar(1) = xsGet(xsArg(i), (xsIndex)index);
fxPush(xsVar(1));
fxPushCount(the, 1);
fxPush(xsThis);
fxPush(xsFunction);
fxCall(the);
}
}
fprintf(stdout, " ]");
}
else {
fprintf(stdout, "{");
xsVar(0) = xsEnumerate(xsArg(i));
for (;;) {
xsVar(1) = xsCall0(xsVar(0), xsID("next"));
if (xsTest(xsGet(xsVar(1), xsID("done"))))
break;
xsVar(2) = xsGet(xsVar(1), xsID("value"));
xsVar(3) = xsGetAt(xsArg(i), xsVar(2));
if (comma)
fprintf(stdout, ",");
else
comma = 1;
fprintf(stdout, " %s: ", xsToString(xsVar(2)));
fxPush(xsVar(3));
fxPushCount(the, 1);
fxPush(xsThis);
fxPush(xsFunction);
fxCall(the);
}
fprintf(stdout, " }");
}
}
else
fprintf(stdout, "%s", xsToString(xsArg(i)));
break;
}
}
console_log_depth--;
if (!console_log_depth)
fprintf(stdout, "\n");
}
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 {
void
xs_console_log(xsMachine* the)
{
xsIntegerValue c = xsToInteger(xsArgc), i;
xsBooleanValue space = 0;
xsBooleanValue comma = 0;
xsBooleanValue nonl = 0;
int options = 0;
FILE *console_out = stdout;
xsVars(4);
console_log_depth++;
for (i = 0; i < c; i++) {
if (space && !nonl)
CONSOLE_OUT("\n");
else
space = 1;
switch (xsTypeOf(xsArg(i))) {
case xsUndefinedType:
case xsNullType:
case xsBooleanType:
case xsIntegerType:
case xsNumberType:
CONSOLE_OUT("%s", xsToString(xsArg(i)));
break;
case xsSymbolType:
xsResult = xsCall1(xsGlobal, xsID("String"), xsArg(i));
CONSOLE_OUT("%s", xsToString(xsResult));
break;
case xsStringType:
case xsStringXType:
if (i == 0 || options) {
const char *opt = xsToString(xsArg(i));
options = 0;
if (strcmp(opt, "-n") == 0) {
nonl++;
options++;
}
else if (strcmp(opt, "-stderr") == 0) {
console_out = stderr;
options++;
}
else if (strcmp(opt, "-stdout") == 0) {
console_out = stdout;
options++;
}
else if (strncmp(opt, "-", 1) == 0) /* end of the option args */
break;
if (options) {
space = 0;
break;
}
}
if (console_log_depth == 1)
CONSOLE_OUT("%s", xsToString(xsArg(i)));
else
CONSOLE_OUT("\"%s\"", xsToString(xsArg(i)));
break;
case xsReferenceType:
if (xsIsInstanceOf(xsArg(i), xsFunctionPrototype)) {
CONSOLE_OUT("function(...) { ... }");
}
else if (xsIsInstanceOf(xsArg(i), xsArrayPrototype)) {
xsGet(xsVar(0), xsArg(i), xsID("length"));
xsIntegerValue length = xsToInteger(xsVar(0)), index;
CONSOLE_OUT("[\n");
for (index = 0; index < length; index++) {
xsGet(xsVar(1), xsArg(i), (xsIndex)index);
if (comma)
CONSOLE_OUT(",\n");
else
comma = 1;
indent(the, console_out, 0);
fxPush(xsVar(1));
fxPushCount(the, 1);
fxPush(xsThis);
fxPush(xsFunction);
fxCall(the);
}
CONSOLE_OUT("\n"); indent(the, console_out, -1); CONSOLE_OUT("]");
}
else {
CONSOLE_OUT( "{\n");
xsVar(0) = xsEnumerate(xsArg(i));
for (;;) {
xsVar(1) = xsCall0(xsVar(0), xsID("next"));
xsGet(xsVar(2), xsVar(1), xsID("done"));
if (xsTest(xsVar(2)))
break;
xsGet(xsVar(2), xsVar(1), xsID("value"));
xsGetAt(xsVar(3), xsArg(i), xsVar(2));
if (comma)
CONSOLE_OUT( ",\n");
else
comma = 1;
indent(the, console_out, 0); CONSOLE_OUT("%s: ", xsToString(xsVar(2)));
fxPush(xsVar(3));
fxPushCount(the, 1);
fxPush(xsThis);
fxPush(xsFunction);
fxCall(the);
}
CONSOLE_OUT("\n"); indent(the, console_out, -1); CONSOLE_OUT("}");
}
break;
}
}
console_log_depth--;
if (!console_log_depth && !nonl)
CONSOLE_OUT("\n");
}