/src/moddable/xs/sources/xsCode.c

Source
/*
 * 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 "xsScript.h"

//#define mxCodePrint 1

#define mxByteCodePart\
  txByteCode* nextCode;\
  txInteger id;\
  txInteger stackLevel
  
struct sxByteCode {
  mxByteCodePart;
};
  
struct sxBigIntCode {
  mxByteCodePart;
  txBigInt bigint;
};
  
struct sxBranchCode {
  mxByteCodePart;
  txTargetCode* target;
};
  
struct sxIndexCode {
  mxByteCodePart;
  txInteger index;
};
  
struct sxIntegerCode {
  mxByteCodePart;
  txInteger integer;
};
  
struct sxNumberCode {
  mxByteCodePart;
  txNumber number;
};
  
struct sxStringCode {
  mxByteCodePart;
  txInteger length;
  txString string;
};
  
struct sxSymbolCode {
  mxByteCodePart;
  txSymbol* symbol;
};

struct sxTargetCode {
  mxByteCodePart;
  txInteger index;
  txLabelNode* label;
  txTargetCode* nextTarget;
  txInteger environmentLevel;
  txInteger scopeLevel;
  txInteger offset;
  txTargetCode* original;
  txBoolean used;
};
  
struct sxVariableCode {
  mxByteCodePart;
  txSymbol* symbol;
  txInteger index;
};

struct sxCoder {
  txParser* parser;
  txByteCode* firstCode;
  txByteCode* lastCode;
  txTargetCode* firstBreakTarget;
  txTargetCode* firstContinueTarget;
  txTargetCode* returnTarget;
  txInteger environmentLevel;
  txInteger scopeLevel;
  txInteger stackLevel;
  txInteger targetIndex;
  txSymbol* path;
  txInteger line;
  txBoolean programFlag;
  txBoolean evalFlag;
  txBoolean importFlag;
  txBoolean importMetaFlag;
  txClassNode* classNode;
  txTargetCode* chainTarget;
};

typedef struct {
  txInteger exception;
  txInteger selector;
  txTargetCode* catchTarget;
} txUsingContext;

typedef void (*txCompound)(void* it, void* param, txByte step);

static void fxCoderAdd(txCoder* self, txInteger delta, void* it);
static void fxCoderAddBigInt(txCoder* self, txInteger delta, txInteger id, txBigInt* bigint);
static void fxCoderAddBranch(txCoder* self, txInteger delta, txInteger id, txTargetCode* target);
static void fxCoderAddByte(txCoder* self, txInteger delta, txInteger id);
static void fxCoderAddIndex(txCoder* self, txInteger delta, txInteger id, txInteger index);
static void fxCoderAddInteger(txCoder* self, txInteger delta, txInteger id, txInteger integer);
static void fxCoderAddLine(txCoder* self, txInteger delta, txInteger id, txNode* node);
static void fxCoderAddNumber(txCoder* self, txInteger delta, txInteger id, txNumber number);
static void fxCoderAddString(txCoder* self, txInteger delta, txInteger id, txInteger length, txString string);
static void fxCoderAddSymbol(txCoder* self, txInteger delta, txInteger id, txSymbol* symbol);
static void fxCoderAddVariable(txCoder* self, txInteger delta, txInteger id, txSymbol* symbol, txInteger index);
static void fxCoderAdjustEnvironment(txCoder* self, txTargetCode* target);
static void fxCoderAdjustScope(txCoder* self, txTargetCode* target);
static txTargetCode* fxCoderAliasTargets(txCoder* self, txTargetCode* target);
static txInteger fxCoderCountParameters(txCoder* self, txNode* it);
static txTargetCode* fxCoderCreateTarget(txCoder* self);
static txTargetCode* fxCoderFinalizeTargets(txCoder* self, txTargetCode* alias, txInteger selector, txInteger* address, txTargetCode* finallyTarget);
static void fxCoderJumpTargets(txCoder* self, txTargetCode* target, txInteger selector, txInteger* address);
static void fxCoderOptimize(txCoder* self);
static txInteger fxCoderUseTemporaryVariable(txCoder* self);
static void fxCoderUnuseTemporaryVariables(txCoder* self, txInteger count);

static void fxScopeCoded(txScope* self, txCoder* coder);
static void fxScopeCodedBody(txScope* self, txCoder* coder);
static void fxScopeCodingBlock(txScope* self, txCoder* coder);
static void fxScopeCodingBody(txScope* self, txCoder* coder);
static void fxScopeCodingParams(txScope* self, txCoder* coder);
static void fxScopeCodingProgram(txScope* self, txCoder* coder);
static void fxScopeCodeDefineNodes(txScope* self, txCoder* coder);
static void fxScopeCodeRefresh(txScope* self, txCoder* coder);
static void fxScopeCodeReset(txScope* self, txCoder* coder);
static void fxScopeCodeRetrieve(txScope* self, txCoder* coder);
static void fxScopeCodeStore(txScope* self, txCoder* coder);
static void fxScopeCodeStoreAll(txScope* self, txCoder* coder);
static void fxScopeCodeUsed(txScope* self, txCoder* coder, txUsingContext* context);
static void fxScopeCodeUsedReverse(txScope* self, txCoder* coder, txDeclareNode* node, txInteger exception, txInteger selector);
static void fxScopeCodeUsing(txScope* self, txCoder* coder, txUsingContext* context);
static void fxScopeCodeUsingStatement(txScope* self, txCoder* coder, txNode* statement);

static void fxNodeDispatchCode(void* it, void* param);
static void fxNodeDispatchCodeAssign(void* it, void* param, txFlag flag);
static void fxNodeDispatchCodeDelete(void* it, void* param);
static void fxNodeDispatchCodeReference(void* it, void* param, txFlag flag);
static txFlag fxNodeDispatchCodeThis(void* it, void* param, txFlag flag);

static txFlag fxNodeCodeName(txNode* value);
static void fxCompoundExpressionNodeCodeName(void* it, void* param);
static void fxSpreadNodeCode(void* it, void* param, txInteger counter);

txScript* fxParserCode(txParser* parser)
{
  txCoder coder;
  txByteCode* code;
  txScript* script;
  txSize size, delta, offset;
  txSymbol* symbol;
  txSymbol** address;
  txSize c, i;
  txID id, count;
  txSize total;
  txByte* p;
  txHostNode* node;
#ifdef mxMetering
  txUnsigned meterIndex = 0;
#endif

    c_memset(&coder, 0, sizeof(txCoder));
  coder.parser = parser;
  if (parser->errorCount == 0) {
    mxTryParser(parser) {
      txNode* self = parser->root;
      (*self->description->dispatch->code)(parser->root, &coder);
    }
    mxCatchParser(parser) {
    }
  }
  if (parser->errorCount) {
    if (parser->console) {
      coder.firstCode = NULL;
      coder.lastCode = NULL;
      fxCoderAddByte(&coder, 1, XS_CODE_GLOBAL);
      fxCoderAddSymbol(&coder, 0, XS_CODE_GET_VARIABLE, parser->errorSymbol);
      fxCoderAddByte(&coder, 2, XS_CODE_NEW);
      fxCoderAddString(&coder, 1, XS_CODE_STRING_1, mxStringLength(parser->errorMessage), parser->errorMessage);
      fxCoderAddInteger(&coder, -3, XS_CODE_RUN_1, 1);
      fxCoderAddByte(&coder, -1, XS_CODE_THROW);
    }
    else
      return C_NULL;
  }
  
  fxCoderOptimize(&coder);
  
  script = c_malloc(sizeof(txScript));
  if (!script) goto bail;
  c_memset(script, 0, sizeof(txScript));
  
  code = coder.firstCode;
  size = 0;
  delta = 0;
  while (code) {
    txInteger value;
    switch (code->id) {
    case XS_NO_CODE:
      ((txTargetCode*)code)->offset = size;
      break;
    case XS_CODE_BRANCH_1:
    case XS_CODE_BRANCH_CHAIN_1:
    case XS_CODE_BRANCH_COALESCE_1:
    case XS_CODE_BRANCH_ELSE_1:
    case XS_CODE_BRANCH_IF_1:
    case XS_CODE_BRANCH_STATUS_1:
    case XS_CODE_CATCH_1:
    case XS_CODE_CODE_1:
      size += 2;
      delta += 3;
      break;
      
    case XS_CODE_ARGUMENT:
    case XS_CODE_ARGUMENTS:
    case XS_CODE_ARGUMENTS_SLOPPY:
    case XS_CODE_ARGUMENTS_STRICT:
    case XS_CODE_BEGIN_SLOPPY:
    case XS_CODE_BEGIN_STRICT:
    case XS_CODE_BEGIN_STRICT_BASE:
    case XS_CODE_BEGIN_STRICT_DERIVED:
    case XS_CODE_BEGIN_STRICT_FIELD:
    case XS_CODE_MODULE:
      size += 2;
      break;

    case XS_CODE_LINE:
      size += 3;
      break;
    case XS_CODE_ASYNC_FUNCTION:
    case XS_CODE_ASYNC_GENERATOR_FUNCTION:
    case XS_CODE_CONSTRUCTOR_FUNCTION:
    case XS_CODE_DELETE_PROPERTY:
    case XS_CODE_DELETE_SUPER:
    case XS_CODE_FILE:
    case XS_CODE_FUNCTION:
    case XS_CODE_GENERATOR_FUNCTION:
    case XS_CODE_GET_PROPERTY:
    case XS_CODE_GET_SUPER:
    case XS_CODE_GET_THIS_VARIABLE:
    case XS_CODE_GET_VARIABLE:
    case XS_CODE_EVAL_PRIVATE:
    case XS_CODE_EVAL_REFERENCE:
    case XS_CODE_NAME:
    case XS_CODE_NEW_CLOSURE:
    case XS_CODE_NEW_LOCAL:
    case XS_CODE_NEW_PROPERTY:
    case XS_CODE_PROGRAM_REFERENCE:
    case XS_CODE_SET_PROPERTY:
    case XS_CODE_SET_SUPER:
    case XS_CODE_SET_VARIABLE:
    case XS_CODE_SYMBOL:
    case XS_CODE_PROFILE:
      size += 1 + sizeof(txID);
      break;
      
    case XS_CODE_STRING_1:
      size += ((txStringCode*)code)->length;
      // continue
    case XS_CODE_RESERVE_1:
    case XS_CODE_RETRIEVE_1:
    case XS_CODE_UNWIND_1:
      value = ((txIndexCode*)code)->index;
      if (value > 65535) {
        code->id += 2;
        size += 5;
      }
      else if (value > 255) {
        code->id += 1;
        size += 3;
      }
      else
        size += 2;
      break;
    case XS_CODE_BIGINT_1:
      value = fxBigIntMeasure(&((txBigIntCode*)code)->bigint);
      if (value > 255) {
        code->id += 1;
        size += 3;
      }
      else
        size += 2;
      size += value;
      break;
      
    case XS_CODE_CONST_CLOSURE_1:
    case XS_CODE_CONST_LOCAL_1:
    case XS_CODE_GET_CLOSURE_1:
    case XS_CODE_GET_LOCAL_1:
    case XS_CODE_GET_PRIVATE_1:
    case XS_CODE_HAS_PRIVATE_1:
    case XS_CODE_LET_CLOSURE_1:
    case XS_CODE_LET_LOCAL_1:
    case XS_CODE_NEW_PRIVATE_1:
    case XS_CODE_PULL_CLOSURE_1:
    case XS_CODE_PULL_LOCAL_1:
    case XS_CODE_REFRESH_CLOSURE_1:
    case XS_CODE_REFRESH_LOCAL_1:
    case XS_CODE_RESET_CLOSURE_1:
    case XS_CODE_RESET_LOCAL_1:
    case XS_CODE_SET_CLOSURE_1:
    case XS_CODE_SET_LOCAL_1:
    case XS_CODE_SET_PRIVATE_1:
    case XS_CODE_STORE_1:
    case XS_CODE_USED_1:
    case XS_CODE_VAR_CLOSURE_1:
    case XS_CODE_VAR_LOCAL_1:
      value = ((txIndexCode*)code)->index + 1;
      if (value > 65535) {
        code->id += 2;
        size += 5;
      }
      else if (value > 255) {
        code->id += 1;
        size += 3;
      }
      else
        size += 2;
      break;
      
    case XS_CODE_INTEGER_1: 
    case XS_CODE_RUN_1: 
    case XS_CODE_RUN_TAIL_1: 
      value = ((txIntegerCode*)code)->integer;
      if ((value < -32768) || (value > 32767)) {
        code->id += 2;
        size += 5;
      }
      else if ((value < -128) || (value > 127)) {
        code->id += 1;
        size += 3;
      }
      else
        size += 2;
      break;
    case XS_CODE_NUMBER:
      size += 9;
      break;
      
    case XS_CODE_HOST:
      size += 3;
      break;
      
    default:
      size++;
      break;
    }
    code = code->nextCode;
#ifdef mxMetering
    meterIndex++;
#endif
  }  
#ifdef mxMetering
  fxMeterSome(parser->console, meterIndex);
#endif

  code = coder.firstCode;
  size = 0;
  while (code) {
    switch (code->id) {
    case XS_NO_CODE:
      ((txTargetCode*)code)->offset = size;
      break;
    case XS_CODE_BRANCH_1:
    case XS_CODE_BRANCH_CHAIN_1:
    case XS_CODE_BRANCH_COALESCE_1:
    case XS_CODE_BRANCH_ELSE_1:
    case XS_CODE_BRANCH_IF_1:
    case XS_CODE_BRANCH_STATUS_1:
    case XS_CODE_CATCH_1:
    case XS_CODE_CODE_1:
      offset = ((txBranchCode*)code)->target->offset - (size + 5);
      if ((offset < -32768) || (offset + delta > 32767)) {
        code->id += 2;
        size += 5;
      }
      else if ((offset < -128) || (offset + delta > 127)) {
        code->id += 1;
        delta -= 2;
        size += 3;
      }
      else {
        delta -= 3;
        size += 2;
      }
      break;
      
    case XS_CODE_ARGUMENT:
    case XS_CODE_ARGUMENTS:
    case XS_CODE_ARGUMENTS_SLOPPY:
    case XS_CODE_ARGUMENTS_STRICT:
    case XS_CODE_BEGIN_SLOPPY:
    case XS_CODE_BEGIN_STRICT:
    case XS_CODE_BEGIN_STRICT_BASE:
    case XS_CODE_BEGIN_STRICT_DERIVED:
    case XS_CODE_BEGIN_STRICT_FIELD:
    case XS_CODE_MODULE:
      size += 2;
      break;
    case XS_CODE_LINE:
      size += 3;
      break;
    case XS_CODE_ASYNC_FUNCTION:
    case XS_CODE_ASYNC_GENERATOR_FUNCTION:
    case XS_CODE_CONSTRUCTOR_FUNCTION:
    case XS_CODE_DELETE_PROPERTY:
    case XS_CODE_DELETE_SUPER:
    case XS_CODE_FILE:
    case XS_CODE_FUNCTION:
    case XS_CODE_GENERATOR_FUNCTION:
    case XS_CODE_GET_PROPERTY:
    case XS_CODE_GET_SUPER:
    case XS_CODE_GET_THIS_VARIABLE:
    case XS_CODE_GET_VARIABLE:
    case XS_CODE_EVAL_PRIVATE:
    case XS_CODE_EVAL_REFERENCE:
    case XS_CODE_NAME:
    case XS_CODE_NEW_CLOSURE:
    case XS_CODE_NEW_LOCAL:
    case XS_CODE_NEW_PROPERTY:
    case XS_CODE_PROGRAM_REFERENCE:
    case XS_CODE_SET_PROPERTY:
    case XS_CODE_SET_SUPER:
    case XS_CODE_SET_VARIABLE:
    case XS_CODE_SYMBOL:
      symbol = ((txSymbolCode*)code)->symbol;
      if (symbol && symbol->string)
        symbol->usage |= 1;
      size += 1 + sizeof(txID);
      break;
    case XS_CODE_PROFILE:
      size += 1 + sizeof(txID);
      break;
      
    case XS_CODE_CONST_CLOSURE_1:
    case XS_CODE_CONST_LOCAL_1:
    case XS_CODE_GET_CLOSURE_1:
    case XS_CODE_GET_LOCAL_1:
    case XS_CODE_GET_PRIVATE_1:
    case XS_CODE_HAS_PRIVATE_1:
    case XS_CODE_LET_CLOSURE_1:
    case XS_CODE_LET_LOCAL_1:
    case XS_CODE_NEW_PRIVATE_1:
    case XS_CODE_PULL_CLOSURE_1:
    case XS_CODE_PULL_LOCAL_1:
    case XS_CODE_REFRESH_CLOSURE_1:
    case XS_CODE_REFRESH_LOCAL_1:
    case XS_CODE_RESERVE_1:
    case XS_CODE_RESET_CLOSURE_1:
    case XS_CODE_RESET_LOCAL_1:
    case XS_CODE_RETRIEVE_1:
    case XS_CODE_SET_CLOSURE_1:
    case XS_CODE_SET_LOCAL_1:
    case XS_CODE_SET_PRIVATE_1:
    case XS_CODE_STORE_1:
    case XS_CODE_UNWIND_1:
    case XS_CODE_USED_1:
    case XS_CODE_VAR_CLOSURE_1:
    case XS_CODE_VAR_LOCAL_1:
      size += 2;
      break;
    case XS_CODE_CONST_CLOSURE_2:
    case XS_CODE_CONST_LOCAL_2:
    case XS_CODE_GET_CLOSURE_2:
    case XS_CODE_GET_LOCAL_2:
    case XS_CODE_GET_PRIVATE_2:
    case XS_CODE_HAS_PRIVATE_2:
    case XS_CODE_LET_CLOSURE_2:
    case XS_CODE_LET_LOCAL_2:
    case XS_CODE_NEW_PRIVATE_2:
    case XS_CODE_PULL_CLOSURE_2:
    case XS_CODE_PULL_LOCAL_2:
    case XS_CODE_REFRESH_CLOSURE_2:
    case XS_CODE_REFRESH_LOCAL_2:
    case XS_CODE_RESERVE_2:
    case XS_CODE_RESET_CLOSURE_2:
    case XS_CODE_RESET_LOCAL_2:
    case XS_CODE_RETRIEVE_2:
    case XS_CODE_SET_CLOSURE_2:
    case XS_CODE_SET_LOCAL_2:
    case XS_CODE_SET_PRIVATE_2:
    case XS_CODE_STORE_2:
    case XS_CODE_UNWIND_2:
    case XS_CODE_USED_2:
    case XS_CODE_VAR_CLOSURE_2:
    case XS_CODE_VAR_LOCAL_2:
      size += 3;
      break;
    
    case XS_CODE_INTEGER_1: 
    case XS_CODE_RUN_1: 
    case XS_CODE_RUN_TAIL_1: 
      size += 2;
      break;
    case XS_CODE_INTEGER_2: 
    case XS_CODE_RUN_2: 
    case XS_CODE_RUN_TAIL_2: 
      size += 3;
      break;
    case XS_CODE_INTEGER_4: 
    case XS_CODE_RUN_4: 
    case XS_CODE_RUN_TAIL_4: 
      size += 5;
      break;
    case XS_CODE_NUMBER:
      size += 9;
      break;
    case XS_CODE_STRING_1:
      size += 2 + ((txStringCode*)code)->length;
      break;
    case XS_CODE_STRING_2:
      size += 3 + ((txStringCode*)code)->length;
      break;
    case XS_CODE_STRING_4:
      size += 5 + ((txStringCode*)code)->length;
      break;
    case XS_CODE_BIGINT_1:
      size += 2 + fxBigIntMeasure(&((txBigIntCode*)code)->bigint);
      break;
    case XS_CODE_BIGINT_2:
      size += 3 + fxBigIntMeasure(&((txBigIntCode*)code)->bigint);
      break;
      
    case XS_CODE_HOST:
      size += 3;
      break;
    
    default:
      size++;
      break;
    }
    code = code->nextCode;
  }  
  
  node = parser->firstHostNode;
  while (node) {
    if (node->symbol)
      node->symbol->usage |= 1;
    node = node->nextHostNode;
  }
  
  address = parser->symbolTable;
  c = parser->symbolModulo;
  id = 1;
  total = sizeof(txID);
  for (i = 0; i < c; i++) {
    txSymbol* symbol = *address;
    while (symbol) {
      if (symbol->usage & 1) {
        symbol->ID = id;
        id++;
        total += symbol->length;
      }
      symbol = symbol->next;
    }
    address++;
  }
  count = id;
    
  script->codeBuffer = c_malloc(size);
  if (!script->codeBuffer) goto bail;
  script->codeSize = size;
  
  code = coder.firstCode;
  p = script->codeBuffer;
  while (code) {
    txS1 s1; txS2 s2; txS4 s4; 
    txU1 u1; txU2 u2;
    txNumber n;
    if (code->id)
      *p++ = (txS1)(code->id);
    switch (code->id) {
    case XS_CODE_BRANCH_1:
    case XS_CODE_BRANCH_CHAIN_1:
    case XS_CODE_BRANCH_COALESCE_1:
    case XS_CODE_BRANCH_ELSE_1:
    case XS_CODE_BRANCH_IF_1:
    case XS_CODE_BRANCH_STATUS_1:
    case XS_CODE_CATCH_1:
    case XS_CODE_CODE_1:
      offset = mxPtrDiff(p + 1 - script->codeBuffer);
      s1 = (txS1)(((txBranchCode*)code)->target->offset - offset);
      *p++ = s1;
      break;
    case XS_CODE_BRANCH_2:
    case XS_CODE_BRANCH_CHAIN_2:
    case XS_CODE_BRANCH_COALESCE_2:
    case XS_CODE_BRANCH_ELSE_2:
    case XS_CODE_BRANCH_IF_2:
    case XS_CODE_BRANCH_STATUS_2:
    case XS_CODE_CATCH_2:
    case XS_CODE_CODE_2:
      offset = mxPtrDiff(p + 2 - script->codeBuffer);
      s2 = (txS2)(((txBranchCode*)code)->target->offset - offset);
      mxEncode2(p, s2);
      break;
    case XS_CODE_BRANCH_4:
    case XS_CODE_BRANCH_CHAIN_4:
    case XS_CODE_BRANCH_COALESCE_4:
    case XS_CODE_BRANCH_ELSE_4:
    case XS_CODE_BRANCH_IF_4:
    case XS_CODE_BRANCH_STATUS_4:
    case XS_CODE_CATCH_4:
    case XS_CODE_CODE_4:
      offset = mxPtrDiff(p + 4 - script->codeBuffer);
      s4 = (txS4)(((txBranchCode*)code)->target->offset  - offset);
      mxEncode4(p, s4);
      break;
      
    case XS_CODE_ASYNC_FUNCTION:
    case XS_CODE_ASYNC_GENERATOR_FUNCTION:
    case XS_CODE_CONSTRUCTOR_FUNCTION:
    case XS_CODE_DELETE_PROPERTY:
    case XS_CODE_DELETE_SUPER:
    case XS_CODE_FILE:
    case XS_CODE_FUNCTION:
    case XS_CODE_GENERATOR_FUNCTION:
    case XS_CODE_GET_PROPERTY:
    case XS_CODE_GET_SUPER:
    case XS_CODE_GET_THIS_VARIABLE:
    case XS_CODE_GET_VARIABLE:
    case XS_CODE_EVAL_PRIVATE:
    case XS_CODE_EVAL_REFERENCE:
    case XS_CODE_NAME:
    case XS_CODE_NEW_CLOSURE:
    case XS_CODE_NEW_LOCAL:
    case XS_CODE_NEW_PROPERTY:
    case XS_CODE_PROGRAM_REFERENCE:
    case XS_CODE_SET_PROPERTY:
    case XS_CODE_SET_SUPER:
    case XS_CODE_SET_VARIABLE:
    case XS_CODE_SYMBOL:
      symbol = ((txSymbolCode*)code)->symbol;
      if (symbol && symbol->string)
        id = symbol->ID;
      else
        id = XS_NO_ID;
      mxEncodeID(p, id);
      break;
    case XS_CODE_PROFILE:
      id = fxGenerateProfileID(parser->console);
      mxEncodeID(p, id);
      break;
      
    case XS_CODE_ARGUMENT:
    case XS_CODE_ARGUMENTS:
    case XS_CODE_ARGUMENTS_SLOPPY:
    case XS_CODE_ARGUMENTS_STRICT:
    case XS_CODE_BEGIN_SLOPPY:
    case XS_CODE_BEGIN_STRICT:
    case XS_CODE_BEGIN_STRICT_BASE:
    case XS_CODE_BEGIN_STRICT_DERIVED:
    case XS_CODE_BEGIN_STRICT_FIELD:
    case XS_CODE_MODULE:
    case XS_CODE_RESERVE_1:
    case XS_CODE_RETRIEVE_1:
    case XS_CODE_UNWIND_1:
      u1 = (txU1)(((txIndexCode*)code)->index);
      *((txU1*)p++) = u1;
      break;
    case XS_CODE_LINE:
    case XS_CODE_RESERVE_2:
    case XS_CODE_RETRIEVE_2:
    case XS_CODE_UNWIND_2:
      u2 = (txU2)(((txIndexCode*)code)->index);
      mxEncode2(p, u2);
      break;

    case XS_CODE_CONST_CLOSURE_1:
    case XS_CODE_CONST_LOCAL_1:
    case XS_CODE_GET_CLOSURE_1:
    case XS_CODE_GET_LOCAL_1:
    case XS_CODE_GET_PRIVATE_1:
    case XS_CODE_HAS_PRIVATE_1:
    case XS_CODE_LET_CLOSURE_1:
    case XS_CODE_LET_LOCAL_1:
    case XS_CODE_NEW_PRIVATE_1:
    case XS_CODE_PULL_CLOSURE_1:
    case XS_CODE_PULL_LOCAL_1:
    case XS_CODE_REFRESH_CLOSURE_1:
    case XS_CODE_REFRESH_LOCAL_1:
    case XS_CODE_RESET_CLOSURE_1:
    case XS_CODE_RESET_LOCAL_1:
    case XS_CODE_SET_CLOSURE_1:
    case XS_CODE_SET_LOCAL_1:
    case XS_CODE_SET_PRIVATE_1:
    case XS_CODE_STORE_1:
    case XS_CODE_USED_1:
    case XS_CODE_VAR_CLOSURE_1:
    case XS_CODE_VAR_LOCAL_1:
      u1 = (txU1)(((txIndexCode*)code)->index + 1);
      *((txU1*)p++) = u1;
      break;

    case XS_CODE_CONST_CLOSURE_2:
    case XS_CODE_CONST_LOCAL_2:
    case XS_CODE_GET_CLOSURE_2:
    case XS_CODE_GET_LOCAL_2:
    case XS_CODE_GET_PRIVATE_2:
    case XS_CODE_HAS_PRIVATE_2:
    case XS_CODE_LET_CLOSURE_2:
    case XS_CODE_LET_LOCAL_2:
    case XS_CODE_NEW_PRIVATE_2:
    case XS_CODE_PULL_CLOSURE_2:
    case XS_CODE_PULL_LOCAL_2:
    case XS_CODE_REFRESH_CLOSURE_2:
    case XS_CODE_REFRESH_LOCAL_2:
    case XS_CODE_RESET_CLOSURE_2:
    case XS_CODE_RESET_LOCAL_2:
    case XS_CODE_SET_CLOSURE_2:
    case XS_CODE_SET_LOCAL_2:
    case XS_CODE_SET_PRIVATE_2:
    case XS_CODE_STORE_2:
    case XS_CODE_USED_2:
    case XS_CODE_VAR_CLOSURE_2:
    case XS_CODE_VAR_LOCAL_2:
      u2 = (txU2)(((txIndexCode*)code)->index + 1);
      mxEncode2(p, u2);
      break;
  
    case XS_CODE_INTEGER_1: 
    case XS_CODE_RUN_1: 
    case XS_CODE_RUN_TAIL_1: 
      s1 = (txS1)(((txIntegerCode*)code)->integer);
      *p++ = s1;
      break;
    case XS_CODE_INTEGER_2: 
    case XS_CODE_RUN_2: 
    case XS_CODE_RUN_TAIL_2: 
      s2 = (txS2)(((txIntegerCode*)code)->integer);
      mxEncode2(p, s2);
      break;
    case XS_CODE_INTEGER_4: 
    case XS_CODE_RUN_4: 
    case XS_CODE_RUN_TAIL_4: 
      s4 = (txS4)(((txIntegerCode*)code)->integer);
      mxEncode4(p, s4);
      break;
    case XS_CODE_NUMBER:
      n = ((txNumberCode*)code)->number;
      mxEncode8(p, n);
      break;
    case XS_CODE_STRING_1:
      u1 = (txU1)(((txStringCode*)code)->length);
      *((txU1*)p++) = u1;
      c_memcpy(p, ((txStringCode*)code)->string, u1);
      p += u1;
      break;
    case XS_CODE_STRING_2:
      u2 = (txU2)(((txStringCode*)code)->length);
      mxEncode2(p, u2);
      c_memcpy(p, ((txStringCode*)code)->string, u2);
      p += u2;
      break;
    case XS_CODE_STRING_4:
      s4 = (txS4)(((txStringCode*)code)->length);
      mxEncode4(p, s4);
      c_memcpy(p, ((txStringCode*)code)->string, s4);
      p += s4;
      break;
    case XS_CODE_BIGINT_1:
      u1 = (txU1)fxBigIntMeasure(&((txBigIntCode*)code)->bigint);
      *((txU1*)p++) = u1;
      fxBigIntEncode(p, &((txBigIntCode*)code)->bigint, u1);
      p += u1;
      break;
    case XS_CODE_BIGINT_2:
      u2 = (txU2)fxBigIntMeasure(&((txBigIntCode*)code)->bigint);
            mxEncode2(p, u2);
      fxBigIntEncode(p, &((txBigIntCode*)code)->bigint, u2);
      p += u2;
      break;
      
    case XS_CODE_HOST:
      u2 = (txU2)(((txIndexCode*)code)->index);
      mxEncode2(p, u2);
      break;
    }
    code = code->nextCode;
  }  
  
#ifdef mxCodePrint
  fprintf(stderr, "\n");
  code = coder.firstCode;
  while (code) {
    txInteger tab;
    for (tab = 0; tab < code->stackLevel; tab++)
      fprintf(stderr, "\t");
    switch (code->id) {
    case XS_NO_CODE:
      fprintf(stderr, "_%d\n", ((txTargetCode*)code)->index);
      break;
    
    case XS_CODE_BRANCH_1:
    case XS_CODE_BRANCH_2:
    case XS_CODE_BRANCH_4:
    case XS_CODE_BRANCH_CHAIN_1:
    case XS_CODE_BRANCH_CHAIN_2:
    case XS_CODE_BRANCH_CHAIN_4:
    case XS_CODE_BRANCH_COALESCE_1:
    case XS_CODE_BRANCH_COALESCE_2:
    case XS_CODE_BRANCH_COALESCE_4:
    case XS_CODE_BRANCH_ELSE_1:
    case XS_CODE_BRANCH_ELSE_2:
    case XS_CODE_BRANCH_ELSE_4:
    case XS_CODE_BRANCH_IF_1:
    case XS_CODE_BRANCH_IF_2:
    case XS_CODE_BRANCH_IF_4:
    case XS_CODE_BRANCH_STATUS_1:
    case XS_CODE_BRANCH_STATUS_2:
    case XS_CODE_BRANCH_STATUS_4:
    case XS_CODE_CATCH_1:
    case XS_CODE_CATCH_2:
    case XS_CODE_CATCH_4:
    case XS_CODE_CODE_1:
    case XS_CODE_CODE_2:
    case XS_CODE_CODE_4:
      fprintf(stderr, "%s _%d\n", gxCodeNames[code->id], ((txBranchCode*)code)->target->index);
      break;
    
    case XS_CODE_ARGUMENT:
    case XS_CODE_ARGUMENTS:
    case XS_CODE_ARGUMENTS_SLOPPY:
    case XS_CODE_ARGUMENTS_STRICT:
    case XS_CODE_BEGIN_SLOPPY:
    case XS_CODE_BEGIN_STRICT:
    case XS_CODE_BEGIN_STRICT_BASE:
    case XS_CODE_BEGIN_STRICT_DERIVED:
    case XS_CODE_BEGIN_STRICT_FIELD:
    case XS_CODE_LINE:
    case XS_CODE_MODULE:
      fprintf(stderr, "%s %d\n", gxCodeNames[code->id], ((txIndexCode*)code)->index);
      break;
      
    case XS_CODE_ASYNC_FUNCTION:
    case XS_CODE_ASYNC_GENERATOR_FUNCTION:
    case XS_CODE_CONSTRUCTOR_FUNCTION:
    case XS_CODE_DELETE_PROPERTY:
    case XS_CODE_DELETE_SUPER:
    case XS_CODE_FILE:
    case XS_CODE_FUNCTION:
    case XS_CODE_GENERATOR_FUNCTION:
    case XS_CODE_GET_PROPERTY:
    case XS_CODE_GET_SUPER:
    case XS_CODE_GET_THIS_VARIABLE:
    case XS_CODE_GET_VARIABLE:
    case XS_CODE_EVAL_PRIVATE:
    case XS_CODE_EVAL_REFERENCE:
    case XS_CODE_NAME:
    case XS_CODE_NEW_PROPERTY:
    case XS_CODE_PROGRAM_REFERENCE:
    case XS_CODE_SET_PROPERTY:
    case XS_CODE_SET_SUPER:
    case XS_CODE_SET_VARIABLE:
    case XS_CODE_SYMBOL:
      symbol = ((txSymbolCode*)code)->symbol;
      if (symbol && symbol->string)
        fprintf(stderr, "%s %s\n", gxCodeNames[code->id], symbol->string);
      else
        fprintf(stderr, "%s ?\n", gxCodeNames[code->id]);
      break;
    
    case XS_CODE_CONST_CLOSURE_1:
    case XS_CODE_CONST_CLOSURE_2:
    case XS_CODE_CONST_LOCAL_1:
    case XS_CODE_CONST_LOCAL_2:
    case XS_CODE_GET_CLOSURE_1:
    case XS_CODE_GET_CLOSURE_2:
    case XS_CODE_GET_LOCAL_1:
    case XS_CODE_GET_LOCAL_2:
    case XS_CODE_GET_PRIVATE_1:
    case XS_CODE_GET_PRIVATE_2:
    case XS_CODE_HAS_PRIVATE_1:
    case XS_CODE_HAS_PRIVATE_2:
    case XS_CODE_LET_CLOSURE_1:
    case XS_CODE_LET_CLOSURE_2:
    case XS_CODE_LET_LOCAL_1:
    case XS_CODE_LET_LOCAL_2:
    case XS_CODE_NEW_PRIVATE_1:
    case XS_CODE_NEW_PRIVATE_2:
    case XS_CODE_PULL_CLOSURE_1:
    case XS_CODE_PULL_CLOSURE_2:
    case XS_CODE_PULL_LOCAL_1:
    case XS_CODE_PULL_LOCAL_2:
    case XS_CODE_REFRESH_CLOSURE_1:
    case XS_CODE_REFRESH_CLOSURE_2:
    case XS_CODE_REFRESH_LOCAL_1:
    case XS_CODE_REFRESH_LOCAL_2:
    case XS_CODE_RESET_CLOSURE_1:
    case XS_CODE_RESET_CLOSURE_2:
    case XS_CODE_RESET_LOCAL_1:
    case XS_CODE_RESET_LOCAL_2:
    case XS_CODE_SET_CLOSURE_1:
    case XS_CODE_SET_CLOSURE_2:
    case XS_CODE_SET_LOCAL_1:
    case XS_CODE_SET_LOCAL_2:
    case XS_CODE_SET_PRIVATE_1:
    case XS_CODE_SET_PRIVATE_2:
    case XS_CODE_STORE_1:
    case XS_CODE_STORE_2:
    case XS_CODE_USED_1:
    case XS_CODE_USED_2:
    case XS_CODE_VAR_CLOSURE_1:
    case XS_CODE_VAR_CLOSURE_2:
    case XS_CODE_VAR_LOCAL_1:
    case XS_CODE_VAR_LOCAL_2:
      fprintf(stderr, "%s [%d]\n", gxCodeNames[code->id], ((txIndexCode*)code)->index);
      break;
    
    case XS_CODE_RESERVE_1:
    case XS_CODE_RESERVE_2:
    case XS_CODE_UNWIND_1:
    case XS_CODE_UNWIND_2:
      fprintf(stderr, "%s #%d\n", gxCodeNames[code->id], ((txIndexCode*)code)->index);
      break;
    case XS_CODE_NEW_CLOSURE:
    case XS_CODE_NEW_LOCAL:
      fprintf(stderr, "[%d] %s %s\n", ((txVariableCode*)code)->index, gxCodeNames[code->id], ((txSymbolCode*)code)->symbol->string);
      break;
    case XS_CODE_NEW_TEMPORARY:
      fprintf(stderr, "[%d] %s\n", ((txIndexCode*)code)->index, gxCodeNames[code->id]);
      break;
    case XS_CODE_RETRIEVE_1:
    case XS_CODE_RETRIEVE_2:
      {
        txInteger i, c = ((txIndexCode*)code)->index;
        fprintf(stderr, "[0");
        for (i = 1; i < c; i++)
          fprintf(stderr, ",%d", i);
        fprintf(stderr, "] %s\n", gxCodeNames[code->id]);
      }
      break;
    
    case XS_CODE_INTEGER_1: 
    case XS_CODE_INTEGER_2: 
    case XS_CODE_INTEGER_4: 
    case XS_CODE_RUN_1: 
    case XS_CODE_RUN_2: 
    case XS_CODE_RUN_4: 
    case XS_CODE_RUN_TAIL_1: 
    case XS_CODE_RUN_TAIL_2: 
    case XS_CODE_RUN_TAIL_4: 
      fprintf(stderr, "%s %d\n", gxCodeNames[code->id], ((txIntegerCode*)code)->integer);
      break;
    case XS_CODE_NUMBER:
      fprintf(stderr, "%s %lf\n", gxCodeNames[code->id], ((txNumberCode*)code)->number);
      break;
    case XS_CODE_STRING_1:
    case XS_CODE_STRING_2:
    case XS_CODE_STRING_4:
      fprintf(stderr, "%s %d \"%s\"\n", gxCodeNames[code->id], ((txStringCode*)code)->length, ((txStringCode*)code)->string);
      break;
    case XS_CODE_BIGINT_1:
    case XS_CODE_BIGINT_2:
      fprintf(stderr, "%s %d\n", gxCodeNames[code->id], fxBigIntMeasure(&((txBigIntCode*)code)->bigint));
      break;
      
    case XS_CODE_HOST:
      fprintf(stderr, "%s %d\n", gxCodeNames[code->id], ((txIndexCode*)code)->index);
      break;
  
    default:
      fprintf(stderr, "%s\n", gxCodeNames[code->id]);
      break;
    }
    code = code->nextCode;
  }
#endif
  script->symbolsBuffer = c_malloc(total);
  if (!script->symbolsBuffer) goto bail;
  script->symbolsSize = total;
  
  p = script->symbolsBuffer;
  mxEncodeID(p, count);
  
  address = parser->symbolTable;
  c = parser->symbolModulo;
  for (i = 0; i < c; i++) {
    txSymbol* symbol = *address;
    while (symbol) {
      if (symbol->usage & 1) {
        c_memcpy(p, symbol->string, symbol->length);
        p += symbol->length;
      }
      symbol = symbol->next;
    }
    address++;
  }
  
  c = (txS2)(parser->hostNodeIndex);
  if (c) {
    size = sizeof(txID);
    node = parser->firstHostNode;
    while (node) {
      size += 1 + sizeof(txID) + node->at->length + 1;
      node = node->nextHostNode;
    }
  
    script->hostsBuffer = c_malloc(size);
    if (!script->hostsBuffer) goto bail;
    script->hostsSize = size;
  
    p = script->hostsBuffer;
    mxEncodeID(p, c);
    node = parser->firstHostNode;
    while (node) {
      *p++ = (txS1)(node->paramsCount);
      if (node->symbol)
        c = node->symbol->ID;
      else
        c = XS_NO_ID;
      mxEncodeID(p, c);
      c_memcpy(p, node->at->value, node->at->length);
      p += node->at->length;
      *p++ = 0;
      node = node->nextHostNode;
    }
  }

  return script;
bail:
  fxDeleteScript(script);
  return C_NULL;
}

void fxCoderAdd(txCoder* self, txInteger delta, void* it)
{
  txByteCode* code = it;
  if (self->lastCode)
    self->lastCode->nextCode = code;
  else
    self->firstCode = code;
  self->lastCode = code;
  self->stackLevel += delta;
  code->stackLevel = self->stackLevel;
//  if (self->stackLevel < 0)
//    c_fprintf(stderr, "# oops %d\n", code->id);   //@@
}

void fxCoderAddBigInt(txCoder* self, txInteger delta, txInteger id, txBigInt* bigint)
{
  txBigIntCode* code = fxNewParserChunkClear(self->parser, sizeof(txBigIntCode));
  fxCoderAdd(self, delta, code);
  code->id = id;
  code->bigint = *bigint;
}

void fxCoderAddBranch(txCoder* self, txInteger delta, txInteger id, txTargetCode* target)
{
  txBranchCode* code = fxNewParserChunkClear(self->parser, sizeof(txBranchCode));
  fxCoderAdd(self, delta, code);
  code->id = id;
  code->target = target;
  target->used = 1;
}

void fxCoderAddByte(txCoder* self, txInteger delta, txInteger id)
{
  txByteCode* code = fxNewParserChunkClear(self->parser, sizeof(txByteCode));
  fxCoderAdd(self, delta, code);
  code->id = id;
}

void fxCoderAddIndex(txCoder* self, txInteger delta, txInteger id, txInteger index)
{
  txIndexCode* code = fxNewParserChunkClear(self->parser, sizeof(txIndexCode));
  fxCoderAdd(self, delta, code);
  code->id = id;
  code->index = index;
}

void fxCoderAddInteger(txCoder* self, txInteger delta, txInteger id, txInteger integer)
{
  txIntegerCode* code = fxNewParserChunkClear(self->parser, sizeof(txIntegerCode));
  fxCoderAdd(self, delta, code);
  code->id = id;
  code->integer = integer;
}

void fxCoderAddLine(txCoder* self, txInteger delta, txInteger id, txNode* node)
{
  if (self->parser->flags & mxDebugFlag) {
    if (self->parser->lines) {
      if (node->path != self->parser->path) {
        node->path = self->parser->path;
        node->line = self->parser->lines[node->line];
      }
    }
    else if (self->parser->source) {
      node->path = self->parser->source;
    }
    if (self->path != node->path) {
      if (node->path) {
        fxCoderAddSymbol(self, 0, XS_CODE_FILE, node->path);
        fxCoderAddIndex(self, 0, id, node->line);
      }
      self->path = node->path;
      self->line = node->line;
    }
    else if (self->line != node->line) {
      if (self->path) {
        txIndexCode* code = (txIndexCode*)self->lastCode;
        if (code && (code->id == id) && (code->index != 0))
          code->index = node->line;
        else
          fxCoderAddIndex(self, 0, id, node->line);
      }
      self->line = node->line;
    }
  }
}

void fxCoderAddNumber(txCoder* self, txInteger delta, txInteger id, txNumber number)
{
  txNumberCode* code = fxNewParserChunkClear(self->parser, sizeof(txNumberCode));
  fxCoderAdd(self, delta, code);
  code->id = id;
  code->number = number;
}

void fxCoderAddString(txCoder* self, txInteger delta, txInteger id, txInteger length, txString string)
{
  txStringCode* code = fxNewParserChunkClear(self->parser, sizeof(txStringCode));
  fxCoderAdd(self, delta, code);
  code->id = id;
  code->length = length + 1;
  code->string = string;
}

void fxCoderAddSymbol(txCoder* self, txInteger delta, txInteger id, txSymbol* symbol)
{
  txSymbolCode* code = fxNewParserChunkClear(self->parser, sizeof(txSymbolCode));
  fxCoderAdd(self, delta, code);
  code->id = id;
  code->symbol = symbol;
}

void fxCoderAddVariable(txCoder* self, txInteger delta, txInteger id, txSymbol* symbol, txInteger index)
{
  txVariableCode* code = fxNewParserChunkClear(self->parser, sizeof(txVariableCode));
  fxCoderAdd(self, delta, code);
  code->id = id;
  code->symbol = symbol;
  code->index = index;
}

void fxCoderAdjustEnvironment(txCoder* self, txTargetCode* target)
{
  txInteger count = self->environmentLevel - target->environmentLevel;
  while (count) {
    fxCoderAddByte(self, 0, XS_CODE_WITHOUT);
    count--;
  }
}

void fxCoderAdjustScope(txCoder* self, txTargetCode* target)
{
  txInteger count = self->scopeLevel - target->scopeLevel;
  if (count)
    fxCoderAddIndex(self, 0, XS_CODE_UNWIND_1, count);
}

txTargetCode* fxCoderAliasTargets(txCoder* self, txTargetCode* target)
{
  txTargetCode* result = NULL;
  if (target) {
    txTargetCode* alias = result = fxNewParserChunkClear(self->parser, sizeof(txTargetCode));
    alias->index = self->targetIndex++;
    alias->label = target->label;
    alias->environmentLevel = self->environmentLevel;
    alias->scopeLevel = self->scopeLevel;
    alias->stackLevel = self->stackLevel;
    alias->original = target;
    target = target->nextTarget;
    while (target) {
      alias = alias->nextTarget = fxNewParserChunkClear(self->parser, sizeof(txTargetCode));
      alias->index = self->targetIndex++;
      alias->label = target->label;
      alias->environmentLevel = self->environmentLevel;
      alias->scopeLevel = self->scopeLevel;
      alias->stackLevel = self->stackLevel;
      alias->original = target;
      target = target->nextTarget;
    }
  }
  return result;
}

txInteger fxCoderCountParameters(txCoder* self, txNode* params)
{
  txNode* item = ((txParamsBindingNode*)params)->items->first;
  txInteger count = 0;
  while (item) {
    if (item->description->token == XS_TOKEN_REST_BINDING)
      break;
    if ((item->description->token != XS_TOKEN_ARG) && (item->description->token != XS_TOKEN_ARRAY_BINDING) && (item->description->token != XS_TOKEN_OBJECT_BINDING))
      break;
    count++;
    item = item->next;
  }
  return count;
}

txTargetCode* fxCoderCreateTarget(txCoder* self)
{
  txTargetCode* result = fxNewParserChunkClear(self->parser, sizeof(txTargetCode));
  result->index = self->targetIndex++;
  result->environmentLevel = self->environmentLevel;
  result->scopeLevel = self->scopeLevel;
  result->stackLevel = self->stackLevel;
  return result;
}

txTargetCode* fxCoderFinalizeTargets(txCoder* self, txTargetCode* alias, txInteger selector, txInteger* address, txTargetCode* finallyTarget)
{
  txTargetCode* result = NULL;
  txInteger selection = *address;
  if (alias) {
    result = alias->original;
    while (alias) {
      if (alias->used) {
        fxCoderAdd(self, 0, alias);
        fxCoderAddInteger(self, 1, XS_CODE_INTEGER_1, selection);
        fxCoderAddIndex(self, -1, XS_CODE_PULL_LOCAL_1, selector);
        fxCoderAddBranch(self, 0, XS_CODE_BRANCH_1, finallyTarget);
        alias->original->used = 1;
      }
      alias = alias->nextTarget;
      selection++;
    }
  }
  *address = selection;
  return result;
}

void fxCoderJumpTargets(txCoder* self, txTargetCode* target, txInteger selector, txInteger* address)
{
  txInteger selection = *address;
  while (target) {
    if (target->used) {
      txTargetCode* elseTarget = fxCoderCreateTarget(self);
      fxCoderAddInteger(self, 1, XS_CODE_INTEGER_1, selection);
      fxCoderAddIndex(self, 1, XS_CODE_GET_LOCAL_1, selector);
      fxCoderAddByte(self, -1, XS_CODE_STRICT_EQUAL);
      fxCoderAddBranch(self, -1, XS_CODE_BRANCH_ELSE_1, elseTarget);
      fxCoderAdjustEnvironment(self, target);
      fxCoderAdjustScope(self, target);
      fxCoderAddBranch(self, 0, XS_CODE_BRANCH_1, target);
      fxCoderAdd(self, 0, elseTarget);
    }
    target = target->nextTarget;
    selection++;
  }
  *address = selection;
}

void fxCoderOptimize(txCoder* self)
{
  txByteCode** address;
  txByteCode* code;
  
  // branch to (target | unwind)* end => end
  address = &self->firstCode;
  while ((code = *address)) {
    if (code->id == XS_CODE_BRANCH_1) {
      txByteCode* nextCode = ((txBranchCode*)code)->target->nextCode;
      while ((nextCode->id == XS_NO_CODE) || (nextCode->id == XS_CODE_UNWIND_1))
        nextCode = nextCode->nextCode;
      if ((XS_CODE_END <= nextCode->id) && (nextCode->id <= XS_CODE_END_DERIVED)) {
        txByteCode* end = fxNewParserChunkClear(self->parser, sizeof(txByteCode));
        end->nextCode = code->nextCode;
        end->id = nextCode->id;
        end->stackLevel = code->stackLevel;
        *address = end;
      }
      else
        address = &code->nextCode;
    }
    else
      address = &code->nextCode;
  }
  // unwind (target | unwind)* end => (target | unwind)* end
  address = &self->firstCode;
  while ((code = *address)) {
    if (code->id == XS_CODE_UNWIND_1) {
      txByteCode* nextCode = code->nextCode;
      while ((nextCode->id == XS_NO_CODE) || (nextCode->id == XS_CODE_UNWIND_1))
        nextCode = nextCode->nextCode;
      if ((XS_CODE_END <= nextCode->id) && (nextCode->id <= XS_CODE_END_DERIVED))
        *address = code->nextCode;
      else
        address = &code->nextCode;
    }
    else
      address = &code->nextCode;
  }
  // end target* end => target* end
  address = &self->firstCode;
  while ((code = *address)) {
    if ((XS_CODE_END <= code->id) && (code->id <= XS_CODE_END_DERIVED)) {
      txByteCode* nextCode = code->nextCode;
      if (!nextCode)
        break;
      while (nextCode->id == XS_NO_CODE)
        nextCode = nextCode->nextCode;
      if (nextCode->id == code->id)
        *address = code->nextCode;
      else
        address = &code->nextCode;
    }
    else
      address = &code->nextCode;
  }
  // branch to next =>
  address = &self->firstCode;
  while ((code = *address)) {
    if (code->id == XS_CODE_BRANCH_1) {
      if (code->nextCode == (txByteCode*)(((txBranchCode*)code)->target))
        *address = code->nextCode;
      else
        address = &code->nextCode;
    }
    else
      address = &code->nextCode;
  }
}

txInteger fxCoderUseTemporaryVariable(txCoder* self)
{
  txInteger result = self->scopeLevel++;
  fxCoderAddIndex(self, 0, XS_CODE_NEW_TEMPORARY, result);
  return result;
}

void fxCoderUnuseTemporaryVariables(txCoder* self, txInteger count)
{
  fxCoderAddIndex(self, 0, XS_CODE_UNWIND_1, count);
  self->scopeLevel -= count;
}

void fxScopeCoded(txScope* self, txCoder* coder) 
{
  if (self->declareNodeCount) {
    if (self->flags & mxEvalFlag) {
      coder->environmentLevel--;
      fxCoderAddByte(coder, 0, XS_CODE_WITHOUT);
    }
    fxCoderAddIndex(coder, 0, XS_CODE_UNWIND_1, self->declareNodeCount);
    coder->scopeLevel -= self->declareNodeCount;
  }
}

void fxScopeCodedBody(txScope* self, txCoder* coder) 
{
  txScope* functionScope = self->scope;
  if ((functionScope->node->flags & mxEvalFlag) && !(functionScope->node->flags & mxStrictFlag)) {
    coder->environmentLevel--;
    fxCoderAddByte(coder, 0, XS_CODE_WITHOUT);
    coder->environmentLevel--;
    fxCoderAddByte(coder, 0, XS_CODE_WITHOUT);
    fxCoderAddIndex(coder, 0, XS_CODE_UNWIND_1, self->declareNodeCount);
    coder->scopeLevel -= self->declareNodeCount;
  }
  else 
    fxScopeCoded(self, coder);
}

void fxScopeCodingBlock(txScope* self, txCoder* coder) 
{
  if (self->declareNodeCount) {
    txDeclareNode* node = self->firstDeclareNode;
    while (node) {
      if (node->flags & mxDeclareNodeClosureFlag) {
        if (!(node->flags & mxDeclareNodeUseClosureFlag)) {
          node->index = coder->scopeLevel++;
          fxCoderAddVariable(coder, 0, XS_CODE_NEW_CLOSURE, node->symbol, node->index);
          if (node->description->token == XS_TOKEN_VAR) {
            fxCoderAddByte(coder, 1, XS_CODE_UNDEFINED);
            fxCoderAddIndex(coder, 0, XS_CODE_VAR_CLOSURE_1, node->index);
            fxCoderAddByte(coder, -1, XS_CODE_POP);
          }
        }
      }
      else {
        node->index = coder->scopeLevel++;
        if (node->symbol)
          fxCoderAddVariable(coder, 0, XS_CODE_NEW_LOCAL, node->symbol, node->index);
        else
          fxCoderAddIndex(coder, 0, XS_CODE_NEW_TEMPORARY, node->index);
        if (node->description->token == XS_TOKEN_VAR) {
          fxCoderAddByte(coder, 1, XS_CODE_UNDEFINED);
          fxCoderAddIndex(coder, 0, XS_CODE_VAR_LOCAL_1, node->index);
          fxCoderAddByte(coder, -1, XS_CODE_POP);
        }
      }
      node = node->nextDeclareNode;
    }
    if (self->flags & mxEvalFlag) {
      fxCoderAddByte(coder, 1, XS_CODE_UNDEFINED);
      fxCoderAddByte(coder, 0, XS_CODE_WITH);
      node = self->firstDeclareNode;
      while (node) {
        fxCoderAddIndex(coder, 0, XS_CODE_STORE_1, node->index);
        node = node->nextDeclareNode;
      }
      fxCoderAddByte(coder, -1, XS_CODE_POP);
      coder->environmentLevel++;
    }
  }
}

void fxScopeCodingBody(txScope* self, txCoder* coder) 
{
  if ((self->node->flags & mxEvalFlag) && !(self->node->flags & mxStrictFlag)) {
    txDeclareNode* node = self->firstDeclareNode;
    while (node) {
      if (node->description->token == XS_TOKEN_DEFINE) {
        node->index = coder->scopeLevel++;
        fxCoderAddVariable(coder, 0, XS_CODE_NEW_CLOSURE, node->symbol, node->index);
        fxCoderAddByte(coder, 1, XS_CODE_NULL);
        fxCoderAddIndex(coder, 0, XS_CODE_VAR_CLOSURE_1, node->index);
        fxCoderAddByte(coder, -1, XS_CODE_POP);
      }
      else if (node->description->token == XS_TOKEN_VAR) {
        node->index = coder->scopeLevel++;
        fxCoderAddVariable(coder, 0, XS_CODE_NEW_CLOSURE, node->symbol, node->index);
        fxCoderAddByte(coder, 1, XS_CODE_UNDEFINED);
        fxCoderAddIndex(coder, 0, XS_CODE_VAR_CLOSURE_1, node->index);
        fxCoderAddByte(coder, -1, XS_CODE_POP);
      }
      node = node->nextDeclareNode;
    }
    fxCoderAddByte(coder, 1, XS_CODE_NULL);
    fxCoderAddByte(coder, 0, XS_CODE_WITH);
    node = self->firstDeclareNode;
    while (node) {
      if ((node->description->token == XS_TOKEN_DEFINE) || (node->description->token == XS_TOKEN_VAR))
        fxCoderAddIndex(coder, 0, XS_CODE_STORE_1, node->index);
      node = node->nextDeclareNode;
    }
    fxCoderAddByte(coder, -1, XS_CODE_POP);
    coder->environmentLevel++;
    node = self->firstDeclareNode;
    while (node) {
      if ((node->description->token != XS_TOKEN_DEFINE) && (node->description->token != XS_TOKEN_VAR)) {
        node->index = coder->scopeLevel++;
        if (node->symbol)
          fxCoderAddVariable(coder, 0, XS_CODE_NEW_CLOSURE, node->symbol, node->index);
        else
          fxCoderAddIndex(coder, 0, XS_CODE_NEW_TEMPORARY, node->index);
      }
      node = node->nextDeclareNode;
    }
    fxCoderAddByte(coder, 1, XS_CODE_UNDEFINED);
    fxCoderAddByte(coder, 0, XS_CODE_WITH);
    node = self->firstDeclareNode;
    while (node) {
      if ((node->description->token != XS_TOKEN_DEFINE) && (node->description->token != XS_TOKEN_VAR)) {
        if (node->symbol)
          fxCoderAddIndex(coder, 0, XS_CODE_STORE_1, node->index);
      }
      node = node->nextDeclareNode;
    }
    fxCoderAddByte(coder, -1, XS_CODE_POP);
    coder->environmentLevel++;
  }
  else 
    fxScopeCodingBlock(self, coder);
}

void fxScopeCodingEval(txScope* self, txCoder* coder) 
{
  txProgramNode* programNode = (txProgramNode*)self->node;
  txDeclareNode* node;
  if (self->flags & mxStrictFlag) {
    if (programNode->scopeCount) {
      fxCoderAddIndex(coder, 0, XS_CODE_RESERVE_1, programNode->scopeCount);
      fxScopeCodingBlock(self, coder);
      node = self->firstDeclareNode;
      while (node) {
        if (node->description->token == XS_TOKEN_PRIVATE) {
          fxCoderAddSymbol(coder, 1, XS_CODE_EVAL_PRIVATE, node->symbol);
          fxCoderAddIndex(coder, 0, XS_CODE_CONST_CLOSURE_1, node->index);
          fxCoderAddByte(coder, -1, XS_CODE_POP);
        }
        node = node->nextDeclareNode;
      }
    }
  }
  else {
    txInteger count = 0;
    node = self->firstDeclareNode;
    while (node) {
      if ((node->description->token == XS_TOKEN_DEFINE) || (node->description->token == XS_TOKEN_VAR))
        count++;
      node = node->nextDeclareNode;
    }
    if (count) {
      fxCoderAddIndex(coder, 0, XS_CODE_RESERVE_1, count);
      node = self->firstDeclareNode;
      while (node) {
        if (node->description->token == XS_TOKEN_DEFINE) {
          node->index = coder->scopeLevel++;
          fxCoderAddVariable(coder, 0, XS_CODE_NEW_LOCAL, node->symbol, node->index);
          fxCoderAddByte(coder, 1, XS_CODE_NULL);
          fxCoderAddIndex(coder, 0, XS_CODE_VAR_LOCAL_1, node->index);
          fxCoderAddByte(coder, -1, XS_CODE_POP);
        }
        else if (node->description->token == XS_TOKEN_VAR) {
          node->index = coder->scopeLevel++;
          fxCoderAddVariable(coder, 0, XS_CODE_NEW_LOCAL, node->symbol, node->index);
          fxCoderAddByte(coder, 1, XS_CODE_UNDEFINED);
          fxCoderAddIndex(coder, 0, XS_CODE_VAR_LOCAL_1, node->index);
          fxCoderAddByte(coder, -1, XS_CODE_POP);
        }
        node = node->nextDeclareNode;
      }
    }
    fxCoderAddByte(coder, 0, XS_CODE_EVAL_ENVIRONMENT);
    coder->scopeLevel = 0;
    if (programNode->scopeCount) {
      fxCoderAddIndex(coder, 0, XS_CODE_RESERVE_1, programNode->scopeCount);
      if (self->declareNodeCount) {
        node = self->firstDeclareNode;
        while (node) {
          if ((node->description->token != XS_TOKEN_DEFINE) && (node->description->token != XS_TOKEN_VAR)) {
            node->index = coder->scopeLevel++;
            if (node->flags & mxDeclareNodeClosureFlag) {
              fxCoderAddVariable(coder, 0, XS_CODE_NEW_CLOSURE, node->symbol, node->index);
            }
            else {
              fxCoderAddVariable(coder, 0, XS_CODE_NEW_LOCAL, node->symbol, node->index);
            }
          }
          node = node->nextDeclareNode;
        }
        if (self->flags & mxEvalFlag) {
          fxCoderAddByte(coder, 1, XS_CODE_UNDEFINED);
          fxCoderAddByte(coder, 0, XS_CODE_WITH);
          node = self->firstDeclareNode;
          while (node) {
            if ((node->description->token != XS_TOKEN_DEFINE) && (node->description->token != XS_TOKEN_VAR))
              fxCoderAddIndex(coder, 0, XS_CODE_STORE_1, node->index);
            node = node->nextDeclareNode;
          }
          fxCoderAddByte(coder, -1, XS_CODE_POP);
          coder->environmentLevel++;
        }
      }
    }
  }
}

void fxScopeCodingParams(txScope* self, txCoder* coder) 
{
  txDeclareNode* node = self->firstDeclareNode;
  while (node) {
    txToken token = node->description->token;
    if ((token == XS_TOKEN_ARG) || (token == XS_TOKEN_VAR) || (token == XS_TOKEN_CONST)) {
      if (node->flags & mxDeclareNodeClosureFlag) {
        if (node->flags & mxDeclareNodeUseClosureFlag) {
          fxReportParserError(self->parser, node->line, "argument %s use closure", node->symbol->string);
        }
        node->index = coder->scopeLevel++;
        fxCoderAddVariable(coder, 0, XS_CODE_NEW_CLOSURE, node->symbol, node->index);
      }
      else {
        node->index = coder->scopeLevel++;
        fxCoderAddVariable(coder, 0, XS_CODE_NEW_LOCAL, node->symbol, node->index);
      }
    }
    node = node->nextDeclareNode;
  }
  if (self->flags & mxEvalFlag) {
    if (!(self->node->flags & mxStrictFlag)) { 
      fxCoderAddByte(coder, 1, XS_CODE_NULL);
      fxCoderAddByte(coder, 0, XS_CODE_WITH);
      fxCoderAddByte(coder, -1, XS_CODE_POP);
      coder->environmentLevel++;
    }
    fxCoderAddByte(coder, 1, XS_CODE_UNDEFINED);
    fxCoderAddByte(coder, 0, XS_CODE_WITH);
    node = self->firstDeclareNode;
    while (node) {
      txToken token = node->description->token;
      if ((token == XS_TOKEN_ARG) || (token == XS_TOKEN_VAR) || (token == XS_TOKEN_CONST))
        fxCoderAddIndex(coder, 0, XS_CODE_STORE_1, node->index);
      node = node->nextDeclareNode;
    }
    fxCoderAddByte(coder, -1, XS_CODE_POP);
    coder->environmentLevel++;
  }
}

void fxScopeCodingProgram(txScope* self, txCoder* coder) 
{
  txProgramNode* programNode = (txProgramNode*)self->node;
  txDeclareNode* node;
  txInteger count = 0;
  if (programNode->variableCount) {
    fxCoderAddIndex(coder, 0, XS_CODE_RESERVE_1, programNode->variableCount);
    node = self->firstDeclareNode;
    while (node) {
      if ((node->description->token != XS_TOKEN_DEFINE) && (node->description->token != XS_TOKEN_VAR)) {
        node->index = coder->scopeLevel++;
        fxCoderAddVariable(coder, 0, XS_CODE_NEW_CLOSURE, node->symbol, node->index);
      }
      node = node->nextDeclareNode;
    }
    count = coder->scopeLevel;
    node = self->firstDeclareNode;
    while (node) {
      if (node->description->token == XS_TOKEN_DEFINE) {
        // closure -> global property
        node->index = coder->scopeLevel++;
        fxCoderAddVariable(coder, 0, XS_CODE_NEW_LOCAL, node->symbol, node->index);
        fxCoderAddByte(coder, 1, XS_CODE_NULL);
        fxCoderAddIndex(coder, 0, XS_CODE_VAR_LOCAL_1, node->index);
        fxCoderAddByte(coder, -1, XS_CODE_POP);
      }
      else if (node->description->token == XS_TOKEN_VAR) {
        // closure -> global property
        node->index = coder->scopeLevel++;
        fxCoderAddVariable(coder, 0, XS_CODE_NEW_LOCAL, node->symbol, node->index);
        fxCoderAddByte(coder, 1, XS_CODE_UNDEFINED);
        fxCoderAddIndex(coder, 0, XS_CODE_VAR_LOCAL_1, node->index);
        fxCoderAddByte(coder, -1, XS_CODE_POP);
      }
      node = node->nextDeclareNode;
    }
    fxCoderAddByte(coder, 0, XS_CODE_PROGRAM_ENVIRONMENT);
    coder->scopeLevel = count;
  }
  if (programNode->scopeCount > count)
    fxCoderAddIndex(coder, 0, XS_CODE_RESERVE_1, programNode->scopeCount - count);
}

void fxScopeCodeDefineNodes(txScope* self, txCoder* coder) 
{
  txDefineNode* node = self->firstDefineNode;
  while (node) {
    fxDefineNodeCode(node, coder);
    node = node->nextDefineNode;
  }
}

txInteger fxScopeCodeSpecifierNodes(txScope* self, txCoder* coder) 
{
  txDeclareNode* node = self->firstDeclareNode;
  txInteger count = 0;
  while (node) {
    if (node->flags & mxDeclareNodeUseClosureFlag) {
      txSpecifierNode* specifier = node->importSpecifier;
      txInteger index = 3;
      txBoolean flag = 0;
      if (node->symbol)
        fxCoderAddSymbol(coder, 1, XS_CODE_SYMBOL, node->symbol);
      else
        fxCoderAddByte(coder, 1, XS_CODE_NULL);
      if (specifier) {
        if (coder->parser->flags & mxDebugFlag) {
          fxCoderAddLine(coder, 0, XS_CODE_LINE, (txNode*)specifier);
        }
        fxStringNodeCode(specifier->from, coder);
        if (specifier->with)
          flag = 1;
        if (specifier->symbol)
          fxCoderAddSymbol(coder, 1, XS_CODE_SYMBOL, specifier->symbol);
        else
          fxCoderAddByte(coder, 1, XS_CODE_NULL);
      }
      else {
        fxCoderAddByte(coder, 1, XS_CODE_NULL);
        fxCoderAddByte(coder, 1, XS_CODE_NULL);
      }
      specifier = node->firstExportSpecifier;
      while (specifier) {
        if (specifier->asSymbol) {
          fxCoderAddSymbol(coder, 1, XS_CODE_SYMBOL, specifier->asSymbol);
          index++;
        }
        else if (specifier->symbol) {
          fxCoderAddSymbol(coder, 1, XS_CODE_SYMBOL, specifier->symbol);
          index++;
        }
        else {
          fxCoderAddByte(coder, 1, XS_CODE_NULL);
          index++;
        }
        specifier = specifier->nextSpecifier;
      }
      fxCoderAddInteger(coder, 1, XS_CODE_INTEGER_1, index);
      if (flag)
        fxCoderAddByte(coder, 0 - index, XS_CODE_TRANSFER_JSON);
      else
        fxCoderAddByte(coder, 0 - index, XS_CODE_TRANSFER);
      count++;
    }
    node = node->nextDeclareNode;
  }
  return count;
}

void fxScopeCodeRefresh(txScope* self, txCoder* coder) 
{
  txDeclareNode* node = self->firstDeclareNode;
  while (node) {
    if (node->flags & mxDeclareNodeClosureFlag)
      fxCoderAddIndex(coder, 0, XS_CODE_REFRESH_CLOSURE_1, node->index);
    else
      fxCoderAddIndex(coder, 0, XS_CODE_REFRESH_LOCAL_1, node->index);
    node = node->nextDeclareNode;
  }
}

void fxScopeCodeReset(txScope* self, txCoder* coder) 
{
  txDeclareNode* node = self->firstDeclareNode;
  while (node) {
    if (node->flags & mxDeclareNodeClosureFlag)
      fxCoderAddIndex(coder, 0, XS_CODE_RESET_CLOSURE_1, node->index);
    else if (node->symbol)
      fxCoderAddIndex(coder, 0, XS_CODE_RESET_LOCAL_1, node->index);
    else {
      fxCoderAddByte(coder, 1, XS_CODE_UNDEFINED);
      fxCoderAddIndex(coder, -1, XS_CODE_PULL_LOCAL_1, node->index);
    }
    node = node->nextDeclareNode;
  }
}

void fxScopeCodeRetrieve(txScope* self, txCoder* coder) 
{
  txDeclareNode* node;
  txInteger count = 0;
  node = self->firstDeclareNode;
  while (node) {
    if ((node->flags & mxDeclareNodeUseClosureFlag) && node->symbol) {
      node->index = coder->scopeLevel++;
      count++;
    }
    node = node->nextDeclareNode;
  }
  if ((self->node->flags & mxArrowFlag) && ((self->node->flags & mxDefaultFlag) || (self->flags & mxEvalFlag))) {
    fxCoderAddIndex(coder, 0, XS_CODE_RETRIEVE_1, count);
    fxCoderAddByte(coder, 0, XS_CODE_RETRIEVE_TARGET);
    fxCoderAddByte(coder, 0, XS_CODE_RETRIEVE_THIS);
  }
  else if (count)
    fxCoderAddIndex(coder, 0, XS_CODE_RETRIEVE_1, count);
  self->closureNodeCount = count;
}

void fxScopeCodeStore(txScope* self, txCoder* coder) 
{
  txDeclareNode* node = self->firstDeclareNode;
  txUnsigned flags = self->flags & mxEvalFlag;
  while (node) {
    if (node->flags & mxDeclareNodeUseClosureFlag) {
      fxCoderAddIndex(coder, 0, XS_CODE_STORE_1, node->declaration->index);
      node->declaration->flags |= flags;
    }
    node = node->nextDeclareNode;
  }
  if ((self->node->flags & mxArrowFlag) && ((self->node->flags & mxDefaultFlag) || (self->flags & mxEvalFlag)))
    fxCoderAddByte(coder, 0, XS_CODE_STORE_ARROW);
  if (self->flags & mxEvalFlag)
    fxScopeCodeStoreAll(self->scope, coder);
}

void fxScopeCodeStoreAll(txScope* self, txCoder* coder) 
{
  txScope* scope = self;
  while (scope) {
    txDeclareNode* node;
    if (scope->token == XS_TOKEN_WITH)
      break;
    node = scope->firstDeclareNode;
    while (node) {
      if (node->flags & mxEvalFlag)
        node->flags &= ~mxEvalFlag;
      else if ((!(node->flags & mxDeclareNodeUseClosureFlag)) && node->declaration)
        fxCoderAddIndex(coder, 0, XS_CODE_STORE_1, node->declaration->index);
      node = node->nextDeclareNode;
    }
    if ((scope->token == XS_TOKEN_FUNCTION) || (scope->token == XS_TOKEN_MODULE))
      break;
    scope = scope->scope;
  }
}

void fxScopeCodeUsed(txScope* self, txCoder* coder, txUsingContext* context) 
{
  txTargetCode* normalTarget = fxCoderCreateTarget(coder);
  txTargetCode* uncatchTarget = fxCoderCreateTarget(coder);
  txTargetCode* finallyTarget = fxCoderCreateTarget(coder);
  txTargetCode* elseTarget = fxCoderCreateTarget(coder);
  txInteger selection;
  
  fxCoderAddBranch(coder, 0, XS_CODE_BRANCH_1, normalTarget);
  fxCoderAdd(coder, 0, context->catchTarget);
  fxCoderAddByte(coder, 1, XS_CODE_EXCEPTION);
  fxCoderAddIndex(coder, 0, XS_CODE_PULL_LOCAL_1, context->exception);
  fxCoderAddInteger(coder, 1, XS_CODE_INTEGER_1, 0);
  fxCoderAddIndex(coder, -1, XS_CODE_PULL_LOCAL_1, context->selector);
  fxCoderAddBranch(coder, 0, XS_CODE_BRANCH_1, finallyTarget);
  selection = 1;
  coder->firstBreakTarget = fxCoderFinalizeTargets(coder, coder->firstBreakTarget, context->selector, &selection, uncatchTarget);
  coder->firstContinueTarget = fxCoderFinalizeTargets(coder, coder->firstContinueTarget, context->selector, &selection, uncatchTarget);
  coder->returnTarget = fxCoderFinalizeTargets(coder, coder->returnTarget, context->selector, &selection, uncatchTarget);
  fxCoderAdd(coder, 0, normalTarget);
  fxCoderAddInteger(coder, 1, XS_CODE_INTEGER_1, selection);
  fxCoderAddIndex(coder, -1, XS_CODE_PULL_LOCAL_1, context->selector);
  fxCoderAdd(coder, 0, uncatchTarget);
  fxCoderAddByte(coder, 0, XS_CODE_UNCATCH);
  fxCoderAdd(coder, 0, finallyTarget);
  
  fxScopeCodeUsedReverse(self, coder, self->firstDeclareNode, context->exception, context->selector);
  
  fxCoderAddIndex(coder, 1, XS_CODE_GET_LOCAL_1, context->selector);
  fxCoderAddBranch(coder, -1, XS_CODE_BRANCH_IF_1, elseTarget);
  fxCoderAddIndex(coder, 1, XS_CODE_GET_LOCAL_1, context->exception);
  fxCoderAddByte(coder, -1, XS_CODE_THROW);
  fxCoderAdd(coder, 0, elseTarget);
  selection = 1;
  fxCoderJumpTargets(coder, coder->firstBreakTarget, context->selector, &selection);
  fxCoderJumpTargets(coder, coder->firstContinueTarget, context->selector, &selection);
  fxCoderJumpTargets(coder, coder->returnTarget, context->selector, &selection);
  fxCoderUnuseTemporaryVariables(coder, 2);
}

void fxScopeCodeUsedReverse(txScope* self, txCoder* coder, txDeclareNode* node, txInteger exception, txInteger selector) 
{
  if (node) {
    fxCheckParserStack(coder->parser, node->line);
    fxScopeCodeUsedReverse(self, coder, node->nextDeclareNode, exception, selector);
    if (node->description->token == XS_TOKEN_USING) {
      txTargetCode* catchTarget = fxCoderCreateTarget(coder);
      txTargetCode* chainTarget = fxCoderCreateTarget(coder);
      txTargetCode* normalTarget = fxCoderCreateTarget(coder);
      
      fxCoderAddIndex(coder, 1, XS_CODE_GET_LOCAL_1, node->index + 1);
      fxCoderAddByte(coder, 1, XS_CODE_UNDEFINED);
      fxCoderAddByte(coder, -1, XS_CODE_STRICT_EQUAL);
      fxCoderAddBranch(coder, -1, XS_CODE_BRANCH_IF_1, normalTarget);
      
      fxCoderAddBranch(coder, 0, XS_CODE_CATCH_1, catchTarget);
      
      fxCoderAddIndex(coder, 1, (node->flags & mxDeclareNodeClosureFlag) ? XS_CODE_GET_CLOSURE_1: XS_CODE_GET_LOCAL_1, node->index);
      fxCoderAddBranch(coder, 0, XS_CODE_BRANCH_CHAIN_1, chainTarget);
      fxCoderAddIndex(coder, 1, XS_CODE_GET_LOCAL_1, node->index + 1);
      fxCoderAddByte(coder, 1, XS_CODE_CALL);
      fxCoderAddInteger(coder, -2, XS_CODE_RUN_1, 0);
      
      fxCoderAdd(coder, 0, chainTarget);
      if (node->flags & mxAwaitingFlag) {
        fxCoderAddByte(coder, 0, XS_CODE_AWAIT);
        fxCoderAddByte(coder, 0, XS_CODE_THROW_STATUS);
      }
      fxCoderAddByte(coder, -1, XS_CODE_POP);
      
      fxCoderAddByte(coder, 0, XS_CODE_UNCATCH);
      fxCoderAddBranch(coder, 0, XS_CODE_BRANCH_1, normalTarget);
      fxCoderAdd(coder, 0, catchTarget);
      fxCoderAddIndex(coder, 1, XS_CODE_USED_1, selector);
      
      fxCoderAdd(coder, 0, normalTarget);
    }
  }
}

void fxScopeCodeUsing(txScope* self, txCoder* coder, txUsingContext* context) 
{
  context->exception = fxCoderUseTemporaryVariable(coder);
  context->selector = fxCoderUseTemporaryVariable(coder);
  coder->firstBreakTarget = fxCoderAliasTargets(coder, coder->firstBreakTarget);
  coder->firstContinueTarget = fxCoderAliasTargets(coder, coder->firstContinueTarget);
  coder->returnTarget = fxCoderAliasTargets(coder, coder->returnTarget);
  context->catchTarget = fxCoderCreateTarget(coder);
  fxCoderAddBranch(coder, 0, XS_CODE_CATCH_1, context->catchTarget);
}

void fxScopeCodeUsingStatement(txScope* self, txCoder* coder, txNode* statement) 
{
  if (self->disposableNodeCount) {
    txUsingContext context;
    fxScopeCodeUsing(self, coder, &context);
    fxNodeDispatchCode(statement, coder);
    fxScopeCodeUsed(self, coder, &context);
  }
  else
    fxNodeDispatchCode(statement, coder);
}

void fxNodeDispatchCode(void* it, void* param)
{
  txNode* self = it;
  txCoder* coder = param;
  fxCheckParserStack(coder->parser, self->line);
  if (self->line >= 0)
    fxCoderAddLine(coder, 0, XS_CODE_LINE, self); 
  (*self->description->dispatch->code)(it, param);
}

void fxNodeDispatchCodeAssign(void* it, void* param, txFlag flag)
{
  txNode* self = it;
  txCoder* coder = param;
  fxCheckParserStack(coder->parser, self->line);
  if (self->line >= 0)
    fxCoderAddLine(coder, 0, XS_CODE_LINE, self); 
  (*self->description->dispatch->codeAssign)(self, param, flag);
}

void fxNodeDispatchCodeDelete(void* it, void* param)
{
  txNode* self = it;
  txCoder* coder = param;
  fxCheckParserStack(coder->parser, self->line);
  if (self->line >= 0)
    fxCoderAddLine(coder, 0, XS_CODE_LINE, self); 
  (*self->description->dispatch->codeDelete)(self, param);
}

void fxNodeDispatchCodeReference(void* it, void* param, txFlag flag)
{
  txNode* self = it;
  txCoder* coder = param;
  fxCheckParserStack(coder->parser, self->line);
  if (self->line >= 0)
    fxCoderAddLine(coder, 0, XS_CODE_LINE, self); 
  (*self->description->dispatch->codeReference)(self, param, flag);
}

txFlag fxNodeDispatchCodeThis(void* it, void* param, txFlag flag) 
{
  txNode* self = it;
  txCoder* coder = param;
  fxCheckParserStack(coder->parser, self->line);
  if (self->line >= 0)
    fxCoderAddLine(coder, 0, XS_CODE_LINE, self); 
  return (*self->description->dispatch->codeThis)(self, param, flag);
}

void fxNodeCode(void* it, void* param) 
{
  txNode* self = it;
  txCoder* coder = param;
  fxReportParserError(coder->parser, self->line, "no value");
  fxCoderAddByte(param, 1, XS_CODE_UNDEFINED);
}

void fxNodeCodeAssign(void* it, void* param, txFlag flag) 
{
  txNode* self = it;
  txCoder* coder = param;
  fxReportParserError(coder->parser, self->line, "no reference");
}

void fxNodeCodeDelete(void* it, void* param) 
{
  fxNodeDispatchCode(it, param);
  fxCoderAddByte(param, -1, XS_CODE_POP);
  fxCoderAddByte(param, 1, XS_CODE_TRUE);
}

void fxNodeCodeReference(void* it, void* param, txFlag flag) 
{
}

txFlag fxNodeCodeName(txNode* value)
{
  txToken token = value->description->token;
  if (token == XS_TOKEN_EXPRESSIONS) {
    value = ((txExpressionsNode*)value)->items->first;
    if (value->next)
      return 0;
    token = value->description->token;
  }
  if (token == XS_TOKEN_CLASS) {
    txClassNode* node = (txClassNode*)value;
    if (node->symbol)
      return 0;
  }
  else if ((token == XS_TOKEN_FUNCTION) || (token == XS_TOKEN_GENERATOR) || (token == XS_TOKEN_HOST)) {
    txFunctionNode* node = (txFunctionNode*)value;
    if (node->symbol)
      return 0;
  }
  else
    return 0;
  return 1;
}

txFlag fxNodeCodeThis(void* it, void* param, txFlag flag) 
{
  fxCoderAddByte(param, 1, XS_CODE_UNDEFINED);
  fxNodeDispatchCode(it, param);
  return 1;
}

void fxAccessNodeCode(void* it, void* param) 
{
  txAccessNode* self = it;
  txDeclareNode* declaration = self->declaration;
  if (!declaration) {
    fxAccessNodeCodeReference(it, param, 0);
    fxCoderAddSymbol(param, 0, XS_CODE_GET_VARIABLE, self->symbol);
  }
  else
    fxCoderAddIndex(param, 1, (declaration->flags & mxDeclareNodeClosureFlag) ? XS_CODE_GET_CLOSURE_1 : XS_CODE_GET_LOCAL_1, declaration->index);
}

void fxAccessNodeCodeAssign(void* it, void* param, txFlag flag) 
{
  txAccessNode* self = it;
  txDeclareNode* declaration = self->declaration;
  if (!declaration)
    fxCoderAddSymbol(param, -1, XS_CODE_SET_VARIABLE, self->symbol);
  else
    fxCoderAddIndex(param, 0, (declaration->flags & mxDeclareNodeClosureFlag) ? XS_CODE_SET_CLOSURE_1 : XS_CODE_SET_LOCAL_1, declaration->index);
}

void fxAccessNodeCodeDelete(void* it, void* param) 
{
  txAccessNode* self = it;
  txCoder* coder = param;
  txDeclareNode* declaration = self->declaration;
  if (self->flags & mxStrictFlag)
    fxReportParserError(coder->parser, self->line, "delete identifier (strict code)");
  if (!declaration) {
    fxAccessNodeCodeReference(it, param, 0);
    fxCoderAddSymbol(param, 0, XS_CODE_DELETE_PROPERTY, self->symbol);
  }
  else
    fxCoderAddByte(param, 1, XS_CODE_FALSE);
}

void fxAccessNodeCodeReference(void* it, void* param, txFlag flag) 
{
  txAccessNode* self = it;
  txCoder* coder = param;
  txDeclareNode* declaration = self->declaration;
  if (!declaration) {
    if (coder->evalFlag)
      fxCoderAddSymbol(param, 1, XS_CODE_EVAL_REFERENCE, self->symbol);
    else
      fxCoderAddSymbol(param, 1, XS_CODE_PROGRAM_REFERENCE, self->symbol);
  }
}

txFlag fxAccessNodeCodeThis(void* it, void* param, txFlag flag) 
{
  txAccessNode* self = it;
  txDeclareNode* declaration = self->declaration;
  if (!flag)
    fxCoderAddByte(param, 1, XS_CODE_UNDEFINED);
  if (!declaration) {
    fxAccessNodeCodeReference(it, param, 0);
    if (flag)
      fxCoderAddByte(param, 1, XS_CODE_DUB);
    fxCoderAddSymbol(param, 0, XS_CODE_GET_THIS_VARIABLE, self->symbol);
  }
  else {
    fxCoderAddIndex(param, 1, (declaration->flags & mxDeclareNodeClosureFlag) ? XS_CODE_GET_CLOSURE_1 : XS_CODE_GET_LOCAL_1, declaration->index);
    flag = 0;
  }
  return flag;
}

void fxAndExpressionNodeCode(void* it, void* param) 
{
  txBinaryExpressionNode* self = it;
  txTargetCode* endTarget = fxCoderCreateTarget(param);
  self->right->flags |= (self->flags & mxTailRecursionFlag);
  fxNodeDispatchCode(self->left, param);
  fxCoderAddByte(param, 1, XS_CODE_DUB);
  fxCoderAddBranch(param, -1, XS_CODE_BRANCH_ELSE_1, endTarget);
  fxCoderAddByte(param, -1, XS_CODE_POP);
  fxNodeDispatchCode(self->right, param);
  fxCoderAdd(param, 0, endTarget);
}

void fxArgumentsNodeCode(void* it, void* param) 
{
  fxCoderAddIndex(param, 1, XS_CODE_ARGUMENTS, 0);
}

void fxArrayNodeCode(void* it, void* param) 
{
  txArrayNode* self = it;
  txCoder* coder = param;
  txInteger array = fxCoderUseTemporaryVariable(param);
  fxCoderAddByte(param, 1, XS_CODE_ARRAY);
  fxCoderAddIndex(param, 0, XS_CODE_SET_LOCAL_1, array);
  if (self->items) {
    txNode* item = self->items->first;
    if (self->flags & mxSpreadFlag) {
      txInteger counter = fxCoderUseTemporaryVariable(param);
      fxCoderAddInteger(param, 1, XS_CODE_INTEGER_1, 0);
      fxCoderAddIndex(param, -1, XS_CODE_PULL_LOCAL_1, counter);
      while (item) {
        if (item->description->token == XS_TOKEN_SPREAD) {
          txInteger iterator = fxCoderUseTemporaryVariable(param);
          txInteger result = fxCoderUseTemporaryVariable(param);
          txTargetCode* nextTarget = fxCoderCreateTarget(param);
          txTargetCode* doneTarget = fxCoderCreateTarget(param);
          fxNodeDispatchCode(((txSpreadNode*)item)->expression, param);
          fxCoderAddByte(param, 0, XS_CODE_FOR_OF);
          fxCoderAddIndex(param, 0, XS_CODE_SET_LOCAL_1, iterator);
          fxCoderAddByte(param, -1, XS_CODE_POP);
          fxCoderAdd(param, 0, nextTarget);
          fxCoderAddIndex(param, 1, XS_CODE_GET_LOCAL_1, iterator);
          fxCoderAddByte(param, 1, XS_CODE_DUB);
          fxCoderAddSymbol(param, 0, XS_CODE_GET_PROPERTY, coder->parser->nextSymbol);
          fxCoderAddByte(param, 1, XS_CODE_CALL);
          fxCoderAddInteger(param, -2, XS_CODE_RUN_1, 0);
          fxCoderAddIndex(param, 0, XS_CODE_SET_LOCAL_1, result);
          fxCoderAddSymbol(param, 0, XS_CODE_GET_PROPERTY, coder->parser->doneSymbol);
          fxCoderAddBranch(param, -1, XS_CODE_BRANCH_IF_1, doneTarget);
          fxCoderAddIndex(param, 1, XS_CODE_GET_LOCAL_1, array);
          fxCoderAddIndex(param, 1, XS_CODE_GET_LOCAL_1, counter);
          fxCoderAddByte(param, 0, XS_CODE_AT);
          fxCoderAddIndex(param, 0, XS_CODE_GET_LOCAL_1, result);
          fxCoderAddSymbol(param, 0, XS_CODE_GET_PROPERTY, coder->parser->valueSymbol);
          fxCoderAddByte(param, -2, XS_CODE_SET_PROPERTY_AT);
          fxCoderAddByte(param, -1, XS_CODE_POP);
          fxCoderAddIndex(param, 1, XS_CODE_GET_LOCAL_1, counter);
          fxCoderAddByte(param, 0, XS_CODE_INCREMENT);
          fxCoderAddIndex(param, -1, XS_CODE_PULL_LOCAL_1, counter);
          fxCoderAddBranch(param, 0, XS_CODE_BRANCH_1, nextTarget);
          fxCoderAdd(param, 1, doneTarget);
          fxCoderUnuseTemporaryVariables(param, 2);
        }
        else {
          if (item->description->token != XS_TOKEN_ELISION) {
            fxCoderAddIndex(param, 1, XS_CODE_GET_LOCAL_1, array);
            fxCoderAddIndex(param, 1, XS_CODE_GET_LOCAL_1, counter);
            fxCoderAddByte(param, 0, XS_CODE_AT);
            fxNodeDispatchCode(item, param);
            fxCoderAddByte(param, -2, XS_CODE_SET_PROPERTY_AT);
            fxCoderAddByte(param, -1, XS_CODE_POP);
            fxCoderAddIndex(param, 1, XS_CODE_GET_LOCAL_1, counter);
            fxCoderAddByte(param, 0, XS_CODE_INCREMENT);
            fxCoderAddIndex(param, -1, XS_CODE_PULL_LOCAL_1, counter);
          }
          else {
            fxCoderAddIndex(param, 1, XS_CODE_GET_LOCAL_1, array);
            fxCoderAddIndex(param, 1, XS_CODE_GET_LOCAL_1, counter);
            fxCoderAddByte(param, 0, XS_CODE_INCREMENT);
            fxCoderAddIndex(param, 0, XS_CODE_SET_LOCAL_1, counter);
            fxCoderAddSymbol(param, -1, XS_CODE_SET_PROPERTY, coder->parser->lengthSymbol);
            fxCoderAddByte(param, -1, XS_CODE_POP);
          }
        }
        item = item->next;
      }
      fxCoderUnuseTemporaryVariables(param, 1);
    }
    else {
      txInteger index = 0;
      txInteger count = self->items->length;
      fxCoderAddIndex(param, 1, XS_CODE_GET_LOCAL_1, array);
      fxCoderAddInteger(param, 1, XS_CODE_INTEGER_1, count);
      fxCoderAddSymbol(param, -1, XS_CODE_SET_PROPERTY, coder->parser->lengthSymbol);
      fxCoderAddByte(param, -1, XS_CODE_POP);
      while (item) {
        if (item->description->token == XS_TOKEN_ELISION)
          break;
        item = item->next;
      }
//      if (!item) {
//        fxCoderAddIndex(param, 1, XS_CODE_GET_LOCAL_1, array);
//        fxCoderAddByte(param, 1, XS_CODE_DUB);
//        fxCoderAddSymbol(param, 0, XS_CODE_GET_PROPERTY, coder->parser->fillSymbol);
//        fxCoderAddByte(param, 1, XS_CODE_CALL);
//        fxCoderAddInteger(param, -2, XS_CODE_RUN_1, 0);
//        fxCoderAddByte(param, -1, XS_CODE_POP);
//      }
      item = self->items->first;
      while (item) {
        if (item->description->token != XS_TOKEN_ELISION) {
          fxCoderAddIndex(param, 1, XS_CODE_GET_LOCAL_1, array);
          fxCoderAddInteger(param, 1, XS_CODE_INTEGER_1, index);
          fxCoderAddByte(param, 0, XS_CODE_AT);
          fxNodeDispatchCode(item, param);
          fxCoderAddByte(param, -3, XS_CODE_NEW_PROPERTY_AT);
          fxCoderAddInteger(param, 0, XS_CODE_INTEGER_1, 0);
        }
        item = item->next;
        index++;
      }
    }
  }
  fxCoderUnuseTemporaryVariables(param, 1);
}

void fxArrayBindingNodeCode(void* it, void* param)
{
  txArrayBindingNode* self = it;
  txCoder* coder = param;
  fxCoderAddByte(coder, 1, XS_CODE_UNDEFINED);
  fxArrayBindingNodeCodeAssign(self, param, 0);
}

void fxArrayBindingNodeCodeAssign(void* it, void* param, txFlag flag) 
{
  txArrayBindingNode* self = it;
  txCoder* coder = param;
  txNode* item = self->items->first;
  txInteger iterator;
  txInteger next;
  txInteger done;
  txInteger rest;
  txInteger result;
  txInteger selector;
  txInteger selection;
  txTargetCode* catchTarget;
  txTargetCode* normalTarget;
  txTargetCode* finallyTarget;
  
  txTargetCode* returnTarget;
  txTargetCode* stepTarget;
  txTargetCode* doneTarget;
  txTargetCode* nextTarget;
  
  iterator = fxCoderUseTemporaryVariable(param);
  next = fxCoderUseTemporaryVariable(param);
  done = fxCoderUseTemporaryVariable(param);
  selector = fxCoderUseTemporaryVariable(param);
  rest = fxCoderUseTemporaryVariable(param);
  result = fxCoderUseTemporaryVariable(param);
  
  coder->returnTarget = fxCoderAliasTargets(param, coder->returnTarget);
  catchTarget = fxCoderCreateTarget(param);
  normalTarget = fxCoderCreateTarget(param);
  finallyTarget = fxCoderCreateTarget(param);
  
  fxCoderAddByte(param, 1, XS_CODE_DUB);
  fxCoderAddByte(param, 0, XS_CODE_FOR_OF);
  fxCoderAddIndex(param, -1, XS_CODE_PULL_LOCAL_1, iterator);
  fxCoderAddByte(param, 1, XS_CODE_FALSE);
  fxCoderAddIndex(param, -1, XS_CODE_PULL_LOCAL_1, done);
  fxCoderAddInteger(param, 1, XS_CODE_INTEGER_1, 0);
  fxCoderAddIndex(param, -1, XS_CODE_PULL_LOCAL_1, selector);
  fxCoderAddBranch(param, 0, XS_CODE_CATCH_1, catchTarget);
  
  if (item) {
    fxCoderAddIndex(param, 1, XS_CODE_GET_LOCAL_1, iterator);
    fxCoderAddSymbol(param, 0, XS_CODE_GET_PROPERTY, coder->parser->nextSymbol);
    fxCoderAddIndex(param, 0, XS_CODE_PULL_LOCAL_1, next);
  
    while (item && (item->description->token != XS_TOKEN_REST_BINDING)) {
      stepTarget = fxCoderCreateTarget(param);
      
      if (item->description->token == XS_TOKEN_SKIP_BINDING) {
        fxCoderAddIndex(param, 1, XS_CODE_GET_LOCAL_1, done);
        fxCoderAddBranch(param, -1, XS_CODE_BRANCH_IF_1, stepTarget);
        fxCoderAddByte(param, 1, XS_CODE_TRUE);
        fxCoderAddIndex(param, -1, XS_CODE_PULL_LOCAL_1, done);
        fxCoderAddIndex(param, 1, XS_CODE_GET_LOCAL_1, iterator);
        fxCoderAddIndex(param, 1, XS_CODE_GET_LOCAL_1, next);
        fxCoderAddByte(param, 1, XS_CODE_CALL);
        fxCoderAddInteger(param, -2, XS_CODE_RUN_1, 0);
        fxCoderAddByte(param, 0, XS_CODE_CHECK_INSTANCE);
        fxCoderAddSymbol(param, 0, XS_CODE_GET_PROPERTY, coder->parser->doneSymbol);
        fxCoderAddIndex(param, 0, XS_CODE_PULL_LOCAL_1, done);
        fxCoderAdd(param, 1, stepTarget);
      }
      else {
        doneTarget = fxCoderCreateTarget(param);
        nextTarget = fxCoderCreateTarget(param);
        fxNodeDispatchCodeReference(item, param, 1);
        
        fxCoderAddIndex(param, 1, XS_CODE_GET_LOCAL_1, done);
        fxCoderAddBranch(param, -1, XS_CODE_BRANCH_IF_1, stepTarget);
        fxCoderAddByte(param, 1, XS_CODE_TRUE);
        fxCoderAddIndex(param, -1, XS_CODE_PULL_LOCAL_1, done);
        fxCoderAddIndex(param, 1, XS_CODE_GET_LOCAL_1, iterator);
        fxCoderAddIndex(param, 1, XS_CODE_GET_LOCAL_1, next);
        fxCoderAddByte(param, 1, XS_CODE_CALL);
        fxCoderAddInteger(param, -2, XS_CODE_RUN_1, 0);
        fxCoderAddByte(param, 0, XS_CODE_CHECK_INSTANCE);
        fxCoderAddByte(param, 1, XS_CODE_DUB);
        fxCoderAddSymbol(param, 0, XS_CODE_GET_PROPERTY, coder->parser->doneSymbol);
        fxCoderAddIndex(param, 0, XS_CODE_SET_LOCAL_1, done);
        fxCoderAddBranch(param, -1, XS_CODE_BRANCH_IF_1, doneTarget);
        fxCoderAddSymbol(param, 0, XS_CODE_GET_PROPERTY, coder->parser->valueSymbol);
        fxCoderAddBranch(param, 0, XS_CODE_BRANCH_1, nextTarget);
        fxCoderAdd(param, 1, doneTarget);
        fxCoderAddByte(param, -1, XS_CODE_POP);
        fxCoderAdd(param, 1, stepTarget);
        fxCoderAddByte(param, 1, XS_CODE_UNDEFINED);
        fxCoderAdd(param, 1, nextTarget);
        fxNodeDispatchCodeAssign(item, param, 1);
        fxCoderAddByte(param, -1, XS_CODE_POP);
      }
      item = item->next;
    }
    if (item) {
      nextTarget = fxCoderCreateTarget(param);
      doneTarget = fxCoderCreateTarget(param);
    
      fxNodeDispatchCodeReference(((txRestBindingNode*)item)->binding, param, 1);
      fxCoderAddByte(param, 1, XS_CODE_ARRAY);
      fxCoderAddIndex(param, -1, XS_CODE_PULL_LOCAL_1, rest);
      
      fxCoderAddIndex(param, 1, XS_CODE_GET_LOCAL_1, done);
      fxCoderAddBranch(param, -1, XS_CODE_BRANCH_IF_1, doneTarget);

      fxCoderAdd(param, 0, nextTarget);
      fxCoderAddByte(param, 1, XS_CODE_TRUE);
      fxCoderAddIndex(param, -1, XS_CODE_PULL_LOCAL_1, done);
      fxCoderAddIndex(param, 1, XS_CODE_GET_LOCAL_1, iterator);
      fxCoderAddIndex(param, 1, XS_CODE_GET_LOCAL_1, next);
      fxCoderAddByte(param, 1, XS_CODE_CALL);
      fxCoderAddInteger(param, -2, XS_CODE_RUN_1, 0);
      fxCoderAddByte(param, 0, XS_CODE_CHECK_INSTANCE);
      fxCoderAddIndex(param, 1, XS_CODE_SET_LOCAL_1, result);
      fxCoderAddSymbol(param, 0, XS_CODE_GET_PROPERTY, coder->parser->doneSymbol);
      fxCoderAddIndex(param, 0, XS_CODE_SET_LOCAL_1, done);
      
      fxCoderAddBranch(param, -1, XS_CODE_BRANCH_IF_1, doneTarget);
    
      fxCoderAddIndex(param, 1, XS_CODE_GET_LOCAL_1, rest);
      fxCoderAddByte(param, 1, XS_CODE_DUB);
      fxCoderAddSymbol(param, 0, XS_CODE_GET_PROPERTY, coder->parser->lengthSymbol);
      fxCoderAddByte(param, 0, XS_CODE_AT);
      fxCoderAddIndex(param, 1, XS_CODE_GET_LOCAL_1, result);
      fxCoderAddSymbol(param, 0, XS_CODE_GET_PROPERTY, coder->parser->valueSymbol);
      fxCoderAddByte(param, -2, XS_CODE_SET_PROPERTY_AT);
      fxCoderAddByte(param, -1, XS_CODE_POP);
  
      fxCoderAddBranch(param, 0, XS_CODE_BRANCH_1, nextTarget);
      fxCoderAdd(param, 1, doneTarget);
    
      fxCoderAddIndex(param, 0, XS_CODE_GET_LOCAL_1, rest);
      fxNodeDispatchCodeAssign(((txRestBindingNode*)item)->binding, param, 1);
      fxCoderAddByte(param, -1, XS_CODE_POP);
    }
  
  }
  fxCoderAddBranch(param, 0, XS_CODE_BRANCH_1, normalTarget);
  
  selection = 1;
  coder->returnTarget = fxCoderFinalizeTargets(param, coder->returnTarget, selector, &selection, finallyTarget);
  fxCoderAdd(param, 0, normalTarget);
  fxCoderAddInteger(param, 1, XS_CODE_INTEGER_1, selection);
  fxCoderAddIndex(param, 0, XS_CODE_SET_LOCAL_1, selector);
  fxCoderAddByte(param, -1, XS_CODE_POP);
  fxCoderAdd(param, 0, finallyTarget);
  fxCoderAddByte(param, 0, XS_CODE_UNCATCH);
  fxCoderAdd(param, 0, catchTarget);
  
  nextTarget = fxCoderCreateTarget(param);
  fxCoderAddIndex(param, 1, XS_CODE_GET_LOCAL_1, selector);
  fxCoderAddBranch(param, -1, XS_CODE_BRANCH_IF_1, nextTarget);
  fxCoderAddByte(param, 1, XS_CODE_EXCEPTION);
  fxCoderAddIndex(param, 0, XS_CODE_SET_LOCAL_1, result);
  fxCoderAddByte(param, -1, XS_CODE_POP);
  catchTarget = fxCoderCreateTarget(param);
  fxCoderAddBranch(param, 0, XS_CODE_CATCH_1, catchTarget);
  fxCoderAdd(param, 0, nextTarget);
  
  doneTarget = fxCoderCreateTarget(param);
  returnTarget = fxCoderCreateTarget(param);
  fxCoderAddIndex(param, 1, XS_CODE_GET_LOCAL_1, done);
  fxCoderAddBranch(param, -1, XS_CODE_BRANCH_IF_1, doneTarget);
  fxCoderAddIndex(param, 1, XS_CODE_GET_LOCAL_1, iterator);
  fxCoderAddSymbol(param, 0, XS_CODE_GET_PROPERTY, coder->parser->returnSymbol);
  fxCoderAddBranch(param, 0, XS_CODE_BRANCH_CHAIN_1, returnTarget);
  fxCoderAddIndex(param, 1, XS_CODE_GET_LOCAL_1, iterator);
  fxCoderAddByte(param, 0, XS_CODE_SWAP);
  fxCoderAddByte(param, 1, XS_CODE_CALL);
  fxCoderAddInteger(param, -2, XS_CODE_RUN_1, 0);
  fxCoderAddByte(param, 0, XS_CODE_CHECK_INSTANCE);
  fxCoderAdd(param, 0, returnTarget);
  fxCoderAddByte(param, -1, XS_CODE_POP);
  fxCoderAdd(param, 0, doneTarget);
  
  nextTarget = fxCoderCreateTarget(param);
  fxCoderAddIndex(param, 1, XS_CODE_GET_LOCAL_1, selector);
  fxCoderAddBranch(param, -1, XS_CODE_BRANCH_IF_1, nextTarget);
  fxCoderAddByte(param, 0, XS_CODE_UNCATCH);
  fxCoderAdd(param, 0, catchTarget);
  fxCoderAddIndex(param, 1, XS_CODE_GET_LOCAL_1, result);
  fxCoderAddByte(param, -1, XS_CODE_THROW);
  fxCoderAdd(param, 0, nextTarget);

  selection = 1;
  fxCoderJumpTargets(param, coder->returnTarget, selector, &selection);

  fxCoderUnuseTemporaryVariables(param, 6);
}

void fxAssignNodeCode(void* it, void* param) 
{
  txAssignNode* self = it;
  fxNodeDispatchCodeReference(self->reference, param, 1);
  fxNodeDispatchCode(self->value, param);
  fxNodeDispatchCodeAssign(self->reference, param, 1);
}

void fxAwaitNodeCode(void* it, void* param)
{
  txStatementNode* self = it;
  txCoder* coder = param;
  txTargetCode* target = fxCoderCreateTarget(coder);
  fxNodeDispatchCode(self->expression, param);
  fxCoderAddByte(param, 0, XS_CODE_AWAIT);
  fxCoderAddBranch(coder, 1, XS_CODE_BRANCH_STATUS_1, target);
  fxCoderAddByte(param, -1, XS_CODE_SET_RESULT);
  fxCoderAdjustEnvironment(coder, coder->returnTarget);
  fxCoderAdjustScope(coder, coder->returnTarget);
  fxCoderAddBranch(param, 0, XS_CODE_BRANCH_1, coder->returnTarget);
  fxCoderAdd(coder, 0, target);
}

void fxBigIntNodeCode(void* it, void* param) 
{
  txBigIntNode* self = it;
  fxCoderAddBigInt(param, 1, XS_CODE_BIGINT_1, &self->value);
}

void fxBinaryExpressionNodeCode(void* it, void* param) 
{
  txBinaryExpressionNode* self = it;
  fxNodeDispatchCode(self->left, param);
  fxNodeDispatchCode(self->right, param);
  fxCoderAddByte(param, -1, self->description->code);
}

void fxBindingNodeCode(void* it, void* param) 
{
  txBindingNode* self = it;
  txCoder* coder = param;
  
  if (self->target->description->token == XS_TOKEN_ACCESS) {
    fxReportParserError(coder->parser, self->line, "invalid initializer");
    fxNodeDispatchCode(self->initializer, param);
    return;
  }
  
  fxNodeDispatchCodeReference(self->target, param, 0);
  fxNodeDispatchCode(self->initializer, param);
  fxNodeDispatchCodeAssign(self->target, param, 0);
  fxCoderAddByte(coder, -1, XS_CODE_POP);
}

void fxBindingNodeCodeAssign(void* it, void* param, txFlag flag) 
{
  txBindingNode* self = it;
  txTargetCode* target = fxCoderCreateTarget(param);
  fxCoderAddByte(param, 1, XS_CODE_DUB);
  fxCoderAddByte(param, 1, XS_CODE_UNDEFINED);
  fxCoderAddByte(param, -1, XS_CODE_STRICT_NOT_EQUAL);
  fxCoderAddBranch(param, -1, XS_CODE_BRANCH_IF_1, target);
  fxCoderAddByte(param, -1, XS_CODE_POP);
  fxNodeDispatchCode(self->initializer, param);
  fxCoderAdd(param, 0, target);
  fxNodeDispatchCodeAssign(self->target, param, flag);
}

void fxBindingNodeCodeReference(void* it, void* param, txFlag flag) 
{
  txBindingNode* self = it;
  fxNodeDispatchCodeReference(self->target, param, flag);
}

void fxBlockNodeCode(void* it, void* param) 
{
  txBlockNode* self = it;
  fxScopeCodingBlock(self->scope, param);
  fxScopeCodeDefineNodes(self->scope, param);
  fxScopeCodeUsingStatement(self->scope, param, self->statement);
  fxScopeCoded(self->scope, param);
}

void fxBodyNodeCode(void* it, void* param) 
{
  txBlockNode* self = it;
  txCoder* coder = param;
  txBoolean evalFlag = coder->evalFlag;
  if ((self->flags & mxEvalFlag) && !(self->flags & mxStrictFlag))
    coder->evalFlag = 1;
  fxScopeCodingBody(self->scope, param);
  fxScopeCodeDefineNodes(self->scope, param);
  fxScopeCodeUsingStatement(self->scope, param, self->statement);
  fxScopeCodedBody(self->scope, param);
  if ((self->flags & mxEvalFlag) && !(self->flags & mxStrictFlag))
    coder->evalFlag = evalFlag;
}

void fxBreakContinueNodeCode(void* it, void* param) 
{
  txBreakContinueNode* self = it;
  txCoder* coder = param;
  txTargetCode* target = (self->description->token == XS_TOKEN_BREAK) ? coder->firstBreakTarget : coder->firstContinueTarget;
  while (target) {
    txLabelNode* label = target->label;
    while (label) {
      if (label->symbol == self->symbol) {
        fxCoderAdjustEnvironment(coder, target);
        fxCoderAdjustScope(coder, target);
        fxCoderAddBranch(param, 0, XS_CODE_BRANCH_1, target);
        return;
      }
      label = label->nextLabel;
    }
    target = target->nextTarget;
  }
  if (self->description->token == XS_TOKEN_BREAK)
    fxReportParserError(coder->parser, self->line, "invalid break");
  else
    fxReportParserError(coder->parser, self->line, "invalid continue");
}

void fxCallNodeCode(void* it, void* param) 
{
  txCallNewNode* self = it;
  fxNodeDispatchCodeThis(self->reference, param, 0);
  fxCoderAddByte(param, 1, XS_CODE_CALL);
  self->params->flags |= self->flags & mxTailRecursionFlag;
  fxNodeDispatchCode(self->params, param);
}

void fxCatchNodeCode(void* it, void* param) 
{
  txCatchNode* self = it;
  if (self->parameter) {
    fxScopeCodingBlock(self->scope, param);
    fxNodeDispatchCodeReference(self->parameter, param, 0);
    fxCoderAddByte(param, 1, XS_CODE_EXCEPTION);
    fxNodeDispatchCodeAssign(self->parameter, param, 0);
    fxCoderAddByte(param, -1, XS_CODE_POP);
    fxScopeCodingBlock(self->statementScope, param);
    fxScopeCodeDefineNodes(self->statementScope, param);
    fxScopeCodeUsingStatement(self->statementScope, param, self->statement);
    fxScopeCoded(self->statementScope, param);
    fxScopeCoded(self->scope, param);
  }
  else {
    fxScopeCodingBlock(self->statementScope, param);
    fxScopeCodeDefineNodes(self->statementScope, param);
    fxScopeCodeUsingStatement(self->statementScope, param, self->statement);
    fxScopeCoded(self->statementScope, param);
  }
}

void fxChainNodeCode(void* it, void* param)
{
  txUnaryExpressionNode* self = it;
  txCoder* coder = param;
  txTargetCode* chainTarget = coder->chainTarget;
  coder->chainTarget = fxCoderCreateTarget(param);
  fxNodeDispatchCode(self->right, param);
  fxCoderAdd(param, 0, coder->chainTarget);
  coder->chainTarget = chainTarget;
}

txFlag fxChainNodeCodeThis(void* it, void* param, txFlag flag)
{
  txUnaryExpressionNode* self = it;
  txCoder* coder = param;
  txTargetCode* chainTarget = coder->chainTarget;
  coder->chainTarget = fxCoderCreateTarget(param);
  flag = fxNodeDispatchCodeThis(self->right, param, flag);
    fxCoderAdd(param, 0, coder->chainTarget);
  coder->chainTarget = chainTarget;
  return flag;
}

void fxClassNodeCode(void* it, void* param) 
{
  txClassNode* self = it;
  txCoder* coder = param;
  txClassNode* former = coder->classNode;
  txFlag flag;
  txInteger prototype = fxCoderUseTemporaryVariable(coder);
  txInteger constructor = fxCoderUseTemporaryVariable(coder);
  txDeclareNode* declaration = self->scope->firstDeclareNode;
  txNode* item = self->items->first;
  if (self->symbol)
    fxScopeCodingBlock(self->symbolScope, param);
  if (self->heritage) {
    if (self->heritage->description->token == XS_TOKEN_HOST) {
      fxCoderAddByte(param, 1, XS_CODE_NULL);
      fxNodeDispatchCode(self->heritage, param);
    }
    else {
      fxNodeDispatchCode(self->heritage, param);
      fxCoderAddByte(param, 1, XS_CODE_EXTEND);
    }
  }
  else {
    fxCoderAddByte(param, 1, XS_CODE_NULL);
    fxCoderAddByte(param, 1, XS_CODE_OBJECT);
  }
  fxCoderAddIndex(param, 0, XS_CODE_SET_LOCAL_1, prototype);
  fxScopeCodingBlock(self->scope, param);
  
  coder->classNode = self;
  fxNodeDispatchCode(self->constructor, param);
  
  fxCoderAddByte(param, 0, XS_CODE_TO_INSTANCE);
  fxCoderAddIndex(param, 0, XS_CODE_SET_LOCAL_1, constructor);
  fxCoderAddByte(param, -3, XS_CODE_CLASS);
  fxCoderAddIndex(param, 1, XS_CODE_GET_LOCAL_1, constructor);
  if (self->symbol)
    fxCoderAddSymbol(param, 0, XS_CODE_NAME, self->symbol);
    
  while (item) {
    if (item->description->token == XS_TOKEN_PROPERTY) {
      txPropertyNode* property = (txPropertyNode*)item;
      if (item->flags & (mxMethodFlag | mxGetterFlag | mxSetterFlag)) {
        if (item->flags & mxStaticFlag)
          fxCoderAddByte(param, 1, XS_CODE_DUB);
        else
          fxCoderAddIndex(param, 1, XS_CODE_GET_LOCAL_1, prototype);
        fxNodeDispatchCode(property->value, param);
        fxCoderAddSymbol(param, -2, XS_CODE_NEW_PROPERTY, property->symbol);
        flag = XS_DONT_ENUM_FLAG;
        if (item->flags & mxMethodFlag)
          flag |= XS_NAME_FLAG | XS_METHOD_FLAG;
        else if (item->flags & mxGetterFlag)
          flag |= XS_NAME_FLAG | XS_METHOD_FLAG | XS_GETTER_FLAG;
        else if (item->flags & mxSetterFlag)
          flag |= XS_NAME_FLAG | XS_METHOD_FLAG | XS_SETTER_FLAG;
        fxCoderAddInteger(param, 0, XS_CODE_INTEGER_1, flag);
      }
    }
    else if (item->description->token == XS_TOKEN_PROPERTY_AT) {
      txPropertyAtNode* property = (txPropertyAtNode*)item;
      if (item->flags & (mxMethodFlag | mxGetterFlag | mxSetterFlag)) {
        if (item->flags & mxStaticFlag)
          fxCoderAddByte(param, 1, XS_CODE_DUB);
        else
          fxCoderAddIndex(param, 1, XS_CODE_GET_LOCAL_1, prototype);
        fxNodeDispatchCode(property->at, param);
        fxCoderAddByte(param, 0, XS_CODE_AT);
        fxNodeDispatchCode(property->value, param);
        fxCoderAddByte(param, -3, XS_CODE_NEW_PROPERTY_AT);
        flag = XS_DONT_ENUM_FLAG;
        if (item->flags & mxMethodFlag)
          flag |= XS_NAME_FLAG | XS_METHOD_FLAG;
        else if (item->flags & mxGetterFlag)
          flag |= XS_NAME_FLAG | XS_METHOD_FLAG | XS_GETTER_FLAG;
        else if (item->flags & mxSetterFlag)
          flag |= XS_NAME_FLAG | XS_METHOD_FLAG | XS_SETTER_FLAG;
        fxCoderAddInteger(param, 0, XS_CODE_INTEGER_1, flag);
      }
      else {
        fxNodeDispatchCode(property->at, param);
        fxCoderAddByte(param, 0, XS_CODE_AT);
        fxCoderAddIndex(param, 0, XS_CODE_CONST_CLOSURE_1, declaration->index);
        fxCoderAddByte(param, -1, XS_CODE_POP);
        declaration = declaration->nextDeclareNode;
      }
    }
    else  {
      txPrivatePropertyNode* property = (txPrivatePropertyNode*)item;
      fxCoderAddIndex(param, 0, XS_CODE_CONST_CLOSURE_1, declaration->index);
      declaration = declaration->nextDeclareNode;
      if (item->flags & (mxMethodFlag | mxGetterFlag | mxSetterFlag)) {
        fxNodeDispatchCode(property->value, param);
        fxCoderAddIndex(param, 0, XS_CODE_CONST_CLOSURE_1, declaration->index);
        fxCoderAddByte(param, -1, XS_CODE_POP);
        declaration = declaration->nextDeclareNode;
      }
    }
    item = item->next;
  }
  if (self->symbol)
    fxCoderAddIndex(param, 0, XS_CODE_CONST_CLOSURE_1, self->symbolScope->firstDeclareNode->index);
  if (self->instanceInit) {
    fxNodeDispatchCode(self->instanceInit, param);
    fxCoderAddIndex(param, 1, XS_CODE_GET_LOCAL_1, prototype);
    fxCoderAddByte(param, -1, XS_CODE_SET_HOME);
    fxCoderAddIndex(param, 0, XS_CODE_CONST_CLOSURE_1, declaration->index);
    fxCoderAddByte(param, -1, XS_CODE_POP);
  }
  if (self->constructorInit) {
    fxCoderAddIndex(param, 1, XS_CODE_GET_LOCAL_1, constructor);
    fxNodeDispatchCode(self->constructorInit, param);
    fxCoderAddIndex(param, 1, XS_CODE_GET_LOCAL_1, constructor);
    fxCoderAddByte(param, -1, XS_CODE_SET_HOME);
    fxCoderAddByte(param, 1, XS_CODE_CALL);
    fxCoderAddInteger(param, -2, XS_CODE_RUN_1, 0);
    fxCoderAddByte(param, -1, XS_CODE_POP);
  }
  coder->classNode = former;
  fxScopeCoded(self->scope, param);
  if (self->symbol)
    fxScopeCoded(self->symbolScope, param);
  fxCoderUnuseTemporaryVariables(coder, 2);
}

void fxCoalesceExpressionNodeCode(void* it, void* param) 
{
  txBinaryExpressionNode* self = it;
  txTargetCode* endTarget = fxCoderCreateTarget(param);
  self->right->flags |= (self->flags & mxTailRecursionFlag);
  fxNodeDispatchCode(self->left, param);
  fxCoderAddBranch(param, -1, XS_CODE_BRANCH_COALESCE_1, endTarget);
  fxNodeDispatchCode(self->right, param);
  fxCoderAdd(param, 0, endTarget);
}

void fxCompoundExpressionNodeCode(void* it, void* param) 
{
  txAssignNode* self = it;
  txCoder* coder = param;
  txToken token = self->description->token;
  txFlag shortcut = ((token == XS_TOKEN_AND_ASSIGN) || (token == XS_TOKEN_COALESCE_ASSIGN) || (token == XS_TOKEN_OR_ASSIGN)) ? 1 : 0;
  txTargetCode* elseTarget = (shortcut) ? fxCoderCreateTarget(param) : C_NULL;
  txTargetCode* endTarget = (shortcut) ? fxCoderCreateTarget(param) : C_NULL;
  txInteger stackLevel;
  txFlag swap = fxNodeDispatchCodeThis(self->reference, param, 1);
  switch (self->description->token) {
  case XS_TOKEN_AND_ASSIGN:
    fxCoderAddByte(param, 1, XS_CODE_DUB);
    fxCoderAddBranch(param, -1, XS_CODE_BRANCH_ELSE_1, elseTarget);
    fxCoderAddByte(param, -1, XS_CODE_POP);
    fxNodeDispatchCode(self->value, param);
    fxCompoundExpressionNodeCodeName(it, param);
    stackLevel = coder->stackLevel;
    break;
  case XS_TOKEN_COALESCE_ASSIGN:
    fxCoderAddBranch(param, -1, XS_CODE_BRANCH_COALESCE_1, elseTarget);
    fxNodeDispatchCode(self->value, param);
    fxCompoundExpressionNodeCodeName(it, param);
    stackLevel = coder->stackLevel;
    break;
  case XS_TOKEN_OR_ASSIGN:
    fxCoderAddByte(param, 1, XS_CODE_DUB);
    fxCoderAddBranch(param, -1, XS_CODE_BRANCH_IF_1, elseTarget);
    fxCoderAddByte(param, -1, XS_CODE_POP);
    fxNodeDispatchCode(self->value, param);
    fxCompoundExpressionNodeCodeName(it, param);
    stackLevel = coder->stackLevel;
    break;
  default:
    fxNodeDispatchCode(self->value, param);
    fxCoderAddByte(param, -1, self->description->code);
    break;
  }
  fxNodeDispatchCodeAssign(self->reference, param, 0);
  if (shortcut) {
    fxCoderAddBranch(param, 0, XS_CODE_BRANCH_1, endTarget);
    coder->stackLevel = stackLevel;
    fxCoderAdd(param, 0, elseTarget);
    while (swap > 0) {
      if (!(self->flags & mxExpressionNoValue))
        fxCoderAddByte(param, 0, XS_CODE_SWAP);
      fxCoderAddByte(param, -1, XS_CODE_POP);
      swap--;
    }
    fxCoderAdd(param, 0, endTarget);
  }
}

void fxCompoundExpressionNodeCodeName(void* it, void* param) 
{
  txAssignNode* self = it;
  txAccessNode* reference = (txAccessNode*)(self->reference);
  txToken token = reference->description->token;
  txNode* value = self->value;
  if (token != XS_TOKEN_ACCESS)
    return;
  if (fxNodeCodeName(value))
    fxCoderAddSymbol(param, 0, XS_CODE_NAME, reference->symbol);
}

void fxDebuggerNodeCode(void* it, void* param) 
{
  fxCoderAddByte(param, 0, XS_CODE_DEBUGGER);
}

void fxDeclareNodeCode(void* it, void* param) 
{
  txDeclareNode* self = it;
  txCoder* coder = param;
  if (self->description->token == XS_TOKEN_CONST)
    fxReportParserError(coder->parser, self->line, "invalid const");
  else if (self->description->token == XS_TOKEN_LET) {
    fxNodeDispatchCodeReference(self, param, 0);
    fxCoderAddByte(coder, 1, XS_CODE_UNDEFINED);
    fxNodeDispatchCodeAssign(self, param, 0);
    fxCoderAddByte(coder, -1, XS_CODE_POP);
  }
  else if (self->description->token == XS_TOKEN_USING)
    fxReportParserError(coder->parser, self->line, "invalid using");
}

void fxDeclareNodeCodeAssign(void* it, void* param, txFlag flag) 
{
  txDeclareNode* self = it;
  txDeclareNode* declaration = self->declaration;
  if (!declaration)
    fxCoderAddSymbol(param, -1, XS_CODE_SET_VARIABLE, self->symbol);
  else {
    if (self->description->token == XS_TOKEN_CONST)
      fxCoderAddIndex(param, 0, (declaration->flags & mxDeclareNodeClosureFlag) ? XS_CODE_CONST_CLOSURE_1: XS_CODE_CONST_LOCAL_1, declaration->index);
    else if (self->description->token == XS_TOKEN_LET)
      fxCoderAddIndex(param, 0, (declaration->flags & mxDeclareNodeClosureFlag) ? XS_CODE_LET_CLOSURE_1: XS_CODE_LET_LOCAL_1, declaration->index);
    else if (self->description->token == XS_TOKEN_USING) {
      fxCoderAddIndex(param, 0, (declaration->flags & mxDeclareNodeClosureFlag) ? XS_CODE_CONST_CLOSURE_1: XS_CODE_CONST_LOCAL_1, declaration->index);
      if (self->flags & mxAwaitingFlag)
        fxCoderAddByte(param, 0, XS_CODE_USING_ASYNC);
      else
        fxCoderAddByte(param, 0, XS_CODE_USING);
      fxCoderAddIndex(param, 0, XS_CODE_SET_LOCAL_1, declaration->index + 1);
    }
    else
      fxCoderAddIndex(param, 0, (declaration->flags & mxDeclareNodeClosureFlag) ? XS_CODE_VAR_CLOSURE_1 : XS_CODE_VAR_LOCAL_1, declaration->index);
  }
}

void fxDeclareNodeCodeReference(void* it, void* param, txFlag flag) 
{
  txAccessNode* self = it;
  txCoder* coder = param;
  txDeclareNode* declaration = self->declaration;
  if (!declaration) {
    if (coder->evalFlag)
      fxCoderAddSymbol(param, 1, XS_CODE_EVAL_REFERENCE, self->symbol);
    else
      fxCoderAddSymbol(param, 1, XS_CODE_PROGRAM_REFERENCE, self->symbol);
  }
}

void fxDefineNodeCode(void* it, void* param) 
{
  txDefineNode* self = it;
  txCoder* coder = param;
  if (self->flags & mxDefineNodeCodedFlag)
    return;
  self->flags |= mxDefineNodeCodedFlag;
  fxDeclareNodeCodeReference(it, param, 0);
  fxNodeDispatchCode(self->initializer, coder);
    self->initializer = C_NULL;
  fxDeclareNodeCodeAssign(it, param, 0);
  fxCoderAddByte(coder, -1, XS_CODE_POP);
}

void fxDelegateNodeCode(void* it, void* param)
{
  txStatementNode* self = it;
  txBoolean async = (self->flags & mxAsyncFlag) ? 1 : 0;
  txCoder* coder = param;
  txInteger iterator;
  txInteger method;
  txInteger next;
  txInteger result;

  txTargetCode* nextTarget = fxCoderCreateTarget(param);
  txTargetCode* catchTarget = fxCoderCreateTarget(param);
  txTargetCode* rethrowTarget = fxCoderCreateTarget(param);
  txTargetCode* returnTarget = fxCoderCreateTarget(param);
  txTargetCode* normalTarget = fxCoderCreateTarget(param);
  txTargetCode* doneTarget = fxCoderCreateTarget(param);
  
  iterator = fxCoderUseTemporaryVariable(param);
  method = fxCoderUseTemporaryVariable(param);
  next = fxCoderUseTemporaryVariable(param);
  result = fxCoderUseTemporaryVariable(param);
  
  fxNodeDispatchCode(self->expression, param);
  if (async)
    fxCoderAddByte(param, 0, XS_CODE_FOR_AWAIT_OF);
  else
    fxCoderAddByte(param, 0, XS_CODE_FOR_OF);
  fxCoderAddIndex(param, 0, XS_CODE_SET_LOCAL_1, iterator);
  fxCoderAddSymbol(param, 0, XS_CODE_GET_PROPERTY, coder->parser->nextSymbol);
  fxCoderAddIndex(param, 0, XS_CODE_SET_LOCAL_1, next);
  fxCoderAddByte(param, -1, XS_CODE_POP);
  
  fxCoderAddByte(param, 1, XS_CODE_UNDEFINED);
  fxCoderAddIndex(param, 0, XS_CODE_SET_LOCAL_1, result);
  fxCoderAddByte(param, -1, XS_CODE_POP);
  fxCoderAddBranch(param, 0, XS_CODE_CATCH_1, catchTarget);
  fxCoderAddBranch(coder, 0, XS_CODE_BRANCH_1, normalTarget);
  
// LOOP 
  fxCoderAdd(param, 0, nextTarget);
  if (async)
    fxCoderAddSymbol(param, 0, XS_CODE_GET_PROPERTY, coder->parser->valueSymbol);
  fxCoderAddByte(coder, 0, XS_CODE_YIELD_STAR);
  fxCoderAddIndex(param, 0, XS_CODE_SET_LOCAL_1, result);
  fxCoderAddByte(param, -1, XS_CODE_POP);
  fxCoderAddBranch(param, 0, XS_CODE_CATCH_1, catchTarget);
  fxCoderAddBranch(coder, 1, XS_CODE_BRANCH_STATUS_1, normalTarget);
  
// RETURN 
  fxCoderAddByte(param, 0, XS_CODE_UNCATCH);
  if (async) {
    fxCoderAddIndex(param, 1, XS_CODE_GET_LOCAL_1, result);
    fxCoderAddByte(param, 0, XS_CODE_AWAIT);
    fxCoderAddByte(param, 0, XS_CODE_THROW_STATUS);
    fxCoderAddIndex(param, 0, XS_CODE_SET_LOCAL_1, result);
    fxCoderAddByte(param, -1, XS_CODE_POP);
  }  
  
  fxCoderAddIndex(param, 1, XS_CODE_GET_LOCAL_1, iterator);
  fxCoderAddSymbol(param, 0, XS_CODE_GET_PROPERTY, coder->parser->returnSymbol);
  fxCoderAddBranch(param, 0, XS_CODE_BRANCH_CHAIN_1, returnTarget);
  fxCoderAddIndex(param, 1, XS_CODE_GET_LOCAL_1, iterator);
  fxCoderAddByte(param, 0, XS_CODE_SWAP);
  fxCoderAddByte(param, 1, XS_CODE_CALL);
  fxCoderAddIndex(param, 1, XS_CODE_GET_LOCAL_1, result);
  fxCoderAddInteger(param, -3, XS_CODE_RUN_1, 1);
  if (async) {
    fxCoderAddByte(param, 0, XS_CODE_AWAIT);
    fxCoderAddByte(param, 0, XS_CODE_THROW_STATUS);
  }
  fxCoderAddByte(param, 0, XS_CODE_CHECK_INSTANCE);
  fxCoderAddByte(param, 1, XS_CODE_DUB);
  fxCoderAddSymbol(param, 0, XS_CODE_GET_PROPERTY, coder->parser->doneSymbol);
  fxCoderAddBranch(param, -1, XS_CODE_BRANCH_ELSE_1, nextTarget);
  fxCoderAddSymbol(param, 0, XS_CODE_GET_PROPERTY, coder->parser->valueSymbol);
  fxCoderAddIndex(param, 0, XS_CODE_SET_LOCAL_1, result);
  fxCoderAdd(coder, 0, returnTarget);
  fxCoderAddByte(param, -1, XS_CODE_POP);
  fxCoderAddIndex(param, 1, XS_CODE_GET_LOCAL_1, result);
  if (async) {
    fxCoderAddByte(param, 0, XS_CODE_AWAIT);
    fxCoderAddByte(param, 0, XS_CODE_THROW_STATUS);
  }  
  fxCoderAddByte(param, -1, XS_CODE_SET_RESULT);
  fxCoderAdjustEnvironment(coder, coder->returnTarget);
  fxCoderAdjustScope(coder, coder->returnTarget);
  fxCoderAddBranch(coder, 0, XS_CODE_BRANCH_1, coder->returnTarget);
  
// THROW  
  fxCoderAdd(coder, 0, catchTarget);

  fxCoderAddIndex(param, 1, XS_CODE_GET_LOCAL_1, iterator);
  fxCoderAddSymbol(param, 0, XS_CODE_GET_PROPERTY, coder->parser->throwSymbol);
  fxCoderAddIndex(param, 0, XS_CODE_SET_LOCAL_1, method);
  fxCoderAddBranch(param, -1, XS_CODE_BRANCH_COALESCE_1, doneTarget);
  
  fxCoderAddIndex(param, 1, XS_CODE_GET_LOCAL_1, iterator);
  fxCoderAddSymbol(param, 0, XS_CODE_GET_PROPERTY, coder->parser->returnSymbol);
  fxCoderAddBranch(param, -1, XS_CODE_BRANCH_CHAIN_1, rethrowTarget);
  fxCoderAddIndex(param, 1, XS_CODE_GET_LOCAL_1, iterator);
  fxCoderAddByte(param, 0, XS_CODE_SWAP);
  fxCoderAddByte(param, 1, XS_CODE_CALL);
  fxCoderAddInteger(param, -2, XS_CODE_RUN_1, 0);
  if (async) {
    fxCoderAddByte(param, 0, XS_CODE_AWAIT);
    fxCoderAddByte(param, 0, XS_CODE_THROW_STATUS);
  }
  fxCoderAddByte(param, 0, XS_CODE_CHECK_INSTANCE);
  fxCoderAdd(coder, 0, rethrowTarget);
  fxCoderAddByte(param, -1, XS_CODE_POP);
  
  fxCoderAddByte(param, 1, XS_CODE_UNDEFINED);
  fxCoderAddByte(param, 0, XS_CODE_CHECK_INSTANCE);
  fxCoderAddByte(param, -1, XS_CODE_POP);
  
// NORMAL 
  fxCoderAdd(coder, 0, normalTarget);
  fxCoderAddByte(param, 0, XS_CODE_UNCATCH);
  fxCoderAddIndex(param, 1, XS_CODE_GET_LOCAL_1, next);
  fxCoderAddIndex(param, 0, XS_CODE_SET_LOCAL_1, method);
  fxCoderAdd(param, 1, doneTarget);
  fxCoderAddByte(param, -1, XS_CODE_POP);

  fxCoderAddIndex(param, 1, XS_CODE_GET_LOCAL_1, iterator);
  fxCoderAddIndex(param, 1, XS_CODE_GET_LOCAL_1, method);
  fxCoderAddByte(param, 1, XS_CODE_CALL);
  fxCoderAddIndex(param, 1, XS_CODE_GET_LOCAL_1, result);
  fxCoderAddInteger(param, -3, XS_CODE_RUN_1, 1);
  if (async) {
    fxCoderAddByte(param, 0, XS_CODE_AWAIT);
    fxCoderAddByte(param, 0, XS_CODE_THROW_STATUS);
  }
  fxCoderAddByte(param, 0, XS_CODE_CHECK_INSTANCE);
  fxCoderAddByte(param, 1, XS_CODE_DUB);
  fxCoderAddSymbol(param, 0, XS_CODE_GET_PROPERTY, coder->parser->doneSymbol);
  fxCoderAddBranch(param, -1, XS_CODE_BRANCH_ELSE_1, nextTarget);
  fxCoderAddSymbol(param, 0, XS_CODE_GET_PROPERTY, coder->parser->valueSymbol);

  fxCoderUnuseTemporaryVariables(param, 4);
}

void fxDeleteNodeCode(void* it, void* param) 
{
  txDeleteNode* self = it;
  fxNodeDispatchCodeDelete(self->reference, param);
}

void fxDoNodeCode(void* it, void* param) 
{
  txDoNode* self = it;
  txCoder* coder = param;
  txTargetCode* loopTarget = fxCoderCreateTarget(param);
  if (coder->programFlag) {
    fxCoderAddByte(param, 1, XS_CODE_UNDEFINED);
    fxCoderAddByte(param, -1, XS_CODE_SET_RESULT);
  }
  fxCoderAdd(param, 0, loopTarget);
  fxNodeDispatchCode(self->statement, param);
  fxCoderAdd(param, 0, coder->firstContinueTarget);
  fxNodeDispatchCode(self->expression, param);
  fxCoderAddBranch(param, -1, XS_CODE_BRANCH_IF_1, loopTarget);
}

void fxExportNodeCode(void* it, void* param) 
{
}

void fxExpressionsNodeCode(void* it, void* param) 
{
  txExpressionsNode* self = it;
  if (self->items) {
    txNode* item = self->items->first;
    txNode* previous = NULL;
    txNode* next;
    while (item) {
      next = item->next;
      if (previous)
        fxCoderAddByte(param, -1, XS_CODE_POP);
      if (!next)
        item->flags |= (self->flags & mxTailRecursionFlag);
      fxNodeDispatchCode(item, param);
      previous = item;
      item = next;
    }
  }
}

txFlag fxExpressionsNodeCodeThis(void* it, void* param, txFlag flag) 
{
  txExpressionsNode* self = it;
  if (self->items) {
    txNode* item = self->items->first;
    if (item->next == C_NULL) {
      return fxNodeDispatchCodeThis(item, param, flag);
    }
  }
  return fxNodeCodeThis(it, param, flag);
}

void fxExpressionsNodeCodeDelete(void* it, void* param) 
 {
  txExpressionsNode* self = it;
  if (self->items) {
    txNode* item = self->items->first;
    if (item->next == C_NULL) {
      fxNodeDispatchCodeDelete(item, param);
      return;
    }
  }
  fxNodeCodeDelete(it, param);
 }

void fxFieldNodeCode(void* it, void* param) 
{
  txFieldNode* self = it;
  txNode* item = self->item;
  fxCoderAddByte(param, 1, XS_CODE_THIS);
  if (item->description->token == XS_TOKEN_PROPERTY) {
    fxNodeDispatchCode(self->value, param);
    fxCoderAddSymbol(param, -2, XS_CODE_NEW_PROPERTY, ((txPropertyNode*)item)->symbol);
    fxCoderAddInteger(param, 0, XS_CODE_INTEGER_1, fxNodeCodeName(self->value) ? XS_NAME_FLAG : 0);
  }
  else if (item->description->token == XS_TOKEN_PROPERTY_AT) {
    fxCoderAddIndex(param, 1, XS_CODE_GET_CLOSURE_1, ((txPropertyAtNode*)item)->atAccess->declaration->index);
    fxNodeDispatchCode(self->value, param);
    fxCoderAddByte(param, -3, XS_CODE_NEW_PROPERTY_AT);
    fxCoderAddInteger(param, 0, XS_CODE_INTEGER_1, fxNodeCodeName(self->value) ? XS_NAME_FLAG : 0);
  }
  else {
    if (item->flags & (mxMethodFlag | mxGetterFlag | mxSetterFlag))
      fxCoderAddIndex(param, 1, XS_CODE_GET_CLOSURE_1, ((txPrivatePropertyNode*)item)->valueAccess->declaration->index);
    else
      fxNodeDispatchCode(self->value, param);
    fxCoderAddIndex(param, -2, XS_CODE_NEW_PRIVATE_1, ((txPrivatePropertyNode*)item)->symbolAccess->declaration->index);
    if (item->flags & mxMethodFlag)
      fxCoderAddInteger(param, 0, XS_CODE_INTEGER_1, XS_NAME_FLAG | XS_METHOD_FLAG);
    else if (item->flags & mxGetterFlag)
      fxCoderAddInteger(param, 0, XS_CODE_INTEGER_1, XS_NAME_FLAG | XS_METHOD_FLAG | XS_GETTER_FLAG);
    else if (item->flags & mxSetterFlag)
      fxCoderAddInteger(param, 0, XS_CODE_INTEGER_1, XS_NAME_FLAG | XS_METHOD_FLAG | XS_SETTER_FLAG);
    else
      fxCoderAddInteger(param, 0, XS_CODE_INTEGER_1, fxNodeCodeName(self->value) ? XS_NAME_FLAG : 0);
  }
}

void fxForNodeCode(void* it, void* param) 
{
  txForNode* self = it;
  txCoder* coder = param;
  txTargetCode* continueTarget;
  txTargetCode* nextTarget;
  txTargetCode* doneTarget;
  txUsingContext context;
  
  continueTarget = coder->firstContinueTarget;
  coder->firstContinueTarget = continueTarget->nextTarget;
  continueTarget->nextTarget = C_NULL;
  
  fxScopeCodingBlock(self->scope, param);
  fxScopeCodeDefineNodes(self->scope, param);
  if (self->scope->disposableNodeCount)
    fxScopeCodeUsing(self->scope, coder, &context); 
  nextTarget = fxCoderCreateTarget(param);
  doneTarget = fxCoderCreateTarget(param);
  if (self->initialization)
    fxNodeDispatchCode(self->initialization, param);
  if (coder->programFlag) {
    fxCoderAddByte(param, 1, XS_CODE_UNDEFINED);
    fxCoderAddByte(param, -1, XS_CODE_SET_RESULT);
  }
  fxScopeCodeRefresh(self->scope, param);
  fxCoderAdd(param, 0, nextTarget);
  if (self->expression) {
    fxNodeDispatchCode(self->expression, param);
    fxCoderAddBranch(param, -1, XS_CODE_BRANCH_ELSE_1, doneTarget);
  }
  
  continueTarget->environmentLevel = coder->environmentLevel;
  continueTarget->scopeLevel = coder->scopeLevel;
  continueTarget->stackLevel = coder->stackLevel;
  continueTarget->nextTarget = coder->firstContinueTarget;
  coder->firstContinueTarget = continueTarget;
  fxNodeDispatchCode(self->statement, param);
  fxCoderAdd(param, 0, continueTarget);
  coder->firstContinueTarget = continueTarget->nextTarget;
  continueTarget->nextTarget = C_NULL;
  
  if (self->iteration) {
    fxScopeCodeRefresh(self->scope, param);
    self->iteration->flags |= mxExpressionNoValue;
    fxNodeDispatchCode(self->iteration, param);
    fxCoderAddByte(param, -1, XS_CODE_POP);
  }
  fxCoderAddBranch(param, 0, XS_CODE_BRANCH_1, nextTarget);
  fxCoderAdd(param, 0, doneTarget);
  if (self->scope->disposableNodeCount)
    fxScopeCodeUsed(self->scope, coder, &context);
  fxScopeCoded(self->scope, param);
  
  continueTarget->nextTarget = coder->firstContinueTarget;
  coder->firstContinueTarget = continueTarget;
}

void fxForInForOfNodeCode(void* it, void* param) 
{
  txForInForOfNode* self = it;
  txCoder* coder = param;
  txBoolean async = (self->description->code == XS_CODE_FOR_AWAIT_OF) ? 1 : 0;
  txTargetCode* continueTarget;
  txInteger iterator;
  txInteger next;
  txInteger done;
  txInteger result;
  txInteger exception;
  txInteger selector;
  txInteger selection;
  txTargetCode* nextTarget;
  txTargetCode* returnTarget;
  txTargetCode* doneTarget;
  txTargetCode* catchTarget;
  txTargetCode* normalTarget;
  txTargetCode* uncatchTarget;
  txTargetCode* finallyTarget;
  txTargetCode* elseTarget;
  
  iterator = fxCoderUseTemporaryVariable(param);
  next = fxCoderUseTemporaryVariable(param);
  done = fxCoderUseTemporaryVariable(param);
  result = fxCoderUseTemporaryVariable(param);
  exception = fxCoderUseTemporaryVariable(coder);
  selector = fxCoderUseTemporaryVariable(coder);
  
  continueTarget = coder->firstContinueTarget;
  coder->firstContinueTarget = continueTarget->nextTarget;
  continueTarget->nextTarget = C_NULL;
  
  fxScopeCodingBlock(self->scope, param);
  fxScopeCodeDefineNodes(self->scope, param);

  if (coder->programFlag) {
    fxCoderAddByte(param, 1, XS_CODE_UNDEFINED);
    fxCoderAddByte(param, -1, XS_CODE_SET_RESULT);
  }
  fxNodeDispatchCode(self->expression, param);
  fxCoderAddByte(param, 0, self->description->code);
  fxCoderAddIndex(param, 0, XS_CODE_SET_LOCAL_1, iterator);
  fxCoderAddSymbol(param, 0, XS_CODE_GET_PROPERTY, coder->parser->nextSymbol);
  fxCoderAddIndex(param, 0, XS_CODE_PULL_LOCAL_1, next);

  coder->firstBreakTarget = fxCoderAliasTargets(param, coder->firstBreakTarget);
  coder->firstContinueTarget = fxCoderAliasTargets(param, coder->firstContinueTarget);
  coder->returnTarget = fxCoderAliasTargets(param, coder->returnTarget);
  catchTarget = fxCoderCreateTarget(param);
  normalTarget = fxCoderCreateTarget(param);
  fxCoderAddBranch(param, 0, XS_CODE_CATCH_1, catchTarget);
  
// LOOP 
  nextTarget = fxCoderCreateTarget(param);
  fxCoderAdd(param, 0, nextTarget);
  fxCoderAddByte(param, 1, XS_CODE_TRUE);
  fxCoderAddIndex(param, -1, XS_CODE_PULL_LOCAL_1, done);
  fxCoderAddIndex(param, 1, XS_CODE_GET_LOCAL_1, iterator);
  fxCoderAddIndex(param, 1, XS_CODE_GET_LOCAL_1, next);
  fxCoderAddByte(param, 1, XS_CODE_CALL);
  fxCoderAddInteger(param, -2, XS_CODE_RUN_1, 0);
  if (async) {
    fxCoderAddByte(param, 0, XS_CODE_AWAIT);
    fxCoderAddByte(param, 0, XS_CODE_THROW_STATUS);
  }
  fxCoderAddByte(param, 0, XS_CODE_CHECK_INSTANCE);
  fxCoderAddIndex(param, 0, XS_CODE_SET_LOCAL_1, result);
  fxCoderAddSymbol(param, 0, XS_CODE_GET_PROPERTY, coder->parser->doneSymbol);
  fxCoderAddIndex(param, 0, XS_CODE_SET_LOCAL_1, done);
  fxCoderAddBranch(param, -1, XS_CODE_BRANCH_IF_1, normalTarget);

  fxScopeCodeReset(self->scope, param);
  fxNodeDispatchCodeReference(self->reference, param, 0);
  fxCoderAddByte(param, 1, XS_CODE_TRUE);
  fxCoderAddIndex(param, -1, XS_CODE_PULL_LOCAL_1, done);
  fxCoderAddIndex(param, 1, XS_CODE_GET_LOCAL_1, result);
  fxCoderAddSymbol(param, 0, XS_CODE_GET_PROPERTY, coder->parser->valueSymbol);
  fxCoderAddByte(param, 1, XS_CODE_FALSE);
  fxCoderAddIndex(param, -1, XS_CODE_PULL_LOCAL_1, done);
  fxNodeDispatchCodeAssign(self->reference, param, 0);
  fxCoderAddByte(param, -1, XS_CODE_POP);

  continueTarget->environmentLevel = coder->environmentLevel;
  continueTarget->scopeLevel = coder->scopeLevel;
  continueTarget->stackLevel = coder->stackLevel;
  continueTarget->nextTarget = coder->firstContinueTarget;
  coder->firstContinueTarget = continueTarget;
  fxNodeDispatchCode(self->statement, param);
  fxCoderAdd(param, 0, coder->firstContinueTarget);
  coder->firstContinueTarget = continueTarget->nextTarget;
  continueTarget->nextTarget = C_NULL;
  
  fxScopeCodeUsedReverse(self->scope, coder, self->scope->firstDeclareNode, exception, selector);

  fxCoderAddBranch(param, 0, XS_CODE_BRANCH_1, nextTarget);

//   PRE FINALLY
  uncatchTarget = fxCoderCreateTarget(param);
  finallyTarget = fxCoderCreateTarget(param);

  fxCoderAdd(coder, 0, catchTarget);
  fxCoderAddByte(coder, 1, XS_CODE_EXCEPTION);
  fxCoderAddIndex(coder, -1, XS_CODE_PULL_LOCAL_1, exception);
  fxCoderAddInteger(coder, 1, XS_CODE_INTEGER_1, 0);
  fxCoderAddIndex(coder, -1, XS_CODE_PULL_LOCAL_1, selector);
  fxCoderAddBranch(coder, 0, XS_CODE_BRANCH_1, finallyTarget);
  selection = 1;
  coder->firstBreakTarget = fxCoderFinalizeTargets(param, coder->firstBreakTarget, selector, &selection, uncatchTarget);
  coder->firstContinueTarget = fxCoderFinalizeTargets(param, coder->firstContinueTarget, selector, &selection, uncatchTarget);
  coder->returnTarget = fxCoderFinalizeTargets(param, coder->returnTarget, selector, &selection, uncatchTarget);
  fxCoderAdd(param, 0, normalTarget);
  fxCoderAddInteger(param, 1, XS_CODE_INTEGER_1, selection);
  fxCoderAddIndex(param, -1, XS_CODE_PULL_LOCAL_1, selector);
  fxCoderAdd(coder, 0, uncatchTarget);
  fxCoderAddByte(param, 0, XS_CODE_UNCATCH);
  fxCoderAdd(param, 0, finallyTarget);
  
//   FINALLY
  catchTarget = fxCoderCreateTarget(param);
  normalTarget = fxCoderCreateTarget(param);

  fxCoderAddBranch(param, 0, XS_CODE_CATCH_1, catchTarget);

  doneTarget = fxCoderCreateTarget(param);
  returnTarget = fxCoderCreateTarget(param);
  fxCoderAddIndex(param, 1, XS_CODE_GET_LOCAL_1, done);
  fxCoderAddBranch(param, -1, XS_CODE_BRANCH_IF_1, doneTarget);
  fxCoderAddIndex(param, 1, XS_CODE_GET_LOCAL_1, iterator);
  fxCoderAddSymbol(param, 0, XS_CODE_GET_PROPERTY, coder->parser->returnSymbol);
  fxCoderAddBranch(param, 0, XS_CODE_BRANCH_CHAIN_1, returnTarget);
  fxCoderAddIndex(param, 1, XS_CODE_GET_LOCAL_1, iterator);
  fxCoderAddByte(param, 0, XS_CODE_SWAP);
  fxCoderAddByte(param, 1, XS_CODE_CALL);
  fxCoderAddInteger(param, -2, XS_CODE_RUN_1, 0);
  if (async) {
    fxCoderAddByte(param, 0, XS_CODE_AWAIT);
    fxCoderAddByte(param, 0, XS_CODE_THROW_STATUS);
  }
  fxCoderAddByte(param, 0, XS_CODE_CHECK_INSTANCE);
  fxCoderAdd(param, 0, returnTarget);
  fxCoderAddByte(param, -1, XS_CODE_POP);
  fxCoderAdd(param, 0, doneTarget);
  
  fxCoderAddByte(coder, 0, XS_CODE_UNCATCH);
  fxCoderAddBranch(coder, 0, XS_CODE_BRANCH_1, normalTarget);
  
  fxCoderAdd(coder, 0, catchTarget);
  fxCoderAddIndex(param, 1, XS_CODE_GET_LOCAL_1, selector);
  fxCoderAddBranch(param, -1, XS_CODE_BRANCH_ELSE_1, normalTarget);
  fxCoderAddByte(coder, 1, XS_CODE_EXCEPTION);
  fxCoderAddIndex(coder, -1, XS_CODE_PULL_LOCAL_1, exception);
  fxCoderAddInteger(coder, 1, XS_CODE_INTEGER_1, 0);
  fxCoderAddIndex(coder, -1, XS_CODE_PULL_LOCAL_1, selector);
  fxCoderAdd(param, 0, normalTarget);

  fxScopeCodeUsedReverse(self->scope, coder, self->scope->firstDeclareNode, exception, selector);

//   POST FINALLY
  elseTarget = fxCoderCreateTarget(param);
  fxCoderAddIndex(param, 1, XS_CODE_GET_LOCAL_1, selector);
  fxCoderAddBranch(param, -1, XS_CODE_BRANCH_IF_1, elseTarget);
  fxCoderAddIndex(param, 1, XS_CODE_GET_LOCAL_1, exception);
  fxCoderAddByte(param, -1, XS_CODE_THROW);
  fxCoderAdd(param, 0, elseTarget);
  selection = 1;
  fxCoderJumpTargets(param, coder->firstBreakTarget, selector, &selection);
  fxCoderJumpTargets(param, coder->firstContinueTarget, selector, &selection);
  fxCoderJumpTargets(param, coder->returnTarget, selector, &selection);
  
  fxScopeCoded(self->scope, param);
  continueTarget->nextTarget = coder->firstContinueTarget;
  coder->firstContinueTarget = continueTarget;
  
  fxCoderUnuseTemporaryVariables(param, 6);
}

void fxFunctionNodeCode(void* it, void* param) 
{
  txFunctionNode* self = it;
  txCoder* coder = param;
  txInteger environmentLevel = coder->environmentLevel;
  txBoolean evalFlag = coder->evalFlag;
  txInteger line = coder->line;
  txBoolean programFlag = coder->programFlag;
  txInteger scopeLevel = coder->scopeLevel;
  txTargetCode* firstBreakTarget = coder->firstBreakTarget;
  txTargetCode* firstContinueTarget = coder->firstContinueTarget;
  txTargetCode* returnTarget = coder->returnTarget;
  txSymbol* name = self->symbol;
  txTargetCode* target = fxCoderCreateTarget(param);
  
  if ((self->flags & mxEvalFlag) && !(self->flags & mxStrictFlag))
    coder->evalFlag = 1;
  coder->line = -1;
  coder->programFlag = 0;
  coder->scopeLevel = 0;
  coder->firstBreakTarget = NULL;
  coder->firstContinueTarget = NULL;

    if (name) {
        if (self->flags & mxGetterFlag) {
            txString buffer = coder->parser->buffer;
            c_strcpy(buffer, "get ");
            c_strcat(buffer, name->string);
            name = fxNewParserSymbol(coder->parser, buffer);
        }
        else if (self->flags & mxSetterFlag) {
            txString buffer = coder->parser->buffer;
            c_strcpy(buffer, "set ");
            c_strcat(buffer, name->string);
            name = fxNewParserSymbol(coder->parser, buffer);
        }
    }
    
  if (self->flags & mxAsyncFlag) {
    if (self->flags & mxGeneratorFlag)
      fxCoderAddSymbol(param, 1, XS_CODE_ASYNC_GENERATOR_FUNCTION, name);
    else
      fxCoderAddSymbol(param, 1, XS_CODE_ASYNC_FUNCTION, name);
  }
  else if (self->flags & mxGeneratorFlag)
    fxCoderAddSymbol(param, 1, XS_CODE_GENERATOR_FUNCTION, name);
  else if (self->flags & (mxArrowFlag | mxMethodFlag | mxGetterFlag | mxSetterFlag))
    fxCoderAddSymbol(param, 1, XS_CODE_FUNCTION, name);
  else
    fxCoderAddSymbol(param, 1, XS_CODE_CONSTRUCTOR_FUNCTION, name);
  if (coder->parser->flags & mxDebugFlag)
    fxCoderAddByte(param, 0, XS_CODE_PROFILE);
  fxCoderAddBranch(param, 0, XS_CODE_CODE_1, target);
  if (self->flags & mxFieldFlag)
    fxCoderAddIndex(param, 0, XS_CODE_BEGIN_STRICT_FIELD, fxCoderCountParameters(coder, self->params));
  else if (self->flags & mxDerivedFlag)
    fxCoderAddIndex(param, 0, XS_CODE_BEGIN_STRICT_DERIVED, fxCoderCountParameters(coder, self->params));
  else if (self->flags & mxBaseFlag)
    fxCoderAddIndex(param, 0, XS_CODE_BEGIN_STRICT_BASE, fxCoderCountParameters(coder, self->params));
  else if (self->flags & mxStrictFlag)
    fxCoderAddIndex(param, 0, XS_CODE_BEGIN_STRICT, fxCoderCountParameters(coder, self->params));
  else
    fxCoderAddIndex(param, 0, XS_CODE_BEGIN_SLOPPY, fxCoderCountParameters(coder, self->params));
  coder->path = C_NULL;
  if (self->line >= 0)
    fxCoderAddLine(coder, 0, XS_CODE_LINE, it); 
  if (self->scopeCount)
    fxCoderAddIndex(param, 0, XS_CODE_RESERVE_1, self->scopeCount);
  fxScopeCodeRetrieve(self->scope, param);
  fxScopeCodingParams(self->scope, param);
  if ((self->flags & mxAsyncFlag) && !(self->flags & mxGeneratorFlag))
    fxCoderAddByte(param, 0, XS_CODE_START_ASYNC);
  if (self->flags & mxBaseFlag) {
    if (coder->classNode->instanceInitAccess) {
      fxCoderAddByte(param, 1, XS_CODE_THIS);
      fxCoderAddIndex(param, 1, XS_CODE_GET_CLOSURE_1, coder->classNode->instanceInitAccess->declaration->index);
      fxCoderAddByte(param, 1, XS_CODE_CALL);
      fxCoderAddInteger(param, -2, XS_CODE_RUN_1, 0);
      fxCoderAddByte(param, -1, XS_CODE_POP);
    }
  }
  fxNodeDispatchCode(self->params, param);
  if ((coder->parser->flags & mxDebugFlag) && coder->path)
    fxCoderAddIndex(coder, 0, XS_CODE_LINE, 0);
  fxScopeCodeDefineNodes(self->scope, param);
  coder->returnTarget = fxCoderCreateTarget(param);
  if (self->flags & mxGeneratorFlag) {
    if (self->flags & mxAsyncFlag)
      fxCoderAddByte(param, 0, XS_CODE_START_ASYNC_GENERATOR);
    else
      fxCoderAddByte(param, 0, XS_CODE_START_GENERATOR);
  }
  fxNodeDispatchCode(self->body, param);
  fxCoderAdd(param, 0, coder->returnTarget);
  if (self->flags & mxArrowFlag)
    fxCoderAddByte(param, 0, XS_CODE_END_ARROW);
  else if (self->flags & mxBaseFlag)
    fxCoderAddByte(param, 0, XS_CODE_END_BASE);
  else if (self->flags & mxDerivedFlag)
    fxCoderAddByte(param, 0, XS_CODE_END_DERIVED);
  else
    fxCoderAddByte(param, 0, XS_CODE_END);
  fxCoderAdd(param, 0, target);
  
  if ((self->scope->flags & mxEvalFlag) || coder->evalFlag) {
    fxCoderAddByte(coder, 1, XS_CODE_FUNCTION_ENVIRONMENT);
    fxScopeCodeStore(self->scope, param);
    fxCoderAddByte(coder, -1, XS_CODE_POP);
  }
  else if (self->scope->closureNodeCount || ((self->flags & mxArrowFlag) && (self->flags & mxDefaultFlag))) {
    fxCoderAddByte(coder, 1, XS_CODE_ENVIRONMENT);
    fxScopeCodeStore(self->scope, param);
    fxCoderAddByte(coder, -1, XS_CODE_POP);
  }
  if ((self->flags & (mxArrowFlag | mxBaseFlag | mxDerivedFlag | mxGeneratorFlag | mxStrictFlag | mxMethodFlag)) == 0) {
    fxCoderAddByte(param, 1, XS_CODE_DUB);
    fxCoderAddByte(param, 1, XS_CODE_UNDEFINED);
    fxCoderAddSymbol(param, -2, XS_CODE_NEW_PROPERTY, coder->parser->callerSymbol);
    fxCoderAddInteger(param, 0, XS_CODE_INTEGER_1, XS_DONT_ENUM_FLAG);
  }
  
  coder->returnTarget = returnTarget;
  coder->firstContinueTarget = firstContinueTarget;
  coder->firstBreakTarget = firstBreakTarget;
  coder->scopeLevel = scopeLevel;
  coder->programFlag = programFlag;
  coder->line = line;
  coder->evalFlag = evalFlag;
  coder->environmentLevel = environmentLevel;
}

void fxHostNodeCode(void* it, void* param) 
{
  txHostNode* self = it;
  txCoder* coder = param;
  txParser* parser = coder->parser;
    if (self->symbol) {
        if (self->flags & mxGetterFlag) {
            txString buffer = coder->parser->buffer;
            c_strcpy(buffer, "get ");
            c_strcat(buffer, self->symbol->string);
            self->symbol = fxNewParserSymbol(coder->parser, buffer);
        }
        else if (self->flags & mxSetterFlag) {
            txString buffer = coder->parser->buffer;
            c_strcpy(buffer, "set ");
            c_strcat(buffer, self->symbol->string);
            self->symbol = fxNewParserSymbol(coder->parser, buffer);
        }
    }
  if (self->params)
    self->paramsCount = fxCoderCountParameters(coder, self->params);
  else
    self->paramsCount = -1; 
  if (parser->firstHostNode)
    parser->lastHostNode->nextHostNode = self;
  else
    parser->firstHostNode = self;
  parser->lastHostNode = self;
  fxCoderAddIndex(param, 1, XS_CODE_HOST, parser->hostNodeIndex);
  parser->hostNodeIndex++;
}

void fxIfNodeCode(void* it, void* param) 
{
  txIfNode* self = it;
  txCoder* coder = param;
  fxNodeDispatchCode(self->expression, param);
  if (coder->programFlag) {
    txTargetCode* elseTarget = fxCoderCreateTarget(param);
    txTargetCode* endTarget = fxCoderCreateTarget(param);
    fxCoderAddBranch(param, -1, XS_CODE_BRANCH_ELSE_1, elseTarget);
    fxCoderAddByte(param, 1, XS_CODE_UNDEFINED);
    fxCoderAddByte(param, -1, XS_CODE_SET_RESULT);
    fxNodeDispatchCode(self->thenStatement, param);
    fxCoderAddBranch(param, 0, XS_CODE_BRANCH_1, endTarget);
    fxCoderAdd(param, 0, elseTarget);
    fxCoderAddByte(param, 1, XS_CODE_UNDEFINED);
    fxCoderAddByte(param, -1, XS_CODE_SET_RESULT);
    if (self->elseStatement)
      fxNodeDispatchCode(self->elseStatement, param);
    fxCoderAdd(param, 0, endTarget);
  }
  else {
    if (self->elseStatement) {
      txTargetCode* elseTarget = fxCoderCreateTarget(param);
      txTargetCode* endTarget = fxCoderCreateTarget(param);
      fxCoderAddBranch(param, -1, XS_CODE_BRANCH_ELSE_1, elseTarget);
      fxNodeDispatchCode(self->thenStatement, param);
      fxCoderAddBranch(param, 0, XS_CODE_BRANCH_1, endTarget);
      fxCoderAdd(param, 0, elseTarget);
      fxNodeDispatchCode(self->elseStatement, param);
      fxCoderAdd(param, 0, endTarget);
    }
    else {
      txTargetCode* endTarget = fxCoderCreateTarget(param);
      fxCoderAddBranch(param, -1, XS_CODE_BRANCH_ELSE_1, endTarget);
      fxNodeDispatchCode(self->thenStatement, param);
      fxCoderAdd(param, 0, endTarget);
    }
  }
}

void fxImportNodeCode(void* it, void* param) 
{
}

void fxImportCallNodeCode(void* it, void* param)
{
  txCoder* coder = param;
  txImportCallNode* self = it;
  fxNodeDispatchCode(self->expression, param);
  if (self->withExpression)
    fxNodeDispatchCode(self->withExpression, param);
  else
    fxCoderAddByte(param, 1, XS_CODE_UNDEFINED);
  coder->importFlag = 1;
  fxCoderAddByte(param, -1, XS_CODE_IMPORT);
}

void fxImportMetaNodeCode(void* it, void* param)
{
  txCoder* coder = param;
  coder->importMetaFlag = 1;
  fxCoderAddByte(param, 1, XS_CODE_IMPORT_META);
}

void fxIncludeNodeCode(void* it, void* param) 
{
  txIncludeNode* self = it;
  fxNodeDispatchCode(self->body, param);
}

void fxIntegerNodeCode(void* it, void* param) 
{
  txIntegerNode* self = it;
  fxCoderAddInteger(param, 1, XS_CODE_INTEGER_1, self->value);
}

void fxLabelNodeCode(void* it, void* param) 
{
  txLabelNode* self = it;
  txCoder* coder = param;
  txNode* statement = self->statement;
  txTargetCode* breakTarget;
  while (statement->description->token == XS_TOKEN_LABEL) {
    txLabelNode* former = (txLabelNode*)statement;
    txLabelNode* current = self;
    while (current) {
      if (former->symbol && current->symbol && (former->symbol == current->symbol)) {
        fxReportParserError(coder->parser, current->line, "duplicate label %s", current->symbol->string);
      }
      current = current->nextLabel;
    }
    former->nextLabel = self;
    self = former;
    statement = self->statement;
  }
  breakTarget = coder->firstBreakTarget;
  while (breakTarget) {
    txLabelNode* former = breakTarget->label;
    if (former) {
      txLabelNode* current = self;
      while (current) {
        if (former->symbol && current->symbol && (former->symbol == current->symbol)) {
          fxReportParserError(coder->parser, current->line, "duplicate label %s", current->symbol->string);
        }
        current = current->nextLabel;
      }
    }
    breakTarget = breakTarget->nextTarget;
  }
  breakTarget = fxCoderCreateTarget(coder);
  breakTarget->nextTarget = coder->firstBreakTarget;
  coder->firstBreakTarget = breakTarget;
  breakTarget->label = self;
  if (self->symbol)
    fxNodeDispatchCode(statement, param);
  else {
    txTargetCode* continueTarget = fxCoderCreateTarget(coder);
    continueTarget->nextTarget = coder->firstContinueTarget;
    coder->firstContinueTarget = continueTarget;
    continueTarget->label = self;
    fxNodeDispatchCode(statement, param);
    coder->firstContinueTarget = continueTarget->nextTarget;
  }
  fxCoderAdd(param, 0, coder->firstBreakTarget);
  coder->firstBreakTarget = breakTarget->nextTarget;
}

void fxMemberNodeCode(void* it, void* param) 
{
  txMemberNode* self = it;
  fxNodeDispatchCode(self->reference, param);
  fxCoderAddSymbol(param, 0, (self->reference->flags & mxSuperFlag) ? XS_CODE_GET_SUPER : XS_CODE_GET_PROPERTY, self->symbol);
}

void fxMemberNodeCodeAssign(void* it, void* param, txFlag flag) 
{
  txMemberNode* self = it;
  fxCoderAddSymbol(param, -1, (self->reference->flags & mxSuperFlag) ? XS_CODE_SET_SUPER : XS_CODE_SET_PROPERTY, self->symbol);
}

void fxMemberNodeCodeDelete(void* it, void* param) 
{
  txMemberNode* self = it;
  fxNodeDispatchCode(self->reference, param);
  fxCoderAddSymbol(param, 0, (self->reference->flags & mxSuperFlag) ? XS_CODE_DELETE_SUPER : XS_CODE_DELETE_PROPERTY, self->symbol);
}

void fxMemberNodeCodeReference(void* it, void* param, txFlag flag) 
{
  txMemberNode* self = it;
  fxNodeDispatchCode(self->reference, param);
}

txFlag fxMemberNodeCodeThis(void* it, void* param, txFlag flag) 
{
  txMemberNode* self = it;
  fxNodeDispatchCode(self->reference, param);
  fxCoderAddByte(param, 1, XS_CODE_DUB);
  fxCoderAddSymbol(param, 0, (self->reference->flags & mxSuperFlag) ? XS_CODE_GET_SUPER : XS_CODE_GET_PROPERTY, self->symbol);
  return 1;
}

void fxMemberAtNodeCode(void* it, void* param) 
{
  txMemberAtNode* self = it;
  fxNodeDispatchCode(self->reference, param);
  fxNodeDispatchCode(self->at, param);
  fxCoderAddByte(param, 0, (self->reference->flags & mxSuperFlag) ? XS_CODE_SUPER_AT : XS_CODE_AT);
  fxCoderAddByte(param, -1, (self->reference->flags & mxSuperFlag) ? XS_CODE_GET_SUPER_AT : XS_CODE_GET_PROPERTY_AT);
}

void fxMemberAtNodeCodeAssign(void* it, void* param, txFlag flag) 
{
  txMemberAtNode* self = it;
  if (flag)
    fxCoderAddByte(param, 0, (self->reference->flags & mxSuperFlag) ? XS_CODE_SUPER_AT_2 : XS_CODE_AT_2);
  fxCoderAddByte(param, -2, (self->reference->flags & mxSuperFlag) ? XS_CODE_SET_SUPER_AT : XS_CODE_SET_PROPERTY_AT);
}

void fxMemberAtNodeCodeDelete(void* it, void* param) 
{
  txMemberAtNode* self = it;
  fxMemberAtNodeCodeReference(it, param, (self->reference->flags & mxSuperFlag) ? 1 : 0);
  fxCoderAddByte(param, -1, (self->reference->flags & mxSuperFlag) ? XS_CODE_DELETE_SUPER_AT : XS_CODE_DELETE_PROPERTY_AT);
}

void fxMemberAtNodeCodeReference(void* it, void* param, txFlag flag) 
{
  txMemberAtNode* self = it;
  fxNodeDispatchCode(self->reference, param);
  fxNodeDispatchCode(self->at, param);
  if (!flag)
    fxCoderAddByte(param, 0, (self->reference->flags & mxSuperFlag) ? XS_CODE_SUPER_AT : XS_CODE_AT);
}

txFlag fxMemberAtNodeCodeThis(void* it, void* param, txFlag flag) 
{
  txMemberAtNode* self = it;
  if (flag) {
    fxMemberAtNodeCodeReference(it, param, 0);
    fxCoderAddByte(param, 2, XS_CODE_DUB_AT);
    flag = 2;
  }
  else {
    fxNodeDispatchCode(self->reference, param);
    fxCoderAddByte(param, 1, XS_CODE_DUB);
    fxNodeDispatchCode(self->at, param);
    fxCoderAddByte(param, 0, (self->reference->flags & mxSuperFlag) ? XS_CODE_SUPER_AT : XS_CODE_AT);
  }
  fxCoderAddByte(param, -1, (self->reference->flags & mxSuperFlag) ? XS_CODE_GET_SUPER_AT : XS_CODE_GET_PROPERTY_AT);
  return flag;
}

void fxModuleNodeCode(void* it, void* param) 
{
  txModuleNode* self = it;
  txCoder* coder = param;
  txTargetCode* target = fxCoderCreateTarget(param);
  txDeclareNode* declaration;
  txInteger count;
  txSymbol* name = /*(coder->parser->flags & mxDebugFlag) ? self->path :*/ C_NULL;
  txFlag flag = 0;
  
  coder->line = -1;
  coder->programFlag = 0;
  coder->scopeLevel = 0;
  coder->firstBreakTarget = NULL;
  coder->firstContinueTarget = NULL;

  count = 0;
  declaration = self->scope->firstDeclareNode;
  while (declaration) {
    if ((declaration->description->token == XS_TOKEN_DEFINE) || (declaration->description->token == XS_TOKEN_VAR))
      count++;
    declaration = declaration->nextDeclareNode;
  }
  if (count) {
    fxCoderAddSymbol(param, 1, XS_CODE_FUNCTION, name);
    if (coder->parser->flags & mxDebugFlag)
      fxCoderAddByte(param, 0, XS_CODE_PROFILE);
    fxCoderAddBranch(param, 0, XS_CODE_CODE_1, target);
    fxCoderAddIndex(param, 0, XS_CODE_BEGIN_STRICT, 0);
    coder->path = C_NULL;
    if (self->line >= 0)
      fxCoderAddLine(coder, 0, XS_CODE_LINE, it); 
    if (self->scopeCount)
      fxCoderAddIndex(param, 0, XS_CODE_RESERVE_1, self->scopeCount);
    fxScopeCodeRetrieve(self->scope, param);
    declaration = self->scope->firstDeclareNode;
    while (declaration) {
      if (declaration->description->token == XS_TOKEN_VAR) {
        fxCoderAddByte(coder, 1, XS_CODE_UNDEFINED);
        fxCoderAddIndex(coder, 0, XS_CODE_VAR_CLOSURE_1, declaration->index);
        fxCoderAddByte(coder, -1, XS_CODE_POP);
      }
      declaration = declaration->nextDeclareNode;
    }
    fxScopeCodeDefineNodes(self->scope, param);
    fxCoderAddByte(param, 0, XS_CODE_END);
    fxCoderAdd(param, 0, target);
    fxCoderAddByte(param, 1, XS_CODE_ENVIRONMENT);
    fxCoderAddByte(param, -1, XS_CODE_POP);
  
    target = fxCoderCreateTarget(param);
    coder->line = -1;
    coder->programFlag = 0;
    coder->scopeLevel = 0;
    coder->firstBreakTarget = NULL;
    coder->firstContinueTarget = NULL;
  }
  else {
    fxCoderAddByte(coder, 1, XS_CODE_NULL);
  }
  
  if (self->flags & mxAwaitingFlag)
    fxCoderAddSymbol(param, 1, XS_CODE_ASYNC_FUNCTION, name);
  else
    fxCoderAddSymbol(param, 1, XS_CODE_FUNCTION, name);
  if (coder->parser->flags & mxDebugFlag)
    fxCoderAddByte(param, 0, XS_CODE_PROFILE);
  fxCoderAddBranch(param, 0, XS_CODE_CODE_1, target);
  fxCoderAddIndex(param, 0, XS_CODE_BEGIN_STRICT, 0);
  coder->path = C_NULL;
  if (self->line >= 0)
    fxCoderAddLine(coder, 0, XS_CODE_LINE, it); 
  if (self->scopeCount)
    fxCoderAddIndex(param, 0, XS_CODE_RESERVE_1, self->scopeCount);
  fxScopeCodeRetrieve(self->scope, param);
  
  if (self->flags & mxAwaitingFlag)
    fxCoderAddByte(param, 0, XS_CODE_START_ASYNC);

  coder->returnTarget = fxCoderCreateTarget(param);
  
  fxNodeDispatchCode(self->body, param);
  
  fxCoderAdd(param, 0, coder->returnTarget);
  fxCoderAddByte(param, 0, XS_CODE_END);
  fxCoderAdd(param, 0, target);
  
  fxCoderAddByte(param, 1, XS_CODE_ENVIRONMENT);
  fxCoderAddByte(param, -1, XS_CODE_POP);
  
  count = 2 + fxScopeCodeSpecifierNodes(self->scope, coder);
  fxCoderAddInteger(coder, 1, XS_CODE_INTEGER_1, count);
  if (!(self->flags & mxStrictFlag))
    flag |= XS_JSON_MODULE_FLAG;
  if (coder->importFlag)
    flag |= XS_IMPORT_FLAG;
  if (coder->importMetaFlag)
    flag |= XS_IMPORT_META_FLAG;
  fxCoderAddIndex(coder, 0 - count, XS_CODE_MODULE, flag);
  fxCoderAddByte(coder, -1, XS_CODE_SET_RESULT);
  fxCoderAddByte(coder, 0, XS_CODE_END);
}

