/*

 * Copyright (c) 2016-2025  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 <http://www.gnu.org/licenses/>.

 *

 * 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.

 */

#include "xsAll.h"

enum {

  XS_NO_JSON_TOKEN,

  XS_JSON_TOKEN_COLON,

  XS_JSON_TOKEN_COMMA,

  XS_JSON_TOKEN_EOF,

  XS_JSON_TOKEN_FALSE,

  XS_JSON_TOKEN_INTEGER,

  XS_JSON_TOKEN_LEFT_BRACE,

  XS_JSON_TOKEN_LEFT_BRACKET,

  XS_JSON_TOKEN_NULL,

  XS_JSON_TOKEN_NUMBER,

  XS_JSON_TOKEN_RIGHT_BRACE,

  XS_JSON_TOKEN_RIGHT_BRACKET,

  XS_JSON_TOKEN_STRING,

  XS_JSON_TOKEN_TRUE,

};

typedef struct {

  txSlot* slot;

  txSize offset;

  txInteger integer;

  txNumber number;

  txSlot* string;

  txInteger token;

  txSlot* keys;

  txInteger line;

} txJSONParser;

typedef struct {

  txString buffer;

  char indent[64];

  txInteger indentLength;

  txInteger level;

  txSize offset;

  txSize size;

  txSlot* replacer;

  txSlot* keys;

  txSlot* stack;

} txJSONStringifier;

static void fxParseJSON(txMachine* the, txJSONParser* theParser);

static void fxParseJSONArray(txMachine* the, txJSONParser* theParser);

static void fxParseJSONObject(txMachine* the, txJSONParser* theParser);

static void fxParseJSONToken(txMachine* the, txJSONParser* theParser);

static void fxParseJSONValue(txMachine* the, txJSONParser* theParser);

static void fxReviveJSON(txMachine* the, txSlot* reviver);

static void fxStringifyJSON(txMachine* the, txJSONStringifier* theStringifier);

static void fxStringifyJSONCharacter(txMachine* the, txJSONStringifier* theStringifier, txInteger character);

static void fxStringifyJSONChars(txMachine* the, txJSONStringifier* theStringifier, char* s, txSize theSize);

static void fxStringifyJSONIndent(txMachine* the, txJSONStringifier* theStringifier);

static void fxStringifyJSONInteger(txMachine* the, txJSONStringifier* theStringifier, txInteger theInteger);

static void fxStringifyJSONName(txMachine* the, txJSONStringifier* theStringifier, txInteger* theFlag);

static void fxStringifyJSONNumber(txMachine* the, txJSONStringifier* theStringifier, txNumber theNumber);

static void fxStringifyJSONProperty(txMachine* the, txJSONStringifier* theStringifier, txInteger* theFlag);

static void fxStringifyJSONString(txMachine* the, txJSONStringifier* theStringifier, txString theString);

static void fxStringifyJSONUnicodeEscape(txMachine* the, txJSONStringifier* theStringifier, txInteger character);

static txSlot* fxToJSONKeys(txMachine* the, txSlot* reference);

void fxBuildJSON(txMachine* the)

{

  txSlot* slot;

  mxPush(mxObjectPrototype);

  slot = fxLastProperty(the, fxNewObjectInstance(the));

  slot = fxNextHostFunctionProperty(the, slot, mxCallback(fx_JSON_parse), 2, mxID(_parse), XS_DONT_ENUM_FLAG);

  slot = fxNextHostFunctionProperty(the, slot, mxCallback(fx_JSON_stringify), 3, mxID(_stringify), XS_DONT_ENUM_FLAG);

  slot = fxNextStringXProperty(the, slot, "JSON", mxID(_Symbol_toStringTag), XS_DONT_ENUM_FLAG | XS_DONT_SET_FLAG);

  mxPull(mxJSONObject);

}

void fx_JSON_parse(txMachine* the)

