/*

 * Copyright (c) 2016-2017  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"

#ifndef mxRegExp

  #define mxRegExp 1

#endif

#if mxRegExp

static txNumber fxAdvanceStringIndex(txMachine* the, txString string, txNumber index, txBoolean unicodeFlag);

static txSlot* fxCheckRegExpInstance(txMachine* the, txSlot* slot);

static void fxExecuteRegExp(txMachine* the, txSlot* regexp, txSlot* argument);

#endif

static void fx_RegExp_prototype_get_flag(txMachine* the, txU4 flag);

static void fx_RegExp_prototype_split_aux(txMachine* the, txSlot* string, txIndex start, txIndex stop, txSlot* item);

void fxBuildRegExp(txMachine* the)

{

  txSlot* slot;

  mxPush(mxObjectPrototype);

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

  slot = fxNextHostFunctionProperty(the, slot, mxCallback(fx_RegExp_prototype_compile), 0, mxID(_compile), XS_DONT_ENUM_FLAG);

  slot = fxNextHostFunctionProperty(the, slot, mxCallback(fx_RegExp_prototype_exec), 1, mxID(_exec), XS_DONT_ENUM_FLAG);

  mxExecuteRegExpFunction.kind = slot->kind;

  mxExecuteRegExpFunction.value = slot->value;

  slot = fxNextHostFunctionProperty(the, slot, mxCallback(fx_RegExp_prototype_match), 1, mxID(_Symbol_match), XS_DONT_ENUM_FLAG);

  slot = fxNextHostFunctionProperty(the, slot, mxCallback(fx_RegExp_prototype_matchAll), 1, mxID(_Symbol_matchAll), XS_DONT_ENUM_FLAG);

  slot = fxNextHostFunctionProperty(the, slot, mxCallback(fx_RegExp_prototype_replace), 2, mxID(_Symbol_replace), XS_DONT_ENUM_FLAG);

  slot = fxNextHostFunctionProperty(the, slot, mxCallback(fx_RegExp_prototype_search), 1, mxID(_Symbol_search), XS_DONT_ENUM_FLAG);

  slot = fxNextHostFunctionProperty(the, slot, mxCallback(fx_RegExp_prototype_split), 2, mxID(_Symbol_split), XS_DONT_ENUM_FLAG);

  slot = fxNextHostFunctionProperty(the, slot, mxCallback(fx_RegExp_prototype_test), 1, mxID(_test), XS_DONT_ENUM_FLAG);

  slot = fxNextHostFunctionProperty(the, slot, mxCallback(fx_RegExp_prototype_toString), 0, mxID(_toString), XS_DONT_ENUM_FLAG);

  slot = fxNextHostAccessorProperty(the, slot, mxCallback(fx_RegExp_prototype_get_dotAll), C_NULL, mxID(_dotAll), XS_DONT_ENUM_FLAG | XS_DONT_SET_FLAG);

  slot = fxNextHostAccessorProperty(the, slot, mxCallback(fx_RegExp_prototype_get_flags), C_NULL, mxID(_flags), XS_DONT_ENUM_FLAG | XS_DONT_SET_FLAG);

  slot = fxNextHostAccessorProperty(the, slot, mxCallback(fx_RegExp_prototype_get_global), C_NULL, mxID(_global), XS_DONT_ENUM_FLAG | XS_DONT_SET_FLAG);

  slot = fxNextHostAccessorProperty(the, slot, mxCallback(fx_RegExp_prototype_get_hasIndices), C_NULL, mxID(_hasIndices), XS_DONT_ENUM_FLAG | XS_DONT_SET_FLAG);

  slot = fxNextHostAccessorProperty(the, slot, mxCallback(fx_RegExp_prototype_get_ignoreCase), C_NULL, mxID(_ignoreCase), XS_DONT_ENUM_FLAG | XS_DONT_SET_FLAG);

  slot = fxNextHostAccessorProperty(the, slot, mxCallback(fx_RegExp_prototype_get_multiline), C_NULL, mxID(_multiline), XS_DONT_ENUM_FLAG | XS_DONT_SET_FLAG);

  slot = fxNextHostAccessorProperty(the, slot, mxCallback(fx_RegExp_prototype_get_source), C_NULL, mxID(_source), XS_DONT_ENUM_FLAG | XS_DONT_SET_FLAG);

  slot = fxNextHostAccessorProperty(the, slot, mxCallback(fx_RegExp_prototype_get_sticky), C_NULL, mxID(_sticky), XS_DONT_ENUM_FLAG | XS_DONT_SET_FLAG);

  slot = fxNextHostAccessorProperty(the, slot, mxCallback(fx_RegExp_prototype_get_unicode), C_NULL, mxID(_unicode), XS_DONT_ENUM_FLAG | XS_DONT_SET_FLAG);

#if mxECMAScript2024

  slot = fxNextHostAccessorProperty(the, slot, mxCallback(fx_RegExp_prototype_get_unicodeSets), C_NULL, mxID(_unicodeSets), XS_DONT_ENUM_FLAG | XS_DONT_SET_FLAG);

#endif

  mxRegExpPrototype = *the->stack;

  slot = fxBuildHostConstructor(the, mxCallback(fx_RegExp), 2, mxID(_RegExp));

  mxRegExpConstructor = *the->stack;

  slot = fxLastProperty(the, slot);

#if mxECMAScript2025

  slot = fxNextHostFunctionProperty(the, slot, mxCallback(fx_RegExp_escape), 1, mxID(_escape), XS_DONT_ENUM_FLAG);

#endif

  slot = fxNextHostAccessorProperty(the, slot, mxCallback(fx_species_get), C_NULL, mxID(_Symbol_species), XS_DONT_ENUM_FLAG);

  mxPop();

  fxNewHostFunction(the, mxCallback(fxInitializeRegExp), 2, XS_NO_ID, XS_NO_ID);

  mxInitializeRegExpFunction = *the->stack;

  mxPush(mxIteratorPrototype);

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

  slot = fxNextHostFunctionProperty(the, slot, mxCallback(fx_RegExp_prototype_matchAll_next), 0, mxID(_next), XS_DONT_ENUM_FLAG);

  slot = fxNextStringXProperty(the, slot, "RegExp String Iterator", mxID(_Symbol_toStringTag), XS_DONT_ENUM_FLAG | XS_DONT_SET_FLAG);

  mxPull(mxRegExpStringIteratorPrototype);

  mxPop();

}

#if mxRegExp

txNumber fxAdvanceStringIndex(txMachine* the, txString string, txNumber index, txBoolean unicodeFlag)

{

#if mxCESU8

  if (unicodeFlag) {

    txInteger character;

    txSize offset = fxCacheUnicodeLength(the, string);

    if (index >= offset)

      return index + 1;

    offset = fxCacheUnicodeToUTF8Offset(the, string, (txInteger)index);

    offset = mxPtrDiff(mxStringByteDecode(string + offset, &character) - string);

    if (character == C_EOF)

      return index + 1;

    return fxCacheUTF8ToUnicodeOffset(the, string, offset);

  }

#endif

  return index + 1;

}

txSlot* fxCheckRegExpInstance(txMachine* the, txSlot* slot)

{

  if (slot->kind == XS_REFERENCE_KIND) {

    slot = slot->value.reference;

    if ((slot->next) && (slot->next->flag & XS_INTERNAL_FLAG) && (slot->next->kind == XS_REGEXP_KIND))

      return slot;

  }

  mxTypeError("this: not a RegExp instance");

  return C_NULL;

}

void fxExecuteRegExp(txMachine* the, txSlot* regexp, txSlot* argument)

{

  mxPushSlot(regexp);

  mxDub();

  mxGetID(mxID(_exec));

  if ((the->stack->kind != XS_REFERENCE_KIND) || (!mxIsFunction(the->stack->value.reference))) {

    the->stack->kind = mxExecuteRegExpFunction.kind;

    the->stack->value = mxExecuteRegExpFunction.value;

  }

  mxCall();

  mxPushSlot(argument);

  mxRunCount(1);

  if ((the->stack->kind != XS_NULL_KIND) && (the->stack->kind != XS_REFERENCE_KIND))

    mxTypeError("invalid exec result");

}

#endif

void fxInitializeRegExp(txMachine* the) 

{

#if mxRegExp

  txSlot* instance = fxToInstance(the, mxThis);

  txSlot* regexp = instance->next;

  txSlot* key = regexp->next;

  txString pattern;

  txString modifier;

  if (mxArgv(0)->kind == XS_UNDEFINED_KIND)

    *mxArgv(0) = mxEmptyString;

  else

    fxToString(the, mxArgv(0));

  if (mxArgv(1)->kind == XS_UNDEFINED_KIND)

    *mxArgv(1) = mxEmptyString;

  else

    fxToString(the, mxArgv(1));

    key->kind = (mxArgv(0)->kind == XS_STRING_X_KIND) ? XS_KEY_X_KIND : XS_KEY_KIND;

    pattern = key->value.key.string = mxArgv(0)->value.string;

  modifier = mxArgv(1)->value.string;

  if (!fxCompileRegExp(the, pattern, modifier, &regexp->value.regexp.code, &regexp->value.regexp.data, the->nameBuffer, sizeof(the->nameBuffer)))

    mxSyntaxError("invalid regular expression: %s", the->nameBuffer);

  *mxResult = *mxThis;

#endif

}

txBoolean fxIsRegExp(txMachine* the, txSlot* slot)

{

#if mxRegExp

    if (mxIsReference(slot)) {

        txSlot* instance = slot->value.reference;

        mxPushSlot(slot);

        mxGetID(mxID(_Symbol_match));

        if (the->stack->kind != XS_UNDEFINED_KIND)

            return fxToBoolean(the, the->stack++);

        mxPop();

        if ((instance->next) && (instance->next->flag & XS_INTERNAL_FLAG) && (instance->next->kind == XS_REGEXP_KIND))

            return 1;

    }

#endif

  return 0;

}

txSlot* fxNewRegExpInstance(txMachine* the)

{

#if mxRegExp

  txSlot* instance;

  txSlot* property;

  instance = fxNewObjectInstance(the);

  property = instance->next = fxNewSlot(the);

  property->flag = XS_INTERNAL_FLAG;

  property->kind = XS_REGEXP_KIND;

  property->value.regexp.code = C_NULL;

  property->value.regexp.data = C_NULL;

  property = property->next = fxNewSlot(the);

  property->flag = XS_INTERNAL_FLAG;

  property->kind = (mxEmptyString.kind == XS_STRING_X_KIND) ? XS_KEY_X_KIND : XS_KEY_KIND;

  property->value.key.string = mxEmptyString.value.string;

  property->value.key.sum = 0;

  property = fxNextIntegerProperty(the, property, 0, mxID(_lastIndex), XS_DONT_DELETE_FLAG | XS_DONT_ENUM_FLAG);

  return instance;

#else

  return NULL;

#endif

}

void fx_RegExp(txMachine* the)

{

#if mxRegExp

  txSlot* pattern = ((mxArgc > 0) && (mxArgv(0)->kind != XS_UNDEFINED_KIND)) ? mxArgv(0) : C_NULL;

  txSlot* flags = ((mxArgc > 1) && (mxArgv(1)->kind != XS_UNDEFINED_KIND)) ? mxArgv(1) : C_NULL;

  txBoolean patternIsRegExp = (pattern && fxIsRegExp(the, pattern)) ? 1 : 0;

  if (mxTarget->kind == XS_UNDEFINED_KIND) {

    if (patternIsRegExp && !flags) {

      mxPushSlot(pattern);

      mxGetID(mxID(_constructor));

      if ((the->stack->kind == mxFunction->kind) && (the->stack->value.reference == mxFunction->value.reference)) {

        mxPop();

        *mxResult = *pattern;

        return;

      }

      mxPop();

    }

    mxPushSlot(mxFunction);

  }

  else {

    mxPushSlot(mxTarget);

  }

  fxGetPrototypeFromConstructor(the, &mxRegExpPrototype);

  fxNewRegExpInstance(the);

  mxPush(mxInitializeRegExpFunction);

  mxCall();

  if (patternIsRegExp) {

    mxPushSlot(pattern);

    mxGetID(mxID(_source));

    if (flags)

      mxPushSlot(flags);

    else {

      mxPushSlot(pattern);

      mxGetID(mxID(_flags));

    }

  }

  else {

    if (pattern)

      mxPushSlot(pattern);

    else

      mxPushUndefined();

    if (flags)

      mxPushSlot(flags);

    else

      mxPushUndefined();

  }

  mxRunCount(2);

  mxPullSlot(mxResult);

#else

  mxUnknownError("not built-in");

#endif

}

void fx_RegExp_prototype_get_flag(txMachine* the, txU4 flag)

{

#if mxRegExp

  txSlot* slot = mxThis;

  if (slot->kind == XS_REFERENCE_KIND) {

    slot = slot->value.reference;

    if (slot == mxRegExpPrototype.value.reference)

      return;

    slot = slot->next;

    if ((slot) && (slot->flag & XS_INTERNAL_FLAG) && (slot->kind == XS_REGEXP_KIND)) {

      txInteger flags = slot->value.regexp.code[0];

      mxResult->value.boolean = (flags & flag) ? 1 : 0;

      mxResult->kind = XS_BOOLEAN_KIND;

      return;

    }

  }

  mxTypeError("this: not an object");

#endif

}

void fx_RegExp_prototype_get_flags(txMachine* the)

{

#if mxRegExp

  char flags[9];

  txIndex index = 0;

  if (mxThis->kind != XS_REFERENCE_KIND)

    mxTypeError("this: not an object");

  mxPushSlot(mxThis);

  mxGetID(mxID(_hasIndices));

  if (fxToBoolean(the, the->stack++))

    flags[index++] = 'd';

  mxPushSlot(mxThis);

  mxGetID(mxID(_global));

  if (fxToBoolean(the, the->stack++))

    flags[index++] = 'g';

  mxPushSlot(mxThis);

  mxGetID(mxID(_ignoreCase));

  if (fxToBoolean(the, the->stack++))

    flags[index++] = 'i';

  mxPushSlot(mxThis);

  mxGetID(mxID(_multiline));

  if (fxToBoolean(the, the->stack++))

    flags[index++] = 'm';

  mxPushSlot(mxThis);

  mxGetID(mxID(_dotAll));

  if (fxToBoolean(the, the->stack++))

    flags[index++] = 's';

  mxPushSlot(mxThis);

  mxGetID(mxID(_unicode));

  if (fxToBoolean(the, the->stack++))

    flags[index++] = 'u';

#if mxECMAScript2024

  mxPushSlot(mxThis);

  mxGetID(mxID(_unicodeSets));

  if (fxToBoolean(the, the->stack++))

    flags[index++] = 'v';

#endif

  mxPushSlot(mxThis);

  mxGetID(mxID(_sticky));

  if (fxToBoolean(the, the->stack++))

    flags[index++] = 'y';

  flags[index] = 0;

  fxCopyStringC(the, mxResult, flags);

#endif

}

void fx_RegExp_prototype_get_dotAll(txMachine* the)

{

#if mxRegExp

  fx_RegExp_prototype_get_flag(the, XS_REGEXP_S);

#endif

}

void fx_RegExp_prototype_get_global(txMachine* the)

{

#if mxRegExp

  fx_RegExp_prototype_get_flag(the, XS_REGEXP_G);

#endif

}

void fx_RegExp_prototype_get_hasIndices(txMachine* the)

{

#if mxRegExp

  fx_RegExp_prototype_get_flag(the, XS_REGEXP_D);

#endif

}

void fx_RegExp_prototype_get_ignoreCase(txMachine* the)

{

#if mxRegExp

  fx_RegExp_prototype_get_flag(the, XS_REGEXP_I);

#endif

}

void fx_RegExp_prototype_get_multiline(txMachine* the)

{

#if mxRegExp

  fx_RegExp_prototype_get_flag(the, XS_REGEXP_M);

#endif

}

void fx_RegExp_prototype_get_source(txMachine* the)

{

#if mxRegExp

  txSlot* slot = mxThis;

  if (slot->kind == XS_REFERENCE_KIND) {

    slot = slot->value.reference;

    if (slot == mxRegExpPrototype.value.reference) {

      *mxResult = mxEmptyRegExp;

      return;

    }

    slot = slot->next;

    if ((slot) && (slot->flag & XS_INTERNAL_FLAG) && (slot->kind == XS_REGEXP_KIND)) {

      txString pattern;

      txInteger escape = 0;

      txInteger count = 0;

      txU1 c, d, *s, *r;

            slot = slot->next;

      pattern = slot->value.key.string;

      if (*pattern == 0) {

        *mxResult = mxEmptyRegExp;

        return;

      }

      s = (txU1*)pattern;

      d = 0;

      while ((c = *s++)) {

        if ((c == '/') && (d != '\\'))

          escape++;

        else if ((c == 10) || (c == 13)/* || (c == '/')*/)

          escape++;

        else if ((c == 0xE2) && (s[0] == 0x80) && ((s[1] == 0xA8) || (s[1] == 0xA9))) /* LS || PS */

          escape += 3;

        d = c;

        count++;

      }

      if (escape) {

        mxResult->value.string = fxNewChunk(the, count + escape + 1);

        mxResult->kind = XS_STRING_KIND;

        s = (txU1*)slot->value.key.string;

        r = (txU1*)mxResult->value.string;

        d = 0;

        while ((c = *s++)) {

          if ((c == '/') && (d != '\\')) {

            *r++ = '\\'; *r++ = '/';

          }

          else if (c == 10) {

            *r++ = '\\'; *r++ = 'n';

          }

          else if (c == 13) {

            *r++ = '\\'; *r++ = 'r';

          }

          else if ((c == 0xE2) && (s[0] == 0x80) && (s[1] == 0xA8)) {

            *r++ = '\\'; *r++ = 'u'; *r++ = '2'; *r++ = '0'; *r++ = '2'; *r++ = '8';

            s += 2;

          }

          else if ((c == 0xE2) && (s[0] == 0x80) && (s[1] == 0xA9)) {

            *r++ = '\\'; *r++ = 'u'; *r++ = '2'; *r++ = '0'; *r++ = '2'; *r++ = '9';

            s += 2;

          }

          else {

            *r++ = c; 

          }

          d = c;

        }

        *r = 0;

      }

      else {

        mxResult->value.string = slot->value.string;

        mxResult->kind = (slot->kind == XS_KEY_X_KIND) ? XS_STRING_X_KIND : XS_STRING_KIND;

      }

      return;

    }

  }

  mxTypeError("this: not a RegExp instance");