void fxNewNodeCode(void* it, void* param) 
{
  txCallNewNode* self = it;
  fxNodeDispatchCode(self->reference, param);
  fxCoderAddByte(param, 2, XS_CODE_NEW);
  fxNodeDispatchCode(self->params, param);
}

void fxNumberNodeCode(void* it, void* param) 
{
  txNumberNode* self = it;
  fxCoderAddNumber(param, 1, XS_CODE_NUMBER, self->value);
}

void fxObjectNodeCode(void* it, void* param) 
{
  txObjectNode* self = it;
  txCoder* coder = param;
  txInteger object = fxCoderUseTemporaryVariable(param);
  txNode* item;
  txFlag flag = 0;
  if (self->items) {
    item = self->items->first;
    while (item) {
      if (item->description->token == XS_TOKEN_PROPERTY) {
        if (!(item->flags & mxShorthandFlag) && (((txPropertyNode*)item)->symbol == coder->parser->__proto__Symbol)) {
          if (flag)
            fxReportParserError(coder->parser, item->line, "invalid __proto__");
          flag = 1;
          fxNodeDispatchCode(((txPropertyNode*)item)->value, param);
          fxCoderAddByte(param, 0, XS_CODE_INSTANTIATE);
        }
      }
      item = item->next;
    }
  }
  if (!flag)
    fxCoderAddByte(param, 1, XS_CODE_OBJECT);
  fxCoderAddIndex(param, 0, XS_CODE_SET_LOCAL_1, object);
  if (self->items) {
    item = self->items->first;
    while (item) {
      if (item->description->token == XS_TOKEN_SPREAD) {
        fxCoderAddByte(param, 1, XS_CODE_UNDEFINED);
        fxCoderAddByte(param, 1, XS_CODE_COPY_OBJECT);
        fxCoderAddByte(param, 1, XS_CODE_CALL);
        fxCoderAddIndex(param, 1, XS_CODE_GET_LOCAL_1, object);
        fxNodeDispatchCode(((txSpreadNode*)item)->expression, param);
        fxCoderAddInteger(param, -4, XS_CODE_RUN_1, 2);
        fxCoderAddByte(param, -1, XS_CODE_POP);
      }
      else {
        txNode* value;
        if (item->description->token == XS_TOKEN_PROPERTY) {
          if (!(item->flags & mxShorthandFlag) && (((txPropertyNode*)item)->symbol == coder->parser->__proto__Symbol)) {
            item = item->next;
            continue;
          }
          value = ((txPropertyNode*)item)->value;
          fxCoderAddIndex(param, 1, XS_CODE_GET_LOCAL_1, object);
          fxNodeDispatchCode(value, param);
          fxCoderAddSymbol(param, -2, XS_CODE_NEW_PROPERTY, ((txPropertyNode*)item)->symbol);
        }
        else {
          value = ((txPropertyAtNode*)item)->value;
          fxCoderAddIndex(param, 1, XS_CODE_GET_LOCAL_1, object);
          fxNodeDispatchCode(((txPropertyAtNode*)item)->at, param);
          fxCoderAddByte(param, 0, XS_CODE_AT);
          fxNodeDispatchCode(value, param);
          fxCoderAddByte(param, -3, XS_CODE_NEW_PROPERTY_AT);
        }
        flag = 0;
        if (item->flags & mxMethodFlag)
          flag |= XS_NAME_FLAG | XS_METHOD_FLAG;
        else if (item->flags & mxGetterFlag)
          flag |= XS_NAME_FLAG | XS_METHOD_FLAG | XS_GETTER_FLAG;
        else if (item->flags & mxSetterFlag)
          flag |= XS_NAME_FLAG | XS_METHOD_FLAG | XS_SETTER_FLAG;
        else if (fxNodeCodeName(value))
          flag |= XS_NAME_FLAG;
        fxCoderAddInteger(param, 0, XS_CODE_INTEGER_1, flag);
      }
      item = item->next;
    }
  }
  fxCoderUnuseTemporaryVariables(param, 1);
}