{

  volatile txJSONParser aParser = {0};

  if (mxArgc < 1)

    mxSyntaxError("no buffer");

  if ((mxArgc > 1) && mxIsReference(mxArgv(1)) && fxIsArray(the, mxArgv(1)->value.reference))

    aParser.keys = fxToJSONKeys(the, mxArgv(1));

  fxToString(the, mxArgv(0));

  aParser.slot = mxArgv(0);

  aParser.offset = 0;

  fxParseJSON(the, (txJSONParser*)&aParser);

  mxPullSlot(mxResult);

  if (aParser.keys)

    mxPop();

  if ((mxArgc > 1) && mxIsReference(mxArgv(1)) && mxIsCallable(mxArgv(1)->value.reference)) {

    txSlot* instance;

    txID id;

    mxPush(mxObjectPrototype);

    instance = fxNewObjectInstance(the);

    id = fxID(the, "");

    mxBehaviorDefineOwnProperty(the, instance, id, 0, mxResult, XS_GET_ONLY);

    mxPushSlot(mxArgv(1));

    mxCall();

    mxPushUndefined();

    fxKeyAt(the, id, 0, the->stack);

    mxPushSlot(mxResult);

    fxReviveJSON(the, mxArgv(1));

    mxPullSlot(mxResult);

  }

}

void fxParseJSON(txMachine* the, txJSONParser* theParser)

{

  mxPush(mxEmptyString);

  theParser->string = the->stack;

  theParser->line = 1;

  fxParseJSONToken(the, theParser);

  fxParseJSONValue(the, theParser);

  if (theParser->token != XS_JSON_TOKEN_EOF)

    mxSyntaxError("%ld: missing EOF", theParser->line);

}

void fxParseJSONArray(txMachine* the, txJSONParser* theParser)

{

  txSlot* anArray;

  txIndex aLength;

  txSlot* anItem;

  mxCheckCStack();

  fxParseJSONToken(the, theParser);

  mxPush(mxArrayPrototype);

  anArray = fxNewArrayInstance(the);

  aLength = 0;

  anItem = fxLastProperty(the, anArray);

  for (;;) {

    if (theParser->token == XS_JSON_TOKEN_RIGHT_BRACKET)

      break;

    if (aLength) {

      if (theParser->token == XS_JSON_TOKEN_COMMA)

        fxParseJSONToken(the, theParser);

      else

        mxSyntaxError("%ld: missing ,", theParser->line);  

    }  

    fxParseJSONValue(the, theParser);

    aLength++;

    anItem->next = fxNewSlot(the);

    anItem = anItem->next;

    anItem->kind = the->stack->kind;

    anItem->value = the->stack->value;

    mxPop();

  }

  anArray->next->value.array.length = aLength;

  fxCacheArray(the, anArray);

  fxParseJSONToken(the, theParser);

}

void fxParseJSONToken(txMachine* the, txJSONParser* theParser)