#endif

}

void fx_RegExp_prototype_get_sticky(txMachine* the)

{

#if mxRegExp

  fx_RegExp_prototype_get_flag(the, XS_REGEXP_Y);

#endif

}

void fx_RegExp_prototype_get_unicode(txMachine* the)

{

#if mxRegExp

  fx_RegExp_prototype_get_flag(the, XS_REGEXP_U);

#endif

}

void fx_RegExp_prototype_get_unicodeSets(txMachine* the)

{

#if mxRegExp

  fx_RegExp_prototype_get_flag(the, XS_REGEXP_V);

#endif

}

void fx_RegExp_prototype_compile(txMachine* the)

{

#if mxRegExp

  *mxResult = *mxThis;

#endif

}

void fx_RegExp_prototype_exec(txMachine* the)

{

#if mxRegExp

  txSlot* instance = fxCheckRegExpInstance(the, mxThis);

  txSlot* regexp = instance->next;

  txSlot* argument;

  txSlot* temporary;

  txNumber lastIndex;

  txInteger flags;

  txBoolean globalFlag;

  txBoolean namedFlag;

  txBoolean stickyFlag;

  txBoolean hasIndicesFlag;

  txInteger offset;

  if (mxArgc > 0)

    mxPushSlot(mxArgv(0));

  else

    mxPushUndefined();

  fxToString(the, the->stack);

  argument = the->stack;

  if (regexp->value.regexp.data == C_NULL) {

    mxTemporary(temporary);

    temporary->value.regexp.code = C_NULL;

    temporary->value.regexp.data = fxAllocateRegExpData(the, regexp->value.regexp.code);

    temporary->kind = XS_REGEXP_KIND;

  }

  else

    temporary = regexp;

  mxPushSlot(mxThis);

  mxGetID(mxID(_lastIndex));

  lastIndex = fxToLength(the, the->stack);

  mxPop();

  if (lastIndex > 0x7FFFFFFF)

    lastIndex = 0x7FFFFFFF;

  flags = regexp->value.regexp.code[0];

  globalFlag = (flags & XS_REGEXP_G) ? 1 : 0;

  namedFlag = (flags & XS_REGEXP_N) ? 1 : 0;

  stickyFlag = (flags & XS_REGEXP_Y) ? 1 : 0;

  hasIndicesFlag = (flags & XS_REGEXP_D) ? 1 : 0;

  offset = (globalFlag || stickyFlag) ? fxCacheUnicodeToUTF8Offset(the, argument->value.string, (txInteger)lastIndex) : 0;

  if ((offset >= 0) && fxMatchRegExp(the, regexp->value.regexp.code, temporary->value.regexp.data, argument->value.string, offset)) {

    txSlot* resultArray;

    txSlot* resultItem;

    txSlot* indicesArray;

    txSlot* indicesItem;

    txSlot* resultObject;

    txSlot* resultProperty;

    txSlot* indicesObject;

    txSlot* indicesProperty;

    txInteger captureCount;

    txInteger nameCount;

    txInteger captureIndex;

    txInteger nameIndex;

    txInteger length;

    if (globalFlag || stickyFlag) {

      offset = fxCacheUTF8ToUnicodeOffset(the, argument->value.string, temporary->value.regexp.data[1]);

      mxPushInteger(offset);

      mxPushSlot(mxThis);

      mxSetID(mxID(_lastIndex));

      mxPop();

    }

    captureCount = regexp->value.regexp.code[1];

    nameCount = regexp->value.regexp.code[2];

    mxPush(mxArrayPrototype);

    resultArray = fxNewArrayInstance(the);

    resultItem = fxLastProperty(the, resultArray);

    for (captureIndex = 0; captureIndex < captureCount; captureIndex++) {

      txInteger start = temporary->value.regexp.data[2 * captureIndex];

      resultItem = resultItem->next = fxNewSlot(the);

      if (start >= 0) {

        txInteger end = temporary->value.regexp.data[(2 * captureIndex) + 1];

        length = end - start;

        resultItem->value.string = (txString)fxNewChunk(the, length + 1);

        c_memcpy(resultItem->value.string, argument->value.string + start, length);

        resultItem->value.string[length] = 0;

        resultItem->kind = XS_STRING_KIND;

      }

      resultArray->next->value.array.length++;

    }

    fxCacheArray(the, resultArray);

    resultItem = fxLastProperty(the, resultArray);

    resultItem = resultItem->next = fxNewSlot(the);

    resultItem->ID = mxID(_index);

    resultItem->kind = XS_INTEGER_KIND;

    resultItem->value.integer = fxCacheUTF8ToUnicodeOffset(the, argument->value.string, temporary->value.regexp.data[0]);

    resultItem = resultItem->next = fxNewSlot(the);

    resultItem->ID = mxID(_input);

    resultItem->value.string = argument->value.string;

    resultItem->kind = argument->kind;

    resultItem = resultItem->next = fxNewSlot(the);

    resultItem->ID = mxID(_groups);

    if (namedFlag) {

      resultObject = fxNewInstance(the);

      resultProperty = fxLastProperty(the, resultObject);

      for (nameIndex = 0; nameIndex < nameCount; nameIndex++) {

        txID name = (txID)(regexp->value.regexp.code[5 + nameIndex]);

        resultProperty = resultProperty->next = fxNewSlot(the);

        resultProperty->ID = name;

        captureIndex = regexp->value.regexp.data[(2 * captureCount) + nameIndex];

        if (captureIndex >= 0) {

          mxPushReference(resultArray);

          mxGetIndex(captureIndex);

          mxPullSlot(resultProperty);

        }

      }

      mxPullSlot(resultItem);

    } 

    if (hasIndicesFlag) {

      mxPush(mxArrayPrototype);

      indicesArray = fxNewArrayInstance(the);

      indicesItem = fxLastProperty(the, indicesArray);

      for (captureIndex = 0; captureIndex < captureCount; captureIndex++) {

        txInteger start = temporary->value.regexp.data[2 * captureIndex];

        indicesItem = indicesItem->next = fxNewSlot(the);

        if (start >= 0) {

          txInteger end = temporary->value.regexp.data[(2 * captureIndex) + 1];

          length = end - start;

          start = fxCacheUTF8ToUnicodeOffset(the, argument->value.string, start);

          end = start + fxUTF8ToUnicodeOffset(argument->value.string + start, length);

          mxPushInteger(start);

          mxPushInteger(end);

          fxConstructArrayEntry(the, indicesItem);

        }

        indicesArray->next->value.array.length++;

      }

      fxCacheArray(the, indicesArray);

      indicesItem = fxLastProperty(the, indicesArray);

      indicesItem = indicesItem->next = fxNewSlot(the);

      indicesItem->ID = mxID(_groups);

      if (namedFlag) {

        indicesObject = fxNewInstance(the);

        indicesProperty = fxLastProperty(the, indicesObject);

        for (nameIndex = 0; nameIndex < nameCount; nameIndex++) {

          txID name = (txID)(regexp->value.regexp.code[5 + nameIndex]);

          indicesProperty = indicesProperty->next = fxNewSlot(the);

          indicesProperty->ID = name;

          captureIndex = regexp->value.regexp.data[(2 * captureCount) + nameIndex];

          if (captureIndex >= 0) {

            mxPushReference(indicesArray);

            mxGetIndex(captureIndex);

            mxPullSlot(indicesProperty);

          }

        }

        mxPullSlot(indicesItem);

      }

      resultItem = resultItem->next = fxNewSlot(the);

      resultItem->ID = mxID(_indices);

      mxPullSlot(resultItem);

    }

  }

  else {

    if (globalFlag || stickyFlag) {

      mxPushInteger(0);

      mxPushSlot(mxThis);

      mxSetID(mxID(_lastIndex));

      mxPop();

    }

    mxPushNull();

  }

  mxPullSlot(mxResult);

#endif

}