void fxObjectBindingNodeCode(void* it, void* param)
{
  txObjectBindingNode* self = it;
  txCoder* coder = param;
  fxCoderAddByte(coder, 1, XS_CODE_UNDEFINED);
  fxObjectBindingNodeCodeAssign(self, param, 0);
}

void fxObjectBindingNodeCodeAssign(void* it, void* param, txFlag flag) 
{
  txObjectBindingNode* self = it;
  txNode* item = self->items->first;
  txInteger object;
  txInteger at;
  txInteger c = 0;
  object = fxCoderUseTemporaryVariable(param);
  at = fxCoderUseTemporaryVariable(param);
  fxCoderAddByte(param, 1, XS_CODE_DUB);
  fxCoderAddByte(param, 0, XS_CODE_TO_INSTANCE);
  fxCoderAddIndex(param, -1, XS_CODE_PULL_LOCAL_1, object);
  if (self->flags & mxSpreadFlag) {
    fxCoderAddByte(param, 1, XS_CODE_UNDEFINED);
    fxCoderAddByte(param, 1, XS_CODE_COPY_OBJECT);
    fxCoderAddByte(param, 1, XS_CODE_CALL);
    fxCoderAddByte(param, 1, XS_CODE_OBJECT);
    fxCoderAddIndex(param, 1, XS_CODE_GET_LOCAL_1, object);
    c = 2;
  }
  while (item && (item->description->token != XS_TOKEN_REST_BINDING)) {
    if (item->description->token == XS_TOKEN_PROPERTY_BINDING) {
      if (self->flags & mxSpreadFlag) {
        fxCoderAddIndex(param, 1, XS_CODE_GET_LOCAL_1, object);
        fxCoderAddSymbol(param, 1, XS_CODE_SYMBOL, ((txPropertyBindingNode*)item)->symbol);
        fxCoderAddByte(param, 0, XS_CODE_AT);
        fxCoderAddByte(param, 0, XS_CODE_SWAP);
        fxCoderAddByte(param, -1, XS_CODE_POP);
        c++;
      }
      fxNodeDispatchCodeReference(((txPropertyBindingNode*)item)->binding, param, 1);
      fxCoderAddIndex(param, 1, XS_CODE_GET_LOCAL_1, object);
      fxCoderAddSymbol(param, 0, XS_CODE_GET_PROPERTY, ((txPropertyBindingNode*)item)->symbol);
      fxNodeDispatchCodeAssign(((txPropertyBindingNode*)item)->binding, param, 1);
    }
    else {
      fxCoderAddIndex(param, 1, XS_CODE_GET_LOCAL_1, object);
      fxNodeDispatchCode(((txPropertyBindingAtNode*)item)->at, param);
      fxCoderAddByte(param, 0, XS_CODE_AT);
      if (self->flags & mxSpreadFlag) {
        fxCoderAddIndex(param, 0, XS_CODE_SET_LOCAL_1, at);
        fxCoderAddByte(param, 0, XS_CODE_SWAP);
        fxCoderAddByte(param, -1, XS_CODE_POP);
        c++;
      }
      else {
        fxCoderAddIndex(param, -1, XS_CODE_PULL_LOCAL_1, at);
        fxCoderAddByte(param, -1, XS_CODE_POP);
      }
      fxNodeDispatchCodeReference(((txPropertyBindingAtNode*)item)->binding, param, 1);
      fxCoderAddIndex(param, 1, XS_CODE_GET_LOCAL_1, object);
      fxCoderAddIndex(param, 1, XS_CODE_GET_LOCAL_1, at);
      fxCoderAddByte(param, -1, XS_CODE_GET_PROPERTY_AT);
      fxNodeDispatchCodeAssign(((txPropertyBindingAtNode*)item)->binding, param, 1);
    }
    fxCoderAddByte(param, -1, XS_CODE_POP);
    item = item->next;
  }
  if (self->flags & mxSpreadFlag) {
    fxCoderAddInteger(param, -2 - c, XS_CODE_RUN_1, c);
    fxCoderAddIndex(param, -1, XS_CODE_PULL_LOCAL_1, object);
    fxNodeDispatchCodeReference(((txRestBindingNode*)item)->binding, param, 1);
    fxCoderAddIndex(param, 1, XS_CODE_GET_LOCAL_1, object);
    fxNodeDispatchCodeAssign(((txRestBindingNode*)item)->binding, param, 1);
        fxCoderAddByte(param, -1, XS_CODE_POP);
  }
  fxCoderUnuseTemporaryVariables(param, 2);
}