{

  txInteger character;

  txBoolean escaped;

  txNumber number;

  txSize offset;

  txSize size;

  txString p, s;

  theParser->integer = 0;

  theParser->number = 0;

  theParser->string->value.string = mxEmptyString.value.string;

  theParser->string->kind = mxEmptyString.kind;

  theParser->token = XS_NO_JSON_TOKEN;

  p = theParser->slot->value.string + theParser->offset;

  while (theParser->token == XS_NO_JSON_TOKEN) {

    switch (*p) {

    case 0:

      theParser->token = XS_JSON_TOKEN_EOF;

      break;

    case 10:

      p++;

      theParser->line++;

      break;

    case 13:

      p++;

      theParser->line++;

      if (*p == 10)

        p++;

      break;

    case '\t':

    case ' ':

      p++;

      break;

    case '-':

    case '0':

    case '1':

    case '2':

    case '3':

    case '4':

    case '5':

    case '6':

    case '7':

    case '8':

    case '9':

      s = p;

      if (*p == '-')

        p++;

      if (('0' <= *p) && (*p <= '9')) {

        if (*p == '0') {

          p++;

        }

        else {

          p++;

          while (('0' <= *p) && (*p <= '9'))

            p++;

        }

        if (*p == '.') {

          p++;

          if (('0' <= *p) && (*p <= '9')) {

            p++;

            while (('0' <= *p) && (*p <= '9'))

              p++;

          }

          else

            goto error;

        }

        if ((*p == 'e') || (*p == 'E')) {

          p++;

          if ((*p == '+') || (*p == '-'))

            p++;

          if (('0' <= *p) && (*p <= '9')) {

            p++;

            while (('0' <= *p) && (*p <= '9'))

              p++;

          }

          else

            goto error;

        }

      }

      else

        goto error;

      size = mxPtrDiff(p - s);

      if ((size_t)(size + 1) > sizeof(the->nameBuffer))

        mxSyntaxError("%ld: number overflow", theParser->line);

      c_memcpy(the->nameBuffer, s, size);

      the->nameBuffer[size] = 0;

      theParser->number = fxStringToNumber(the, the->nameBuffer, 0);

      theParser->integer = (txInteger)theParser->number;

      number = theParser->integer;

      if ((theParser->number == number) && (theParser->number != -0))

        theParser->token = XS_JSON_TOKEN_INTEGER;

      else

        theParser->token = XS_JSON_TOKEN_NUMBER;

      break;

    case ',':

      p++;

      theParser->token = XS_JSON_TOKEN_COMMA;

      break;  

    case ':':

      p++;

      theParser->token = XS_JSON_TOKEN_COLON;

      break;  

    case '[':

      p++;

      theParser->token = XS_JSON_TOKEN_LEFT_BRACKET;

      break;  

    case ']':

      p++;

      theParser->token = XS_JSON_TOKEN_RIGHT_BRACKET;

      break;  

    case '{':

      p++;

      theParser->token = XS_JSON_TOKEN_LEFT_BRACE;

      break;  

    case '}':

      p++;

      theParser->token = XS_JSON_TOKEN_RIGHT_BRACE;

      break;  

    case '"':

      p++;

      escaped = 0;

      offset = mxPtrDiff(p - theParser->slot->value.string);

      size = 0;

      for (;;) {

        p = mxStringByteDecode(p, &character);

        if (character < 32) {

          goto error;

        }

        else if (character == '"') {

          break;

        }

        else if (character == '\\') {

          escaped = 1;

          switch (*p) {

          case '"':

          case '/':

          case '\\':

          case 'b':

          case 'f':

          case 'n':

          case 'r':

          case 't':

            p++;

            size++;

            break;

          case 'u':

            p++;

            if (fxParseUnicodeEscape(&p, &character, 0, '\\'))

              size += mxStringByteLength(character);

            else

              goto error;

            break;

          default:

            goto error;

          }

        }

        else {

          size += mxStringByteLength(character);

        }

      }

      s = theParser->string->value.string = fxNewChunk(the, size + 1);

      theParser->string->kind = XS_STRING_KIND;

      p = theParser->slot->value.string + offset;

      if (escaped) {

        for (;;) {

          if (*p == '"') {

            p++;

            *s = 0;

            break;

          }

          else if (*p == '\\') {

            p++;

            switch (*p) {

            case '"':

            case '/':

            case '\\':

              *s++ = *p++;

              break;

            case 'b':

              p++;

              *s++ = '\b';

              break;

            case 'f':

              p++;

              *s++ = '\f';

              break;

            case 'n':

              p++;

              *s++ = '\n';

              break;

            case 'r':

              p++;

              *s++ = '\r';

              break;

            case 't':

              p++;

              *s++ = '\t';

              break;

            case 'u':

              p++;

              fxParseUnicodeEscape(&p, &character, 0, '\\');

              s = mxStringByteEncode(s, character);

              break;

            }

          }

          else {

            *s++ = *p++;

          }

        }

      }

      else {

        c_memcpy(s, p, size);

        p += size + 1;

        s[size] = 0;

      }

      theParser->token = XS_JSON_TOKEN_STRING;

      break;

    case 'f':

      p++;

      if (*p != 'a') goto error;  

      p++;

      if (*p != 'l') goto error;  

      p++;

      if (*p != 's') goto error;  

      p++;

      if (*p != 'e') goto error;  

      p++;

      theParser->token = XS_JSON_TOKEN_FALSE;

      break;

    case 'n':

      p++;

      if (*p != 'u') goto error;

      p++;

      if (*p != 'l') goto error;

      p++;

      if (*p != 'l') goto error;

      p++;

      theParser->token = XS_JSON_TOKEN_NULL;

      break;

    case 't':

      p++;

      if (*p != 'r') goto error;

      p++;

      if (*p != 'u') goto error;

      p++;

      if (*p != 'e') goto error;

      p++;

      theParser->token = XS_JSON_TOKEN_TRUE;

      break;

    default:

    error:

      mxSyntaxError("%ld: invalid character", theParser->line); 

      break;

    }

  }

  theParser->offset = mxPtrDiff(p - theParser->slot->value.string);

}