void fx_RegExp_prototype_match(txMachine* the)

{

#if mxRegExp

  txSlot* argument;

  txSlot* flags;

  fxToInstance(the, mxThis);

  if (mxArgc == 0)

    mxPushUndefined();

  else

    mxPushSlot(mxArgv(0));

  argument = the->stack;

  fxToString(the, argument);

  mxPushSlot(mxThis);

  mxGetID(mxID(_flags));

  flags = the->stack;

  if (c_strchr(fxToString(the, flags), 'g')) {

    txIndex count = 0;

    txBoolean unicodeFlag = (c_strchr(fxToString(the, flags), 'u') || c_strchr(fxToString(the, flags), 'v')) ? 1 : 0;

    mxPushInteger(0);

    mxPushSlot(mxThis);

    mxSetID(mxID(_lastIndex));

    mxPop();

    mxPush(mxArrayPrototype);

    fxNewArrayInstance(the);

    mxPullSlot(mxResult);

    for (;;) {

      fxExecuteRegExp(the, mxThis, argument);

      if (the->stack->kind == XS_NULL_KIND) {

        if (count == 0)

          mxPullSlot(mxResult);

        else

          mxPop();

        break;

      }

      mxGetIndex(0);

            fxToString(the, the->stack);

      mxPushSlot(mxResult);

      mxDefineIndex(count, 0, XS_GET_ONLY);

      if (c_isEmpty(the->stack->value.string)) {

        mxPushSlot(mxThis);

        mxGetID(mxID(_lastIndex));

        fxToLength(the, the->stack);

        the->stack->value.number = fxAdvanceStringIndex(the, argument->value.string, the->stack->value.number, unicodeFlag);

        mxPushSlot(mxThis);

        mxSetID(mxID(_lastIndex));

        mxPop();

      }

      mxPop();

      count++;

            mxCheckMetering();

    }

  }

  else {

    fxExecuteRegExp(the, mxThis, argument);

    mxPullSlot(mxResult);

  }

  mxPop();

  mxPop();

#endif

}