void fxOptionNodeCode(void* it, void* param) 
{
  txUnaryExpressionNode* self = it;
  txCoder* coder = param;
  self->right->flags |= (self->flags & mxTailRecursionFlag);
  fxNodeDispatchCode(self->right, param);
  fxCoderAddBranch(param, 0, XS_CODE_BRANCH_CHAIN_1, coder->chainTarget);
}

txFlag fxOptionNodeCodeThis(void* it, void* param, txFlag flag) 
{
  txUnaryExpressionNode* self = it;
  txCoder* coder = param;
  txTargetCode* swapTarget = fxCoderCreateTarget(param);
  txTargetCode* skipTarget = fxCoderCreateTarget(param);
  self->right->flags |= (self->flags & mxTailRecursionFlag);
  flag = fxNodeDispatchCodeThis(self->right, param, flag);
  fxCoderAddBranch(param, 0, XS_CODE_BRANCH_CHAIN_1, swapTarget);
  fxCoderAddBranch(param, 1, XS_CODE_BRANCH_1, skipTarget);
  fxCoderAdd(param, 0, swapTarget);
  fxCoderAddByte(param, 0, XS_CODE_SWAP);
  fxCoderAddByte(param, -1, XS_CODE_POP);
  fxCoderAddBranch(param, 0, XS_CODE_BRANCH_1, coder->chainTarget);
  fxCoderAdd(param, 0, skipTarget);
  return flag;
}