void fxParseJSONObject(txMachine* the, txJSONParser* theParser)

{

  txSlot* anObject;

  txBoolean comma = 0;

  txSlot* at;

  txIndex index;

  txID id;

  txSlot* aProperty;

  mxCheckCStack();

  fxParseJSONToken(the, theParser);

  mxPush(mxObjectPrototype);

  anObject = fxNewObjectInstance(the);

  for (;;) {

    if (theParser->token == XS_JSON_TOKEN_RIGHT_BRACE)

      break;

    if (comma) {

      if (theParser->token == XS_JSON_TOKEN_COMMA)

        fxParseJSONToken(the, theParser);

      else

        mxSyntaxError("%ld: missing ,", theParser->line);  

    }  

    if (theParser->token != XS_JSON_TOKEN_STRING)

      mxSyntaxError("%ld: missing name", theParser->line);

    mxPushString(theParser->string->value.string);

    at = the->stack;

    index = 0;

    if (theParser->keys) {

      at->kind = XS_UNDEFINED_KIND;

      if (fxStringToIndex(the, at->value.string, &index))

        id = 0;

      else

        id = fxFindName(the, at->value.string);

      if (id != XS_NO_ID) {

        txSlot* item = theParser->keys->value.reference->next;

        while (item) {

          if ((item->value.at.id == id) && (item->value.at.index == index)) {

            at->value.at.id = id;

            at->value.at.index = index;

            at->kind = XS_AT_KIND;

            break;

          }

          item = item->next;

        }

      }

    }

    else {

      if (fxStringToIndex(the, at->value.string, &index))

        id = 0;

      else

        id = fxNewName(the, at);

      at->value.at.id = id;

            at->value.at.index = index;

      at->kind = XS_AT_KIND;

    }

    fxParseJSONToken(the, theParser);

    if (theParser->token != XS_JSON_TOKEN_COLON)

      mxSyntaxError("%ld: missing :", theParser->line);

    fxParseJSONToken(the, theParser);

    fxParseJSONValue(the, theParser);

    if ((at->kind == XS_AT_KIND) && (the->stack->kind != XS_UNDEFINED_KIND)) {

      aProperty = mxBehaviorSetProperty(the, anObject, at->value.at.id, at->value.at.index, XS_OWN);

      aProperty->kind = the->stack->kind;

      aProperty->value = the->stack->value;

    }

    mxPop();

    mxPop();

    comma = 1;

  }

  fxParseJSONToken(the, theParser);

}

void fxParseJSONValue(txMachine* the, txJSONParser* theParser)

