void fxSerializeJSONOwnProperty(txMachine* the, txSlot* theContext, txID id, txIndex index, txSlot* theProperty)
{
txJSONSerializer* theSerializer = theContext->value.regexp.code;
txInteger* theFlag = theContext->value.regexp.offsets;
if (id) {
txSlot* key = fxGetKey(the, id);
if (key && (key->flag & XS_DONT_ENUM_FLAG)) {
if (key->kind == XS_KEY_KIND) {
mxPushSlot(theProperty);
mxPushString(key->value.key.string);
fxSerializeJSONProperty(the, theSerializer, theFlag);
}
else {
mxPushSlot(theProperty);
mxPushStringX(key->value.key.string);
fxSerializeJSONProperty(the, theSerializer, theFlag);
}
}
}
else {
mxPushSlot(theProperty);
mxPushInteger((txInteger)index);
fxSerializeJSONProperty(the, theSerializer, theFlag);
}
}
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_Error_toString(txMachine* the)
{
txInteger aLength;
mxPushSlot(mxThis);
fxGetID(the, mxID(_name));
if (the->stack->kind == XS_UNDEFINED_KIND)
fxCopyStringC(the, the->stack, "Error");
else
fxToString(the, the->stack);
mxPushSlot(mxThis);
fxGetID(the, mxID(_message));
if (the->stack->kind == XS_UNDEFINED_KIND)
fxCopyStringC(the, the->stack, "");
else
fxToString(the, the->stack);
aLength = c_strlen(the->stack->value.string);
if (aLength) {
aLength += c_strlen((the->stack + 1)->value.string) + 2;
mxResult->value.string = (txString)fxNewChunk(the, aLength + 1);
mxResult->kind = XS_STRING_KIND;
c_strcpy(mxResult->value.string, (the->stack + 1)->value.string);
c_strcat(mxResult->value.string, ": ");
c_strcat(mxResult->value.string, the->stack->value.string);
the->stack++;
the->stack++;
}
else {
the->stack++;
mxPullSlot(mxResult);
}
}
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* fxConstructArrayResult(txMachine* the, txSlot* constructor, txUnsigned length)
{
mxPushUnsigned(length);
mxPushInteger(1);
if (constructor) {
mxPushSlot(constructor);
fxGetID(the, mxID(_Symbol_species));
}
else {
txSlot* instance = mxThis->value.reference;
if (mxIsArray(instance)) {
mxPushSlot(mxThis);
fxGetID(the, mxID(_constructor));
if (mxIsReference(the->stack) && mxIsFunction(the->stack->value.reference))
fxGetID(the, mxID(_Symbol_species));
else
the->stack->kind = XS_UNDEFINED_KIND;
}
else
mxPushUndefined();
}
if (the->stack->kind == XS_NULL_KIND)
the->stack->kind = XS_UNDEFINED_KIND;
if (the->stack->kind == XS_UNDEFINED_KIND) {
*the->stack = mxGlobal;
fxGetID(the, mxID(_Array));
}
fxNew(the);
mxPullSlot(mxResult);
return mxResult->value.reference->next;
}
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 fx_xs_isInstanceOf(txMachine* the)
{
if ((mxArgc < 1) || (mxArgv(0)->kind != XS_REFERENCE_KIND))
mxTypeError("instance is no object");
if ((mxArgc < 2) || (mxArgv(1)->kind != XS_REFERENCE_KIND))
mxTypeError("prototype is no object");
mxPushSlot(mxArgv(1));
mxPushSlot(mxArgv(0));
mxResult->value.boolean = fxIsInstanceOf(the);
mxResult->kind = XS_BOOLEAN_KIND;
}
void fx_Function_prototype_hasInstance(txMachine* the)
{
txSlot* instance;
txSlot* prototype;
mxResult->value.boolean = 0;
mxResult->kind = XS_BOOLEAN_KIND;
if (mxArgc == 0)
return;
instance = fxGetInstance(the, mxArgv(0));
if (!instance)
return;
mxPushSlot(mxThis);
fxGetID(the, mxID(_prototype));
prototype = fxGetInstance(the, the->stack);
if (!prototype)
mxTypeError("prototype is no object");
while (instance) {
if (instance == prototype) {
mxResult->value.boolean = 1;
break;
}
instance = fxGetParent(the, instance);
}
the->stack++;
}
void fx_xs_newInstanceOf(txMachine* the)
{
if ((mxArgc < 1) || (mxArgv(0)->kind != XS_REFERENCE_KIND))
mxTypeError("prototype is no object");
mxPushSlot(mxArgv(0));
fxNewInstanceOf(the);
mxPullSlot(mxResult);
}
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 fxSerializeJSON(txMachine* the, txJSONSerializer* theSerializer)
{
txSlot* aSlot;
txInteger aFlag;
aSlot = fxGetInstance(the, mxThis);
theSerializer->offset = 0;
theSerializer->size = 1024;
theSerializer->buffer = c_malloc(1024);
if (!theSerializer->buffer)
mxUnknownError("out of memory");
if (mxArgc > 1) {
aSlot = mxArgv(1);
if (mxIsReference(aSlot)) {
aSlot = fxGetInstance(the, aSlot);
if (mxIsFunction(aSlot))
theSerializer->replacer = mxArgv(1);
else if (mxIsArray(aSlot))
mxSyntaxError("not yet implememented");
}
}
if (mxArgc > 2) {
aSlot = mxArgv(2);
if (mxIsReference(aSlot)) {
aSlot = fxGetInstance(the, aSlot);
if (mxIsNumber(aSlot) || mxIsString(aSlot))
aSlot = aSlot->next;
}
if ((aSlot->kind == XS_INTEGER_KIND) || (aSlot->kind == XS_NUMBER_KIND)) {
txInteger aCount = fxToInteger(the, aSlot), anIndex;
if (aCount < 0)
aCount = 0;
else if (aCount > 10)
aCount = 10;
for (anIndex = 0; anIndex < aCount; anIndex++)
theSerializer->indent[anIndex] = ' ';
}
else if (mxIsStringPrimitive(aSlot))
c_strncpy((char *)theSerializer->indent, aSlot->value.string, 10);
}
theSerializer->stack = the->stack;
mxPush(mxObjectPrototype);
fxNewObjectInstance(the);
aFlag = 0;
if (mxArgc > 0)
mxPushSlot(mxArgv(0));
else
mxPushUndefined();
mxPush(mxEmptyString);
fxSerializeJSONProperty(the, theSerializer, &aFlag);
the->stack++;
}
void fx_Date_prototype_toPrimitive(txMachine* the)
{
if (mxThis->kind == XS_REFERENCE_KIND) {
txInteger hint = ((mxArgc > 0) && (c_strcmp(fxToString(the, mxArgv(0)), "number") == 0)) ? XS_NUMBER_HINT : XS_STRING_HINT;
if (hint == XS_STRING_HINT) {
mxPushInteger(0);
mxPushSlot(mxThis);
fxCallID(the, mxID(_toString));
if (mxIsReference(the->stack)) {
the->stack++;
mxPushInteger(0);
mxPushSlot(mxThis);
fxCallID(the, mxID(_valueOf));
}
}
else {
mxPushInteger(0);
mxPushSlot(mxThis);
fxCallID(the, mxID(_valueOf));
if (mxIsReference(the->stack)) {
the->stack++;
mxPushInteger(0);
mxPushSlot(mxThis);
fxCallID(the, mxID(_toString));
}
}
if (mxIsReference(the->stack)) {
if (hint == XS_STRING_HINT)
mxTypeError("Cannot coerce object to string");
else
mxTypeError("Cannot coerce object to number");
}
mxResult->kind = the->stack->kind;
mxResult->value = the->stack->value;
the->stack++;
}
else {
mxResult->kind = mxThis->kind;
mxResult->value = mxThis->value;
}
}
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 fx_Enumerator(txMachine* the)
{
txSlot* iterator;
if (mxThis->kind == XS_REFERENCE_KIND)
fxEnumerateInstance(the, mxThis->value.reference);
else {
mxPushSlot(mxFunctionInstancePrototype(mxEnumeratorFunction.value.reference));
iterator = fxNewIteratorInstance(the, mxThis);
mxPullSlot(mxResult);
iterator->next->next->next = C_NULL;
}
}
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 fx_JSON_parse(txMachine* the)
{
volatile txJSONParser* aParser = C_NULL;
txSlot* slot;
mxTry(the) {
if (mxArgc < 1)
mxSyntaxError("no buffer");
aParser = c_malloc(sizeof(txJSONParser));
if (NULL == aParser)
mxUnknownError("out of memory");
c_memset((txJSONParser*)aParser, 0, sizeof(txJSONParser));
if (mxArgc > 1) {
slot = mxArgv(1);
if (slot->kind == XS_REFERENCE_KIND) {
slot = slot->value.reference;
if (slot->next && ((slot->next->kind == XS_CODE_KIND) || (slot->next->kind == XS_CODE_X_KIND) || (slot->next->kind == XS_CALLBACK_KIND)))
aParser->reviver = slot;
}
}
slot = mxArgv(0);
if (slot->kind == XS_REFERENCE_KIND) {
slot = slot->value.reference->next;
if (slot && (slot->flag & XS_INTERNAL_FLAG) && (slot->kind == XS_HOST_KIND)) {
aParser->data = slot->value.host.data;
aParser->offset = 0;
mxPushSlot(mxArgv(0));
fxGetID(the, mxID(_length));
aParser->size = fxToInteger(the, the->stack++);
}
}
if (!aParser->data) {
fxToString(the, mxArgv(0));
aParser->slot = mxArgv(0);
aParser->offset = 0;
aParser->size = c_strlen(aParser->slot->value.string);
}
fxParseJSON(the, (txJSONParser*)aParser);
mxPullSlot(mxResult);
c_free((txJSONParser*)aParser);
// @@ reviver
}
mxCatch(the) {
if (aParser)
c_free((txJSONParser*)aParser);
fxJump(the);
}
}
void fx_xs_setProfilingDirectory(txMachine* the)
{
if (the->profileDirectory) {
c_free(the->profileDirectory);
the->profileDirectory = C_NULL;
}
if (mxArgc > 0) {
mxPushSlot(mxArgv(0));
if (fxRunTest(the)) {
txString aString = fxToString(the, mxArgv(0));
txInteger aLength = c_strlen(aString) + 1;
the->profileDirectory = c_malloc(aLength);
if (!the->profileDirectory)
fxJump(the);
c_memcpy(the->profileDirectory, aString, aLength);
}
}
}
void fxToPrimitive(txMachine* the, txSlot* theSlot, txInteger theHint)
{
if (theSlot->kind == XS_REFERENCE_KIND) {
fxBeginHost(the);
if (theHint == XS_NO_HINT)
mxPushString(mxDefaultString.value.string);
else if (theHint == XS_NUMBER_HINT)
mxPushString(mxNumberString.value.string);
else
mxPushString(mxStringString.value.string);
mxPushInteger(1);
mxPushSlot(theSlot);
fxCallID(the, mxID(_Symbol_toPrimitive));
theSlot->kind = the->stack->kind;
theSlot->value = the->stack->value;
the->stack++;
fxEndHost(the);
}
}
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 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 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
}