void fxOrExpressionNodeCode(void* it, void* param) 
{
  txBinaryExpressionNode* self = it;
  txTargetCode* endTarget = fxCoderCreateTarget(param);
  self->right->flags |= (self->flags & mxTailRecursionFlag);
  fxNodeDispatchCode(self->left, param);
  fxCoderAddByte(param, 1, XS_CODE_DUB);
  fxCoderAddBranch(param, -1, XS_CODE_BRANCH_IF_1, endTarget);
  fxCoderAddByte(param, -1, XS_CODE_POP);
  fxNodeDispatchCode(self->right, param);
  fxCoderAdd(param, 0, endTarget);
}

void fxParamsNodeCode(void* it, void* param) 
{
  txParamsNode* self = it;
  txInteger c = 0;
  if (self->flags & mxSpreadFlag) {
    txInteger counter = fxCoderUseTemporaryVariable(param);
    fxCoderAddInteger(param, 1, XS_CODE_INTEGER_1, 0);
    fxCoderAddIndex(param, 0, XS_CODE_SET_LOCAL_1, counter);
    fxCoderAddByte(param, -1, XS_CODE_POP);
    if (self->items) {
      txNode* item = self->items->first;
      while (item) {
        if (item->description->token == XS_TOKEN_SPREAD) {
          fxSpreadNodeCode(item, param, counter);
        }
        else {
          c++;
          fxNodeDispatchCode(item, param);
          fxCoderAddIndex(param, 1, XS_CODE_GET_LOCAL_1, counter);
          fxCoderAddInteger(param, 1, XS_CODE_INTEGER_1, 1);
          fxCoderAddByte(param, -1, XS_CODE_ADD);
          fxCoderAddIndex(param, 0, XS_CODE_SET_LOCAL_1, counter);
          fxCoderAddByte(param, -1, XS_CODE_POP);
        }
        item = item->next;
      }
    }
    fxCoderAddIndex(param, 1, XS_CODE_GET_LOCAL_1, counter);
    if (self->flags & mxEvalParametersFlag)
      fxCoderAddByte(param, -3 - c, (self->flags & mxTailRecursionFlag) ? XS_CODE_EVAL_TAIL : XS_CODE_EVAL);
    else
      fxCoderAddByte(param, -3 - c, (self->flags & mxTailRecursionFlag) ? XS_CODE_RUN_TAIL : XS_CODE_RUN);
    fxCoderUnuseTemporaryVariables(param, 1);
  }
  else {
    if (self->items) {
      txNode* item = self->items->first;
      while (item) {
        fxNodeDispatchCode(item, param);
        c++;
        item = item->next;
      }
      if (self->flags & mxEvalParametersFlag) {
        fxCoderAddInteger(param, 1, XS_CODE_INTEGER_1, c);
        fxCoderAddByte(param, -3 - c, (self->flags & mxTailRecursionFlag) ? XS_CODE_EVAL_TAIL : XS_CODE_EVAL);
      }
      else
        fxCoderAddInteger(param, -2 - c, (self->flags & mxTailRecursionFlag) ? XS_CODE_RUN_TAIL_1 : XS_CODE_RUN_1, c);
    }
  }
}