{

  switch (theParser->token) {

  case XS_JSON_TOKEN_FALSE:

    mxPushBoolean(0);

    fxParseJSONToken(the, theParser);

    break;

  case XS_JSON_TOKEN_TRUE:

    mxPushBoolean(1);

    fxParseJSONToken(the, theParser);

    break;

  case XS_JSON_TOKEN_NULL:

    mxPushNull();

    fxParseJSONToken(the, theParser);

    break;

  case XS_JSON_TOKEN_INTEGER:

    mxPushInteger(theParser->integer);

    fxParseJSONToken(the, theParser);

    break;

  case XS_JSON_TOKEN_NUMBER:

    mxPushNumber(theParser->number);

    fxParseJSONToken(the, theParser);

    break;

  case XS_JSON_TOKEN_STRING:

    mxPushString(theParser->string->value.string);

    fxParseJSONToken(the, theParser);

    break;

  case XS_JSON_TOKEN_LEFT_BRACE:

    fxParseJSONObject(the, theParser);

    break;

  case XS_JSON_TOKEN_LEFT_BRACKET:

    fxParseJSONArray(the, theParser);

    break;

  default:

    mxPushUndefined();

    mxSyntaxError("%ld: invalid value", theParser->line);

    break;

  }

}

void fxReviveJSON(txMachine* the, txSlot* reviver)

{

  txSlot* reference = the->stack;

  mxCheckCStack();

  if (mxIsReference(reference)) {

    txSlot* instance = reference->value.reference;

    if (fxIsArray(the, instance)) {

      txIndex length, index;

      mxPushSlot(reference);

      mxGetID(mxID(_length));

      length = (txIndex)fxToLength(the, the->stack);

      mxPop();

      index = 0;

      while (index < length) {

        mxPushSlot(reference);

        mxPushSlot(reviver);

        mxCall();

        mxPushUndefined();

        fxKeyAt(the, 0, index, the->stack);

        mxPushSlot(reference);

        mxGetIndex(index);

        fxReviveJSON(the, reviver);

        if (mxIsUndefined(the->stack)) {

          mxBehaviorDeleteProperty(the, reference->value.reference, 0, index);

        }

        else {

          mxBehaviorDefineOwnProperty(the, reference->value.reference, 0, index, the->stack, XS_GET_ONLY);

        }

        mxPop();

        index++;

      }

    }

    else {

      txSlot* at = fxNewInstance(the);

      mxBehaviorOwnKeys(the, instance, XS_EACH_NAME_FLAG, at);

      while ((at = at->next)) {

        mxPushSlot(reference);

        mxPushSlot(reviver);

                mxCall();

        mxPushUndefined();

        fxKeyAt(the, at->value.at.id, at->value.at.index, the->stack);

        mxPushSlot(reference);

        mxGetAll(at->value.at.id, at->value.at.index);

        fxReviveJSON(the, reviver);

        if (mxIsUndefined(the->stack)) {

          mxBehaviorDeleteProperty(the, reference->value.reference, at->value.at.id, at->value.at.index);

        }

        else {

          mxBehaviorDefineOwnProperty(the, reference->value.reference, at->value.at.id, at->value.at.index, the->stack, XS_GET_ONLY);

        }

        mxPop();

      }

      mxPop();

    }

  }

  mxRunCount(2);

}

void fx_JSON_stringify(txMachine* the)

{

  volatile txJSONStringifier aStringifier = {0};

  mxTry(the) {

    fxStringifyJSON(the, (txJSONStringifier*)&aStringifier);

    if (aStringifier.offset) {

      fxStringifyJSONChars(the, (txJSONStringifier*)&aStringifier, "\0", 1);

      mxResult->value.string = (txString)fxNewChunk(the, aStringifier.offset);

      c_memcpy(mxResult->value.string, aStringifier.buffer, aStringifier.offset);

      mxResult->kind = XS_STRING_KIND;

    }

    c_free(aStringifier.buffer);

  }

  mxCatch(the) {

    if (aStringifier.buffer)

      c_free(aStringifier.buffer);

    fxJump(the);

  }

}