void fx_RegExp_prototype_matchAll(txMachine* the)

{

#if mxRegExp

  txSlot* argument;

  txBoolean globalFlag = 0;

  txBoolean unicodeFlag = 0;

  txSlot* matcher;

  txSlot* iterator;

  txSlot* property;

  if (!mxIsReference(mxThis))

    mxTypeError("this: not an object");

  if (mxArgc == 0)

    mxPushUndefined();

  else

    mxPushSlot(mxArgv(0));

  argument = the->stack;

  fxToString(the, argument);

  mxPushSlot(mxThis);

  mxGetID(mxID(_constructor));

  fxToSpeciesConstructor(the, &mxRegExpConstructor);

  mxNew(); 

  mxPushSlot(mxThis);

  mxPushSlot(mxThis);

  mxGetID(mxID(_flags));

  if (c_strchr(fxToString(the, the->stack), 'g'))

    globalFlag = 1;

  if (c_strchr(fxToString(the, the->stack), 'u') || c_strchr(fxToString(the, the->stack), 'v'))

    unicodeFlag = 1;

  mxRunCount(2);

  matcher = the->stack;

  mxPushSlot(mxThis);

  mxGetID(mxID(_lastIndex));

  fxToInteger(the, the->stack);

  mxPushSlot(matcher);

  mxSetID(mxID(_lastIndex));

  mxPush(mxRegExpStringIteratorPrototype);

  iterator = fxNewIteratorInstance(the, matcher, mxID(_RegExp));

  property = fxLastProperty(the, iterator);

  property->kind = argument->kind;

  property->value = argument->value;

  property = fxNextBooleanProperty(the, property, globalFlag, XS_NO_ID, XS_INTERNAL_FLAG);

  property = fxNextBooleanProperty(the, property, unicodeFlag, XS_NO_ID, XS_INTERNAL_FLAG);

  property = fxNextBooleanProperty(the, property, 0, XS_NO_ID, XS_INTERNAL_FLAG);

  mxPullSlot(mxResult);

#endif

}