void fxParamsBindingNodeCode(void* it, void* param) 
{
  txParamsBindingNode* self = it;
  txNode* item = self->items->first;
  txInteger index = 0;
  if (self->declaration) {
    if (self->mapped)
      fxCoderAddIndex(param, 1, XS_CODE_ARGUMENTS_SLOPPY, self->items->length);
    else
      fxCoderAddIndex(param, 1, XS_CODE_ARGUMENTS_STRICT, self->items->length);
    if (self->declaration->flags & mxDeclareNodeClosureFlag)
      fxCoderAddIndex(param, 0, XS_CODE_VAR_CLOSURE_1, self->declaration->index);
    else 
      fxCoderAddIndex(param, 0, XS_CODE_VAR_LOCAL_1, self->declaration->index);
    fxCoderAddByte(param, -1, XS_CODE_POP);
  }
  while (item) {
    if (item->description->token == XS_TOKEN_REST_BINDING) {
      fxNodeDispatchCodeReference(((txRestBindingNode*)item)->binding, param, 0);
      fxCoderAddIndex(param, 1, XS_CODE_ARGUMENTS, index);
      fxNodeDispatchCodeAssign(((txRestBindingNode*)item)->binding, param, 0);
    }
    else {
      fxNodeDispatchCodeReference(item, param, 0);
      fxCoderAddIndex(param, 1, XS_CODE_ARGUMENT, index);
      fxNodeDispatchCodeAssign(item, param, 0);
    }
    fxCoderAddByte(param, -1, XS_CODE_POP);
    item = item->next;
    index++;
  }
}