void fxStringifyJSON(txMachine* the, txJSONStringifier* theStringifier)

{

  txSlot* aSlot;

  txInteger aFlag;

  txSlot* instance;

  aSlot = fxGetInstance(the, mxThis);

  theStringifier->offset = 0;

  theStringifier->size = 1024;

  theStringifier->buffer = c_malloc(1024);

  if (!theStringifier->buffer)

    fxAbort(the, XS_NOT_ENOUGH_MEMORY_EXIT);

  if (mxArgc > 1) {

    aSlot = mxArgv(1);

    if (mxIsReference(aSlot)) {

      if (fxIsCallable(the, aSlot))

        theStringifier->replacer = mxArgv(1);

      else if (fxIsArray(the, fxGetInstance(the, aSlot)))

        theStringifier->keys = fxToJSONKeys(the, aSlot);

    }

  }

  if (mxArgc > 2) {

    aSlot = mxArgv(2);

    if (mxIsReference(aSlot)) {

      txSlot* instance = fxGetInstance(the, aSlot);

      if (mxIsNumber(instance)) {

        fxToNumber(the, aSlot);

      }

      else if (mxIsString(instance)) {

        fxToString(the, aSlot);

      }

    }

    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++)

        theStringifier->indent[anIndex] = ' ';

      theStringifier->indentLength = aCount;

    }

    else if (mxIsStringPrimitive(aSlot)) {

      txInteger aCount = fxUnicodeLength(aSlot->value.string, C_NULL);

      if (aCount > 10) {

        aCount = fxUnicodeToUTF8Offset(aSlot->value.string, 10);

      }

      else {

        aCount = (txInteger)c_strlen(aSlot->value.string);

      }

      c_memcpy(theStringifier->indent, aSlot->value.string, aCount);

      theStringifier->indent[aCount] = 0;

      theStringifier->indentLength = aCount;

    }

  }

  theStringifier->stack = the->stack;

  mxPush(mxObjectPrototype);

  instance = fxNewObjectInstance(the);

  aFlag = 0;

  if (mxArgc > 0)

    mxPushSlot(mxArgv(0));

  else

    mxPushUndefined();

  fxNextSlotProperty(the, instance, the->stack, mxID(__empty_string_), XS_NO_FLAG);

  mxPush(mxEmptyString);

  fxStringifyJSONProperty(the, theStringifier, &aFlag);

  mxPop();

}

void fxStringifyJSONCharacter(txMachine* the, txJSONStringifier* theStringifier, txInteger character)

{

    txSize size = mxStringByteLength(character);

  if ((theStringifier->offset + size) >= theStringifier->size) {

    char* aBuffer;

    theStringifier->size += ((size / 1024) + 1) * 1024;

    aBuffer = c_realloc(theStringifier->buffer, theStringifier->size);

    if (!aBuffer)

      fxAbort(the, XS_NOT_ENOUGH_MEMORY_EXIT);

    theStringifier->buffer = aBuffer;

  }

  mxStringByteEncode(theStringifier->buffer + theStringifier->offset, character);

  theStringifier->offset += size;

}

void fxStringifyJSONChars(txMachine* the, txJSONStringifier* theStringifier, char* s, txSize theSize)

{

    //fprintf(stderr, "%s", s);

  if ((theStringifier->offset + theSize) >= theStringifier->size) {

    char* aBuffer;

    theStringifier->size += ((theSize / 1024) + 1) * 1024;

    aBuffer = c_realloc(theStringifier->buffer, theStringifier->size);

    if (!aBuffer)

      fxAbort(the, XS_NOT_ENOUGH_MEMORY_EXIT);

    theStringifier->buffer = aBuffer;

  }

  c_memcpy(theStringifier->buffer + theStringifier->offset, s, theSize);

  theStringifier->offset += theSize;

}