void fx_RegExp_prototype_matchAll_next(txMachine* the)

{

#if mxRegExp

  txSlot* iterator = fxCheckIteratorInstance(the, mxThis, mxID(_RegExp));

  txSlot* result = iterator->next;

  txSlot* value = fxCheckIteratorResult(the, result);

  txSlot* done = value->next;

  txSlot* matcher = result->next;

  txSlot* argument = matcher->next;

  txSlot* global = argument->next;

  txSlot* unicode = global->next;

  txSlot* complete = unicode->next;

  txSlot* match;

  if (complete->value.boolean) {

    value->kind = XS_UNDEFINED_KIND;

    done->value.boolean = 1;

  }

  else {

    fxExecuteRegExp(the, matcher, argument);

    match = the->stack;

    if (match->kind == XS_NULL_KIND) {

      value->kind = XS_UNDEFINED_KIND;

      done->value.boolean = 1;

            complete->value.boolean = 1;

    }

    else if (global->value.boolean) {

      mxPushSlot(match);

      mxGetIndex(0);

      fxToString(the, the->stack);

      if (c_isEmpty(the->stack->value.string)) {

        mxPushSlot(matcher);

        mxGetID(mxID(_lastIndex));

        fxToLength(the, the->stack);

        the->stack->value.number = fxAdvanceStringIndex(the, argument->value.string, the->stack->value.number, unicode->value.boolean);

        mxPushSlot(matcher);

        mxSetID(mxID(_lastIndex));

        mxPop();

      }

      mxPop();

      value->kind = match->kind;

      value->value = match->value;

      done->value.boolean = 0;

    }

    else {

      value->kind = match->kind;

      value->value = match->value;

      done->value.boolean = 0;

      complete->value.boolean = 1;

    }

    mxPop();

  }

  mxResult->kind = result->kind;

  mxResult->value = result->value;

#endif

}

void fx_RegExp_prototype_replace(txMachine* the)

{

#if mxRegExp

  txSlot* argument;

  txSlot* function = C_NULL;;

  txSlot* replacement = C_NULL;;

  txSlot* flags;

  txBoolean globalFlag = 0;

  txBoolean unicodeFlag = 0;

  txSlot* list;

  txSlot* item;

  txSize size; 

  txSize utf8Size; 

  txInteger former; 

  txSlot* result;