void fxPostfixExpressionNodeCode(void* it, void* param) 
{
  txPostfixExpressionNode* self = it;
  txInteger value;
  fxNodeDispatchCodeThis(self->left, param, 1);
  if (!(self->flags & mxExpressionNoValue)) {
    value = fxCoderUseTemporaryVariable(param);
    fxCoderAddByte(param, 0, XS_CODE_TO_NUMERIC);
    fxCoderAddIndex(param, 0, XS_CODE_SET_LOCAL_1, value);
  }
  fxCoderAddByte(param, 0, self->description->code);
  fxNodeDispatchCodeAssign(self->left, param, 0);
  if (!(self->flags & mxExpressionNoValue)) {
    fxCoderAddByte(param, -1, XS_CODE_POP);
    fxCoderAddIndex(param, 1, XS_CODE_GET_LOCAL_1, value);
    fxCoderUnuseTemporaryVariables(param, 1);
  }
}

void fxPrivateIdentifierNodeCode(void* it, void* param) 
{
  txPrivateMemberNode* self = it;
  fxNodeDispatchCode(self->reference, param);
  fxCoderAddIndex(param, 0,  XS_CODE_HAS_PRIVATE_1, self->declaration->index);
}

void fxPrivateMemberNodeCode(void* it, void* param) 
{
  txPrivateMemberNode* self = it;
  fxNodeDispatchCode(self->reference, param);
  fxCoderAddIndex(param, 0,  XS_CODE_GET_PRIVATE_1, self->declaration->index);
}

void fxPrivateMemberNodeCodeAssign(void* it, void* param, txFlag flag) 
{
  txPrivateMemberNode* self = it;
  fxCoderAddIndex(param, -1, XS_CODE_SET_PRIVATE_1, self->declaration->index);
}

void fxPrivateMemberNodeCodeDelete(void* it, void* param) 
{
  txPrivateMemberNode* self = it;
  txCoder* coder = param;
  fxNodeDispatchCode(self->reference, param);
  fxReportParserError(coder->parser, self->line, "delete private property");
}