void fxStringifyJSONIndent(txMachine* the, txJSONStringifier* theStringifier)

{

  txInteger aLevel;

  if (theStringifier->indent[0]) {

    fxStringifyJSONChars(the, theStringifier, "\n", 1);

    for (aLevel = 0; aLevel < theStringifier->level; aLevel++)

      fxStringifyJSONChars(the, theStringifier, theStringifier->indent, theStringifier->indentLength);

  }

}

void fxStringifyJSONInteger(txMachine* the, txJSONStringifier* theStringifier, txInteger theInteger)

{

  char aBuffer[256];

  fxIntegerToString(the, theInteger, aBuffer, sizeof(aBuffer));

  fxStringifyJSONChars(the, theStringifier, aBuffer, (txSize)c_strlen(aBuffer));

}

void fxStringifyJSONName(txMachine* the, txJSONStringifier* theStringifier, txInteger* theFlag)

{

  txSlot* aSlot = the->stack;

  if (*theFlag & 1) {

    fxStringifyJSONChars(the, theStringifier, ",", 1);

    fxStringifyJSONIndent(the, theStringifier);

  }

  else

    *theFlag |= 1;

  if (*theFlag & 2) {

    if (aSlot->kind == XS_INTEGER_KIND) {

      fxStringifyJSONChars(the, theStringifier, "\"", 1);

      fxStringifyJSONInteger(the, theStringifier, aSlot->value.integer);

      fxStringifyJSONChars(the, theStringifier, "\"", 1);

    }

    else

      fxStringifyJSONString(the, theStringifier, aSlot->value.string);

    fxStringifyJSONChars(the, theStringifier, ":", 1);

    if (theStringifier->indent[0])

      fxStringifyJSONChars(the, theStringifier, " ", 1);

  }

  mxPop(); // POP KEY

}

void fxStringifyJSONNumber(txMachine* the, txJSONStringifier* theStringifier, txNumber theNumber)

{

  int fpclass = c_fpclassify(theNumber);

  if ((fpclass != C_FP_NAN) && (fpclass != C_FP_INFINITE)) {

    char aBuffer[256];

    fxNumberToString(the, theNumber, aBuffer, sizeof(aBuffer), 0, 0);

    fxStringifyJSONChars(the, theStringifier, aBuffer, (txSize)c_strlen(aBuffer));

  }

  else

    fxStringifyJSONChars(the, theStringifier, "null", 4);

}

void fxStringifyJSONProperty(txMachine* the, txJSONStringifier* theStringifier, txInteger* theFlag)