void fxPrivateMemberNodeCodeReference(void* it, void* param, txFlag flag) 
{
  txPrivateMemberNode* self = it;
  fxNodeDispatchCode(self->reference, param);
}

txFlag fxPrivateMemberNodeCodeThis(void* it, void* param, txFlag flag) 
{
  txPrivateMemberNode* self = it;
  fxNodeDispatchCode(self->reference, param);
  fxCoderAddByte(param, 1, XS_CODE_DUB);
  fxCoderAddIndex(param, 0, XS_CODE_GET_PRIVATE_1, self->declaration->index);
  return 1;
}

void fxProgramNodeCode(void* it, void* param) 
{
  txProgramNode* self = it;
  txCoder* coder = param;
  
  coder->line = -1;
  coder->programFlag = 1;
  coder->scopeLevel = 0;
  coder->firstBreakTarget = NULL;
  coder->firstContinueTarget = NULL;
  
  if (self->flags & mxStrictFlag)
    fxCoderAddIndex(param, 0, XS_CODE_BEGIN_STRICT, 0);
  else
    fxCoderAddIndex(param, 0, XS_CODE_BEGIN_SLOPPY, 0);
  coder->path = C_NULL;
  if (self->line >= 0)
    fxCoderAddLine(coder, 0, XS_CODE_LINE, it); 
  if (coder->parser->flags & mxEvalFlag) {
    coder->evalFlag = 1;
    fxScopeCodingEval(self->scope, param);
  }
  else
    fxScopeCodingProgram(self->scope, param);
  coder->returnTarget = fxCoderCreateTarget(param);
  fxScopeCodeDefineNodes(self->scope, param);
  fxNodeDispatchCode(self->body, param);
  fxCoderAdd(param, 0, coder->returnTarget);
  fxCoderAddByte(param, 0, XS_CODE_RETURN);
}

void fxQuestionMarkNodeCode(void* it, void* param) 
{
  txQuestionMarkNode* self = it;
  txTargetCode* elseTarget = fxCoderCreateTarget(param);
  txTargetCode* endTarget = fxCoderCreateTarget(param);
  self->thenExpression->flags |= (self->flags & mxTailRecursionFlag);
  self->elseExpression->flags |= (self->flags & mxTailRecursionFlag);
  fxNodeDispatchCode(self->expression, param);
  fxCoderAddBranch(param, -1, XS_CODE_BRANCH_ELSE_1, elseTarget);
  fxNodeDispatchCode(self->thenExpression, param);
  fxCoderAddBranch(param, 0, XS_CODE_BRANCH_1, endTarget);
  fxCoderAdd(param, -1, elseTarget);
  fxNodeDispatchCode(self->elseExpression, param);
  fxCoderAdd(param, 0, endTarget);
}

void fxRegexpNodeCode(void* it, void* param) 
{
  txRegexpNode* self = it;
  fxCoderAddByte(param, 1, XS_CODE_REGEXP);
  fxCoderAddByte(param, 2, XS_CODE_NEW);
  fxNodeDispatchCode(self->modifier, param);
  fxNodeDispatchCode(self->value, param);
  fxCoderAddInteger(param, -4, XS_CODE_RUN_1, 2);
}

void fxReturnNodeCode(void* it, void* param) 
{
  txStatementNode* self = it;
  txCoder* coder = param;
  if (coder->programFlag)
    fxReportParserError(coder->parser, self->line, "invalid return");
  if (self->expression) { 
    if (((self->flags & (mxStrictFlag | mxGeneratorFlag)) == mxStrictFlag) && (coder->returnTarget->original == NULL))
      self->expression->flags |= mxTailRecursionFlag;
    fxNodeDispatchCode(self->expression, param);
    if ((self->flags & (mxAsyncFlag | mxGeneratorFlag)) == (mxAsyncFlag | mxGeneratorFlag)) {
      fxCoderAddByte(param, 0, XS_CODE_AWAIT);
      fxCoderAddByte(coder, 0, XS_CODE_THROW_STATUS);
    }
    fxCoderAddByte(param, -1, XS_CODE_SET_RESULT);
  }
  else if ((self->flags & (mxAsyncFlag | mxGeneratorFlag)) != (mxAsyncFlag | mxGeneratorFlag)) {
    fxCoderAddByte(param, 1, XS_CODE_UNDEFINED);
    fxCoderAddByte(param, -1, XS_CODE_SET_RESULT);
  }
  fxCoderAdjustEnvironment(coder, coder->returnTarget);
  fxCoderAdjustScope(coder, coder->returnTarget);
  fxCoderAddBranch(param, 0, XS_CODE_BRANCH_1, coder->returnTarget);
}

void fxSpreadNodeCode(void* it, void* param, txInteger counter) 
{
  txSpreadNode* self = it;
  txCoder* coder = param;
  txTargetCode* nextTarget = fxCoderCreateTarget(param);
  txTargetCode* doneTarget = fxCoderCreateTarget(param);
  txInteger iterator;
  fxNodeDispatchCode(self->expression, param);
  fxCoderAddByte(param, 0, XS_CODE_FOR_OF);
  iterator = fxCoderUseTemporaryVariable(param);
  fxCoderAddIndex(param, 0, XS_CODE_SET_LOCAL_1, iterator);
  fxCoderAddByte(param, -1, XS_CODE_POP);
  fxCoderAdd(param, 0, nextTarget);
  fxCoderAddIndex(param, 1, XS_CODE_GET_LOCAL_1, iterator);
  fxCoderAddByte(param, 1, XS_CODE_DUB);
  fxCoderAddSymbol(param, 0, XS_CODE_GET_PROPERTY, coder->parser->nextSymbol);
  fxCoderAddByte(param, 1, XS_CODE_CALL);
  fxCoderAddInteger(param, -2, XS_CODE_RUN_1, 0);
  fxCoderAddByte(param, 1, XS_CODE_DUB);
  fxCoderAddSymbol(param, 0, XS_CODE_GET_PROPERTY, coder->parser->doneSymbol);
  fxCoderAddBranch(param, -1, XS_CODE_BRANCH_IF_1, doneTarget);
  fxCoderAddSymbol(param, 0, XS_CODE_GET_PROPERTY, coder->parser->valueSymbol);
  fxCoderAddIndex(param, 1, XS_CODE_GET_LOCAL_1, counter);
  fxCoderAddInteger(param, 1, XS_CODE_INTEGER_1, 1);
  fxCoderAddByte(param, -1, XS_CODE_ADD);
  fxCoderAddIndex(param, 0, XS_CODE_SET_LOCAL_1, counter);
  fxCoderAddByte(param, -1, XS_CODE_POP);
  fxCoderAddBranch(param, 0, XS_CODE_BRANCH_1, nextTarget);
  fxCoderAdd(param, 1, doneTarget);
  fxCoderAddByte(param, -1, XS_CODE_POP);
  fxCoderUnuseTemporaryVariables(param, 1);
}

void fxStatementNodeCode(void* it, void* param) 
{
  txStatementNode* self = it;
  txCoder* coder = param;
  if (coder->programFlag) {
    fxNodeDispatchCode(self->expression, param);
    fxCoderAddByte(param, -1, XS_CODE_SET_RESULT);
  }
  else {
    self->expression->flags |= mxExpressionNoValue;
    fxNodeDispatchCode(self->expression, param);
    if (coder->lastCode->id == XS_CODE_SET_CLOSURE_1) {
      coder->lastCode->id = XS_CODE_PULL_CLOSURE_1;
      coder->stackLevel--;
      coder->lastCode->stackLevel = coder->stackLevel;
    }
    else if (coder->lastCode->id == XS_CODE_SET_LOCAL_1) {
      coder->lastCode->id = XS_CODE_PULL_LOCAL_1;
      coder->stackLevel--;
      coder->lastCode->stackLevel = coder->stackLevel;
    }
    else
      fxCoderAddByte(param, -1, XS_CODE_POP);
  }
}

void fxStatementsNodeCode(void* it, void* param) 
{
  txStatementsNode* self = it;
  txNode* item = self->items->first;
  while (item) {
    fxNodeDispatchCode(item, param);
    item = item->next;
  }
}

void fxStringNodeCode(void* it, void* param) 
{
  txStringNode* self = it;
  txCoder* coder = param;
  txParser* parser = coder->parser;
  if (self->flags & mxStringErrorFlag)
    fxReportParserError(parser, self->line, "invalid escape sequence");
  fxCoderAddString(param, 1, XS_CODE_STRING_1, self->length, self->value);
}

void fxSuperNodeCode(void* it, void* param)
{
  txSuperNode* self = it;
  fxCoderAddByte(param, 3, XS_CODE_SUPER);
  fxNodeDispatchCode(self->params, param);
  fxCoderAddByte(param, 0, XS_CODE_SET_THIS);
  if (self->instanceInitAccess) {
    fxCoderAddByte(param, 1, XS_CODE_GET_THIS);
    fxCoderAddIndex(param, 1, XS_CODE_GET_CLOSURE_1, self->instanceInitAccess->declaration->index);
    fxCoderAddByte(param, 1, XS_CODE_CALL);
    fxCoderAddInteger(param, -2, XS_CODE_RUN_1, 0);
    fxCoderAddByte(param, -1, XS_CODE_POP);
  }
}

void fxSwitchNodeCode(void* it, void* param) 
{
  txSwitchNode* self = it;
  txCoder* coder = param;
  txTargetCode* breakTarget;
  txCaseNode* caseNode;
  txCaseNode* defaultNode = NULL;
  txUsingContext context;
  fxNodeDispatchCode(self->expression, param);
  fxScopeCodingBlock(self->scope, param);
  if (self->scope->disposableNodeCount)
    fxScopeCodeUsing(self->scope, coder, &context);
  breakTarget = fxCoderCreateTarget(coder);
  breakTarget->label = fxNewParserChunkClear(coder->parser, sizeof(txLabelNode));
  breakTarget->nextTarget = coder->firstBreakTarget;
  coder->firstBreakTarget = breakTarget;
  if (coder->programFlag) {
    fxCoderAddByte(param, 1, XS_CODE_UNDEFINED);
    fxCoderAddByte(param, -1, XS_CODE_SET_RESULT);
  }
  caseNode = (txCaseNode*)self->items->first;
  while (caseNode) {
    caseNode->target = fxCoderCreateTarget(param);
    if (caseNode->expression) {
      fxCoderAddByte(param, 1, XS_CODE_DUB);
      fxNodeDispatchCode(caseNode->expression, param);
      fxCoderAddByte(param, -1, XS_CODE_STRICT_EQUAL);
      fxCoderAddBranch(param, -1, XS_CODE_BRANCH_IF_1, caseNode->target);
    }
    else
      defaultNode = caseNode;
    caseNode = (txCaseNode*)caseNode->next;
  }
  if (defaultNode)
    fxCoderAddBranch(param, 0, XS_CODE_BRANCH_1, defaultNode->target);
  else
    fxCoderAddBranch(param, 0, XS_CODE_BRANCH_1, coder->firstBreakTarget);
  caseNode = (txCaseNode*)self->items->first;
  while (caseNode) {
    fxCoderAdd(param, 0, caseNode->target);
    if (caseNode->statement)
      fxNodeDispatchCode(caseNode->statement, param);
    caseNode = (txCaseNode*)caseNode->next;
  }
  fxCoderAdd(param, 0, coder->firstBreakTarget);
  coder->firstBreakTarget = breakTarget->nextTarget;
  if (self->scope->disposableNodeCount)
    fxScopeCodeUsed(self->scope, coder, &context);
  fxScopeCoded(self->scope, param);
  fxCoderAddByte(param, -1, XS_CODE_POP);
}

void fxTemplateNodeCode(void* it, void* param) 
{
  txTemplateNode* self = it;
  txCoder* coder = param;
  txParser* parser = coder->parser;
  txNode* item = self->items->first;
  
  if (self->reference) {
    txSymbol* symbol;
    txTargetCode* cacheTarget = fxCoderCreateTarget(param);
    txInteger i = (self->items->length / 2) + 1;
    txInteger raws = fxCoderUseTemporaryVariable(param);
    txInteger strings = fxCoderUseTemporaryVariable(param);
    txFlag flag = XS_DONT_DELETE_FLAG | XS_DONT_SET_FLAG;

    fxNodeDispatchCodeThis(self->reference, param, 0);
    fxCoderAddByte(param, 1, XS_CODE_CALL);

    fxGenerateTag(parser->console, parser->buffer, parser->bufferSize, (parser->path) ? parser->path->string : C_NULL);
    symbol = fxNewParserSymbol(parser, parser->buffer);
    fxCoderAddByte(param, 1, XS_CODE_TEMPLATE_CACHE);
    fxCoderAddSymbol(param, 0, XS_CODE_GET_PROPERTY, symbol);
    fxCoderAddBranch(param, 0, XS_CODE_BRANCH_COALESCE_1, cacheTarget);
    fxCoderAddByte(param, 1, XS_CODE_TEMPLATE_CACHE);

    fxCoderAddByte(param, 1, XS_CODE_ARRAY);
    fxCoderAddIndex(param, 0, XS_CODE_SET_LOCAL_1, strings);
    fxCoderAddInteger(param, 1, XS_CODE_INTEGER_1, i);
    fxCoderAddSymbol(param, -1, XS_CODE_SET_PROPERTY, coder->parser->lengthSymbol);
    fxCoderAddByte(param, -1, XS_CODE_POP);
    fxCoderAddByte(param, 1, XS_CODE_ARRAY);
    fxCoderAddIndex(param, 0, XS_CODE_SET_LOCAL_1, raws);
    fxCoderAddInteger(param, 1, XS_CODE_INTEGER_1, i);
    fxCoderAddSymbol(param, -1, XS_CODE_SET_PROPERTY, coder->parser->lengthSymbol);
    fxCoderAddByte(param, -1, XS_CODE_POP);
    i = 0;
    while (item) {
      if (item->description->token == XS_TOKEN_TEMPLATE_MIDDLE) {
    
        fxCoderAddIndex(param, 1, XS_CODE_GET_LOCAL_1, strings);
        fxCoderAddInteger(param, 1, XS_CODE_INTEGER_1, i);
        fxCoderAddByte(param, 0, XS_CODE_AT);
        if (((txTemplateItemNode*)item)->string->flags & mxStringErrorFlag)
          fxCoderAddByte(param, 1, XS_CODE_UNDEFINED);
        else
          fxNodeDispatchCode(((txTemplateItemNode*)item)->string, param);
        fxCoderAddByte(param, -3, XS_CODE_NEW_PROPERTY_AT);
        fxCoderAddInteger(param, 0, XS_CODE_INTEGER_1, flag);
      
        fxCoderAddIndex(param, 1, XS_CODE_GET_LOCAL_1, raws);
        fxCoderAddInteger(param, 1, XS_CODE_INTEGER_1, i);
        fxCoderAddByte(param, 0, XS_CODE_AT);
        fxNodeDispatchCode(((txTemplateItemNode*)item)->raw, param);
        fxCoderAddByte(param, -3, XS_CODE_NEW_PROPERTY_AT);
        fxCoderAddInteger(param, 0, XS_CODE_INTEGER_1, flag);
      
        i++;
      }
      item = item->next;
    }
    fxCoderAddIndex(param, 1, XS_CODE_GET_LOCAL_1, strings);
    fxCoderAddIndex(param, 1, XS_CODE_GET_LOCAL_1, raws);
    fxCoderAddSymbol(param, -1, XS_CODE_SET_PROPERTY, parser->rawSymbol);
    fxCoderAddByte(param, -1, XS_CODE_POP);
    fxCoderAddIndex(param, 1, XS_CODE_GET_LOCAL_1, strings);
    fxCoderAddByte(param, 0, XS_CODE_TEMPLATE);
    
    fxCoderAddSymbol(param, -1, XS_CODE_SET_PROPERTY, symbol);
    
    fxCoderAdd(param, 0, cacheTarget);
    
    i = 1;
    item = self->items->first;
    while (item) {
      if (item->description->token != XS_TOKEN_TEMPLATE_MIDDLE) {
        fxNodeDispatchCode(item, param);
        i++;
      }
      item = item->next;
    }
    fxCoderAddInteger(param, -2 - i, (self->flags & mxTailRecursionFlag) ? XS_CODE_RUN_TAIL_1 : XS_CODE_RUN_1, i);
    fxCoderUnuseTemporaryVariables(coder, 2);
  }
  else {
    fxNodeDispatchCode(((txTemplateItemNode*)item)->string, param);
    item = item->next;
    while (item) {
      if (item->description->token == XS_TOKEN_TEMPLATE_MIDDLE) {
        fxNodeDispatchCode(((txTemplateItemNode*)item)->string, param);
      }
      else {
        fxNodeDispatchCode(item, param);
        fxCoderAddByte(param, 1, XS_CODE_TO_STRING);
      }
      fxCoderAddByte(param, -1, XS_CODE_ADD);
      item = item->next;
    }
  }
}

void fxThisNodeCode(void* it, void* param) 
{
  txNode* self = it;
  if (self->flags & mxDerivedFlag)
    fxCoderAddByte(param, 1, XS_CODE_GET_THIS);
  else
    fxCoderAddByte(param, 1, self->description->code);
}

void fxThrowNodeCode(void* it, void* param) 
{
  txStatementNode* self = it;
  fxNodeDispatchCode(self->expression, param);
  fxCoderAddByte(param, -1, XS_CODE_THROW);
}

void fxTryNodeCode(void* it, void* param) 
{
  txTryNode* self = it;
  txCoder* coder = param;
  txInteger exception;
  txInteger selector;
  txInteger result;
  txInteger selection;
  txTargetCode* catchTarget;
  txTargetCode* normalTarget;
  txTargetCode* finallyTarget;

  exception = fxCoderUseTemporaryVariable(coder);
  selector = fxCoderUseTemporaryVariable(coder);
  result = fxCoderUseTemporaryVariable(coder);

  coder->firstBreakTarget = fxCoderAliasTargets(param, coder->firstBreakTarget);
  coder->firstContinueTarget = fxCoderAliasTargets(param, coder->firstContinueTarget);
  coder->returnTarget = fxCoderAliasTargets(param, coder->returnTarget);
  catchTarget = fxCoderCreateTarget(param);
  normalTarget = fxCoderCreateTarget(param);
  finallyTarget = fxCoderCreateTarget(param);

  fxCoderAddInteger(param, 1, XS_CODE_INTEGER_1, 0);
  fxCoderAddIndex(param, 0, XS_CODE_SET_LOCAL_1, selector);
  fxCoderAddByte(param, -1, XS_CODE_POP);

  fxCoderAddBranch(param, 0, XS_CODE_CATCH_1, catchTarget);
  if (coder->programFlag) {
    fxCoderAddByte(param, 1, XS_CODE_UNDEFINED);
    fxCoderAddByte(param, -1, XS_CODE_SET_RESULT);
  }
  fxNodeDispatchCode(self->tryBlock, param);
  fxCoderAddBranch(param, 0, XS_CODE_BRANCH_1, normalTarget);
  if (self->catchBlock) {
    fxCoderAddByte(param, 0, XS_CODE_UNCATCH);
    fxCoderAdd(param, 0, catchTarget);
    catchTarget = fxCoderCreateTarget(param);
    fxCoderAddBranch(param, 0, XS_CODE_CATCH_1, catchTarget);
    if (coder->programFlag) {
      fxCoderAddByte(param, 1, XS_CODE_UNDEFINED);
      fxCoderAddByte(param, -1, XS_CODE_SET_RESULT);
    }
    fxNodeDispatchCode(self->catchBlock, param);
    fxCoderAddBranch(param, 0, XS_CODE_BRANCH_1, normalTarget);
  }
  
  selection = 1;
  coder->firstBreakTarget = fxCoderFinalizeTargets(param, coder->firstBreakTarget, selector, &selection, finallyTarget);
  coder->firstContinueTarget = fxCoderFinalizeTargets(param, coder->firstContinueTarget, selector, &selection, finallyTarget);
  coder->returnTarget = fxCoderFinalizeTargets(param, coder->returnTarget, selector, &selection, finallyTarget);
  fxCoderAdd(param, 0, normalTarget);
  fxCoderAddInteger(param, 1, XS_CODE_INTEGER_1, selection);
  fxCoderAddIndex(param, 0, XS_CODE_SET_LOCAL_1, selector);
  fxCoderAddByte(param, -1, XS_CODE_POP);
  fxCoderAdd(param, 0, finallyTarget);
  fxCoderAddByte(param, 0, XS_CODE_UNCATCH);
  fxCoderAdd(param, 0, catchTarget);
  fxCoderAddByte(param, 1, XS_CODE_EXCEPTION);
  fxCoderAddIndex(param, 0, XS_CODE_SET_LOCAL_1, exception);
  fxCoderAddByte(param, -1, XS_CODE_POP);
  if (self->finallyBlock) {
    if (coder->programFlag) {
      fxCoderAddByte(param, 1, XS_CODE_GET_RESULT);
      fxCoderAddIndex(param, -1, XS_CODE_PULL_LOCAL_1, result);
      fxCoderAddByte(param, 1, XS_CODE_UNDEFINED);
      fxCoderAddByte(param, -1, XS_CODE_SET_RESULT);
    }
    fxNodeDispatchCode(self->finallyBlock, param);
    if (coder->programFlag) {
      fxCoderAddIndex(param, 1, XS_CODE_GET_LOCAL_1, result);
      fxCoderAddByte(param, -1, XS_CODE_SET_RESULT);
    }    
  }
  catchTarget = fxCoderCreateTarget(param);
  fxCoderAddIndex(param, 1, XS_CODE_GET_LOCAL_1, selector);
  fxCoderAddBranch(param, -1, XS_CODE_BRANCH_IF_1, catchTarget);
  fxCoderAddIndex(param, 1, XS_CODE_GET_LOCAL_1, exception);
  fxCoderAddByte(param, -1, XS_CODE_THROW);
  fxCoderAdd(param, 0, catchTarget);
  selection = 1;
  fxCoderJumpTargets(param, coder->firstBreakTarget, selector, &selection);
  fxCoderJumpTargets(param, coder->firstContinueTarget, selector, &selection);
  fxCoderJumpTargets(param, coder->returnTarget, selector, &selection);
  fxCoderUnuseTemporaryVariables(coder, 3);
}

void fxUnaryExpressionNodeCode(void* it, void* param) 
{
  txUnaryExpressionNode* self = it;
  fxNodeDispatchCode(self->right, param);
  fxCoderAddByte(param, 0, self->description->code);
}

void fxUndefinedNodeCodeAssign(void* it, void* param, txFlag flag) 
{
  txCoder* coder = param;
  fxCoderAddSymbol(param, -1, XS_CODE_SET_VARIABLE, coder->parser->undefinedSymbol);
}

void fxUndefinedNodeCodeDelete(void* it, void* param) 
{
  txNode* self = it;
  txCoder* coder = param;
  if (self->flags & mxStrictFlag)
    fxReportParserError(coder->parser, self->line, "delete identifier (strict code)");
  fxCoderAddByte(param, 1, XS_CODE_FALSE);
}

void fxUndefinedNodeCodeReference(void* it, void* param, txFlag flag) 
{
  txCoder* coder = param;
  if (coder->evalFlag)
    fxCoderAddSymbol(param, 1, XS_CODE_EVAL_REFERENCE, coder->parser->undefinedSymbol);
  else
    fxCoderAddSymbol(param, 1, XS_CODE_PROGRAM_REFERENCE, coder->parser->undefinedSymbol);
}

void fxValueNodeCode(void* it, void* param) 
{
  txNode* self = it;
  fxCoderAddByte(param, 1, self->description->code);
}

void fxWhileNodeCode(void* it, void* param) 
{
  txWhileNode* self = it;
  txCoder* coder = param;
  if (coder->programFlag) {
    fxCoderAddByte(param, 1, XS_CODE_UNDEFINED);
    fxCoderAddByte(param, -1, XS_CODE_SET_RESULT);
  }
  fxCoderAdd(param, 0, coder->firstContinueTarget);
  fxNodeDispatchCode(self->expression, param);
  fxCoderAddBranch(param, -1, XS_CODE_BRANCH_ELSE_1, coder->firstBreakTarget);
  fxNodeDispatchCode(self->statement, param);
  fxCoderAddBranch(param, 0, XS_CODE_BRANCH_1, coder->firstContinueTarget);
}

void fxWithNodeCode(void* it, void* param)
{
  txWithNode* self = it;
  txCoder* coder = param;
  txBoolean evalFlag;
  fxNodeDispatchCode(self->expression, param);
  fxCoderAddByte(param, 0, XS_CODE_TO_INSTANCE);
  fxCoderAddByte(param, 0, XS_CODE_WITH);
  fxCoderAddByte(param, -1, XS_CODE_POP);
  evalFlag = coder->evalFlag;
  coder->environmentLevel++;
  coder->evalFlag = 1;
  if (coder->programFlag) {
    fxCoderAddByte(param, 1, XS_CODE_UNDEFINED);
    fxCoderAddByte(param, -1, XS_CODE_SET_RESULT);
  }
  fxNodeDispatchCode(self->statement, param);
  coder->evalFlag = evalFlag;
  coder->environmentLevel--;
  fxCoderAddByte(param, 0, XS_CODE_WITHOUT);
}

void fxYieldNodeCode(void* it, void* param) 
{
  txStatementNode* self = it;
  txBoolean async = (self->flags & mxAsyncFlag) ? 1 : 0;
  txCoder* coder = param;
  txTargetCode* target = fxCoderCreateTarget(coder);
  if (async) {
    fxNodeDispatchCode(self->expression, param);
  }
  else {
    fxCoderAddByte(param, 1, XS_CODE_OBJECT);
    fxCoderAddByte(param, 1, XS_CODE_DUB);
    fxNodeDispatchCode(self->expression, param);
    fxCoderAddSymbol(param, -2, XS_CODE_NEW_PROPERTY, coder->parser->valueSymbol);
    fxCoderAddInteger(param, 0, XS_CODE_INTEGER_1, 0);
    fxCoderAddByte(param, 1, XS_CODE_DUB);
    fxCoderAddByte(param, 1, XS_CODE_FALSE);
    fxCoderAddSymbol(param, -2, XS_CODE_NEW_PROPERTY, coder->parser->doneSymbol);
    fxCoderAddInteger(param, 0, XS_CODE_INTEGER_1, 0);
  }
  fxCoderAddByte(coder, 0, XS_CODE_YIELD);
  fxCoderAddBranch(coder, 1, XS_CODE_BRANCH_STATUS_1, target);
  if (async) {
    fxCoderAddByte(param, 0, XS_CODE_AWAIT);
    fxCoderAddByte(coder, 0, XS_CODE_THROW_STATUS);
  }
  fxCoderAddByte(param, -1, XS_CODE_SET_RESULT);
  fxCoderAdjustEnvironment(coder, coder->returnTarget);
  fxCoderAdjustScope(coder, coder->returnTarget);
  fxCoderAddBranch(coder, 0, XS_CODE_BRANCH_1, coder->returnTarget);
  fxCoderAdd(coder, 0, target);
}


Coverage Report

Created: 2025-10-29 06:26