{

  txSlot* aWrapper = the->stack + 2;

  txSlot* aValue = the->stack + 1;

  txSlot* aKey = the->stack;

  txSlot* anInstance;

  txSlot* aSlot;

  txInteger aFlag;

  txIndex aLength, anIndex;

  mxCheckCStack();

  if (mxIsReference(aValue) || mxIsBigInt(aValue)) {

    /* THIS */

    mxPushSlot(aValue);

    /* FUNCTION */

    mxDub();

    mxGetID(mxID(_toJSON));

    if (mxIsReference(the->stack) && mxIsFunction(the->stack->value.reference))  {

      mxCall();

      mxPushSlot(aKey);

      fxToString(the, the->stack);

      mxRunCount(1);

      mxPullSlot(aValue);

    }

    the->stack = aKey;

  }

  if (theStringifier->replacer) {

    /* THIS */

    mxPushSlot(aWrapper);

    /* FUNCTION */

    mxPushSlot(theStringifier->replacer);

    mxCall();

    /* ARGUMENTS */

    mxPushSlot(aKey);

    fxToString(the, the->stack);

    mxPushSlot(aValue);

    /* COUNT */

    mxRunCount(2);

    mxPullSlot(aValue);

    the->stack = aKey;

  }

  if (mxIsReference(aValue)) {

    mxPushSlot(aValue);

    anInstance = fxToInstance(the, the->stack);

    if (anInstance->flag & XS_LEVEL_FLAG)

      mxTypeError("cyclic value");

    the->stack = aKey;

    aSlot = anInstance->next;

    if (aSlot && (aSlot->flag & XS_INTERNAL_FLAG)) {

      if ((aSlot->kind == XS_INTEGER_KIND) || (aSlot->kind == XS_NUMBER_KIND)) {

        fxToNumber(the, aValue);

      }

      else if (mxIsStringPrimitive(aSlot)) {

        fxToString(the, aValue);

      }

      else if ((aSlot->kind == XS_BOOLEAN_KIND) || (aSlot->kind == XS_BIGINT_KIND) || (aSlot->kind == XS_BIGINT_X_KIND)) {

        aValue->kind = aSlot->kind;

        aValue->value = aSlot->value;

      }

    }

  }

  if (aValue->kind == XS_NULL_KIND) {

    fxStringifyJSONName(the, theStringifier, theFlag);

    fxStringifyJSONChars(the, theStringifier, "null", 4);

  }

  else if (aValue->kind == XS_BOOLEAN_KIND) {

    fxStringifyJSONName(the, theStringifier, theFlag);

    if (aValue->value.boolean)

      fxStringifyJSONChars(the, theStringifier, "true", 4);

    else

      fxStringifyJSONChars(the, theStringifier, "false", 5);

  }

  else if (aValue->kind == XS_INTEGER_KIND) {

    fxStringifyJSONName(the, theStringifier, theFlag);

    fxStringifyJSONInteger(the, theStringifier, aValue->value.integer);

  }

  else if (aValue->kind == XS_NUMBER_KIND) {

    fxStringifyJSONName(the, theStringifier, theFlag);

    fxStringifyJSONNumber(the, theStringifier, aValue->value.number);

  }

  else if ((aValue->kind == XS_STRING_KIND) || (aValue->kind == XS_STRING_X_KIND)) {

    fxStringifyJSONName(the, theStringifier, theFlag);

    fxStringifyJSONString(the, theStringifier, aValue->value.string);

  }

  else if ((aValue->kind == XS_BIGINT_KIND) || (aValue->kind == XS_BIGINT_X_KIND)) {

    mxTypeError("stringify bigint");

  }

  else if ((aValue->kind == XS_REFERENCE_KIND) && !fxIsCallable(the, aValue)) {

    mxTry(the) {

      fxStringifyJSONName(the, theStringifier, theFlag);

      if (anInstance->flag & XS_MARK_FLAG)

        mxTypeError("read only value");

      anInstance->flag |= XS_LEVEL_FLAG;

      if (fxIsArray(the, anInstance)) {

        fxStringifyJSONChars(the, theStringifier, "[", 1);

        theStringifier->level++;

        fxStringifyJSONIndent(the, theStringifier);

        aFlag = 4;

        mxPushReference(anInstance);

        mxGetID(mxID(_length));

        aLength = fxToInteger(the, the->stack);

        mxPop();

        for (anIndex = 0; anIndex < aLength; anIndex++) {

          mxPushReference(anInstance);

          mxGetIndex(anIndex);

          mxPushInteger(anIndex);

          fxStringifyJSONProperty(the, theStringifier, &aFlag);

        }

        theStringifier->level--;

        fxStringifyJSONIndent(the, theStringifier);

        fxStringifyJSONChars(the, theStringifier, "]", 1);

      }

      else {

        fxStringifyJSONChars(the, theStringifier, "{", 1);

        theStringifier->level++;

        fxStringifyJSONIndent(the, theStringifier);

        aFlag = 2;

        {

          txSlot* at;

          txSlot* property;

          if (theStringifier->keys) {

            mxPushUndefined();

            at = theStringifier->keys->value.reference;