/src/moddable/xs/sources/xsSyntaxical.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"

static txBoolean fxIsKeyword(txParser* parser, txSymbol* keyword);
static txBoolean fxIsToken(txParser* parser, txToken theToken);
static void fxMatchToken(txParser* parser, txToken theToken);
static txNode* fxPopNode(txParser* parser);
static void fxPushNode(txParser* parser, txNode* node);
static void fxPushBigIntNode(txParser* parser, txBigInt* value, txInteger line);
static void fxPushIndexNode(txParser* parser, txIndex value, txInteger line);
static void fxPushIntegerNode(txParser* parser, txInteger value, txInteger line);
static void fxPushNodeStruct(txParser* parser, txInteger count, txToken token, txInteger line);
static void fxPushNodeList(txParser* parser, txInteger count);
static void fxPushNULL(txParser* parser);
static void fxPushNumberNode(txParser* parser, txNumber value, txInteger line);
static void fxPushRawNode(txParser* parser, txInteger length, txString value, txInteger line);
static void fxPushStringNode(txParser* parser, txInteger length, txString value, txInteger line);
static void fxPushSymbol(txParser* parser, txSymbol* symbol);
static void fxSwapNodes(txParser* parser);

static void fxExportDeclaration(txParser* parser);
static void fxExportBinding(txParser* parser, txNode* node);
static void fxImportDeclaration(txParser* parser);
static void fxWithAttributes(txParser* parser);
static void fxSpecifiers(txParser* parser);

static void fxBody(txParser* parser);
static void fxStatements(txParser* parser);
static void fxBlock(txParser* parser);
static void fxStatement(txParser* parser, txInteger blockIt);
static void fxSemicolon(txParser* parser);

static void fxBreakStatement(txParser* parser);
static void fxContinueStatement(txParser* parser);
static void fxDebuggerStatement(txParser* parser);
static void fxDoStatement(txParser* parser);
static void fxForStatement(txParser* parser);
static void fxIfStatement(txParser* parser);
static void fxReturnStatement(txParser* parser);
static void fxSwitchStatement(txParser* parser);
static void fxThrowStatement(txParser* parser);
static void fxTryStatement(txParser* parser);
static void fxVariableStatement(txParser* parser, txToken theToken, txUnsigned flags);
static void fxWhileStatement(txParser* parser);
static void fxWithStatement(txParser* parser);

static void fxCommaExpression(txParser* parser);
static void fxAssignmentExpression(txParser* parser);
static void fxConditionalExpression(txParser* parser);
static void fxOrExpression(txParser* parser);
static void fxAndExpression(txParser* parser);
static void fxCoalesceExpression(txParser* parser);
static void fxBitOrExpression(txParser* parser);
static void fxBitXorExpression(txParser* parser);
static void fxBitAndExpression(txParser* parser);
static void fxEqualExpression(txParser* parser);
static void fxRelationalExpression(txParser* parser);
static void fxShiftExpression(txParser* parser);
static void fxAdditiveExpression(txParser* parser);
static void fxMultiplicativeExpression(txParser* parser);
static void fxExponentiationExpression(txParser* parser);
static void fxUnaryExpression(txParser* parser);
static void fxPrefixExpression(txParser* parser);
static void fxPostfixExpression(txParser* parser);
static void fxCallExpression(txParser* parser);

static void fxLiteralExpression(txParser* parser, txUnsigned flag);
static void fxArrayExpression(txParser* parser);
static void fxArrowExpression(txParser* parser, txUnsigned flag);
static void fxClassExpression(txParser* parser, txInteger theLine, txSymbol** theSymbol);
static void fxFunctionExpression(txParser* parser, txInteger theLine, txSymbol** theSymbol, txUnsigned flag);
static void fxGeneratorExpression(txParser* parser, txInteger theLine, txSymbol** theSymbol, txUnsigned flag);
static void fxGroupExpression(txParser* parser, txUnsigned flag);
static void fxObjectExpression(txParser* parser);
static void fxNewExpression(txParser* parser);
static void fxTemplateExpression(txParser* parser);
static void fxYieldExpression(txParser* parser);

static void fxParameters(txParser* parser);
static void fxPropertyName(txParser* parser, txSymbol** theSymbol, txToken* theToken0, txToken* theToken1, txToken* theToken2, txUnsigned* flag);

static void fxBinding(txParser* parser, txToken theToken, txUnsigned flags);
static txNode* fxBindingFromExpression(txParser* parser, txNode* theNode, txToken theToken);
static void fxArrayBinding(txParser* parser, txToken theToken);
static txNode* fxArrayBindingFromExpression(txParser* parser, txNode* theNode, txToken theToken);
static txUnsigned fxObjectBinding(txParser* parser, txToken theToken);
static txNode* fxObjectBindingFromExpression(txParser* parser, txNode* theNode, txToken theToken);
static void fxParametersBinding(txParser* parser);
static txNode* fxParametersBindingFromExpressions(txParser* parser, txNode* theNode);
static void fxRestBinding(txParser* parser, txToken theToken, txUnsigned flag);
static txNode* fxRestBindingFromExpression(txParser* parser, txNode* theNode, txToken theToken, txUnsigned flag);

static void fxCheckArrowFunction(txParser* parser, txInteger count);
static void fxCheckNativeConstructor(txParser* parser);
static void fxCheckNativeFunction(txParser* parser);
static txBoolean fxCheckReference(txParser* parser, txToken theToken);
static void fxCheckStrictBinding(txParser* parser, txNode* node);
static void fxCheckStrictFunction(txParser* parser, txFunctionNode* function);
static void fxCheckStrictSymbol(txParser* parser, txSymbol* symbol);
static void fxCheckUniqueProperty(txParser* parser, txNode* base, txNode* current);
static void fxCheckUniquePropertyAux(txParser* parser, txNode* baseNode, txNode* currentNode);

static void fxJSONObject(txParser* parser);
static void fxJSONArray(txParser* parser);

static void fxJSXAttributeName(txParser* parser);
static void fxJSXAttributeValue(txParser* parser);
static void fxJSXElement(txParser* parser);
static void fxJSXElementName(txParser* parser);
static txBoolean fxJSXMatch(txParser* parser, txNode* opening, txNode* closing);
static txSymbol* fxJSXNamespace(txParser* parser, txSymbol* namespace, txSymbol* name);

#define XS_TOKEN_BEGIN_STATEMENT 1
#define XS_TOKEN_BEGIN_EXPRESSION 2
#define XS_TOKEN_ASSIGN_EXPRESSION 4
#define XS_TOKEN_EQUAL_EXPRESSION 8
#define XS_TOKEN_RELATIONAL_EXPRESSION 16
#define XS_TOKEN_SHIFT_EXPRESSION 32
#define XS_TOKEN_ADDITIVE_EXPRESSION 64
#define XS_TOKEN_MULTIPLICATIVE_EXPRESSION 128
#define XS_TOKEN_EXPONENTIATION_EXPRESSION 256
#define XS_TOKEN_PREFIX_EXPRESSION 512
#define XS_TOKEN_POSTFIX_EXPRESSION 1024
#define XS_TOKEN_END_STATEMENT 2048
#define XS_TOKEN_REFERENCE_EXPRESSION 4096
#define XS_TOKEN_BEGIN_BINDING 16384
#define XS_TOKEN_IDENTIFIER_NAME 32768
#define XS_TOKEN_UNARY_EXPRESSION 65536
#define XS_TOKEN_CALL_EXPRESSION 131072

static txTokenFlag gxTokenFlags[XS_TOKEN_COUNT] = {
  /* XS_NO_TOKEN */ 0,
  /* XS_TOKEN_ACCESS */ 0,
  /* XS_TOKEN_ADD */ XS_TOKEN_BEGIN_STATEMENT | XS_TOKEN_BEGIN_EXPRESSION | XS_TOKEN_ADDITIVE_EXPRESSION | XS_TOKEN_UNARY_EXPRESSION,
  /* XS_TOKEN_ADD_ASSIGN */ XS_TOKEN_ASSIGN_EXPRESSION,
  /* XS_TOKEN_AND */ 0,
  /* XS_TOKEN_AND_ASSIGN */ XS_TOKEN_ASSIGN_EXPRESSION,
  /* XS_TOKEN_ARG */ 0,
  /* XS_TOKEN_ARGUMENTS */ 0,
  /* XS_TOKEN_ARGUMENTS_SLOPPY */ 0,
  /* XS_TOKEN_ARGUMENTS_STRICT */ 0,
  /* XS_TOKEN_ARRAY */ 0,
  /* XS_TOKEN_ARRAY_BINDING */ 0,
  /* XS_TOKEN_ARROW */ 0,
  /* XS_TOKEN_ASSIGN */ XS_TOKEN_ASSIGN_EXPRESSION,
  /* XS_TOKEN_AWAIT */ XS_TOKEN_BEGIN_STATEMENT | XS_TOKEN_BEGIN_EXPRESSION | XS_TOKEN_UNARY_EXPRESSION | XS_TOKEN_IDENTIFIER_NAME,
  /* XS_TOKEN_BIGINT */ XS_TOKEN_BEGIN_STATEMENT | XS_TOKEN_BEGIN_EXPRESSION,
  /* XS_TOKEN_BINDING */ 0,
  /* XS_TOKEN_BIT_AND */ 0,
  /* XS_TOKEN_BIT_AND_ASSIGN */ XS_TOKEN_ASSIGN_EXPRESSION,
  /* XS_TOKEN_BIT_NOT */ XS_TOKEN_BEGIN_STATEMENT | XS_TOKEN_BEGIN_EXPRESSION | XS_TOKEN_UNARY_EXPRESSION,
  /* XS_TOKEN_BIT_OR */ 0,
  /* XS_TOKEN_BIT_OR_ASSIGN */ XS_TOKEN_ASSIGN_EXPRESSION,
  /* XS_TOKEN_BIT_XOR */ 0,
  /* XS_TOKEN_BIT_XOR_ASSIGN */ XS_TOKEN_ASSIGN_EXPRESSION,
  /* XS_TOKEN_BLOCK */ 0,
  /* XS_TOKEN_BODY */ 0,
  /* XS_TOKEN_BREAK */ XS_TOKEN_BEGIN_STATEMENT | XS_TOKEN_IDENTIFIER_NAME,
  /* XS_TOKEN_CALL */ 0,
  /* XS_TOKEN_CASE */ XS_TOKEN_IDENTIFIER_NAME,
  /* XS_TOKEN_CATCH */ XS_TOKEN_IDENTIFIER_NAME,
  /* XS_TOKEN_CHAIN */ XS_TOKEN_CALL_EXPRESSION,
  /* XS_TOKEN_CLASS */ XS_TOKEN_BEGIN_STATEMENT | XS_TOKEN_BEGIN_EXPRESSION | XS_TOKEN_IDENTIFIER_NAME,
  /* XS_TOKEN_COALESCE */ 0,
  /* XS_TOKEN_COALESCE_ASSIGN */ XS_TOKEN_ASSIGN_EXPRESSION,
  /* XS_TOKEN_COLON */ 0,
  /* XS_TOKEN_COMMA */ XS_TOKEN_END_STATEMENT,
  /* XS_TOKEN_CONST */ XS_TOKEN_BEGIN_STATEMENT | XS_TOKEN_IDENTIFIER_NAME,
  /* XS_TOKEN_CONTINUE */ XS_TOKEN_BEGIN_STATEMENT | XS_TOKEN_IDENTIFIER_NAME,
  /* XS_TOKEN_CURRENT */ 0,
  /* XS_TOKEN_DEBUGGER */ XS_TOKEN_BEGIN_STATEMENT | XS_TOKEN_IDENTIFIER_NAME,
  /* XS_TOKEN_DECREMENT */ XS_TOKEN_BEGIN_STATEMENT | XS_TOKEN_BEGIN_EXPRESSION | XS_TOKEN_PREFIX_EXPRESSION | XS_TOKEN_POSTFIX_EXPRESSION,
  /* XS_TOKEN_DEFAULT */ XS_TOKEN_IDENTIFIER_NAME,
  /* XS_TOKEN_DEFINE */ 0,
  /* XS_TOKEN_DELEGATE */ 0,
  /* XS_TOKEN_DELETE */ XS_TOKEN_BEGIN_STATEMENT | XS_TOKEN_BEGIN_EXPRESSION | XS_TOKEN_UNARY_EXPRESSION | XS_TOKEN_IDENTIFIER_NAME,
  /* XS_TOKEN_DIVIDE */ XS_TOKEN_BEGIN_EXPRESSION | XS_TOKEN_MULTIPLICATIVE_EXPRESSION,
  /* XS_TOKEN_DIVIDE_ASSIGN */ XS_TOKEN_BEGIN_EXPRESSION | XS_TOKEN_ASSIGN_EXPRESSION,
  /* XS_TOKEN_DO */ XS_TOKEN_BEGIN_STATEMENT | XS_TOKEN_IDENTIFIER_NAME,
  /* XS_TOKEN_DOT */ XS_TOKEN_CALL_EXPRESSION,
  /* XS_TOKEN_ELISION */ 0,
  /* XS_TOKEN_ELSE */ XS_TOKEN_IDENTIFIER_NAME,
  /* XS_TOKEN_ENUM */ XS_TOKEN_IDENTIFIER_NAME,
  /* XS_TOKEN_EOF */ XS_TOKEN_END_STATEMENT,
  /* XS_TOKEN_EQUAL */ XS_TOKEN_EQUAL_EXPRESSION,
  /* XS_TOKEN_EVAL */ 0,
  /* XS_TOKEN_EXPONENTIATION */ XS_TOKEN_EXPONENTIATION_EXPRESSION,
  /* XS_TOKEN_EXPONENTIATION_ASSIGN */ XS_TOKEN_ASSIGN_EXPRESSION,
  /* XS_TOKEN_EXPORT */ XS_TOKEN_IDENTIFIER_NAME,
  /* XS_TOKEN_EXPRESSIONS */ 0,
  /* XS_TOKEN_EXTENDS */ XS_TOKEN_IDENTIFIER_NAME,
  /* XS_TOKEN_FALSE */ XS_TOKEN_BEGIN_STATEMENT | XS_TOKEN_BEGIN_EXPRESSION | XS_TOKEN_IDENTIFIER_NAME,
  /* XS_TOKEN_FIELD */ 0,
  /* XS_TOKEN_FINALLY */ XS_TOKEN_IDENTIFIER_NAME | XS_TOKEN_IDENTIFIER_NAME,
  /* XS_TOKEN_FOR */ XS_TOKEN_BEGIN_STATEMENT | XS_TOKEN_IDENTIFIER_NAME,
  /* XS_TOKEN_FOR_AWAIT_OF */ 0,
  /* XS_TOKEN_FOR_IN */ 0,
  /* XS_TOKEN_FOR_OF */ 0,
  /* XS_TOKEN_FUNCTION */ XS_TOKEN_BEGIN_STATEMENT | XS_TOKEN_BEGIN_EXPRESSION | XS_TOKEN_IDENTIFIER_NAME,
  /* XS_TOKEN_GENERATOR */ 0,
  /* XS_TOKEN_GETTER */ 0,
  /* XS_TOKEN_HOST */ XS_TOKEN_BEGIN_EXPRESSION,
  /* XS_TOKEN_IDENTIFIER */ XS_TOKEN_BEGIN_STATEMENT | XS_TOKEN_BEGIN_EXPRESSION | XS_TOKEN_BEGIN_BINDING | XS_TOKEN_IDENTIFIER_NAME,
  /* XS_TOKEN_IF */ XS_TOKEN_BEGIN_STATEMENT | XS_TOKEN_IDENTIFIER_NAME,
  /* XS_TOKEN_IMPLEMENTS */ XS_TOKEN_IDENTIFIER_NAME,
  /* XS_TOKEN_IMPORT */ XS_TOKEN_BEGIN_EXPRESSION | XS_TOKEN_IDENTIFIER_NAME,
  /* XS_TOKEN_IMPORT_CALL */ 0,
  /* XS_TOKEN_IMPORT_META */ 0,
  /* XS_TOKEN_IN */ XS_TOKEN_RELATIONAL_EXPRESSION | XS_TOKEN_IDENTIFIER_NAME,
  /* XS_TOKEN_INCLUDE */ 0,
  /* XS_TOKEN_INCREMENT */ XS_TOKEN_BEGIN_STATEMENT | XS_TOKEN_BEGIN_EXPRESSION | XS_TOKEN_PREFIX_EXPRESSION | XS_TOKEN_POSTFIX_EXPRESSION,
  /* XS_TOKEN_INSTANCEOF */ XS_TOKEN_RELATIONAL_EXPRESSION | XS_TOKEN_IDENTIFIER_NAME,
  /* XS_TOKEN_INTEGER */ XS_TOKEN_BEGIN_STATEMENT | XS_TOKEN_BEGIN_EXPRESSION,
  /* XS_TOKEN_INTERFACE */ XS_TOKEN_IDENTIFIER_NAME,
  /* XS_TOKEN_ITEMS */ 0,
  /* XS_TOKEN_LABEL */ 0,
  /* XS_TOKEN_LEFT_BRACE */ XS_TOKEN_BEGIN_STATEMENT | XS_TOKEN_BEGIN_EXPRESSION | XS_TOKEN_BEGIN_BINDING,
  /* XS_TOKEN_LEFT_BRACKET */ XS_TOKEN_BEGIN_STATEMENT | XS_TOKEN_BEGIN_EXPRESSION | XS_TOKEN_BEGIN_BINDING | XS_TOKEN_CALL_EXPRESSION,
  /* XS_TOKEN_LEFT_PARENTHESIS */ XS_TOKEN_BEGIN_STATEMENT | XS_TOKEN_BEGIN_EXPRESSION | XS_TOKEN_CALL_EXPRESSION,
  /* XS_TOKEN_LEFT_SHIFT */ XS_TOKEN_SHIFT_EXPRESSION,
  /* XS_TOKEN_LEFT_SHIFT_ASSIGN */ XS_TOKEN_ASSIGN_EXPRESSION,
  /* XS_TOKEN_LESS */ XS_TOKEN_BEGIN_EXPRESSION | XS_TOKEN_RELATIONAL_EXPRESSION,
  /* XS_TOKEN_LESS_EQUAL */ XS_TOKEN_RELATIONAL_EXPRESSION,
  /* XS_TOKEN_LET */ XS_TOKEN_BEGIN_STATEMENT | XS_TOKEN_IDENTIFIER_NAME,
  /* XS_TOKEN_MEMBER */ 0,
  /* XS_TOKEN_MEMBER_AT */ 0,
  /* XS_TOKEN_MINUS */ 0,
  /* XS_TOKEN_MODULE */ 0,
  /* XS_TOKEN_MODULO */ XS_TOKEN_MULTIPLICATIVE_EXPRESSION,
  /* XS_TOKEN_MODULO_ASSIGN */ XS_TOKEN_ASSIGN_EXPRESSION,
  /* XS_TOKEN_MORE */ XS_TOKEN_RELATIONAL_EXPRESSION,
  /* XS_TOKEN_MORE_EQUAL */ XS_TOKEN_RELATIONAL_EXPRESSION,
  /* XS_TOKEN_MULTIPLY */ XS_TOKEN_MULTIPLICATIVE_EXPRESSION,
  /* XS_TOKEN_MULTIPLY_ASSIGN */ XS_TOKEN_ASSIGN_EXPRESSION,
  /* XS_TOKEN_NEW */ XS_TOKEN_BEGIN_STATEMENT | XS_TOKEN_BEGIN_EXPRESSION | XS_TOKEN_IDENTIFIER_NAME, 
  /* XS_TOKEN_NOT */ XS_TOKEN_BEGIN_STATEMENT | XS_TOKEN_BEGIN_EXPRESSION | XS_TOKEN_UNARY_EXPRESSION,
  /* XS_TOKEN_NOT_EQUAL */ XS_TOKEN_EQUAL_EXPRESSION,
  /* XS_TOKEN_NULL */ XS_TOKEN_BEGIN_STATEMENT | XS_TOKEN_BEGIN_EXPRESSION | XS_TOKEN_IDENTIFIER_NAME, 
  /* XS_TOKEN_NUMBER */ XS_TOKEN_BEGIN_STATEMENT | XS_TOKEN_BEGIN_EXPRESSION,
  /* XS_TOKEN_OBJECT */ 0,
  /* XS_TOKEN_OBJECT_BINDING */ 0,
  /* XS_TOKEN_OPTION */ 0,
  /* XS_TOKEN_OR */ 0,
  /* XS_TOKEN_OR_ASSIGN */ XS_TOKEN_ASSIGN_EXPRESSION,
  /* XS_TOKEN_PACKAGE */ XS_TOKEN_IDENTIFIER_NAME,
  /* XS_TOKEN_PARAMS */ 0,
  /* XS_TOKEN_PARAMS_BINDING */ 0,
  /* XS_TOKEN_PLUS */ 0,
  /* XS_TOKEN_PRIVATE */ XS_TOKEN_IDENTIFIER_NAME,
  /* XS_TOKEN_PRIVATE_IDENTIFIER */ XS_TOKEN_BEGIN_EXPRESSION,
  /* XS_TOKEN_PRIVATE_MEMBER */ 0,
  /* XS_TOKEN_PRIVATE_PROPERTY */ 0,
  /* XS_TOKEN_PROGRAM */ 0,
  /* XS_TOKEN_PROPERTY */ 0,
  /* XS_TOKEN_PROPERTY_AT */ 0,
  /* XS_TOKEN_PROPERTY_BINDING */ 0,
  /* XS_TOKEN_PROPERTY_BINDING_AT */ 0,
  /* XS_TOKEN_PROTECTED */ XS_TOKEN_IDENTIFIER_NAME,
  /* XS_TOKEN_PUBLIC */ XS_TOKEN_IDENTIFIER_NAME,
  /* XS_TOKEN_QUESTION_MARK */ 0,
  /* XS_TOKEN_REGEXP */ XS_TOKEN_BEGIN_STATEMENT | XS_TOKEN_BEGIN_EXPRESSION,
  /* XS_TOKEN_REST_BINDING */ 0,
  /* XS_TOKEN_RETURN */ XS_TOKEN_BEGIN_STATEMENT | XS_TOKEN_IDENTIFIER_NAME,
  /* XS_TOKEN_RIGHT_BRACE */ XS_TOKEN_END_STATEMENT,
  /* XS_TOKEN_RIGHT_BRACKET */ 0,
  /* XS_TOKEN_RIGHT_PARENTHESIS */ 0,
  /* XS_TOKEN_SEMICOLON */ XS_TOKEN_BEGIN_STATEMENT | XS_TOKEN_END_STATEMENT,
  /* XS_TOKEN_SETTER */ 0,
  /* XS_TOKEN_SHORT */ 0,
  /* XS_TOKEN_SIGNED_RIGHT_SHIFT */ XS_TOKEN_SHIFT_EXPRESSION,
  /* XS_TOKEN_SIGNED_RIGHT_SHIFT_ASSIGN */ XS_TOKEN_ASSIGN_EXPRESSION,
  /* XS_TOKEN_SKIP_BINDING */ 0,
  /* XS_TOKEN_SPECIFIER */ 0,
  /* XS_TOKEN_SPREAD */ XS_TOKEN_BEGIN_BINDING,
  /* XS_TOKEN_STATEMENT */ 0,
  /* XS_TOKEN_STATEMENTS */ 0,
  /* XS_TOKEN_STATIC */ XS_TOKEN_IDENTIFIER_NAME,
  /* XS_TOKEN_STRICT_EQUAL */ XS_TOKEN_EQUAL_EXPRESSION,
  /* XS_TOKEN_STRICT_NOT_EQUAL */ XS_TOKEN_EQUAL_EXPRESSION,
  /* XS_TOKEN_STRING */ XS_TOKEN_BEGIN_STATEMENT | XS_TOKEN_BEGIN_EXPRESSION,
  /* XS_TOKEN_SUBTRACT */ XS_TOKEN_BEGIN_STATEMENT | XS_TOKEN_BEGIN_EXPRESSION | XS_TOKEN_ADDITIVE_EXPRESSION | XS_TOKEN_UNARY_EXPRESSION,
  /* XS_TOKEN_SUBTRACT_ASSIGN */ XS_TOKEN_ASSIGN_EXPRESSION,
  /* XS_TOKEN_SUPER */ XS_TOKEN_BEGIN_STATEMENT | XS_TOKEN_BEGIN_EXPRESSION | XS_TOKEN_IDENTIFIER_NAME,
  /* XS_TOKEN_SWITCH */ XS_TOKEN_BEGIN_STATEMENT | XS_TOKEN_IDENTIFIER_NAME,
  /* XS_TOKEN_TARGET */ 0,
  /* XS_TOKEN_TEMPLATE */ XS_TOKEN_BEGIN_STATEMENT | XS_TOKEN_BEGIN_EXPRESSION | XS_TOKEN_CALL_EXPRESSION,
  /* XS_TOKEN_TEMPLATE_HEAD */ XS_TOKEN_BEGIN_STATEMENT | XS_TOKEN_BEGIN_EXPRESSION | XS_TOKEN_CALL_EXPRESSION,
  /* XS_TOKEN_TEMPLATE_MIDDLE */ 0,
  /* XS_TOKEN_TEMPLATE_TAIL */ 0,
  /* XS_TOKEN_THIS */ XS_TOKEN_BEGIN_STATEMENT | XS_TOKEN_BEGIN_EXPRESSION | XS_TOKEN_IDENTIFIER_NAME,
  /* XS_TOKEN_THROW */ XS_TOKEN_BEGIN_STATEMENT | XS_TOKEN_IDENTIFIER_NAME,
  /* XS_TOKEN_TRUE */ XS_TOKEN_BEGIN_STATEMENT | XS_TOKEN_BEGIN_EXPRESSION | XS_TOKEN_IDENTIFIER_NAME,
  /* XS_TOKEN_TRY */ XS_TOKEN_BEGIN_STATEMENT | XS_TOKEN_IDENTIFIER_NAME,
  /* XS_TOKEN_TYPEOF */ XS_TOKEN_BEGIN_STATEMENT | XS_TOKEN_BEGIN_EXPRESSION | XS_TOKEN_UNARY_EXPRESSION | XS_TOKEN_IDENTIFIER_NAME,
  /* XS_TOKEN_UNDEFINED */ 0,
  /* XS_TOKEN_UNSIGNED_RIGHT_SHIFT */ XS_TOKEN_SHIFT_EXPRESSION,
  /* XS_TOKEN_UNSIGNED_RIGHT_SHIFT_ASSIGN */ XS_TOKEN_ASSIGN_EXPRESSION,
  /* XS_TOKEN_USING */ XS_TOKEN_BEGIN_STATEMENT | XS_TOKEN_IDENTIFIER_NAME,
  /* XS_TOKEN_VAR */ XS_TOKEN_BEGIN_STATEMENT | XS_TOKEN_IDENTIFIER_NAME,
  /* XS_TOKEN_VOID */ XS_TOKEN_BEGIN_STATEMENT | XS_TOKEN_BEGIN_EXPRESSION | XS_TOKEN_UNARY_EXPRESSION | XS_TOKEN_IDENTIFIER_NAME,
  /* XS_TOKEN_WHILE */ XS_TOKEN_BEGIN_STATEMENT | XS_TOKEN_IDENTIFIER_NAME,
  /* XS_TOKEN_WITH */ XS_TOKEN_BEGIN_STATEMENT | XS_TOKEN_IDENTIFIER_NAME,
  /* XS_TOKEN_YIELD */ XS_TOKEN_BEGIN_STATEMENT | XS_TOKEN_BEGIN_EXPRESSION | XS_TOKEN_IDENTIFIER_NAME
};

static txString const gxTokenNames[XS_TOKEN_COUNT] ICACHE_FLASH_ATTR = {
  /* XS_NO_TOKEN */ "",
  /* XS_TOKEN_ACCESS */ "access",
  /* XS_TOKEN_ADD */ "+",
  /* XS_TOKEN_ADD_ASSIGN */ "+=",
  /* XS_TOKEN_AND */ "&&",
  /* XS_TOKEN_AND_ASSIGN */ "&&=",
  /* XS_TOKEN_ARG */ "arg",
  /* XS_TOKEN_ARGUMENTS */ "arguments",
  /* XS_TOKEN_ARGUMENTS_SLOPPY */ "arguments_sloppy",
  /* XS_TOKEN_ARGUMENTS_STRICT */ "arguments_strict",
  /* XS_TOKEN_ARRAY */ "array",
  /* XS_TOKEN_ARRAY_BINDING */ "array_binding",
  /* XS_TOKEN_ARROW */ "=>",
  /* XS_TOKEN_ASSIGN */ "=",
  /* XS_TOKEN_AWAIT */ "await",
  /* XS_TOKEN_BIGINT */ "bigint",
  /* XS_TOKEN_BINDING */ "binding",
  /* XS_TOKEN_BIT_AND */ "&",
  /* XS_TOKEN_BIT_AND_ASSIGN */ "&=",
  /* XS_TOKEN_BIT_NOT */ "~",
  /* XS_TOKEN_BIT_OR */ "|",
  /* XS_TOKEN_BIT_OR_ASSIGN */ "|=",
  /* XS_TOKEN_BIT_XOR */ "^",
  /* XS_TOKEN_BIT_XOR_ASSIGN */ "^=",
  /* XS_TOKEN_BLOCK */ "block",
  /* XS_TOKEN_BODY */ "body",
  /* XS_TOKEN_BREAK */ "break",
  /* XS_TOKEN_CALL */ "call",
  /* XS_TOKEN_CASE */ "case",
  /* XS_TOKEN_CATCH */ "catch",
  /* XS_TOKEN_CHAIN */ "?.",
  /* XS_TOKEN_CLASS */ "class",
  /* XS_TOKEN_COALESCE */ "??",
  /* XS_TOKEN_COALESCE_ASSIGN */ "\?\?=",
  /* XS_TOKEN_COLON */ ":",
  /* XS_TOKEN_COMMA */ ",",
  /* XS_TOKEN_CONST */ "const",
  /* XS_TOKEN_CONTINUE */ "continue",
  /* XS_TOKEN_CURRENT */ "current",
  /* XS_TOKEN_DEBUGGER */ "debugger",
  /* XS_TOKEN_DECREMENT */ "--",
  /* XS_TOKEN_DEFAULT */ "default",
  /* XS_TOKEN_DEFINE */ "define",
  /* XS_TOKEN_DELEGATE */ "delegate",
  /* XS_TOKEN_DELETE */ "delete",
  /* XS_TOKEN_DIVIDE */ "/",
  /* XS_TOKEN_DIVIDE_ASSIGN */ "/=",
  /* XS_TOKEN_DO */ "do",
  /* XS_TOKEN_DOT */ ".",
  /* XS_TOKEN_ELISION */ "elision",
  /* XS_TOKEN_ELSE */ "else",
  /* XS_TOKEN_ENUM */ "enum",
  /* XS_TOKEN_EOF */ "",
  /* XS_TOKEN_EQUAL */ "==",
  /* XS_TOKEN_EVAL */ "eval",
  /* XS_TOKEN_EXPONENTIATION */ "**",
  /* XS_TOKEN_EXPONENTIATION_ASSIGN */ "**=",
  /* XS_TOKEN_EXPORT */ "export",
  /* XS_TOKEN_EXPRESSIONS */ "expressions",
  /* XS_TOKEN_EXTENDS */ "extends",
  /* XS_TOKEN_FALSE */ "false",
  /* XS_TOKEN_FIELD */ "field",
  /* XS_TOKEN_FINALLY */ "finally",
  /* XS_TOKEN_FOR */ "for",
  /* XS_TOKEN_FOR_AWAIT_OF */ "for_await_of",
  /* XS_TOKEN_FOR_IN */ "for_in",
  /* XS_TOKEN_FOR_OF */ "for_of",
  /* XS_TOKEN_FUNCTION */ "function",
  /* XS_TOKEN_GENERATOR */ "generator",
  /* XS_TOKEN_GETTER */ "getter",
  /* XS_TOKEN_HOST */ "host", 
  /* XS_TOKEN_IDENTIFIER */ "identifier",
  /* XS_TOKEN_IF */ "if",
  /* XS_TOKEN_IMPLEMENTS */ "implements",
  /* XS_TOKEN_IMPORT */ "import",
  /* XS_TOKEN_IMPORT_CALL */ "import",
  /* XS_TOKEN_IMPORT_META */ "import.meta",
  /* XS_TOKEN_IN */ "in",
  /* XS_TOKEN_INCLUDE */ "include",
  /* XS_TOKEN_INCREMENT */ "++",
  /* XS_TOKEN_INSTANCEOF */ "instanceof",
  /* XS_TOKEN_INTEGER */ "integer",
  /* XS_TOKEN_INTERFACE */ "interface",
  /* XS_TOKEN_ITEMS */ "items",
  /* XS_TOKEN_LABEL */ "label",
  /* XS_TOKEN_LEFT_BRACE */ "{",
  /* XS_TOKEN_LEFT_BRACKET */ "[",
  /* XS_TOKEN_LEFT_PARENTHESIS */ "(",
  /* XS_TOKEN_LEFT_SHIFT */ "<<",
  /* XS_TOKEN_LEFT_SHIFT_ASSIGN */ "<<=",
  /* XS_TOKEN_LESS */ "<",
  /* XS_TOKEN_LESS_EQUAL */ "<=",
  /* XS_TOKEN_LET */ "let",
  /* XS_TOKEN_MEMBER */ "member",
  /* XS_TOKEN_MEMBER_AT */ "member_at",
  /* XS_TOKEN_MINUS */ "minus",
  /* XS_TOKEN_MODULE */ "module",
  /* XS_TOKEN_MODULO */ "%",
  /* XS_TOKEN_MODULO_ASSIGN */ "%=",
  /* XS_TOKEN_MORE */ ">",
  /* XS_TOKEN_MORE_EQUAL */ ">=",
  /* XS_TOKEN_MULTIPLY */ "*",
  /* XS_TOKEN_MULTIPLY_ASSIGN */ "*=",
  /* XS_TOKEN_NEW */ "new", 
  /* XS_TOKEN_NOT */ "!",
  /* XS_TOKEN_NOT_EQUAL */ "!=",
  /* XS_TOKEN_NULL */ "null", 
  /* XS_TOKEN_NUMBER */ "number",
  /* XS_TOKEN_OBJECT */ "object",
  /* XS_TOKEN_OBJECT_BINDING */ "object_binding",
  /* XS_TOKEN_OPTION */ "?.",
  /* XS_TOKEN_OR */ "||",
  /* XS_TOKEN_OR_ASSIGN */ "||=",
  /* XS_TOKEN_PACKAGE */ "package",
  /* XS_TOKEN_PARAMS */ "params",
  /* XS_TOKEN_PARAMS_BINDING */ "params_binding",
  /* XS_TOKEN_PLUS */ "plus",
  /* XS_TOKEN_PRIVATE */ "private",
  /* XS_TOKEN_PRIVATE_IDENTIFIER */ "private_identifier",
  /* XS_TOKEN_PRIVATE_MEMBER */ "private_member",
  /* XS_TOKEN_PRIVATE_PROPERTY */ "private_property",
  /* XS_TOKEN_PROGRAM */ "program",
  /* XS_TOKEN_PROPERTY */ "property",
  /* XS_TOKEN_PROPERTY_AT */ "property_at",
  /* XS_TOKEN_PROPERTY_BINDING */ "property_binding",
  /* XS_TOKEN_PROPERTY_BINDING_AT */ "property_binding_at",
  /* XS_TOKEN_PROTECTED */ "protected",
  /* XS_TOKEN_PUBLIC */ "public",
  /* XS_TOKEN_QUESTION_MARK */ "?",
  /* XS_TOKEN_REGEXP */ "regexp",
  /* XS_TOKEN_REST_BINDING */ "rest_binding",
  /* XS_TOKEN_RETURN */ "return",
  /* XS_TOKEN_RIGHT_BRACE */ "}",
  /* XS_TOKEN_RIGHT_BRACKET */ "]",
  /* XS_TOKEN_RIGHT_PARENTHESIS */ ")",
  /* XS_TOKEN_SEMICOLON */ ";",
  /* XS_TOKEN_SETTER */ "setter",
  /* XS_TOKEN_SHORT */ "short",
  /* XS_TOKEN_SIGNED_RIGHT_SHIFT */ ">>",
  /* XS_TOKEN_SIGNED_RIGHT_SHIFT_ASSIGN */ ">>=",
  /* XS_TOKEN_SKIP_BINDING */ "skip_binding",
  /* XS_TOKEN_SPECIFIER */ "specifier",
  /* XS_TOKEN_SPREAD */ "...",
  /* XS_TOKEN_STATEMENT */ "statement",
  /* XS_TOKEN_STATEMENTS */ "statements",
  /* XS_TOKEN_STATIC */ "static",
  /* XS_TOKEN_STRICT_EQUAL */ "===",
  /* XS_TOKEN_STRICT_NOT_EQUAL */ "!==",
  /* XS_TOKEN_STRING */ "string",
  /* XS_TOKEN_SUBTRACT */ "-",
  /* XS_TOKEN_SUBTRACT_ASSIGN */ "-=",
  /* XS_TOKEN_SUPER */ "super",
  /* XS_TOKEN_SWITCH */ "switch",
  /* XS_TOKEN_TARGET */ "target",
  /* XS_TOKEN_TEMPLATE */ "template",
  /* XS_TOKEN_TEMPLATE_HEAD */ "template_head",
  /* XS_TOKEN_TEMPLATE_MIDDLE */ "template_middle",
  /* XS_TOKEN_TEMPLATE_TAIL */ "template_tail",
  /* XS_TOKEN_THIS */ "this",
  /* XS_TOKEN_THROW */ "throw",
  /* XS_TOKEN_TRUE */ "true",
  /* XS_TOKEN_TRY */ "try",
  /* XS_TOKEN_TYPEOF */ "typeof",
  /* XS_TOKEN_UNDEFINED */ "undefined",
  /* XS_TOKEN_UNSIGNED_RIGHT_SHIFT */ ">>>",
  /* XS_TOKEN_UNSIGNED_RIGHT_SHIFT_ASSIGN */ ">>>=",
  /* XS_TOKEN_USIGN */ "using",
  /* XS_TOKEN_VAR */ "var",
  /* XS_TOKEN_VOID */ "void",
  /* XS_TOKEN_WHILE */ "while",
  /* XS_TOKEN_WITH */ "with",
  /* XS_TOKEN_YIELD */ "yield",
};

txBoolean fxIsKeyword(txParser* parser, txSymbol* keyword)
{
  txBoolean result = ((parser->states[0].token == XS_TOKEN_IDENTIFIER) && (parser->states[0].symbol == keyword)) ? 1 : 0;
  if (result) {
    if (parser->states[0].escaped)
      fxReportParserError(parser, parser->states[0].line, "escaped keyword");
  }
  return result;
}

txBoolean fxIsToken(txParser* parser, txToken theToken)
{
  txBoolean result = (parser->states[0].token == theToken) ? 1 : 0;
  if (result) {
    if (parser->states[0].escaped)
      fxReportParserError(parser, parser->states[0].line, "escaped keyword");
  }
  return result;
}

void fxMatchToken(txParser* parser, txToken theToken)
{
  if (parser->states[0].token == theToken) {
    if (parser->states[0].escaped)
      fxReportParserError(parser, parser->states[0].line, "escaped keyword");
    fxGetNextToken(parser);
  }
  else
    fxReportParserError(parser, parser->states[0].line, "missing %s", gxTokenNames[theToken]);
}

txNode* fxPopNode(txParser* parser)
{
  txNode* node = parser->root;
  parser->root = node->next;
  node->next = NULL;
  parser->nodeCount--;
  return node;
}

void fxPushNode(txParser* parser, txNode* node)
{
  node->next = parser->root;
  parser->root = (txNode*)node;
  parser->nodeCount++;
}

void fxPushBigIntNode(txParser* parser, txBigInt* value, txInteger line)
{
  txBigIntNode* node = fxNewParserChunk(parser, sizeof(txBigIntNode));
  node->description = &gxTokenDescriptions[XS_TOKEN_BIGINT];
  node->path = parser->path;
  node->line = line;
  node->flags = 0;
  node->value = *value;
  fxPushNode(parser, (txNode*)node);
}

void fxPushIndexNode(txParser* parser, txIndex value, txInteger line)
{
  if (((txInteger)value) >= 0)
    fxPushIntegerNode(parser, (txInteger)value, line);
  else
    fxPushNumberNode(parser, value, line);
}

void fxPushIntegerNode(txParser* parser, txInteger value, txInteger line)
{
  txIntegerNode* node = fxNewParserChunk(parser, sizeof(txIntegerNode));
  node->description = &gxTokenDescriptions[XS_TOKEN_INTEGER];
  node->path = parser->path;
  node->line = line;
  node->flags = 0;
  node->value = value;
  fxPushNode(parser, (txNode*)node);
}

void fxPushNodeStruct(txParser* parser, txInteger count, txToken token, txInteger line)
{
  const txNodeDescription* description = &gxTokenDescriptions[token];
  txNode* node;
  if ((count > parser->nodeCount) || ((sizeof(txNode) + (count * sizeof(txNode*))) > (size_t)(description->size))) {
    fxReportParserError(parser, parser->states[0].line, "invalid %s", gxTokenNames[token]);
  }
    node = fxNewParserChunkClear(parser, description->size);
  node->description = description;
  node->flags |= parser->flags & (mxStrictFlag | mxGeneratorFlag | mxAsyncFlag);
  node->path = parser->path;
  node->line = line;
    parser->nodeCount -= count;
  if (count) {
    txNode** dst = (txNode**)&node[1];
    txNode* src = parser->root;
    while (count) {
      txNode* next = src->next;
      src->next = NULL;
      count--;
      if (src->description)
        dst[count] = src;
      else if (src->path)
        dst[count] = (txNode*)(src->path);
      src = next;
    }
    parser->root = src;
  }
  fxPushNode(parser, node);
}

void fxPushNodeList(txParser* parser, txInteger count)
{
  txNodeList* list = fxNewParserChunk(parser, sizeof(txNodeList));
  txNode* previous = NULL;
  txNode* current = parser->root;
  txNode* next;
    parser->nodeCount -= count;
  list->length = count;
  while (count) {
    next = current->next;
    current->next = previous;
    previous = current;
    current = next;
    count--;
  }
  parser->root = current;
  list->description = &gxTokenDescriptions[XS_NO_TOKEN];
  list->first = previous;
  fxPushNode(parser, (txNode*)list);
}

void fxPushNULL(txParser* parser)
{
    txNodeLink* node = fxNewParserChunkClear(parser, sizeof(txNodeLink));
  fxPushNode(parser, (txNode*)node);
}

void fxPushNumberNode(txParser* parser, txNumber value, txInteger line)
{
  txNumberNode* node = fxNewParserChunk(parser, sizeof(txNumberNode));
  node->description = &gxTokenDescriptions[XS_TOKEN_NUMBER];
  node->path = parser->path;
  node->line = line;
  node->flags = 0;
  node->value = value;
  fxPushNode(parser, (txNode*)node);
}

void fxPushRawNode(txParser* parser, txInteger length, txString value, txInteger line)
{
  txStringNode* node = fxNewParserChunk(parser, sizeof(txStringNode));
  node->description = &gxTokenDescriptions[XS_TOKEN_STRING];
  node->path = parser->path;
  node->line = line;
  node->flags = 0;
  node->length = length;
  node->value = value;
  fxPushNode(parser, (txNode*)node);
}

void fxPushStringNode(txParser* parser, txInteger length, txString value, txInteger line)
{
  txStringNode* node = fxNewParserChunk(parser, sizeof(txStringNode));
  node->description = &gxTokenDescriptions[XS_TOKEN_STRING];
  node->path = parser->path;
  node->line = line;
  node->flags = parser->states[0].escaped;
  node->length = length;
  node->value = value;
  fxPushNode(parser, (txNode*)node);
}

void fxPushSymbol(txParser* parser, txSymbol* symbol)
{
    txNodeLink* node = fxNewParserChunkClear(parser, sizeof(txNodeLink));
  node->symbol = symbol;  
  fxPushNode(parser, (txNode*)node);
}

void fxSwapNodes(txParser* parser)
{
  txNode* previous = parser->root;
  txNode* current = previous->next;
  previous->next = current->next;
  current->next = previous;
  parser->root = current;
}

void fxModule(txParser* parser)
{
  txInteger aCount = parser->nodeCount;
  txInteger aLine = parser->states[0].line;
  while ((parser->states[0].token != XS_TOKEN_EOF)) {
    if (parser->states[0].token == XS_TOKEN_EXPORT)
      fxExportDeclaration(parser);
    else if (parser->states[0].token == XS_TOKEN_IMPORT) {
      fxLookAheadOnce(parser);
      if ((parser->states[1].token == XS_TOKEN_DOT) || (parser->states[1].token == XS_TOKEN_LEFT_PARENTHESIS))
        fxStatement(parser, 1);
      else
        fxImportDeclaration(parser);
    }
    else if (parser->states[0].token == XS_TOKEN_RETURN) {
      fxReportParserError(parser, parser->states[0].line, "invalid return");
      fxGetNextToken(parser);
    }
    else if (parser->states[0].token == XS_TOKEN_YIELD) {
      fxReportParserError(parser, parser->states[0].line, "invalid yield");
      fxGetNextToken(parser);
    }
    else {
      fxStatement(parser, 1);
    }
  }
  aCount = parser->nodeCount - aCount;
  if (aCount > 1) {
    fxPushNodeList(parser, aCount);
    fxPushNodeStruct(parser, 1, XS_TOKEN_STATEMENTS, aLine);
  }
  else if (aCount == 0) {
    fxPushNodeStruct(parser, 0, XS_TOKEN_UNDEFINED, aLine);
    fxPushNodeStruct(parser, 1, XS_TOKEN_STATEMENT, aLine);
  }
  fxPushNodeStruct(parser, 1, XS_TOKEN_MODULE, aLine);
  parser->root->flags = parser->flags & (mxStrictFlag | mxAwaitingFlag);
}

void fxExportDeclaration(txParser* parser)
{
  txSymbol* symbol = C_NULL;
  txInteger count;
  txInteger line = parser->states[0].line;
  txUnsigned flag = 0;
  txToken aToken;
  fxMatchToken(parser, XS_TOKEN_EXPORT);
  switch (parser->states[0].token) {
  case XS_TOKEN_MULTIPLY:
    fxPushNULL(parser);
    fxGetNextToken(parser);
    if (fxIsKeyword(parser, parser->asSymbol)) {
      fxGetNextToken(parser);
      if (gxTokenFlags[parser->states[0].token] & XS_TOKEN_IDENTIFIER_NAME) {
        fxPushSymbol(parser, parser->states[0].symbol);
        fxGetNextToken(parser);
      }
      else {
        fxPushNULL(parser);
        fxReportParserError(parser, parser->states[0].line, "missing identifier");
      }
    }
    else {
      fxPushNULL(parser);
    }
    if (fxIsKeyword(parser, parser->fromSymbol)) {
      fxGetNextToken(parser);
      if (parser->states[0].token == XS_TOKEN_STRING) {
        fxPushNodeStruct(parser, 2, XS_TOKEN_SPECIFIER, line);
        fxPushNodeList(parser, 1);
        fxPushStringNode(parser, parser->states[0].stringLength, parser->states[0].string, line);
        fxGetNextToken(parser);
        if (!parser->states[0].crlf && (parser->states[0].token == XS_TOKEN_WITH)) {
          fxGetNextToken(parser);
          fxWithAttributes(parser);
        }
        else
          fxPushNULL(parser);
        fxPushNodeStruct(parser, 3, XS_TOKEN_EXPORT, line);
        fxSemicolon(parser);
      }
      else
        fxReportParserError(parser, parser->states[0].line, "missing module");
    }
    else
      fxReportParserError(parser, parser->states[0].line, "missing from");
    break;
  case XS_TOKEN_DEFAULT:
    fxMatchToken(parser, XS_TOKEN_DEFAULT);
    if (parser->flags & mxDefaultFlag)
      fxReportParserError(parser, parser->states[0].line, "invalid default");
    parser->flags |= mxDefaultFlag;
    if (parser->states[0].token == XS_TOKEN_CLASS) {
      fxClassExpression(parser, line, &symbol);
      if (symbol)
        fxPushSymbol(parser, symbol);
      else
        fxPushSymbol(parser, parser->defaultSymbol);
      fxPushNodeStruct(parser, 1, XS_TOKEN_LET, line);
      fxSwapNodes(parser);
      fxPushNodeStruct(parser, 2, XS_TOKEN_BINDING, line);
    }
    else if (parser->states[0].token == XS_TOKEN_FUNCTION) {
  again:
      fxMatchToken(parser, XS_TOKEN_FUNCTION);
      if (parser->states[0].token == XS_TOKEN_MULTIPLY) {
        fxGetNextToken(parser);
        fxGeneratorExpression(parser, line, &symbol, flag);
      }
      else
        fxFunctionExpression(parser, line, &symbol, flag);
      if (symbol) {
        txDefineNode* node = fxDefineNodeNew(parser, XS_TOKEN_DEFINE, symbol);
        node->initializer = fxPopNode(parser);
        fxPushNode(parser, (txNode*)node);
      }
      else {
        txDefineNode* node = fxDefineNodeNew(parser, XS_TOKEN_DEFINE, parser->defaultSymbol);
        node->initializer = fxPopNode(parser);
        fxPushNode(parser, (txNode*)node);
      }
    }
    else {
      if ((parser->states[0].token == XS_TOKEN_IDENTIFIER) && (parser->states[0].symbol == parser->asyncSymbol) && (!parser->states[0].escaped)) {
        fxLookAheadOnce(parser);
        if ((!parser->states[1].crlf) && (parser->states[1].token == XS_TOKEN_FUNCTION)) {
          fxGetNextToken(parser);
          flag = mxAsyncFlag;
          goto again;         
        }
      }
      fxAssignmentExpression(parser);
      fxSemicolon(parser);
      fxPushSymbol(parser, parser->defaultSymbol);
      fxPushNULL(parser);
      fxPushNodeStruct(parser, 2, XS_TOKEN_CONST, line);
      fxSwapNodes(parser);
      fxPushNodeStruct(parser, 2, XS_TOKEN_ASSIGN, line);
      fxPushNodeStruct(parser, 1, XS_TOKEN_STATEMENT, line);
    }
    if (symbol) {
      fxPushSymbol(parser, symbol);
      fxPushSymbol(parser, parser->defaultSymbol);
    }
    else {
      fxPushSymbol(parser, parser->defaultSymbol);
      fxPushNULL(parser);
    }
    fxPushNodeStruct(parser, 2, XS_TOKEN_SPECIFIER, line);
    fxPushNodeList(parser, 1);
    fxPushNULL(parser);
    fxPushNULL(parser);
    fxPushNodeStruct(parser, 3, XS_TOKEN_EXPORT, line);
    break;
  case XS_TOKEN_CLASS:
    fxClassExpression(parser, line, &symbol);
    if (symbol) {
      fxPushSymbol(parser, symbol);
      fxPushNodeStruct(parser, 1, XS_TOKEN_LET, line);
      fxSwapNodes(parser);
      fxPushNodeStruct(parser, 2, XS_TOKEN_BINDING, line);
      
      fxPushSymbol(parser, symbol);
      fxPushNULL(parser);
      fxPushNodeStruct(parser, 2, XS_TOKEN_SPECIFIER, line);
      fxPushNodeList(parser, 1);
      fxPushNULL(parser);
      fxPushNULL(parser);
      fxPushNodeStruct(parser, 3, XS_TOKEN_EXPORT, line);
    }
    else
      fxReportParserError(parser, parser->states[0].line, "missing identifier");
    break;
  case XS_TOKEN_FUNCTION:
  again2:
    fxMatchToken(parser, XS_TOKEN_FUNCTION);
    if (parser->states[0].token == XS_TOKEN_MULTIPLY) {
      fxGetNextToken(parser);
      fxGeneratorExpression(parser, line, &symbol, flag);
    }
    else
      fxFunctionExpression(parser, line, &symbol, flag);
    if (symbol) {
      txDefineNode* node = fxDefineNodeNew(parser, XS_TOKEN_DEFINE, symbol);
      node->initializer = fxPopNode(parser);
      fxPushNode(parser, (txNode*)node);
      fxPushSymbol(parser, symbol);
      fxPushNULL(parser);
      fxPushNodeStruct(parser, 2, XS_TOKEN_SPECIFIER, line);
      fxPushNodeList(parser, 1);
      fxPushNULL(parser);
      fxPushNULL(parser);
      fxPushNodeStruct(parser, 3, XS_TOKEN_EXPORT, line);
    }
    else
      fxReportParserError(parser, parser->states[0].line, "missing identifier");
    break;
  case XS_TOKEN_CONST:
  case XS_TOKEN_LET:
  case XS_TOKEN_VAR:
    aToken = parser->states[0].token;
    fxVariableStatement(parser, aToken, 0);
    count = parser->nodeCount;
    fxExportBinding(parser, parser->root);
    fxPushNodeList(parser, parser->nodeCount - count);
    fxPushNULL(parser);
    fxPushNULL(parser);
    fxPushNodeStruct(parser, 3, XS_TOKEN_EXPORT, line);
    fxSemicolon(parser);
    break;
  case XS_TOKEN_LEFT_BRACE:
    count = parser->nodeCount;
    fxSpecifiers(parser);
    fxPushNodeList(parser, parser->nodeCount - count);
    if (fxIsKeyword(parser, parser->fromSymbol)) {
      fxGetNextToken(parser);
      if (parser->states[0].token == XS_TOKEN_STRING) {
        fxPushStringNode(parser, parser->states[0].stringLength, parser->states[0].string, line);
        fxGetNextToken(parser);
      }
      else {
        fxPushNULL(parser);
        fxReportParserError(parser, parser->states[0].line, "missing module");
      }
      if (!parser->states[0].crlf && (parser->states[0].token == XS_TOKEN_WITH)) {
        fxGetNextToken(parser);
        fxWithAttributes(parser);
      }
      else
        fxPushNULL(parser);
    }
    else {
      fxPushNULL(parser);
      fxPushNULL(parser);
    }
    fxPushNodeStruct(parser, 3, XS_TOKEN_EXPORT, line);
    fxSemicolon(parser);
    break;
  default:
    if ((parser->states[0].token == XS_TOKEN_IDENTIFIER) && (parser->states[0].symbol == parser->asyncSymbol) && (!parser->states[0].escaped)) {
      fxLookAheadOnce(parser);
      if ((!parser->states[1].crlf) && (parser->states[1].token == XS_TOKEN_FUNCTION)) {
        fxGetNextToken(parser);
        flag = mxAsyncFlag;
        goto again2;          
      }
    }
    fxReportParserError(parser, parser->states[0].line, "invalid export %s", gxTokenNames[parser->states[0].token]);
    fxGetNextToken(parser);
    break;
  }
}

void fxExportBinding(txParser* parser, txNode* node)
{
  txToken token = node->description->token;
  if ((token == XS_TOKEN_CONST) || (token == XS_TOKEN_LET) || (token == XS_TOKEN_VAR)) {
    fxPushSymbol(parser, ((txDeclareNode*)node)->symbol);
    fxPushNULL(parser);
    fxPushNodeStruct(parser, 2, XS_TOKEN_SPECIFIER, node->line);
  }
  else if (token == XS_TOKEN_BINDING) {
    fxExportBinding(parser, ((txBindingNode*)node)->target);
  }
  else if (token == XS_TOKEN_ARRAY_BINDING) {
    node = ((txArrayBindingNode*)node)->items->first;
    while (node) {
      fxExportBinding(parser, node);
      node = node->next;
    }
  }
  else if (token == XS_TOKEN_OBJECT_BINDING) {
    node = ((txObjectBindingNode*)node)->items->first;
    while (node) {
      fxExportBinding(parser, node);
      node = node->next;
    }
  }
  else if (token == XS_TOKEN_PROPERTY_BINDING)
    fxExportBinding(parser, ((txPropertyBindingNode*)node)->binding);
  else if (token == XS_TOKEN_PROPERTY_BINDING_AT)
    fxExportBinding(parser, ((txPropertyBindingAtNode*)node)->binding);
  else if (token == XS_TOKEN_REST_BINDING)
    fxExportBinding(parser, ((txRestBindingNode*)node)->binding);
  else if (token == XS_TOKEN_STATEMENTS) {
    node = ((txStatementsNode*)node)->items->first;
    while (node) {
      fxExportBinding(parser, node);
      node = node->next;
    }
  }
}


void fxImportDeclaration(txParser* parser)
{
  txBoolean asFlag = 1;
  txBoolean fromFlag = 0;
  txInteger count = parser->nodeCount;
  fxMatchToken(parser, XS_TOKEN_IMPORT);
  if (parser->states[0].token == XS_TOKEN_IDENTIFIER) {
    fxPushSymbol(parser, parser->defaultSymbol);
    fxPushSymbol(parser, parser->states[0].symbol);
    fxPushNodeStruct(parser, 2, XS_TOKEN_SPECIFIER, parser->states[0].line);
    fxGetNextToken(parser);
    if (parser->states[0].token == XS_TOKEN_COMMA)
      fxGetNextToken(parser);
    else
      asFlag = 0;
    fromFlag = 1;
  }
  if (asFlag) {
    if (parser->states[0].token == XS_TOKEN_MULTIPLY) {
      fxGetNextToken(parser);
      if (fxIsKeyword(parser, parser->asSymbol)) {
        fxGetNextToken(parser);
        if (parser->states[0].token == XS_TOKEN_IDENTIFIER) {
          fxPushNULL(parser);
          fxPushSymbol(parser, parser->states[0].symbol);
          fxPushNodeStruct(parser, 2, XS_TOKEN_SPECIFIER, parser->states[0].line);
          fxGetNextToken(parser);
        }
        else {
          fxReportParserError(parser, parser->states[0].line, "missing identifier");
        }
      }
      else {
        fxReportParserError(parser, parser->states[0].line, "missing as");
      }
      fromFlag = 1;
    }
    else if (parser->states[0].token == XS_TOKEN_LEFT_BRACE) {
      fxSpecifiers(parser);
      fromFlag = 1;
    }
  }
  fxPushNodeList(parser, parser->nodeCount - count);
  if (fromFlag) {
    if (fxIsKeyword(parser, parser->fromSymbol)) {
      fxGetNextToken(parser);
      if (parser->states[0].token == XS_TOKEN_STRING) {
        fxPushStringNode(parser, parser->states[0].stringLength, parser->states[0].string, parser->states[0].line);
        fxGetNextToken(parser);
      }
      else {
        fxPushNULL(parser);
        fxReportParserError(parser, parser->states[0].line, "missing module");
      }
    }
    else {
      fxPushNULL(parser);
      fxReportParserError(parser, parser->states[0].line, "missing from");
    }
  }
  else if (parser->states[0].token == XS_TOKEN_STRING) {
    fxPushStringNode(parser, parser->states[0].stringLength, parser->states[0].string, parser->states[0].line);
    fxGetNextToken(parser);
  }
  else {
    fxPushNULL(parser);
    fxReportParserError(parser, parser->states[0].line, "missing module");
  }
  if (!parser->states[0].crlf && (parser->states[0].token == XS_TOKEN_WITH)) {
    fxGetNextToken(parser);
    fxWithAttributes(parser);
  }
  else
    fxPushNULL(parser);
  fxPushNodeStruct(parser, 3, XS_TOKEN_IMPORT, parser->states[0].line);
  fxSemicolon(parser);
}

void fxSpecifiers(txParser* parser)
{
//  txInteger aCount = 0;
  fxMatchToken(parser, XS_TOKEN_LEFT_BRACE);
  while (gxTokenFlags[parser->states[0].token] & XS_TOKEN_IDENTIFIER_NAME) {
    fxPushSymbol(parser, parser->states[0].symbol);
    fxGetNextToken(parser);
    if (fxIsKeyword(parser, parser->asSymbol)) {
      fxGetNextToken(parser);
      if (gxTokenFlags[parser->states[0].token] & XS_TOKEN_IDENTIFIER_NAME) {
        fxPushSymbol(parser, parser->states[0].symbol);
        fxGetNextToken(parser);
      }
      else {
        fxPushNULL(parser);
        fxReportParserError(parser, parser->states[0].line, "missing identifier");
      }
    }
    else
      fxPushNULL(parser);
    fxPushNodeStruct(parser, 2, XS_TOKEN_SPECIFIER, parser->states[0].line);
//    aCount++;
    if (parser->states[0].token != XS_TOKEN_COMMA) 
      break;
    fxGetNextToken(parser);
  }
  fxMatchToken(parser, XS_TOKEN_RIGHT_BRACE);
}

void fxWithAttributes(txParser* parser)
{
  txBoolean flag = 0;
  txString string;
  fxMatchToken(parser, XS_TOKEN_LEFT_BRACE);
  while (parser->states[0].token != XS_TOKEN_RIGHT_BRACE) {
    if ((gxTokenFlags[parser->states[0].token] & XS_TOKEN_IDENTIFIER_NAME))
      string = parser->states[0].symbol->string;
    else if (parser->states[0].token == XS_TOKEN_STRING)
      string = parser->states[0].string;
    else {
      fxReportParserError(parser, parser->states[0].line, "missing attribute key");
      break;
    }
    if (c_strcmp(string, "type"))
      fxReportParserError(parser, parser->states[0].line, "invalid attribute key");
    else if (flag)
      fxReportParserError(parser, parser->states[0].line, "duplicate attribute");
    fxGetNextToken(parser);
    if (parser->states[0].token != XS_TOKEN_COLON) {
      fxReportParserError(parser, parser->states[0].line, "missing :");
      break;
    }
        fxGetNextToken(parser);
    if (parser->states[0].token == XS_TOKEN_STRING)
      string = parser->states[0].string;
    else {
      fxReportParserError(parser, parser->states[0].line, "missing attribute value");
      break;
    }
    if (c_strcmp(string, "json"))
      fxReportParserError(parser, parser->states[0].line, "invalid attribute value");
    flag = 1;
    fxGetNextToken(parser);
    if (parser->states[0].token != XS_TOKEN_COMMA)
      break;
    fxGetNextToken(parser);
  }
  fxMatchToken(parser, XS_TOKEN_RIGHT_BRACE);
  if (flag)
    fxPushSymbol(parser, parser->jsonSymbol);
  else
    fxPushNULL(parser);
}

void fxProgram(txParser* parser)
{
  txInteger count = parser->nodeCount;
  txInteger line = parser->states[0].line;
  txNode* node;
  while (parser->states[0].token != XS_TOKEN_EOF) {
    fxStatement(parser, -1);
    node = parser->root;
    if (!node || !node->description || (node->description->token != XS_TOKEN_STATEMENT))
      break;
    node = ((txStatementNode*)node)->expression;
    if (!node || !node->description || (node->description->token != XS_TOKEN_STRING))
      break;
    if (!(node->flags & mxStringEscapeFlag) && (c_strcmp(((txStringNode*)node)->value, "use strict") == 0)) {
      if (!(parser->flags & mxStrictFlag)) {
        parser->flags |= mxStrictFlag;
        if (parser->states[0].token == XS_TOKEN_IDENTIFIER)
          fxCheckStrictKeyword(parser);
      }
    }
  }
  while (parser->states[0].token != XS_TOKEN_EOF) {
    fxStatement(parser, -1);
  }
  count = parser->nodeCount - count;
  if (count > 1) {
    fxPushNodeList(parser, count);
    fxPushNodeStruct(parser, 1, XS_TOKEN_STATEMENTS, line);
  }
  else if (count == 0) {
    fxPushNodeStruct(parser, 0, XS_TOKEN_UNDEFINED, line);
    fxPushNodeStruct(parser, 1, XS_TOKEN_STATEMENT, line);
  }
  fxPushNodeStruct(parser, 1, XS_TOKEN_PROGRAM, line);
  if (parser->flags & mxFieldFlag)
    if (parser->flags & mxArgumentsFlag)
      fxReportParserError(parser, parser->states[0].line, "invalid arguments");
  parser->root->flags = parser->flags & mxStrictFlag;
}

void fxBody(txParser* parser)
{
  txInteger count = parser->nodeCount;
  txInteger line = parser->states[0].line;
  txNode* node;
    fxCheckParserStack(parser, line);
  while ((parser->states[0].token != XS_TOKEN_EOF) && (parser->states[0].token != XS_TOKEN_RIGHT_BRACE)) {
    fxStatement(parser, 1);
    node = parser->root;
    if (!node || !node->description || (node->description->token != XS_TOKEN_STATEMENT))
      break;
    node = ((txStatementNode*)node)->expression;
    if (!node || !node->description || (node->description->token != XS_TOKEN_STRING))
      break;
    if (!(node->flags & mxStringEscapeFlag) && (c_strcmp(((txStringNode*)node)->value, "use strict") == 0)) {
      if (parser->flags & mxNotSimpleParametersFlag)
        fxReportParserError(parser, parser->states[0].line, "invalid directive");
      if (!(parser->flags & mxStrictFlag)) {
        parser->flags |= mxStrictFlag;
        if (parser->states[0].token == XS_TOKEN_IDENTIFIER)
          fxCheckStrictKeyword(parser);
      }
    }
  }
  while ((parser->states[0].token != XS_TOKEN_EOF) && (parser->states[0].token != XS_TOKEN_RIGHT_BRACE)) {
    fxStatement(parser, 1);
  }
  count = parser->nodeCount - count;
  if (count > 1) {
    fxPushNodeList(parser, count);
    fxPushNodeStruct(parser, 1, XS_TOKEN_STATEMENTS, line);
  }
  else if (count == 0) {
    fxPushNodeStruct(parser, 0, XS_TOKEN_UNDEFINED, line);
    fxPushNodeStruct(parser, 1, XS_TOKEN_STATEMENT, line);
  }
}

void fxBlock(txParser* parser)
{
  txInteger aLine = parser->states[0].line;
  fxCheckParserStack(parser, aLine);
  fxMatchToken(parser, XS_TOKEN_LEFT_BRACE);
  fxStatements(parser);
  fxMatchToken(parser, XS_TOKEN_RIGHT_BRACE);
  fxPushNodeStruct(parser, 1, XS_TOKEN_BLOCK, aLine);
}

void fxStatements(txParser* parser)
{
  txInteger count = parser->nodeCount;
  txInteger line = parser->states[0].line;
  while ((parser->states[0].token != XS_TOKEN_EOF) && (parser->states[0].token != XS_TOKEN_RIGHT_BRACE)) {
    fxStatement(parser, 1);
  }
  count = parser->nodeCount - count;
  fxPushNodeList(parser, count);
  fxPushNodeStruct(parser, 1, XS_TOKEN_STATEMENTS, line);
}

void fxStatement(txParser* parser, txInteger blockIt)
{
  txInteger line = parser->states[0].line;
  txSymbol* symbol = C_NULL;
  txUnsigned flag = 0;
  switch (parser->states[0].token) {
//  case XS_TOKEN_COMMA:
  case XS_TOKEN_SEMICOLON:
    fxGetNextToken(parser);
    if (!blockIt) {
      fxPushNodeStruct(parser, 0, XS_TOKEN_UNDEFINED, line);
      fxPushNodeStruct(parser, 1, XS_TOKEN_STATEMENT, line);
    }
    break;
  case XS_TOKEN_BREAK:
    fxBreakStatement(parser);
    fxSemicolon(parser);
    break;
  case XS_TOKEN_CLASS:
    if (!blockIt)
      fxReportParserError(parser, parser->states[0].line, "no block");
    fxClassExpression(parser, line, &symbol);
    if (symbol) {
      fxPushSymbol(parser, symbol);
      fxPushNodeStruct(parser, 1, XS_TOKEN_LET, line);
      fxSwapNodes(parser);
      fxPushNodeStruct(parser, 2, XS_TOKEN_BINDING, line);
    }
    else
      fxReportParserError(parser, parser->states[0].line, "missing identifier");
    break;
  case XS_TOKEN_CONST:
    if (!blockIt)
      fxReportParserError(parser, parser->states[0].line, "no block");
    fxVariableStatement(parser, XS_TOKEN_CONST, 0);
    fxSemicolon(parser);
    break;
  case XS_TOKEN_CONTINUE:
    fxContinueStatement(parser);
    fxSemicolon(parser);
    break;
  case XS_TOKEN_DEBUGGER:
    fxDebuggerStatement(parser);
    fxSemicolon(parser);
    break;
  case XS_TOKEN_DO:
    fxDoStatement(parser);
    break;
  case XS_TOKEN_FOR:
    fxForStatement(parser);
    break;
  case XS_TOKEN_FUNCTION:
    //if ((parser->flags & mxStrictFlag) && !blockIt) BROWSER
  again:
    if (!blockIt)
      fxReportParserError(parser, parser->states[0].line, "no block (strict code)");
    fxMatchToken(parser, XS_TOKEN_FUNCTION);
    if (parser->states[0].token == XS_TOKEN_MULTIPLY) {
      fxGetNextToken(parser);
      fxGeneratorExpression(parser, line, &symbol, flag);
    }
    else
      fxFunctionExpression(parser, line, &symbol, flag);
    if (symbol) {
      txDefineNode* node = fxDefineNodeNew(parser, XS_TOKEN_DEFINE, symbol);
      node->initializer = fxPopNode(parser);
      fxPushNode(parser, (txNode*)node);
    }
    else
      fxReportParserError(parser, parser->states[0].line, "missing identifier");
    break;
  case XS_TOKEN_IF:
    fxIfStatement(parser);
    break;
  case XS_TOKEN_RETURN:
    if (!(parser->flags & (mxArrowFlag | mxFunctionFlag | mxGeneratorFlag)))
      fxReportParserError(parser, parser->states[0].line, "invalid return");
    fxReturnStatement(parser);
    fxSemicolon(parser);
    break;
  case XS_TOKEN_LEFT_BRACE:
    fxBlock(parser);
    break;
  case XS_TOKEN_LET:
    if (!blockIt)
      fxReportParserError(parser, parser->states[0].line, "no block");
    fxVariableStatement(parser, XS_TOKEN_LET, 0);
    fxSemicolon(parser);
    break;
  case XS_TOKEN_SWITCH:
    fxSwitchStatement(parser);
    break;
  case XS_TOKEN_THROW:
    fxThrowStatement(parser);
    fxSemicolon(parser);
    break;
  case XS_TOKEN_TRY:
    fxTryStatement(parser);
    break;
  case XS_TOKEN_VAR:
    fxVariableStatement(parser, XS_TOKEN_VAR, 0);
    fxSemicolon(parser);
    break;
  case XS_TOKEN_WHILE:
    fxWhileStatement(parser);
    break;
  case XS_TOKEN_WITH:
    if (parser->flags & mxStrictFlag)
      fxReportParserError(parser, parser->states[0].line, "with (strict code)");
    fxWithStatement(parser);
    break;
#if mxExplicitResourceManagement
  case XS_TOKEN_AWAIT:
    fxLookAheadOnce(parser);
    if ((!parser->states[1].crlf) && (parser->states[1].token == XS_TOKEN_IDENTIFIER) && (parser->states[1].symbol == parser->usingSymbol) && (!parser->states[1].escaped)) {
      fxLookAheadTwice(parser);
      if ((!parser->states[2].crlf) && ((parser->states[2].token == XS_TOKEN_IDENTIFIER) || (parser->states[2].token == XS_TOKEN_AWAIT) || (parser->states[2].token == XS_TOKEN_YIELD))) {
        fxGetNextToken(parser);
        parser->states[0].token = XS_TOKEN_USING;
        if (blockIt <= 0)
          fxReportParserError(parser, parser->states[0].line, "no block");
        fxVariableStatement(parser, XS_TOKEN_USING, mxAwaitingFlag);
        parser->flags |= mxAwaitingFlag;
        fxSemicolon(parser);
        break;
      }
    }
    fxCommaExpression(parser);
    fxPushNodeStruct(parser, 1, XS_TOKEN_STATEMENT, line);
    fxSemicolon(parser);
    break;
#endif
  case XS_TOKEN_IDENTIFIER:
    fxLookAheadOnce(parser);
    if (parser->states[1].token == XS_TOKEN_COLON) {
      fxPushSymbol(parser, parser->states[0].symbol);
      fxGetNextToken(parser);
      fxMatchToken(parser, XS_TOKEN_COLON);
      //if ((parser->flags & mxStrictFlag) && (parser->states[0].token == XS_TOKEN_FUNCTION)) BROWSER
      //  fxReportParserError(parser, parser->states[0].line, "labeled function (strict code)");
      if (parser->states[0].token == XS_TOKEN_FUNCTION)
        fxReportParserError(parser, parser->states[0].line, "labeled function");
      fxCheckParserStack(parser, line);
      fxStatement(parser, 0);
      fxPushNodeStruct(parser, 2, XS_TOKEN_LABEL, line);
      break;
    }
    if ((parser->states[0].symbol == parser->asyncSymbol) && (!parser->states[0].escaped) 
        && (!parser->states[1].crlf) && (parser->states[1].token == XS_TOKEN_FUNCTION)) {
      fxGetNextToken(parser);
      flag = mxAsyncFlag;
      goto again;
    }
    if ((parser->states[0].symbol == parser->letSymbol) && (!parser->states[0].escaped) 
        && ((gxTokenFlags[parser->states[1].token] & XS_TOKEN_BEGIN_BINDING) || (parser->states[1].token == XS_TOKEN_AWAIT) || (parser->states[1].token == XS_TOKEN_YIELD))
        && (blockIt || (!parser->states[1].crlf) || (parser->states[1].token == XS_TOKEN_LEFT_BRACKET))) {
      parser->states[0].token = XS_TOKEN_LET;
      if (!blockIt)
        fxReportParserError(parser, parser->states[0].line, "no block");
      fxVariableStatement(parser, XS_TOKEN_LET, 0);
      fxSemicolon(parser);
      break;
    }
#if mxExplicitResourceManagement
    if ((parser->states[0].symbol == parser->usingSymbol) && (!parser->states[0].escaped)
        && (!parser->states[1].crlf) && ((parser->states[1].token == XS_TOKEN_IDENTIFIER) || (parser->states[1].token == XS_TOKEN_AWAIT) || (parser->states[1].token == XS_TOKEN_YIELD))) {
      parser->states[0].token = XS_TOKEN_USING;
      if (blockIt <= 0)
        fxReportParserError(parser, parser->states[0].line, "no block");
      fxVariableStatement(parser, XS_TOKEN_USING, 0);
      fxSemicolon(parser);
      break;
    }
#endif
    /* continue */
    mxFallThrough;
  default:
    if (gxTokenFlags[parser->states[0].token] & XS_TOKEN_BEGIN_EXPRESSION) {
      fxCommaExpression(parser);
      fxPushNodeStruct(parser, 1, XS_TOKEN_STATEMENT, line);
      fxSemicolon(parser);
    }
    else {
      fxReportParserError(parser, parser->states[0].line, "invalid token %s", gxTokenNames[parser->states[0].token]);
      fxPushNULL(parser);
      fxGetNextToken(parser);
    }
    break;
  }
}

void fxSemicolon(txParser* parser)
{
  if ((parser->states[0].crlf) || (gxTokenFlags[parser->states[0].token] & XS_TOKEN_END_STATEMENT)) {
    if (parser->states[0].token == XS_TOKEN_SEMICOLON)
      fxGetNextToken(parser);
  }
  else
    fxReportParserError(parser, parser->states[0].line, "missing ;");
}

void fxBreakStatement(txParser* parser)
{
  txInteger aLine = parser->states[0].line;
  fxMatchToken(parser, XS_TOKEN_BREAK);
  if ((!parser->states[0].crlf) && (parser->states[0].token == XS_TOKEN_IDENTIFIER)) {
    fxPushSymbol(parser, parser->states[0].symbol);
    fxGetNextToken(parser);
  }
  else {
    fxPushNULL(parser);
  }
  fxPushNodeStruct(parser, 1, XS_TOKEN_BREAK, aLine);
}

void fxContinueStatement(txParser* parser)
{
  txInteger aLine = parser->states[0].line;
  fxMatchToken(parser, XS_TOKEN_CONTINUE);
  if ((!parser->states[0].crlf) && (parser->states[0].token == XS_TOKEN_IDENTIFIER)) {
    fxPushSymbol(parser, parser->states[0].symbol);
    fxGetNextToken(parser);
  }
  else {
    fxPushNULL(parser);
  }
  fxPushNodeStruct(parser, 1, XS_TOKEN_CONTINUE, aLine);
}

void fxDebuggerStatement(txParser* parser)
{
  txInteger aLine = parser->states[0].line;
  fxMatchToken(parser, XS_TOKEN_DEBUGGER);
  fxPushNodeStruct(parser, 0, XS_TOKEN_DEBUGGER, aLine);
}

void fxDoStatement(txParser* parser)
{
  txInteger aLine = parser->states[0].line;
  fxCheckParserStack(parser, aLine);
  fxPushNULL(parser);
  fxMatchToken(parser, XS_TOKEN_DO);
  fxStatement(parser, 0);
  fxMatchToken(parser, XS_TOKEN_WHILE);
  fxMatchToken(parser, XS_TOKEN_LEFT_PARENTHESIS);
  fxCommaExpression(parser);
  fxMatchToken(parser, XS_TOKEN_RIGHT_PARENTHESIS);
  if (parser->states[0].token == XS_TOKEN_SEMICOLON)
    fxGetNextToken(parser);
  fxPushNodeStruct(parser, 2, XS_TOKEN_DO, aLine);
  fxPushNodeStruct(parser, 2, XS_TOKEN_LABEL, aLine);
}

void fxForStatement(txParser* parser)
{
  txInteger aLine = parser->states[0].line;
  txBoolean awaitFlag = 0;
  txBoolean expressionFlag = 0;
  txToken aToken;
  fxPushNULL(parser);
  fxMatchToken(parser, XS_TOKEN_FOR);
  if (parser->states[0].token == XS_TOKEN_AWAIT) {
    awaitFlag = 1;
    fxMatchToken(parser, XS_TOKEN_AWAIT);
  }
  fxMatchToken(parser, XS_TOKEN_LEFT_PARENTHESIS);
  fxLookAheadOnce(parser);
  parser->flags |= mxForFlag;
  if (parser->states[0].token == XS_TOKEN_SEMICOLON) {
    fxPushNULL(parser);
  }
  else if (parser->states[0].token == XS_TOKEN_CONST) {
    fxVariableStatement(parser, XS_TOKEN_CONST, 0);
  }
  else if (parser->states[0].token == XS_TOKEN_LET) {
    fxVariableStatement(parser, XS_TOKEN_LET, 0);
  }
  else if (fxIsKeyword(parser, parser->letSymbol) && (gxTokenFlags[parser->states[1].token] & XS_TOKEN_BEGIN_BINDING)) {
    parser->states[0].token = XS_TOKEN_LET;
    fxVariableStatement(parser, XS_TOKEN_LET, 0);
  }
#if mxExplicitResourceManagement
  else if ((parser->states[0].token == XS_TOKEN_IDENTIFIER) && (parser->states[0].symbol == parser->usingSymbol) && (!parser->states[0].escaped)
        && (!parser->states[1].crlf) && ((parser->states[1].token == XS_TOKEN_IDENTIFIER) || (parser->states[1].token == XS_TOKEN_AWAIT) || (parser->states[1].token == XS_TOKEN_YIELD))) {
    fxLookAheadTwice(parser);
    if ((parser->states[1].symbol == parser->ofSymbol) && (!parser->states[1].escaped) && (parser->states[2].token != XS_TOKEN_ASSIGN)) {
      fxCommaExpression(parser);
      expressionFlag = 1;
    }
    else {
      parser->states[0].token = XS_TOKEN_USING;
      fxVariableStatement(parser, XS_TOKEN_USING, 0);
    }
  }
  else if ((parser->states[0].token == XS_TOKEN_AWAIT)
        && (!parser->states[1].crlf) && (parser->states[1].token == XS_TOKEN_IDENTIFIER) && (parser->states[1].symbol == parser->usingSymbol) && (!parser->states[1].escaped)) {
    fxLookAheadTwice(parser);
    if ((!parser->states[2].crlf) && ((parser->states[2].token == XS_TOKEN_IDENTIFIER) || (parser->states[2].token == XS_TOKEN_AWAIT) || (parser->states[2].token == XS_TOKEN_YIELD))) {
      fxGetNextToken(parser);
      parser->states[0].token = XS_TOKEN_USING;
      fxVariableStatement(parser, XS_TOKEN_USING, mxAwaitingFlag);
      parser->flags |= mxAwaitingFlag;
    }
    else {
      fxCommaExpression(parser);
      expressionFlag = 1;
    }
  }
#endif
  else if (parser->states[0].token == XS_TOKEN_VAR) {
    fxVariableStatement(parser, XS_TOKEN_VAR, 0);
  }
  else {
    fxCommaExpression(parser);
    expressionFlag = 1;
  }
  parser->flags &= ~mxForFlag;
  if (awaitFlag && !fxIsKeyword(parser, parser->ofSymbol))
    fxReportParserError(parser, parser->states[0].line, "invalid for await");
  if (fxIsToken(parser, XS_TOKEN_IN) || fxIsKeyword(parser, parser->ofSymbol)) {
    if (expressionFlag) {
      if (!fxCheckReference(parser, XS_TOKEN_ASSIGN)) {
        fxReportParserError(parser, parser->states[0].line, "no reference");
      }
    }
    else {
      aToken = parser->root->description->token;
      if (aToken == XS_TOKEN_BINDING) {
        if (((txBindingNode*)(parser->root))->initializer)
          fxReportParserError(parser, parser->states[0].line, "invalid binding initializer");
      }
      if (fxIsToken(parser, XS_TOKEN_IN) && (aToken == XS_TOKEN_USING))
        fxReportParserError(parser, parser->states[0].line, "invalid using in");
      
//      else if (aToken == XS_TOKEN_ARRAY_BINDING) {
//        if (((txArrayBindingNode*)(parser->root))->initializer)
//          fxReportParserError(parser, parser->states[0].line, "invalid array binding initializer");
//      }
//      else if (aToken == XS_TOKEN_OBJECT_BINDING) {
//        if (((txObjectBindingNode*)(parser->root))->initializer)
//          fxReportParserError(parser, parser->states[0].line, "invalid object binding initializer");
//      }
//      else
//        fxReportParserError(parser, parser->states[0].line, "no reference %s", gxTokenNames[aToken]);
    }
    aToken = parser->states[0].token;
    fxGetNextToken(parser);
    if (aToken == XS_TOKEN_IN)
      fxCommaExpression(parser);
    else
      fxAssignmentExpression(parser);
    fxMatchToken(parser, XS_TOKEN_RIGHT_PARENTHESIS);
    fxStatement(parser, 0);
    if (awaitFlag) {
      fxPushNodeStruct(parser, 3, XS_TOKEN_FOR_AWAIT_OF, aLine);
      parser->flags |= mxAwaitingFlag;
    }
    else if (aToken == XS_TOKEN_IN)
      fxPushNodeStruct(parser, 3, XS_TOKEN_FOR_IN, aLine);
    else
      fxPushNodeStruct(parser, 3, XS_TOKEN_FOR_OF, aLine);
  }
  else {
    if (expressionFlag)
      fxPushNodeStruct(parser, 1, XS_TOKEN_STATEMENT, aLine);
    fxMatchToken(parser, XS_TOKEN_SEMICOLON);
    if (gxTokenFlags[parser->states[0].token] & XS_TOKEN_BEGIN_EXPRESSION) {
      fxCommaExpression(parser);
    }
    else {
      fxPushNULL(parser);
    }
    fxMatchToken(parser, XS_TOKEN_SEMICOLON);
    if (gxTokenFlags[parser->states[0].token] & XS_TOKEN_BEGIN_EXPRESSION) {
      fxCommaExpression(parser);
    }
    else {
      fxPushNULL(parser);
    }
    fxMatchToken(parser, XS_TOKEN_RIGHT_PARENTHESIS);
    fxCheckParserStack(parser, aLine);
    fxStatement(parser, 0);
    fxPushNodeStruct(parser, 4, XS_TOKEN_FOR, aLine);
  }
  fxPushNodeStruct(parser, 2, XS_TOKEN_LABEL, aLine);
}

void fxIfStatement(txParser* parser)
{
  txInteger aLine = parser->states[0].line;
  fxMatchToken(parser, XS_TOKEN_IF);
  fxMatchToken(parser, XS_TOKEN_LEFT_PARENTHESIS);
  fxCommaExpression(parser);
  fxMatchToken(parser, XS_TOKEN_RIGHT_PARENTHESIS);
  fxStatement(parser, 0);
  if (parser->states[0].token == XS_TOKEN_ELSE) {
    fxMatchToken(parser, XS_TOKEN_ELSE);
    fxStatement(parser, 0);
  }
  else {
    fxPushNULL(parser);
  }
  fxPushNodeStruct(parser, 3, XS_TOKEN_IF, aLine);
}

void fxReturnStatement(txParser* parser)
{
  txInteger aLine = parser->states[0].line;
  fxMatchToken(parser, XS_TOKEN_RETURN);
  if ((!parser->states[0].crlf) && (gxTokenFlags[parser->states[0].token] & XS_TOKEN_BEGIN_EXPRESSION)) {
    fxCommaExpression(parser);
  }
  else {
    fxPushNULL(parser);
  }
  fxPushNodeStruct(parser, 1, XS_TOKEN_RETURN, aLine);
}

void fxSwitchStatement(txParser* parser)
{
  txInteger aCount = 0;
  txBoolean aDefaultFlag = 0;
  txInteger aLine = parser->states[0].line;
  fxMatchToken(parser, XS_TOKEN_SWITCH);
  fxMatchToken(parser, XS_TOKEN_LEFT_PARENTHESIS);
  fxCommaExpression(parser);
  fxMatchToken(parser, XS_TOKEN_RIGHT_PARENTHESIS);
  fxMatchToken(parser, XS_TOKEN_LEFT_BRACE);
  while ((parser->states[0].token == XS_TOKEN_CASE) || (parser->states[0].token == XS_TOKEN_DEFAULT)) {
    txInteger aCaseCount;
    txInteger aCaseLine = parser->states[0].line;
    if (parser->states[0].token == XS_TOKEN_CASE) {
      fxMatchToken(parser, XS_TOKEN_CASE);
      fxCommaExpression(parser);
      fxMatchToken(parser, XS_TOKEN_COLON);
      aCaseCount = parser->nodeCount;
      while (gxTokenFlags[parser->states[0].token] & XS_TOKEN_BEGIN_STATEMENT)
        fxStatement(parser, -1);
      aCaseCount = parser->nodeCount - aCaseCount;
      if (aCaseCount > 1) {
        fxPushNodeList(parser, aCaseCount);
        fxPushNodeStruct(parser, 1, XS_TOKEN_STATEMENTS, aCaseLine);
      }
      else if (aCaseCount == 0) {
        fxPushNULL(parser);
      }
      fxPushNodeStruct(parser, 2, XS_TOKEN_CASE, aCaseLine);
    }
    else {
      fxMatchToken(parser, XS_TOKEN_DEFAULT);
      if (aDefaultFlag) 
        fxReportParserError(parser, parser->states[0].line, "invalid default");
      fxPushNULL(parser);
      fxMatchToken(parser, XS_TOKEN_COLON);
      aCaseCount = parser->nodeCount;
      while (gxTokenFlags[parser->states[0].token] & XS_TOKEN_BEGIN_STATEMENT)
        fxStatement(parser, -1);
      aCaseCount = parser->nodeCount - aCaseCount;
      if (aCaseCount > 1) {
        fxPushNodeList(parser, aCaseCount);
        fxPushNodeStruct(parser, 1, XS_TOKEN_STATEMENTS, aLine);
      }
      else if (aCaseCount == 0) {
        fxPushNULL(parser);
      }
      fxPushNodeStruct(parser, 2, XS_TOKEN_CASE, aCaseLine);
      aDefaultFlag = 1;
    }
    aCount++;
  }
  fxMatchToken(parser, XS_TOKEN_RIGHT_BRACE);
  fxPushNodeList(parser, aCount);
  fxPushNodeStruct(parser, 2, XS_TOKEN_SWITCH, aLine);
}

void fxThrowStatement(txParser* parser)
{
  txInteger aLine = parser->states[0].line;
  fxMatchToken(parser, XS_TOKEN_THROW);
  if ((!parser->states[0].crlf) && (gxTokenFlags[parser->states[0].token] & XS_TOKEN_BEGIN_EXPRESSION)) {
    fxCommaExpression(parser);
  }
  else {
    fxReportParserError(parser, parser->states[0].line, "missing expression");
    fxPushNodeStruct(parser, 0, XS_TOKEN_UNDEFINED, aLine);
  }
  fxPushNodeStruct(parser, 1, XS_TOKEN_THROW, aLine);
}

void fxTryStatement(txParser* parser)
{
  txInteger aLine = parser->states[0].line;
  txBoolean ok = 0;
  fxMatchToken(parser, XS_TOKEN_TRY);
  fxBlock(parser);
  if (parser->states[0].token == XS_TOKEN_CATCH) {
    txInteger aCatchLine = parser->states[0].line;
    fxMatchToken(parser, XS_TOKEN_CATCH);
    if (parser->states[0].token == XS_TOKEN_LEFT_PARENTHESIS) {
      fxMatchToken(parser, XS_TOKEN_LEFT_PARENTHESIS);
      fxBinding(parser, XS_TOKEN_LET, 1);
      fxMatchToken(parser, XS_TOKEN_RIGHT_PARENTHESIS);
    }
    else
      fxPushNULL(parser);
    fxMatchToken(parser, XS_TOKEN_LEFT_BRACE);
    fxStatements(parser);
    fxMatchToken(parser, XS_TOKEN_RIGHT_BRACE);
    fxPushNodeStruct(parser, 2, XS_TOKEN_CATCH, aCatchLine);
    ok = 1;
  }
  else {
    fxPushNULL(parser);
  }
  if (parser->states[0].token == XS_TOKEN_FINALLY) {
    fxMatchToken(parser, XS_TOKEN_FINALLY);
    fxBlock(parser);
    ok = 1;
  }
  else {
    fxPushNULL(parser);
  }
  if (!ok)
    fxReportParserError(parser, parser->states[0].line, "missing catch or finally");
  fxPushNodeStruct(parser, 3, XS_TOKEN_TRY, aLine);
}

void fxVariableStatement(txParser* parser, txToken theToken, txUnsigned flags)
{
  txBoolean commaFlag = 0;
  txInteger aCount = 0;
  txInteger aLine = parser->states[0].line;
  fxMatchToken(parser, theToken);
  while (gxTokenFlags[parser->states[0].token] & XS_TOKEN_BEGIN_BINDING) {
    commaFlag = 0;
    fxBinding(parser, theToken, 1 | flags);
//    if (parser->states[0].token == XS_TOKEN_ASSIGN) {
//      parser->flags &= ~mxForFlag;
//      fxGetNextToken(parser);
//      fxAssignmentExpression(parser);
//      fxPushNodeStruct(parser, 2, XS_TOKEN_ASSIGN, aLine);
//      fxPushNodeStruct(parser, 1, XS_TOKEN_STATEMENT, aLine);
//    }
    aCount++;
    if (parser->states[0].token == XS_TOKEN_COMMA) {
      parser->flags &= ~mxForFlag;
      fxGetNextToken(parser);
      commaFlag = 1;
    }
    else
      break;
  }
    if ((aCount == 0) || commaFlag) {
    fxPushNULL(parser);
    fxPushNULL(parser);
    fxPushNodeStruct(parser, 2, theToken, aLine);
    fxReportParserError(parser, parser->states[0].line, "missing identifier");
  }
  if (aCount > 1) {
    fxPushNodeList(parser, aCount);
    fxPushNodeStruct(parser, 1, XS_TOKEN_STATEMENTS, aLine);
  }
}

void fxWhileStatement(txParser* parser)
{
  txInteger aLine = parser->states[0].line;
  fxPushNULL(parser);
  fxMatchToken(parser, XS_TOKEN_WHILE);
  fxMatchToken(parser, XS_TOKEN_LEFT_PARENTHESIS);
  fxCommaExpression(parser);
  fxMatchToken(parser, XS_TOKEN_RIGHT_PARENTHESIS);
  fxStatement(parser, 0);
  fxPushNodeStruct(parser, 2, XS_TOKEN_WHILE, aLine);
  fxPushNodeStruct(parser, 2, XS_TOKEN_LABEL, aLine);
}

void fxWithStatement(txParser* parser)
{
  txInteger aLine = parser->states[0].line;
  fxMatchToken(parser, XS_TOKEN_WITH);
  fxMatchToken(parser, XS_TOKEN_LEFT_PARENTHESIS);
  fxCommaExpression(parser);
  fxMatchToken(parser, XS_TOKEN_RIGHT_PARENTHESIS);
  fxStatement(parser, 0);
  fxPushNodeStruct(parser, 2, XS_TOKEN_WITH, aLine);
}

void fxCommaExpression(txParser* parser)
{
  txInteger aCount = 0;
  txInteger aLine = parser->states[0].line;
  if (gxTokenFlags[parser->states[0].token] & XS_TOKEN_BEGIN_EXPRESSION) {
    fxAssignmentExpression(parser);
    aCount++;
    while (parser->states[0].token == XS_TOKEN_COMMA) {
      fxGetNextToken(parser);
      fxAssignmentExpression(parser);
      aCount++;
    }
  }
  if (aCount > 1) {
    fxPushNodeList(parser, aCount);
    fxPushNodeStruct(parser, 1, XS_TOKEN_EXPRESSIONS, aLine);
  }
  else if (aCount == 0) {
    fxPushNULL(parser);
    fxReportParserError(parser, parser->states[0].line, "missing expression");
  }
}

void fxAssignmentExpression(txParser* parser)
{
  fxCheckParserStack(parser, parser->states[0].line);
  if (parser->states[0].token == XS_TOKEN_YIELD)
    fxYieldExpression(parser);
  else {
    fxConditionalExpression(parser);
    while (gxTokenFlags[parser->states[0].token] & XS_TOKEN_ASSIGN_EXPRESSION) {
      txToken aToken = parser->states[0].token;
      txInteger aLine = parser->states[0].line;
      if (!fxCheckReference(parser, aToken)) 
        fxReportParserError(parser, parser->states[0].line, "no reference");
      fxGetNextToken(parser);
      fxAssignmentExpression(parser);
      fxPushNodeStruct(parser, 2, aToken, aLine);
    }
  }
}

void fxConditionalExpression(txParser* parser)
{
  fxCoalesceExpression(parser);
  if (parser->states[0].token == XS_TOKEN_QUESTION_MARK) {
    txInteger aLine = parser->states[0].line;
    txUnsigned flags;
    fxCheckArrowFunction(parser, 1);
    fxGetNextToken(parser);
    flags = parser->flags & mxForFlag;
    parser->flags &= ~mxForFlag;
    fxAssignmentExpression(parser);
    parser->flags |= flags;
    fxMatchToken(parser, XS_TOKEN_COLON);
    fxAssignmentExpression(parser);
    fxPushNodeStruct(parser, 3, XS_TOKEN_QUESTION_MARK, aLine);
  }
}

void fxCoalesceExpression(txParser* parser)
{
  fxOrExpression(parser);
  while (parser->states[0].token == XS_TOKEN_COALESCE) {
    txInteger aLine = parser->states[0].line;
    fxGetNextToken(parser);
    fxOrExpression(parser);
    fxCheckArrowFunction(parser, 2);
    fxPushNodeStruct(parser, 2, XS_TOKEN_COALESCE, aLine);
  }
}

void fxOrExpression(txParser* parser)
{
  fxAndExpression(parser);
  while (parser->states[0].token == XS_TOKEN_OR) {
    txInteger aLine = parser->states[0].line;
    fxGetNextToken(parser);
    fxAndExpression(parser);
    fxCheckArrowFunction(parser, 2);
    fxPushNodeStruct(parser, 2, XS_TOKEN_OR, aLine);
  }
}

void fxAndExpression(txParser* parser)
{
  fxBitOrExpression(parser);
  while (parser->states[0].token == XS_TOKEN_AND) {
    txInteger aLine = parser->states[0].line;
    fxGetNextToken(parser);
    fxBitOrExpression(parser);
    fxCheckArrowFunction(parser, 2);
    fxPushNodeStruct(parser, 2, XS_TOKEN_AND, aLine);
  }
}

void fxBitOrExpression(txParser* parser)
{
  fxBitXorExpression(parser);
  while (parser->states[0].token == XS_TOKEN_BIT_OR) {
    txInteger aLine = parser->states[0].line;
    fxGetNextToken(parser);
    fxBitXorExpression(parser);
    fxCheckArrowFunction(parser, 2);
    fxPushNodeStruct(parser, 2, XS_TOKEN_BIT_OR, aLine);
  }
}

void fxBitXorExpression(txParser* parser)
{
  fxBitAndExpression(parser);
  while (parser->states[0].token == XS_TOKEN_BIT_XOR) {
    txInteger aLine = parser->states[0].line;
    fxGetNextToken(parser);
    fxBitAndExpression(parser);
    fxCheckArrowFunction(parser, 2);
    fxPushNodeStruct(parser, 2, XS_TOKEN_BIT_XOR, aLine);
  }
}

void fxBitAndExpression(txParser* parser)
{
  fxEqualExpression(parser);
  while (parser->states[0].token == XS_TOKEN_BIT_AND) {
    txInteger aLine = parser->states[0].line;
    fxGetNextToken(parser);
    fxEqualExpression(parser);
    fxCheckArrowFunction(parser, 2);
    fxPushNodeStruct(parser, 2, XS_TOKEN_BIT_AND, aLine);
  }
}

void fxEqualExpression(txParser* parser)
{
  fxRelationalExpression(parser);
  while (gxTokenFlags[parser->states[0].token] & XS_TOKEN_EQUAL_EXPRESSION) {
    txToken aToken = parser->states[0].token;
    txInteger aLine = parser->states[0].line;
    fxGetNextToken(parser);
    fxRelationalExpression(parser);
    fxCheckArrowFunction(parser, 2);
    fxPushNodeStruct(parser, 2, aToken, aLine);
  }
}

void fxRelationalExpression(txParser* parser)
{
  if (parser->states[0].token == XS_TOKEN_PRIVATE_IDENTIFIER) {
    txInteger aLine = parser->states[0].line;
    fxPushSymbol(parser, parser->states[0].symbol);
    fxGetNextToken(parser);
    fxMatchToken(parser, XS_TOKEN_IN);
    if (parser->flags & mxForFlag)
      fxReportParserError(parser, parser->states[0].line, "invalid %s", gxTokenNames[XS_TOKEN_IN]);
    fxShiftExpression(parser);
    fxCheckArrowFunction(parser, 2);
    fxPushNodeStruct(parser, 2, XS_TOKEN_PRIVATE_IDENTIFIER, aLine);
  }
  else {
    fxShiftExpression(parser);
    if ((parser->flags & mxForFlag) && ((parser->states[0].token == XS_TOKEN_IN) || fxIsKeyword(parser, parser->ofSymbol)))
      return;
    while (gxTokenFlags[parser->states[0].token] & XS_TOKEN_RELATIONAL_EXPRESSION) {
      txToken aToken = parser->states[0].token;
      txInteger aLine = parser->states[0].line;
      fxMatchToken(parser, aToken);
      fxShiftExpression(parser);
      fxCheckArrowFunction(parser, 2);
      fxPushNodeStruct(parser, 2, aToken, aLine);
    }
  }
}

void fxShiftExpression(txParser* parser)
{
  fxAdditiveExpression(parser);
  while (gxTokenFlags[parser->states[0].token] & XS_TOKEN_SHIFT_EXPRESSION) {
    txToken aToken = parser->states[0].token;
    txInteger aLine = parser->states[0].line;
    fxGetNextToken(parser);
    fxAdditiveExpression(parser);
    fxCheckArrowFunction(parser, 2);
    fxPushNodeStruct(parser, 2, aToken, aLine);
  }
}

void fxAdditiveExpression(txParser* parser)
{
  fxMultiplicativeExpression(parser);
  while (gxTokenFlags[parser->states[0].token] & XS_TOKEN_ADDITIVE_EXPRESSION) {
    txToken aToken = parser->states[0].token;
    txInteger aLine = parser->states[0].line;
    fxGetNextToken(parser);
    fxMultiplicativeExpression(parser);
    fxCheckArrowFunction(parser, 2);
    fxPushNodeStruct(parser, 2, aToken, aLine);
  }
}

void fxMultiplicativeExpression(txParser* parser)
{
  fxExponentiationExpression(parser);
  while (gxTokenFlags[parser->states[0].token] & XS_TOKEN_MULTIPLICATIVE_EXPRESSION) {
    txToken aToken = parser->states[0].token;
    txInteger aLine = parser->states[0].line;
    fxGetNextToken(parser);
    fxExponentiationExpression(parser);
    fxCheckArrowFunction(parser, 2);
    fxPushNodeStruct(parser, 2, aToken, aLine);
  }
}

void fxExponentiationExpression(txParser* parser)
{
  if (gxTokenFlags[parser->states[0].token] & XS_TOKEN_UNARY_EXPRESSION)
    fxUnaryExpression(parser);
  else {
    fxPrefixExpression(parser);
    if (gxTokenFlags[parser->states[0].token] & XS_TOKEN_EXPONENTIATION_EXPRESSION) {
      txToken aToken = parser->states[0].token;
      txInteger aLine = parser->states[0].line;
      fxGetNextToken(parser);
            fxExponentiationExpression(parser);
      fxCheckArrowFunction(parser, 2);
      fxPushNodeStruct(parser, 2, aToken, aLine);
    }
  }
}

void fxUnaryExpression(txParser* parser)
{
  if (gxTokenFlags[parser->states[0].token] & XS_TOKEN_UNARY_EXPRESSION) {
    txToken aToken = parser->states[0].token;
    txInteger aLine = parser->states[0].line;
    fxCheckParserStack(parser, aLine);
    fxMatchToken(parser, aToken);
    fxUnaryExpression(parser);
    fxCheckArrowFunction(parser, 1);
    if (aToken == XS_TOKEN_ADD)
      fxPushNodeStruct(parser, 1, XS_TOKEN_PLUS, aLine);
    else if (aToken == XS_TOKEN_SUBTRACT)
      fxPushNodeStruct(parser, 1, XS_TOKEN_MINUS, aLine);
    else if (aToken == XS_TOKEN_DELETE) {
      //if ((parser->flags & mxStrictFlag) && (parser->root->description->token == XS_TOKEN_ACCESS)) {
      //  fxReportParserError(parser, parser->states[0].line, "no reference (strict mode)");
      //}
      if (!fxCheckReference(parser, aToken)) 
        fxReportParserError(parser, parser->states[0].line, "no reference");
      fxPushNodeStruct(parser, 1, aToken, aLine);
    }
    else if (aToken == XS_TOKEN_AWAIT) {
      if ((parser->flags & mxGeneratorFlag) && !(parser->flags & mxYieldFlag))
        fxReportParserError(parser, parser->states[0].line, "invalid await");
      else
        parser->flags |= mxAwaitingFlag;
      fxPushNodeStruct(parser, 1, aToken, aLine);
    }
    else
      fxPushNodeStruct(parser, 1, aToken, aLine);
      
  }
  else
    fxPrefixExpression(parser);
}

void fxPrefixExpression(txParser* parser)
{
  if (gxTokenFlags[parser->states[0].token] & XS_TOKEN_PREFIX_EXPRESSION) {
    txToken aToken = parser->states[0].token;
    txInteger aLine = parser->states[0].line;
    fxCheckParserStack(parser, aLine);
    fxGetNextToken(parser);
    fxPrefixExpression(parser);
    fxCheckArrowFunction(parser, 1);
    if (!fxCheckReference(parser, aToken)) 
      fxReportParserError(parser, parser->states[0].line, "no reference");
    fxPushNodeStruct(parser, 1, aToken, aLine);
    parser->root->flags = mxExpressionNoValue;
  }
  else
    fxPostfixExpression(parser);
}

void fxPostfixExpression(txParser* parser)
{
  fxCallExpression(parser);
  if ((!parser->states[0].crlf) && (gxTokenFlags[parser->states[0].token] & XS_TOKEN_POSTFIX_EXPRESSION)) {
    fxCheckArrowFunction(parser, 1);
    if (!fxCheckReference(parser, parser->states[0].token)) 
      fxReportParserError(parser, parser->states[0].line, "no reference");
    fxPushNodeStruct(parser, 1, parser->states[0].token, parser->states[0].line);
    fxGetNextToken(parser);
  }
}

void fxCallExpression(txParser* parser)
{
  txInteger chainLine = parser->states[0].line;
  fxLiteralExpression(parser, 0);
  if (gxTokenFlags[parser->states[0].token] & XS_TOKEN_CALL_EXPRESSION) {
    txBoolean chainFlag = 0;
    fxCheckArrowFunction(parser, 1);
    for (;;) {
      txInteger aLine = parser->states[0].line;
      if (parser->states[0].token == XS_TOKEN_DOT) {
        fxGetNextToken(parser);
        if (parser->states[0].token == XS_TOKEN_IDENTIFIER) {
          fxPushSymbol(parser, parser->states[0].symbol);
          fxPushNodeStruct(parser, 2, XS_TOKEN_MEMBER, aLine);
          fxGetNextToken(parser);
        }
        else if (parser->states[0].token == XS_TOKEN_PRIVATE_IDENTIFIER) {
          if (parser->root->flags & mxSuperFlag)
            fxReportParserError(parser, parser->states[0].line, "invalid super");
          fxPushSymbol(parser, parser->states[0].symbol);
          fxSwapNodes(parser);
          fxPushNodeStruct(parser, 2, XS_TOKEN_PRIVATE_MEMBER, aLine);
          fxGetNextToken(parser);
        }
        else
          fxReportParserError(parser, parser->states[0].line, "missing property");
      }
      //else if (parser->states[0].crlf)
      //  break;
      else if (parser->states[0].token == XS_TOKEN_LEFT_BRACKET) {
        fxGetNextToken(parser);
        fxCommaExpression(parser);
        fxPushNodeStruct(parser, 2, XS_TOKEN_MEMBER_AT, aLine);
        fxMatchToken(parser, XS_TOKEN_RIGHT_BRACKET);
      }
      else if (parser->states[0].token == XS_TOKEN_LEFT_PARENTHESIS) {
        txUnsigned nativeFlags = 0;
        txAccessNode* access = NULL;
        if (parser->root->description && (parser->root->description->token == XS_TOKEN_ACCESS)) {
          access = (txAccessNode*)parser->root;
          if (access->symbol == parser->evalSymbol) {
            parser->flags |= mxEvalFlag;
          }
          else if (parser->flags & mxCFlag) {
            if (access->symbol == parser->NativeSymbol) {
              nativeFlags = mxNativeConstructorFlag;
            }
            else if (access->symbol == parser->nativeSymbol) {
              nativeFlags = mxNativeFunctionFlag;
              parser->flags |= mxNativeFlag;
            }
          }
        }
        fxParameters(parser);
        if (nativeFlags) {
          txParamsNode* params = (txParamsNode*)parser->root;
          if (params->items->length == 0)
             fxReportParserError(parser, aLine, "%s: no argument", access->symbol->string);
          if (params->items->length > 1)
             fxReportParserError(parser, aLine, "%s: too many arguments", access->symbol->string);
          txStringNode* param = (txStringNode*)(params->items->first);
          if (param->description->token != XS_TOKEN_STRING)
             fxReportParserError(parser, aLine, "%s: argument is no string literal", access->symbol->string);
          fxPopNode(parser);
          fxPopNode(parser);
          if (nativeFlags & mxNativeFunctionFlag) {
            fxPushNULL(parser);
            fxPushNodeList(parser, 0);
            fxPushNodeStruct(parser, 1, XS_TOKEN_PARAMS_BINDING, aLine);
            fxPushStringNode(parser, param->length, param->value, aLine);
            fxPushNodeStruct(parser, 3, XS_TOKEN_HOST, aLine);
          }
          else {
            fxPushNULL(parser);

            fxPushNULL(parser);
            fxPushNULL(parser);
            fxPushStringNode(parser, param->length, param->value, aLine);
            fxPushNodeStruct(parser, 3, XS_TOKEN_HOST, aLine);
            
            fxPushNodeList(parser, 0);
            
            fxPushNULL(parser);
            fxPushNULL(parser);
            
            fxPushNULL(parser);
            fxPushNodeList(parser, 0);
            fxPushNodeStruct(parser, 1, XS_TOKEN_PARAMS_BINDING, aLine);
            fxPushNodeStruct(parser, 0, XS_TOKEN_UNDEFINED, aLine);
            fxPushNodeStruct(parser, 1, XS_TOKEN_STATEMENT, aLine);
            fxPushNodeStruct(parser, 1, XS_TOKEN_BODY, aLine);
            fxPushNodeStruct(parser, 3, XS_TOKEN_FUNCTION, aLine);
            parser->root->flags = mxStrictFlag | mxBaseFlag | mxMethodFlag | mxTargetFlag;
            
            fxPushNodeStruct(parser, 6, XS_TOKEN_CLASS, aLine);
          }
        }
        else
          fxPushNodeStruct(parser, 2, XS_TOKEN_CALL, aLine);
      }
      else if (parser->states[0].token == XS_TOKEN_TEMPLATE) {
        if (chainFlag)
          fxReportParserError(parser, parser->states[0].line, "invalid template");
        fxPushStringNode(parser, parser->states[0].stringLength, parser->states[0].string, aLine);
        fxPushRawNode(parser, parser->states[0].rawLength, parser->states[0].raw, aLine);
        fxPushNodeStruct(parser, 2, XS_TOKEN_TEMPLATE_MIDDLE, aLine);
        fxGetNextToken(parser);
        fxPushNodeList(parser, 1);
        fxPushNodeStruct(parser, 2, XS_TOKEN_TEMPLATE, aLine);
      }
      else if (parser->states[0].token == XS_TOKEN_TEMPLATE_HEAD) {
        if (chainFlag)
          fxReportParserError(parser, parser->states[0].line, "invalid template");
        fxTemplateExpression(parser);
        fxPushNodeStruct(parser, 2, XS_TOKEN_TEMPLATE, aLine);
      }
      else if (parser->states[0].token == XS_TOKEN_CHAIN) {
        fxGetNextToken(parser);
        chainFlag = 1;
        if (parser->states[0].token == XS_TOKEN_IDENTIFIER) {
          fxPushNodeStruct(parser, 1, XS_TOKEN_OPTION, aLine);
          fxPushSymbol(parser, parser->states[0].symbol);
          fxPushNodeStruct(parser, 2, XS_TOKEN_MEMBER, aLine);
          fxGetNextToken(parser);
        }
        else if (parser->states[0].token == XS_TOKEN_PRIVATE_IDENTIFIER) {
          fxPushNodeStruct(parser, 1, XS_TOKEN_OPTION, aLine);
          fxPushSymbol(parser, parser->states[0].symbol);
          fxSwapNodes(parser);
          fxPushNodeStruct(parser, 2, XS_TOKEN_PRIVATE_MEMBER, aLine);
          fxGetNextToken(parser);
        }
        else if (parser->states[0].token == XS_TOKEN_LEFT_BRACKET) {
          fxPushNodeStruct(parser, 1, XS_TOKEN_OPTION, aLine);
          fxGetNextToken(parser);
          fxCommaExpression(parser);
          fxPushNodeStruct(parser, 2, XS_TOKEN_MEMBER_AT, aLine);
          fxMatchToken(parser, XS_TOKEN_RIGHT_BRACKET);
        }
        else if (parser->states[0].token == XS_TOKEN_LEFT_PARENTHESIS) {
          fxPushNodeStruct(parser, 1, XS_TOKEN_OPTION, aLine);
          fxParameters(parser);
          fxPushNodeStruct(parser, 2, XS_TOKEN_CALL, aLine);
        }
        else
          fxReportParserError(parser, parser->states[0].line, "invalid ?.");
      }
      else
        break;
    } 
    if (chainFlag)
      fxPushNodeStruct(parser, 1, XS_TOKEN_CHAIN, chainLine);
  } 
}

void fxLiteralExpression(txParser* parser, txUnsigned flag)
{
  int escaped;
  txSymbol* aSymbol;
  txInteger aLine = parser->states[0].line;
  txUnsigned flags = 0;
  char c = 0;
  fxCheckParserStack(parser, aLine);
  switch (parser->states[0].token) {
  case XS_TOKEN_NULL:
  case XS_TOKEN_TRUE:
  case XS_TOKEN_FALSE:
    fxPushNodeStruct(parser, 0, parser->states[0].token, aLine);
    fxMatchToken(parser, parser->states[0].token);
    break;
  case XS_TOKEN_IMPORT:
    fxMatchToken(parser, XS_TOKEN_IMPORT);
    if (!flag && (parser->states[0].token == XS_TOKEN_LEFT_PARENTHESIS)) {
      txUnsigned flags = parser->flags & mxForFlag;
      fxGetNextToken(parser);
      parser->flags &= ~mxForFlag;
      fxAssignmentExpression(parser);
      if (parser->states[0].token == XS_TOKEN_COMMA) {
        fxGetNextToken(parser);
        if (gxTokenFlags[parser->states[0].token] & XS_TOKEN_BEGIN_EXPRESSION) {
          fxAssignmentExpression(parser);
          if (parser->states[0].token == XS_TOKEN_COMMA)
            fxGetNextToken(parser);
        }
        else
          fxPushNULL(parser);
      }
      else
        fxPushNULL(parser);
      parser->flags |= flags;
      fxMatchToken(parser, XS_TOKEN_RIGHT_PARENTHESIS);
      fxPushNodeStruct(parser, 2, XS_TOKEN_IMPORT_CALL, aLine);
    }
    else if (parser->states[0].token == XS_TOKEN_DOT) {
      fxGetNextToken(parser);
      if ((parser->states[0].token == XS_TOKEN_IDENTIFIER) && (parser->states[0].symbol == parser->metaSymbol) && (!parser->states[0].escaped)) { 
        fxGetNextToken(parser);
        if (parser->flags & mxProgramFlag)
          fxReportParserError(parser, parser->states[0].line, "invalid import.meta");
        else
          fxPushNodeStruct(parser, 0, XS_TOKEN_IMPORT_META, aLine);
      }
      else
        fxReportParserError(parser, parser->states[0].line, "invalid import.");
    }
    else
      fxReportParserError(parser, parser->states[0].line, "invalid import");
    break;
  case XS_TOKEN_SUPER:
    fxMatchToken(parser, XS_TOKEN_SUPER);
    if (parser->states[0].token == XS_TOKEN_LEFT_PARENTHESIS) {
      if (parser->flags & mxDerivedFlag) {
        fxParameters(parser);
        fxPushNodeStruct(parser, 1, XS_TOKEN_SUPER, aLine);
      }
      else {
        fxPushNodeStruct(parser, 0, XS_TOKEN_UNDEFINED, aLine);
        fxReportParserError(parser, parser->states[0].line, "invalid super");
      }
    }
    else if ((parser->states[0].token == XS_TOKEN_DOT) || (parser->states[0].token == XS_TOKEN_LEFT_BRACKET)) {
      if (parser->flags & mxSuperFlag) {
        fxPushNodeStruct(parser, 0, XS_TOKEN_THIS, aLine);
        parser->root->flags |= parser->flags & (mxDerivedFlag | mxSuperFlag);
      }
      else {
        fxPushNodeStruct(parser, 0, XS_TOKEN_UNDEFINED, aLine);
        fxReportParserError(parser, parser->states[0].line, "invalid super");
      }
    }
    else
      fxReportParserError(parser, parser->states[0].line, "invalid super");
    parser->flags |= mxSuperFlag;
    break;
  case XS_TOKEN_THIS:
    fxPushNodeStruct(parser, 0, parser->states[0].token, aLine);
    parser->root->flags |= parser->flags & mxDerivedFlag;
    fxMatchToken(parser, XS_TOKEN_THIS);
    break;
  case XS_TOKEN_INTEGER:
    fxPushIntegerNode(parser, parser->states[0].integer, aLine);
    fxGetNextToken(parser);
    break;
  case XS_TOKEN_NUMBER:
    fxPushNumberNode(parser, parser->states[0].number, aLine);
    fxGetNextToken(parser);
    break;
  case XS_TOKEN_BIGINT:
    fxPushBigIntNode(parser, &parser->states[0].bigint, aLine);
    fxGetNextToken(parser);
    break;
  case XS_TOKEN_DIVIDE_ASSIGN:
    c = '=';
    // continue
    mxFallThrough;
  case XS_TOKEN_DIVIDE:
    fxGetNextRegExp(parser, c);
    fxPushStringNode(parser, parser->states[0].modifierLength, parser->states[0].modifier, aLine);
    fxPushStringNode(parser, parser->states[0].stringLength, parser->states[0].string, aLine);
    fxPushNodeStruct(parser, 2, XS_TOKEN_REGEXP, aLine);
    fxGetNextToken(parser);
    break;
  case XS_TOKEN_STRING:
    fxPushStringNode(parser, parser->states[0].stringLength, parser->states[0].string, aLine);
    fxGetNextToken(parser);
    break;
  case XS_TOKEN_IDENTIFIER:
    escaped = parser->states[0].escaped;
    aSymbol = parser->states[0].symbol;
    fxGetNextToken(parser);
//    if (aSymbol == parser->undefinedSymbol) {
//      fxPushNodeStruct(parser, 0, XS_TOKEN_UNDEFINED, aLine);
//      break;
//    }
    flags = 0;
    if ((aSymbol == parser->asyncSymbol) && (!escaped) && (!parser->states[0].crlf)) {
      if (parser->states[0].token == XS_TOKEN_FUNCTION) {
        fxMatchToken(parser, XS_TOKEN_FUNCTION);
        if (parser->states[0].token == XS_TOKEN_MULTIPLY) {
          fxGetNextToken(parser);
          fxGeneratorExpression(parser, aLine, C_NULL, mxAsyncFlag);
        }
        else
          fxFunctionExpression(parser, aLine, C_NULL, mxAsyncFlag);
        break;
      }
      if (parser->states[0].token == XS_TOKEN_LEFT_PARENTHESIS) {
        fxGroupExpression(parser, mxAsyncFlag);
        break;
      }
      if (parser->states[0].token == XS_TOKEN_IDENTIFIER) {
//        if (!(parser->flags & mxForFlag) || !fxIsKeyword(parser, parser->ofSymbol)) {
          aSymbol = parser->states[0].symbol;
          fxGetNextToken(parser);
          flags = mxAsyncFlag;
//        }
      }
    }
    if (aSymbol == parser->awaitSymbol)
      parser->flags |= mxAwaitingFlag;
    if ((!parser->states[0].crlf) && (parser->states[0].token == XS_TOKEN_ARROW)) {
      fxCheckStrictSymbol(parser, aSymbol);
      if (flags && (aSymbol == parser->awaitSymbol))
        fxReportParserError(parser, parser->states[0].line, "invalid await");
      fxPushSymbol(parser, aSymbol);
      fxPushNULL(parser);
      fxPushNodeStruct(parser, 2, XS_TOKEN_ARG, aLine);
      fxPushNodeList(parser, 1);
      fxPushNodeStruct(parser, 1, XS_TOKEN_PARAMS_BINDING, aLine);
      fxArrowExpression(parser, flags);
      break;
    }
    if (aSymbol == parser->argumentsSymbol)
      parser->flags |= mxArgumentsFlag;
    fxPushSymbol(parser, aSymbol);
    fxPushNodeStruct(parser, 1, XS_TOKEN_ACCESS, aLine);
    break;
  case XS_TOKEN_CLASS:
    flags = parser->flags & mxForFlag;
    parser->flags &= ~mxForFlag;
    fxClassExpression(parser, aLine, C_NULL);
    parser->flags |= flags;
    break;
  case XS_TOKEN_FUNCTION:
    fxMatchToken(parser, XS_TOKEN_FUNCTION);
    if (parser->states[0].token == XS_TOKEN_MULTIPLY) {
      fxGetNextToken(parser);
      fxGeneratorExpression(parser, aLine, C_NULL, 0);
    }
    else
      fxFunctionExpression(parser, aLine, C_NULL, 0);
    break;
  case XS_TOKEN_NEW:
    fxNewExpression(parser);
    break;
  case XS_TOKEN_LEFT_BRACE:
    flags = parser->flags & mxForFlag;
    parser->flags &= ~mxForFlag;
    fxObjectExpression(parser);
    parser->flags |= flags;
    break;
  case XS_TOKEN_LEFT_BRACKET:
    flags = parser->flags & mxForFlag;
    parser->flags &= ~mxForFlag;
    fxArrayExpression(parser);
    parser->flags |= flags;
    break;
  case XS_TOKEN_LEFT_PARENTHESIS:
    fxGroupExpression(parser, 0);
    break;
  case XS_TOKEN_TEMPLATE:
    fxPushNULL(parser);
    fxPushStringNode(parser, parser->states[0].stringLength, parser->states[0].string, aLine);
    fxPushRawNode(parser, parser->states[0].rawLength, parser->states[0].raw, aLine);
    fxPushNodeStruct(parser, 2, XS_TOKEN_TEMPLATE_MIDDLE, aLine);
    fxGetNextToken(parser);
    fxPushNodeList(parser, 1);
    fxPushNodeStruct(parser, 2, XS_TOKEN_TEMPLATE, aLine);
    break;
  case XS_TOKEN_TEMPLATE_HEAD:
    fxPushNULL(parser);
    fxTemplateExpression(parser);
    fxPushNodeStruct(parser, 2, XS_TOKEN_TEMPLATE, aLine);
    break;
  case XS_TOKEN_HOST:
    fxGetNextToken(parser);
    fxPushNULL(parser);
    fxPushNULL(parser);
    if (parser->states[0].token == XS_TOKEN_STRING) {
      fxPushStringNode(parser, parser->states[0].stringLength, parser->states[0].string, aLine);
      fxGetNextToken(parser);
    }
    else {
      fxReportParserError(parser, parser->states[0].line, "invalid host object");
      fxPushNULL(parser);
    }
    fxPushNodeStruct(parser, 3, XS_TOKEN_HOST, aLine);
    break;
  case XS_TOKEN_LESS:
    fxGetNextToken(parser);
    fxJSXElement(parser);
    fxGetNextToken(parser);
    break;
  default:
    fxPushNodeStruct(parser, 0, XS_TOKEN_UNDEFINED, aLine);
    fxReportParserError(parser, parser->states[0].line, "missing expression");
    break;
  }
}

void fxArrayExpression(txParser* parser)
{
  txInteger aCount = 0;
  int elision = 1;
  txInteger aLine = parser->states[0].line;
  txBoolean aSpreadFlag = 0;
  fxMatchToken(parser, XS_TOKEN_LEFT_BRACKET);
  while ((parser->states[0].token == XS_TOKEN_COMMA) || (parser->states[0].token == XS_TOKEN_SPREAD) || (gxTokenFlags[parser->states[0].token] & XS_TOKEN_BEGIN_EXPRESSION)) {
    txInteger anItemLine = parser->states[0].line;
    if (parser->states[0].token == XS_TOKEN_COMMA) {
      fxGetNextToken(parser);
      if (elision) {
        fxPushNodeStruct(parser, 0, XS_TOKEN_ELISION, anItemLine);
        aCount++;
      }
      else
        elision = 1;
    }
    else if (parser->states[0].token == XS_TOKEN_SPREAD) {
      fxGetNextToken(parser);
      if (!elision)
        fxReportParserError(parser, parser->states[0].line, "missing ,");
      fxAssignmentExpression(parser);
      fxPushNodeStruct(parser, 1, XS_TOKEN_SPREAD, anItemLine);
      aCount++;
      elision = 0;
      aSpreadFlag = 1;
    }
    else {
      if (!elision)
        fxReportParserError(parser, parser->states[0].line, "missing ,");
      fxAssignmentExpression(parser);
      aCount++;
      elision = 0;
    }
  }
  fxMatchToken(parser, XS_TOKEN_RIGHT_BRACKET);
  fxPushNodeList(parser, aCount);
  fxPushNodeStruct(parser, 1, XS_TOKEN_ARRAY, aLine);
  if (aCount && elision)
    parser->root->flags |= mxElisionFlag;
  if (aSpreadFlag)
    parser->root->flags |= mxSpreadFlag;
}

void fxArrowExpression(txParser* parser, txUnsigned flag)
{
  txInteger aLine = parser->states[0].line;
  txUnsigned flags = parser->flags;
  parser->flags &= ~(mxAsyncFlag | mxGeneratorFlag);
  parser->flags |= mxArrowFlag | flag;
  fxMatchToken(parser, XS_TOKEN_ARROW);
  fxPushNULL(parser);
  fxSwapNodes(parser);  
  if (parser->states[0].token == XS_TOKEN_LEFT_BRACE) {
    fxMatchToken(parser, XS_TOKEN_LEFT_BRACE);
    fxBody(parser);
    fxPushNodeStruct(parser, 1, XS_TOKEN_BODY, aLine);
    fxMatchToken(parser, XS_TOKEN_RIGHT_BRACE);
  }
  else {
    fxAssignmentExpression(parser);
    fxPushNodeStruct(parser, 1, XS_TOKEN_RETURN, aLine);
    fxPushNodeStruct(parser, 1, XS_TOKEN_BODY, aLine);
    if (!(flags & mxAsyncFlag) && (flag & mxAsyncFlag)) {
      if (parser->states[0].token == XS_TOKEN_AWAIT) {
        parser->states[0].token = XS_TOKEN_IDENTIFIER;
      }
    }
  }
  fxPushNodeStruct(parser, 3, XS_TOKEN_FUNCTION, aLine);
  parser->root->flags = parser->flags & (mxStrictFlag | mxFieldFlag | mxNotSimpleParametersFlag | mxArrowFlag | mxSuperFlag | flag);
  if (!(flags & mxStrictFlag) && (parser->flags & mxStrictFlag))
    fxCheckStrictFunction(parser, (txFunctionNode*)parser->root);
  parser->flags = flags | (parser->flags & (mxArgumentsFlag | mxEvalFlag));
}

void fxClassExpression(txParser* parser, txInteger theLine, txSymbol** theSymbol)
{
  txBoolean heritageFlag = 0;
//  txBoolean hostFlag = 0;
  txNode* constructor = NULL;
  txInteger aCount = 0;
  txInteger aLine = parser->states[0].line;
  txUnsigned flags = parser->flags;
  txUnsigned constructorFlags = mxSuperFlag;
  txInteger constructorInitCount = 0;
  txInteger instanceInitCount = 0;
  parser->flags |= mxStrictFlag;
  fxMatchToken(parser, XS_TOKEN_CLASS);
  if (parser->states[0].token == XS_TOKEN_IDENTIFIER) {
    fxPushSymbol(parser, parser->states[0].symbol);
    if (theSymbol)
      *theSymbol = parser->states[0].symbol;
    fxGetNextToken(parser);
  }
  else
    fxPushNULL(parser);
  if (parser->states[0].token == XS_TOKEN_EXTENDS) {
    fxMatchToken(parser, XS_TOKEN_EXTENDS);
    fxCallExpression(parser);
    fxCheckArrowFunction(parser, 1);
    fxCheckNativeConstructor(parser);
    flags |= parser->flags & mxAwaitingFlag;
    constructorFlags |= mxDerivedFlag;
    if (parser->root->description->token == XS_TOKEN_HOST)
      constructorFlags |= mxHostFlag;
    heritageFlag = 1;
  }
  else if (parser->states[0].token == XS_TOKEN_HOST) {
    fxGetNextToken(parser);
    fxPushNULL(parser);
    fxPushNULL(parser);
    if (parser->states[0].token == XS_TOKEN_STRING) {
      fxPushStringNode(parser, parser->states[0].stringLength, parser->states[0].string, aLine);
      fxGetNextToken(parser);
    }
    else {
      fxReportParserError(parser, parser->states[0].line, "invalid host class");
      fxPushNULL(parser);
    }
    fxPushNodeStruct(parser, 3, XS_TOKEN_HOST, aLine);
    constructorFlags |= mxBaseFlag | mxHostFlag;
//    hostFlag = 1;
  }
  else {
    fxPushNULL(parser);
    constructorFlags |= mxBaseFlag;
  }
  if (parser->states[0].token == XS_TOKEN_LEFT_BRACE) {
    fxMatchToken(parser, XS_TOKEN_LEFT_BRACE);
    for (;;) {
      txBoolean aStaticFlag;
      txInteger aPropertyLine = parser->states[0].line;
      txSymbol* aSymbol;
      txToken aToken0;
      txToken aToken1;
      txToken aToken2;
      txUnsigned flag;
      while (parser->states[0].token == XS_TOKEN_SEMICOLON)
        fxGetNextToken(parser);
      if (parser->states[0].token == XS_TOKEN_RIGHT_BRACE)
        break;
      aStaticFlag = 0;
      if ((parser->states[0].token == XS_TOKEN_STATIC) && (!parser->states[0].escaped)) {
        fxGetNextToken(parser);
        if ((parser->states[0].token == XS_TOKEN_ASSIGN) || parser->states[0].token == XS_TOKEN_SEMICOLON) {
          fxPushSymbol(parser, parser->staticSymbol);
          aToken1 = XS_TOKEN_PROPERTY;
          goto field;
        }
        if (parser->states[0].token == XS_TOKEN_LEFT_BRACE) {
          txUnsigned flags = parser->flags;
          parser->flags = (flags & (mxParserFlags | mxStrictFlag)) | mxSuperFlag | mxTargetFlag | mxFieldFlag | mxAsyncFlag;
          fxCheckParserStack(parser, aPropertyLine);
          fxGetNextToken(parser);
          fxStatements(parser);
          fxMatchToken(parser, XS_TOKEN_RIGHT_BRACE);
          fxPushNodeStruct(parser, 1, XS_TOKEN_BODY, aPropertyLine);
          if (parser->flags & mxArgumentsFlag)
            fxReportParserError(parser, parser->states[0].line, "invalid arguments");
          if (parser->flags & mxAwaitingFlag)
            fxReportParserError(parser, parser->states[0].line, "invalid await");
          parser->flags = flags;
          parser->root->flags |= mxStaticFlag;
          constructorInitCount++;
          aCount++;
          continue;
        }
        aStaticFlag = 1;
      }
      fxPropertyName(parser, &aSymbol, &aToken0, &aToken1, &aToken2, &flag);
      if ((aStaticFlag == 0) && (aSymbol == parser->constructorSymbol)) {
        fxPopNode(parser); // symbol
        if (constructor || (aToken2 == XS_TOKEN_GENERATOR) || (aToken2 == XS_TOKEN_GETTER) || (aToken2 == XS_TOKEN_SETTER) || (flag & mxAsyncFlag)) 
          fxReportParserError(parser, parser->states[0].line, "invalid constructor");
        fxFunctionExpression(parser, aPropertyLine, C_NULL, constructorFlags);
        constructor = fxPopNode(parser);
      }
      else if (parser->states[0].token == XS_TOKEN_LEFT_PARENTHESIS) {
        if ((aToken1 == XS_TOKEN_PRIVATE_PROPERTY) && (aSymbol == parser->privateConstructorSymbol))
          fxReportParserError(parser, parser->states[0].line, "invalid method: #constructor");
        if (aStaticFlag && (aSymbol == parser->prototypeSymbol))
          fxReportParserError(parser, parser->states[0].line, "invalid static method: prototype");
        if (aStaticFlag)
          flag |= mxStaticFlag;
        if (aToken2 == XS_TOKEN_GETTER) 
          flag |= mxGetterFlag;
        else if (aToken2 == XS_TOKEN_SETTER) 
          flag |= mxSetterFlag;
        else
          flag |= mxMethodFlag;
        if (aToken2 == XS_TOKEN_GENERATOR)
          fxGeneratorExpression(parser, aPropertyLine, C_NULL, mxSuperFlag | flag);
        else
          fxFunctionExpression(parser, aPropertyLine, C_NULL, mxSuperFlag | flag);
        fxPushNodeStruct(parser, 2, aToken1, aPropertyLine);
        parser->root->flags |= flag & (mxStaticFlag | mxGetterFlag | mxSetterFlag | mxMethodFlag);
        if (aToken1 == XS_TOKEN_PRIVATE_PROPERTY) {
          if (aStaticFlag)
            constructorInitCount++;
          else
            instanceInitCount++;
        }
        aCount++;
      }
      else {
        if ((aToken1 == XS_TOKEN_PRIVATE_PROPERTY) && (aSymbol == parser->privateConstructorSymbol))
          fxReportParserError(parser, parser->states[0].line, "invalid field: #constructor");
        if (aSymbol == parser->constructorSymbol)
          fxReportParserError(parser, parser->states[0].line, "invalid field: constructor");
        if (aSymbol == parser->prototypeSymbol)
          fxReportParserError(parser, parser->states[0].line, "invalid field: prototype");
      field:
        if (parser->states[0].token == XS_TOKEN_ASSIGN) {
          txUnsigned flags = parser->flags;
          parser->flags = (flags & (mxParserFlags | mxStrictFlag)) | mxSuperFlag | mxTargetFlag | mxFieldFlag;
          fxGetNextToken(parser);
          fxAssignmentExpression(parser);
          if (parser->flags & mxArgumentsFlag)
            fxReportParserError(parser, parser->states[0].line, "invalid arguments");
          parser->flags = flags;
        }
        else {
          fxPushNodeStruct(parser, 0, XS_TOKEN_UNDEFINED, aLine);
        }
        fxPushNodeStruct(parser, 2, aToken1, aPropertyLine);
        if (aStaticFlag) {
          parser->root->flags |= mxStaticFlag;
          constructorInitCount++;
        }
        else
          instanceInitCount++;
        fxSemicolon(parser);
        aCount++;
      }
    }
  }
  fxMatchToken(parser, XS_TOKEN_RIGHT_BRACE);
  fxPushNodeList(parser, aCount);
  
  if (constructorInitCount || instanceInitCount) {
    txNodeList* itemsList = (txNodeList*)(parser->root);
    txNodeList* constructorInitList = C_NULL;
    txNode** constructorInitAddress = C_NULL;
    txNodeList* instanceInitList = C_NULL;
    txNode** instanceInitAddress = C_NULL;
    txNode** address;
    txNode* item;
    if (constructorInitCount) {
      fxPushNULL(parser);
      fxPushNodeList(parser, 0);
      fxPushNodeStruct(parser, 1, XS_TOKEN_PARAMS_BINDING, aLine);
      fxPushNodeList(parser, 0);
      constructorInitList = (txNodeList*)(parser->root);
      constructorInitList->length = constructorInitCount;
      constructorInitAddress = &(((txNodeList*)(parser->root))->first);
      fxPushNodeStruct(parser, 1, XS_TOKEN_STATEMENTS, aLine);
      fxPushNodeStruct(parser, 1, XS_TOKEN_BODY, aLine);
      fxPushNodeStruct(parser, 3, XS_TOKEN_FUNCTION, aLine);
      parser->root->flags = mxStrictFlag | mxSuperFlag | mxFieldFlag;
    }
    else 
      fxPushNULL(parser);
    if (instanceInitCount) {
      fxPushNULL(parser);
      fxPushNodeList(parser, 0);
      fxPushNodeStruct(parser, 1, XS_TOKEN_PARAMS_BINDING, aLine);
      fxPushNodeList(parser, 0);
      instanceInitList = (txNodeList*)(parser->root);
      instanceInitList->length = instanceInitCount;
      instanceInitAddress = &(((txNodeList*)(parser->root))->first);
      fxPushNodeStruct(parser, 1, XS_TOKEN_STATEMENTS, aLine);
      fxPushNodeStruct(parser, 1, XS_TOKEN_BODY, aLine);
      fxPushNodeStruct(parser, 3, XS_TOKEN_FUNCTION, aLine);
      parser->root->flags = mxStrictFlag | mxSuperFlag | mxFieldFlag;
    }
    else 
      fxPushNULL(parser);
    address = &(itemsList->first);
    while ((item = *address)) {
      if (item->flags & (mxMethodFlag | mxGetterFlag | mxSetterFlag)) {
        if (item->description->token == XS_TOKEN_PRIVATE_PROPERTY) {
          txFieldNode* field = fxFieldNodeNew(parser, XS_TOKEN_FIELD);
          field->item = item;
          if (item->flags & mxStaticFlag) {
            *constructorInitAddress = (txNode*)field;
            constructorInitAddress = &field->next;
          }
          else {
            *instanceInitAddress = (txNode*)field;
            instanceInitAddress = &field->next;
          }
        }
      }
      address = &(item->next);
    }
    address = &(itemsList->first);
    while ((item = *address)) {
      if (item->description->token == XS_TOKEN_BODY) {
        *address = item->next;
        item->next = C_NULL;
        itemsList->length--;
        *constructorInitAddress = (txNode*)item;
        constructorInitAddress = &item->next;
      }
      else if (item->flags & (mxMethodFlag | mxGetterFlag | mxSetterFlag)) {
        address = &(item->next);
      }
      else {
        txFieldNode* field = fxFieldNodeNew(parser, XS_TOKEN_FIELD);
        field->item = item;
        if (item->description->token == XS_TOKEN_PROPERTY) {
          field->value = ((txPropertyNode*)item)->value;
          ((txPropertyNode*)item)->value = C_NULL;
        }
        else if (item->description->token == XS_TOKEN_PROPERTY_AT) {
          field->value = ((txPropertyAtNode*)item)->value;
          ((txPropertyAtNode*)item)->value = C_NULL;
        }
        else {
          field->value = ((txPrivatePropertyNode*)item)->value;
          ((txPrivatePropertyNode*)item)->value = C_NULL;
        }
        if (item->flags & mxStaticFlag) {
          *constructorInitAddress = (txNode*)field;
          constructorInitAddress = &field->next;
        }
        else {
          *instanceInitAddress = (txNode*)field;
          instanceInitAddress = &field->next;
        }
        address = &(item->next);
      }
    }
  }
  else {
    fxPushNULL(parser);
    fxPushNULL(parser);
  }
  if (constructor) {
    fxPushNode(parser, constructor);
  }
  else {
    if (heritageFlag) {
      fxPushNULL(parser);
    
      fxPushSymbol(parser, parser->argsSymbol);
      fxPushNULL(parser);
      fxPushNodeStruct(parser, 2, XS_TOKEN_ARG, aLine);
      fxPushNodeStruct(parser, 1, XS_TOKEN_REST_BINDING, aLine);
      fxPushNodeList(parser, 1);
      fxPushNodeStruct(parser, 1, XS_TOKEN_PARAMS_BINDING, aLine);
      
      fxPushSymbol(parser, parser->argsSymbol);
      fxPushNodeStruct(parser, 1, XS_TOKEN_ACCESS, aLine);
      fxPushNodeStruct(parser, 1, XS_TOKEN_SPREAD, aLine);
      fxPushNodeList(parser, 1);
      fxPushNodeStruct(parser, 1, XS_TOKEN_PARAMS, aLine);
      parser->root->flags |= mxSpreadFlag;
      fxPushNodeStruct(parser, 1, XS_TOKEN_SUPER, aLine);
      fxPushNodeStruct(parser, 1, XS_TOKEN_STATEMENT, aLine);
      fxPushNodeStruct(parser, 1, XS_TOKEN_BODY, aLine);
      
      fxPushNodeStruct(parser, 3, XS_TOKEN_FUNCTION, aLine);
      parser->root->flags = mxStrictFlag | mxDerivedFlag | mxMethodFlag | mxTargetFlag | mxSuperFlag;
    }
    else {
      fxPushNULL(parser);
    
      fxPushNodeList(parser, 0);
      fxPushNodeStruct(parser, 1, XS_TOKEN_PARAMS_BINDING, aLine);
      
      fxPushNodeStruct(parser, 0, XS_TOKEN_UNDEFINED, aLine);
      fxPushNodeStruct(parser, 1, XS_TOKEN_STATEMENT, aLine);
      fxPushNodeStruct(parser, 1, XS_TOKEN_BODY, aLine);
      
      fxPushNodeStruct(parser, 3, XS_TOKEN_FUNCTION, aLine);
      parser->root->flags = mxStrictFlag | mxBaseFlag | mxMethodFlag | mxTargetFlag;
    }
  }
  fxPushNodeStruct(parser, 6, XS_TOKEN_CLASS, aLine);
  parser->flags = flags | (parser->flags & (mxArgumentsFlag));
}

void fxFunctionExpression(txParser* parser, txInteger theLine, txSymbol** theSymbol, txUnsigned flag)
{
  txUnsigned flags = parser->flags;
  parser->flags = (flags & (mxParserFlags | mxStrictFlag)) | mxFunctionFlag | mxTargetFlag | flag;
  if ((parser->states[0].token == XS_TOKEN_IDENTIFIER)
      || ((flags & mxGeneratorFlag) && !(flags & mxStrictFlag) && (parser->states[0].token == XS_TOKEN_YIELD))
      || ((theSymbol == C_NULL) && (parser->states[0].token == XS_TOKEN_AWAIT))) {
    fxPushSymbol(parser, parser->states[0].symbol);
    if (theSymbol)
      *theSymbol = parser->states[0].symbol;
    fxCheckStrictSymbol(parser, parser->states[0].symbol);
    fxGetNextToken(parser);
  }
  else
    fxPushNULL(parser);
  fxParametersBinding(parser);
  if (parser->states[0].token == XS_TOKEN_HOST) {
    fxGetNextToken(parser);
    if (parser->states[0].token == XS_TOKEN_STRING) {
      fxPushStringNode(parser, parser->states[0].stringLength, parser->states[0].string, theLine);
      fxGetNextToken(parser);
    }
    else {
      fxReportParserError(parser, parser->states[0].line, "invalid host function");
      fxPushNULL(parser);
    }
    fxPushNodeStruct(parser, 3, XS_TOKEN_HOST, theLine);
        parser->root->flags = parser->flags & (mxStrictFlag | mxNotSimpleParametersFlag | mxTargetFlag | mxArgumentsFlag | mxEvalFlag | flag);
        if (!(flags & mxStrictFlag) && (parser->flags & mxStrictFlag))
            fxCheckStrictFunction(parser, (txFunctionNode*)parser->root);
        parser->flags = flags;
  }
  else {
    fxMatchToken(parser, XS_TOKEN_LEFT_BRACE);
    fxBody(parser);
    fxPushNodeStruct(parser, 1, XS_TOKEN_BODY, theLine);
    fxPushNodeStruct(parser, 3, XS_TOKEN_FUNCTION, theLine);
        parser->root->flags = parser->flags & (mxStrictFlag | mxNotSimpleParametersFlag | mxTargetFlag | mxArgumentsFlag | mxEvalFlag | flag);
        if (!(flags & mxStrictFlag) && (parser->flags & mxStrictFlag))
            fxCheckStrictFunction(parser, (txFunctionNode*)parser->root);
        if (parser->flags & mxNativeFlag) {
          fxCheckNativeFunction(parser);
        }     
        parser->flags = flags;
        fxMatchToken(parser, XS_TOKEN_RIGHT_BRACE);
  }
}

void fxGeneratorExpression(txParser* parser, txInteger theLine, txSymbol** theSymbol, txUnsigned flag)
{
  txUnsigned flags = parser->flags;
  parser->flags = (flags & (mxParserFlags | mxStrictFlag)) | mxGeneratorFlag | mxTargetFlag | flag;
  if ((parser->states[0].token == XS_TOKEN_IDENTIFIER)
      || ((theSymbol == C_NULL) && (parser->states[0].token == XS_TOKEN_AWAIT))) {
    fxPushSymbol(parser, parser->states[0].symbol);
    if (theSymbol)
      *theSymbol = parser->states[0].symbol;
    else if (parser->states[0].symbol == parser->yieldSymbol)
      fxReportParserError(parser, parser->states[0].line, "invalid yield");
    else if ((parser->flags & mxAsyncFlag) && (parser->states[0].symbol == parser->awaitSymbol))
      fxReportParserError(parser, parser->states[0].line, "invalid await");
    fxCheckStrictSymbol(parser, parser->states[0].symbol);
    fxGetNextToken(parser);
  }
  else
    fxPushNULL(parser);
  fxParametersBinding(parser);
  fxMatchToken(parser, XS_TOKEN_LEFT_BRACE);
  parser->flags |= mxYieldFlag;
    fxBody(parser);
  parser->flags &= ~mxYieldFlag;
  fxPushNodeStruct(parser, 1, XS_TOKEN_BODY, theLine);
  fxPushNodeStruct(parser, 3, XS_TOKEN_GENERATOR, theLine);
  parser->root->flags = parser->flags & (mxStrictFlag | mxNotSimpleParametersFlag | mxGeneratorFlag | mxArgumentsFlag | mxEvalFlag | flag);
  if (!(flags & mxStrictFlag) && (parser->flags & mxStrictFlag))
    fxCheckStrictFunction(parser, (txFunctionNode*)parser->root);
  parser->flags = flags;
    fxMatchToken(parser, XS_TOKEN_RIGHT_BRACE);
}

void fxGroupExpression(txParser* parser, txUnsigned flag)
{
  txBoolean commaFlag = 0;
  txBoolean spreadFlag = 0;
  txInteger aCount = 0;
  txInteger aLine;
  txUnsigned formerAwaitingYieldingFlags = parser->flags & (mxAwaitingFlag | mxYieldingFlag);
  parser->flags &= ~(mxAwaitingFlag | mxYieldingFlag);
  fxMatchToken(parser, XS_TOKEN_LEFT_PARENTHESIS);
  while ((parser->states[0].token == XS_TOKEN_SPREAD) || (gxTokenFlags[parser->states[0].token] & XS_TOKEN_BEGIN_EXPRESSION)) {
    aLine = parser->states[0].line;
    commaFlag = 0;
    if (parser->states[0].token == XS_TOKEN_SPREAD) {
      fxGetNextToken(parser);
      fxAssignmentExpression(parser);
      fxPushNodeStruct(parser, 1, XS_TOKEN_SPREAD, aLine);
      spreadFlag = 1;
    }
    else
      fxAssignmentExpression(parser);
    aCount++;
    if (parser->states[0].token != XS_TOKEN_COMMA) 
      break;
    fxGetNextToken(parser);
    commaFlag = 1;
  }
  aLine = parser->states[0].line;
  fxMatchToken(parser, XS_TOKEN_RIGHT_PARENTHESIS);
  if ((!parser->states[0].crlf) && (parser->states[0].token == XS_TOKEN_ARROW)) {
    fxPushNodeList(parser, aCount);
    fxPushNodeStruct(parser, 1, XS_TOKEN_EXPRESSIONS, aLine);
    if (commaFlag && spreadFlag)
      fxReportParserError(parser, parser->states[0].line, "invalid parameters");
    if (!fxParametersBindingFromExpressions(parser, parser->root))
      fxReportParserError(parser, parser->states[0].line, "no parameters");
    fxCheckStrictBinding(parser, parser->root);
    parser->root->flags |= flag;
    if (parser->flags & mxAwaitingFlag) {
      if (flag || (parser->flags & mxAsyncFlag))
        fxReportParserError(parser, parser->states[0].line, "invalid await");
      else
        formerAwaitingYieldingFlags |= mxAwaitingFlag;
    }
    if (parser->flags & mxYieldingFlag)
      fxReportParserError(parser, parser->states[0].line, "invalid yield");
    fxArrowExpression(parser, flag);
  }
  else if (flag) {
    fxPushNodeList(parser, aCount);
    fxPushNodeStruct(parser, 1, XS_TOKEN_PARAMS, aLine);
    if (spreadFlag)
      parser->root->flags |= mxSpreadFlag;
    
    fxPushSymbol(parser, parser->asyncSymbol);
    fxPushNodeStruct(parser, 1, XS_TOKEN_ACCESS, aLine);
    fxSwapNodes(parser);
    fxPushNodeStruct(parser, 2, XS_TOKEN_CALL, aLine);
  }
  else {
        if ((aCount == 0) || commaFlag) {
            fxPushNULL(parser);
      fxReportParserError(parser, parser->states[0].line, "missing expression");
        }
    else /*if (aCount > 1)*/ {
      fxPushNodeList(parser, aCount);
      fxPushNodeStruct(parser, 1, XS_TOKEN_EXPRESSIONS, aLine);
    }
  }
  parser->flags |= formerAwaitingYieldingFlags;
}

void fxNewExpression(txParser* parser)
{
  txInteger aLine = parser->states[0].line;
  fxMatchToken(parser, XS_TOKEN_NEW);
  if (parser->states[0].token == XS_TOKEN_DOT) {
    fxGetNextToken(parser);
    if (fxIsKeyword(parser, parser->targetSymbol)) {
      if (!(parser->flags & mxTargetFlag))
        fxReportParserError(parser, parser->states[0].line, "invalid new.target");
      fxGetNextToken(parser);
      fxPushNodeStruct(parser, 0, XS_TOKEN_TARGET, aLine);
    }
    else
      fxReportParserError(parser, parser->states[0].line, "missing target");
    return;
  }
  fxLiteralExpression(parser, 1);
  fxCheckArrowFunction(parser, 1);
  for (;;) {
    txInteger aMemberLine = parser->states[0].line;
    if (parser->states[0].token == XS_TOKEN_DOT) {
      fxGetNextToken(parser);
      if (parser->states[0].token == XS_TOKEN_IDENTIFIER) {
        fxPushSymbol(parser, parser->states[0].symbol);
        fxPushNodeStruct(parser, 2, XS_TOKEN_MEMBER, aMemberLine);
        fxGetNextToken(parser);
      }
      else if (parser->states[0].token == XS_TOKEN_PRIVATE_IDENTIFIER) {
        fxPushSymbol(parser, parser->states[0].symbol);
        fxSwapNodes(parser);
        fxPushNodeStruct(parser, 2, XS_TOKEN_PRIVATE_MEMBER, aMemberLine);
        fxGetNextToken(parser);
      }
      else
        fxReportParserError(parser, parser->states[0].line, "missing property");
    }
    else if (parser->states[0].token == XS_TOKEN_LEFT_BRACKET) {
      fxGetNextToken(parser);
      fxCommaExpression(parser);
      fxPushNodeStruct(parser, 2, XS_TOKEN_MEMBER_AT, aMemberLine);
      fxMatchToken(parser, XS_TOKEN_RIGHT_BRACKET);
    }
    else if (parser->states[0].token == XS_TOKEN_TEMPLATE) {
      fxPushStringNode(parser, parser->states[0].stringLength, parser->states[0].string, aLine);
      fxPushRawNode(parser, parser->states[0].rawLength, parser->states[0].raw, aLine);
      fxPushNodeStruct(parser, 2, XS_TOKEN_TEMPLATE_MIDDLE, aLine);
      fxGetNextToken(parser);
      fxPushNodeList(parser, 1);
      fxPushNodeStruct(parser, 2, XS_TOKEN_TEMPLATE, aLine);
    }
    else if (parser->states[0].token == XS_TOKEN_TEMPLATE_HEAD) {
      fxTemplateExpression(parser);
      fxPushNodeStruct(parser, 2, XS_TOKEN_TEMPLATE, aLine);
    }
    else
      break;
  } 
  if (parser->states[0].token == XS_TOKEN_LEFT_PARENTHESIS)
    fxParameters(parser);
  else {
    fxPushNodeList(parser, 0);
    fxPushNodeStruct(parser, 1, XS_TOKEN_PARAMS, aLine);
  }
  fxPushNodeStruct(parser, 2, XS_TOKEN_NEW, aLine);
}

void fxObjectExpression(txParser* parser)
{
  txInteger aCount = 0;
  txSymbol* aSymbol;
  txToken aToken0;
  txToken aToken1;
  txToken aToken2;
  txInteger aLine = parser->states[0].line;
  txNode* base = parser->root;
  fxMatchToken(parser, XS_TOKEN_LEFT_BRACE);
  for (;;) {
    txInteger aPropertyLine = parser->states[0].line;
    txUnsigned flags = 0;
        if (parser->states[0].token == XS_TOKEN_RIGHT_BRACE)
            break;
        if (parser->states[0].token == XS_TOKEN_SPREAD) {
      fxGetNextToken(parser);
      fxAssignmentExpression(parser);
      fxPushNodeStruct(parser, 1, XS_TOKEN_SPREAD, aPropertyLine);
        }
        else {
      fxPropertyName(parser, &aSymbol, &aToken0, &aToken1, &aToken2, &flags);
      if (aToken1 == XS_TOKEN_PRIVATE_PROPERTY) {
        fxReportParserError(parser, parser->states[0].line, "invalid private property");
      }
      else if ((aToken2 == XS_TOKEN_GETTER) || (aToken2 == XS_TOKEN_SETTER)) {
        flags |= mxShorthandFlag;
        if (aToken2 == XS_TOKEN_GETTER)
          flags |= mxGetterFlag;
        else if (aToken2 == XS_TOKEN_SETTER)
          flags |= mxSetterFlag;
        if (parser->states[0].token == XS_TOKEN_LEFT_PARENTHESIS)
          fxFunctionExpression(parser, aPropertyLine, C_NULL, mxSuperFlag);
        else
          fxReportParserError(parser, parser->states[0].line, "missing (");
      }
      else if (aToken2 == XS_TOKEN_GENERATOR) {
        flags |= mxShorthandFlag | mxMethodFlag;
        if (parser->states[0].token == XS_TOKEN_LEFT_PARENTHESIS)
          fxGeneratorExpression(parser, aPropertyLine, C_NULL, mxSuperFlag | flags);
        else
          fxReportParserError(parser, parser->states[0].line, "missing (");
      }
      else if (aToken2 == XS_TOKEN_FUNCTION) {
        flags |= mxShorthandFlag | mxMethodFlag;
        if (parser->states[0].token == XS_TOKEN_LEFT_PARENTHESIS)
          fxFunctionExpression(parser, aPropertyLine, C_NULL, mxSuperFlag | flags);
        else
          fxReportParserError(parser, parser->states[0].line, "missing (");
      }
      else if (parser->states[0].token == XS_TOKEN_LEFT_PARENTHESIS) {
        flags |= mxShorthandFlag | mxMethodFlag;
        fxFunctionExpression(parser, aPropertyLine, C_NULL, mxSuperFlag | flags);
      }
      else if (parser->states[0].token == XS_TOKEN_COLON) {
        fxGetNextToken(parser);
        fxAssignmentExpression(parser);
      }
      else if (aToken1 == XS_TOKEN_PROPERTY) {
        flags |= mxShorthandFlag;
        fxPushSymbol(parser, aSymbol);
        if (parser->states[0].token == XS_TOKEN_ASSIGN) {
          fxPushNodeStruct(parser, 1, XS_TOKEN_ACCESS, aPropertyLine);
          fxGetNextToken(parser);
          fxAssignmentExpression(parser);
          fxPushNodeStruct(parser, 2, XS_TOKEN_BINDING, aPropertyLine);
        }
        else if (aToken0 == XS_TOKEN_IDENTIFIER) {
          fxPushNodeStruct(parser, 1, XS_TOKEN_ACCESS, aPropertyLine);
        }
        else {
          fxReportParserError(parser, parser->states[0].line, "invalid identifier");
          fxPushNodeStruct(parser, 0, XS_TOKEN_UNDEFINED, aPropertyLine);
        }
      }
      else {
        fxReportParserError(parser, parser->states[0].line, "missing :");
        fxPushNodeStruct(parser, 0, XS_TOKEN_UNDEFINED, aPropertyLine);
      }
      fxPushNodeStruct(parser, 2, aToken1, aPropertyLine);
      parser->root->flags |= flags;
      fxCheckUniqueProperty(parser, base, parser->root); 
    }
    aCount++;
        if (parser->states[0].token == XS_TOKEN_RIGHT_BRACE)
            break;
    fxMatchToken(parser, XS_TOKEN_COMMA);
  }
  fxMatchToken(parser, XS_TOKEN_RIGHT_BRACE);
  fxPushNodeList(parser, aCount);
  fxPushNodeStruct(parser, 1, XS_TOKEN_OBJECT, aLine);
}

void fxTemplateExpression(txParser* parser)
{
  txInteger aCount = 0;
  txInteger aLine = parser->states[0].line;
  fxPushStringNode(parser, parser->states[0].stringLength, parser->states[0].string, aLine);
  fxPushRawNode(parser, parser->states[0].rawLength, parser->states[0].raw, aLine);
  fxPushNodeStruct(parser, 2, XS_TOKEN_TEMPLATE_MIDDLE, aLine);
  aCount++;
  for (;;) {
    fxGetNextToken(parser);
        if (parser->states[0].token != XS_TOKEN_RIGHT_BRACE) {
            fxCommaExpression(parser);
            aCount++;
        }
    if (parser->states[0].token != XS_TOKEN_RIGHT_BRACE) {
      fxReportParserError(parser, parser->states[0].line, "missing }");
    }
    fxGetNextTokenTemplate(parser);
    fxPushStringNode(parser, parser->states[0].stringLength, parser->states[0].string, aLine);
    fxPushRawNode(parser, parser->states[0].rawLength, parser->states[0].raw, aLine);
    fxPushNodeStruct(parser, 2, XS_TOKEN_TEMPLATE_MIDDLE, aLine);
    aCount++;
    if (parser->states[0].token == XS_TOKEN_TEMPLATE_TAIL) {
      fxGetNextToken(parser);
      break;
    }
  }
  fxPushNodeList(parser, aCount);
}

void fxYieldExpression(txParser* parser)
{
  txInteger aLine = parser->states[0].line;
  if (!(parser->flags & mxYieldFlag))
    fxReportParserError(parser, parser->states[0].line, "invalid yield");
  else
    parser->flags |= mxYieldingFlag;
  fxMatchToken(parser, XS_TOKEN_YIELD);
  if ((!parser->states[0].crlf) && (parser->states[0].token == XS_TOKEN_MULTIPLY)) {
    fxGetNextToken(parser);
    fxAssignmentExpression(parser);
    fxPushNodeStruct(parser, 1, XS_TOKEN_DELEGATE, aLine);
    return;
  }
  if ((!parser->states[0].crlf) && (gxTokenFlags[parser->states[0].token] & XS_TOKEN_BEGIN_EXPRESSION)) {
    fxAssignmentExpression(parser);
  }
  else {
    fxPushNodeStruct(parser, 0, XS_TOKEN_UNDEFINED, aLine);
  }
  fxPushNodeStruct(parser, 1, XS_TOKEN_YIELD, aLine);
}

void fxParameters(txParser* parser)
{
  txInteger aCount = 0;
  txInteger aLine = parser->states[0].line;
  txBoolean aSpreadFlag = 0;
  fxMatchToken(parser, XS_TOKEN_LEFT_PARENTHESIS);
  while ((parser->states[0].token == XS_TOKEN_SPREAD) || (gxTokenFlags[parser->states[0].token] & XS_TOKEN_BEGIN_EXPRESSION)) {
    txInteger aParamLine = parser->states[0].line;
    if (parser->states[0].token == XS_TOKEN_SPREAD) {
      fxGetNextToken(parser);
      fxAssignmentExpression(parser);
      fxPushNodeStruct(parser, 1, XS_TOKEN_SPREAD, aParamLine);
      aSpreadFlag = 1;
    }
    else
      fxAssignmentExpression(parser);
    aCount++;
    if (parser->states[0].token != XS_TOKEN_RIGHT_PARENTHESIS)
      fxMatchToken(parser, XS_TOKEN_COMMA);
  }
  fxMatchToken(parser, XS_TOKEN_RIGHT_PARENTHESIS);
  fxPushNodeList(parser, aCount);
  fxPushNodeStruct(parser, 1, XS_TOKEN_PARAMS, aLine);
  if (aSpreadFlag)
    parser->root->flags |= mxSpreadFlag;
}

void fxPropertyName(txParser* parser, txSymbol** theSymbol, txToken* theToken0, txToken* theToken1, txToken* theToken2, txUnsigned* flag)
{
  txSymbol* aSymbol = C_NULL;
  txToken aToken0 = XS_NO_TOKEN;
  txToken aToken1 = XS_NO_TOKEN;
  txToken aToken2 = XS_NO_TOKEN;
  txInteger aLine = parser->states[0].line;
  txIndex index;
  *flag = 0;
  fxLookAheadOnce(parser);
  aToken0 = parser->states[0].token;
  if ((gxTokenFlags[aToken0] & XS_TOKEN_IDENTIFIER_NAME)) {
    aSymbol = parser->states[0].symbol;
    if (parser->states[1].token == XS_TOKEN_COLON) {
      fxPushSymbol(parser, aSymbol);
      aToken1 = XS_TOKEN_PROPERTY;
    }
    else if (fxIsKeyword(parser, parser->asyncSymbol) && (!parser->states[1].crlf)) {
      *flag = mxAsyncFlag;
      fxGetNextToken(parser);
      if (parser->states[0].token == XS_TOKEN_MULTIPLY) {
        aToken2 = XS_TOKEN_GENERATOR;
        fxGetNextToken(parser);
      }
      else
        aToken2 = XS_TOKEN_FUNCTION;
    }
    else if (fxIsKeyword(parser, parser->getSymbol)) {
      aToken2 = XS_TOKEN_GETTER;
      fxGetNextToken(parser);
    }
    else if (fxIsKeyword(parser, parser->setSymbol)) {
      aToken2 = XS_TOKEN_SETTER;
      fxGetNextToken(parser);
    }
    else {
      fxPushSymbol(parser, aSymbol);
      aToken1 = XS_TOKEN_PROPERTY;
    }
  }
  else if (parser->states[0].token == XS_TOKEN_MULTIPLY) {
    aToken2 = XS_TOKEN_GENERATOR;
    fxGetNextToken(parser);
  }
  else if (parser->states[0].token == XS_TOKEN_PRIVATE_IDENTIFIER) {
    aSymbol = parser->states[0].symbol;
    fxPushSymbol(parser, aSymbol);
    aToken1 = XS_TOKEN_PRIVATE_PROPERTY;
  }
  else if (parser->states[0].token == XS_TOKEN_INTEGER) {
    if (fxIntegerToIndex(parser->console, parser->states[0].integer, &index)) {
      fxPushIndexNode(parser, index, aLine);
      aToken1 = XS_TOKEN_PROPERTY_AT;
    }
    else {
      aSymbol = fxNewParserSymbol(parser, fxIntegerToString(parser->console, parser->states[0].integer, parser->buffer, parser->bufferSize));
      fxPushSymbol(parser, aSymbol);
      aToken1 = XS_TOKEN_PROPERTY;
    }
  }
  else if (parser->states[0].token == XS_TOKEN_NUMBER) {
    if (fxNumberToIndex(parser->console, parser->states[0].number, &index)) {
      fxPushIndexNode(parser, index, aLine);
      aToken1 = XS_TOKEN_PROPERTY_AT;
    }
    else {
      aSymbol = fxNewParserSymbol(parser, fxNumberToString(parser->console, parser->states[0].number, parser->buffer, parser->bufferSize, 0, 0));
      fxPushSymbol(parser, aSymbol);
      aToken1 = XS_TOKEN_PROPERTY;
    }
  }
  else if (parser->states[0].token == XS_TOKEN_STRING) {
    if (fxStringToIndex(parser->console, parser->states[0].string, &index)) {
      fxPushIndexNode(parser, index, aLine);
      aToken1 = XS_TOKEN_PROPERTY_AT;
    }
    else {
      aSymbol = fxNewParserSymbol(parser, parser->states[0].string);
      fxPushSymbol(parser, aSymbol);
      aToken1 = XS_TOKEN_PROPERTY;
    }
  }
  else if (parser->states[0].token == XS_TOKEN_LEFT_BRACKET) {
    fxGetNextToken(parser);
    fxCommaExpression(parser);
    if (parser->states[0].token != XS_TOKEN_RIGHT_BRACKET) {
      fxReportParserError(parser, parser->states[0].line, "missing ]");
    }
    aToken1 = XS_TOKEN_PROPERTY_AT;
  }
  else {
    fxReportParserError(parser, parser->states[0].line, "missing identifier");
    fxPushNULL(parser);
  }
  if (aToken2 != XS_NO_TOKEN) {
    if ((gxTokenFlags[parser->states[0].token] & XS_TOKEN_IDENTIFIER_NAME)) {
      aSymbol = parser->states[0].symbol;
      fxPushSymbol(parser, aSymbol);
      aToken1 = XS_TOKEN_PROPERTY;
      fxGetNextToken(parser);
    }
    else if (parser->states[0].token == XS_TOKEN_PRIVATE_IDENTIFIER) {
      aSymbol = parser->states[0].symbol;
      fxPushSymbol(parser, aSymbol);
      aToken1 = XS_TOKEN_PRIVATE_PROPERTY;
      fxGetNextToken(parser);
    }
    else if (parser->states[0].token == XS_TOKEN_INTEGER) {
      if (fxIntegerToIndex(parser->console, parser->states[0].integer, &index)) {
        fxPushIndexNode(parser, index, aLine);
        aToken1 = XS_TOKEN_PROPERTY_AT;
      }
      else {
        aSymbol = fxNewParserSymbol(parser, fxIntegerToString(parser->console, parser->states[0].integer, parser->buffer, parser->bufferSize));
        fxPushSymbol(parser, aSymbol);
        aToken1 = XS_TOKEN_PROPERTY;
      }
      fxGetNextToken(parser);
    }
    else if (parser->states[0].token == XS_TOKEN_NUMBER) {
      if (fxNumberToIndex(parser->console, parser->states[0].number, &index)) {
        fxPushIndexNode(parser, index, aLine);
        aToken1 = XS_TOKEN_PROPERTY_AT;
      }
      else {
        aSymbol = fxNewParserSymbol(parser, fxNumberToString(parser->console, parser->states[0].number, parser->buffer, parser->bufferSize, 0, 0));
        fxPushSymbol(parser, aSymbol);
        aToken1 = XS_TOKEN_PROPERTY;
      }
      fxGetNextToken(parser);
    }
    else if (parser->states[0].token == XS_TOKEN_STRING) {
      if (fxStringToIndex(parser->console, parser->states[0].string, &index)) {
        fxPushIndexNode(parser, index, aLine);
        aToken1 = XS_TOKEN_PROPERTY_AT;
      }
      else {
        aSymbol = fxNewParserSymbol(parser, parser->states[0].string);
        fxPushSymbol(parser, aSymbol);
        aToken1 = XS_TOKEN_PROPERTY;
      }
      fxGetNextToken(parser);
    }
    else if (parser->states[0].token == XS_TOKEN_LEFT_BRACKET) {
      fxGetNextToken(parser);
      fxCommaExpression(parser);
      if (parser->states[0].token != XS_TOKEN_RIGHT_BRACKET) {
        fxReportParserError(parser, parser->states[0].line, "missing ]");
      }
      aToken1 = XS_TOKEN_PROPERTY_AT;
      fxGetNextToken(parser);
    }
    else if (aToken2 == XS_TOKEN_GETTER) {
      fxPushSymbol(parser, aSymbol);
      aToken1 = XS_TOKEN_PROPERTY;
      aToken2 = XS_NO_TOKEN;
    }
    else if (aToken2 == XS_TOKEN_SETTER) {
      fxPushSymbol(parser, aSymbol);
      aToken1 = XS_TOKEN_PROPERTY;
      aToken2 = XS_NO_TOKEN;
    }
    else {
      fxReportParserError(parser, parser->states[0].line, "missing identifier");
      fxPushNULL(parser);
    }
  }
  else
    fxGetNextToken(parser);
  *theSymbol = aSymbol;
  *theToken0 = aToken0;
  *theToken1 = aToken1;
  *theToken2 = aToken2;
}

void fxBinding(txParser* parser, txToken theToken, txUnsigned flags)
{
  txInteger aLine = parser->states[0].line;
  fxCheckParserStack(parser, aLine);
  if (parser->states[0].token == XS_TOKEN_IDENTIFIER) {
    fxCheckStrictSymbol(parser, parser->states[0].symbol);
    if (((theToken == XS_TOKEN_CONST) || (theToken == XS_TOKEN_LET) || (theToken == XS_TOKEN_USING)) && (parser->states[0].symbol == parser->letSymbol))
      fxReportParserError(parser, parser->states[0].line, "invalid identifier");
    fxPushSymbol(parser, parser->states[0].symbol);
    fxPushNodeStruct(parser, 1, theToken, aLine);
    if (flags & mxAwaitingFlag)
      parser->root->flags |= mxAwaitingFlag;
    fxGetNextToken(parser);
  }
  else if (parser->states[0].token == XS_TOKEN_LEFT_BRACE) {
    if (theToken == XS_TOKEN_USING)
      fxReportParserError(parser, parser->states[0].line, "invalid using");
    fxObjectBinding(parser, theToken);
  }
  else if (parser->states[0].token == XS_TOKEN_LEFT_BRACKET) {
    if (theToken == XS_TOKEN_USING)
      fxReportParserError(parser, parser->states[0].line, "invalid using");
    fxArrayBinding(parser, theToken);
  }
  else {
    fxReportParserError(parser, parser->states[0].line, "missing identifier");
    fxPushNULL(parser);
  }
  if ((flags & 1) && (parser->states[0].token == XS_TOKEN_ASSIGN)) {
    parser->flags &= ~mxForFlag;
    fxGetNextToken(parser);
    fxAssignmentExpression(parser);
    fxPushNodeStruct(parser, 2, XS_TOKEN_BINDING, aLine);
  }
}

txNode* fxBindingFromExpression(txParser* parser, txNode* theNode, txToken theToken)
{
  txToken aToken = (theNode && theNode->description) ? theNode->description->token : XS_NO_TOKEN;
  txNode* binding;
again:
  if (aToken == XS_TOKEN_EXPRESSIONS) {
    txNode* item = ((txExpressionsNode*)theNode)->items->first;
    if (item && !item->next) {
      aToken = item->description->token;
      if ((aToken == XS_TOKEN_ACCESS) || (aToken == XS_TOKEN_MEMBER) || (aToken == XS_TOKEN_MEMBER_AT) || (aToken == XS_TOKEN_PRIVATE_MEMBER) || (aToken == XS_TOKEN_UNDEFINED)) {
        item->next = theNode->next;
        theNode = item;
      }
      else if (aToken == XS_TOKEN_EXPRESSIONS) {
        item->next = theNode->next;
        theNode = item;
        goto again;
      }
      else
        return NULL;
    }
  }
  if (aToken == XS_TOKEN_BINDING) {
    binding = fxBindingFromExpression(parser, ((txBindingNode*)theNode)->target, theToken);
    ((txBindingNode*)theNode)->target = binding;
//    fxCheckStrictBinding(parser, theNode);
//    fxCheckStrictSymbol(parser, ((txBindingNode*)theNode)->symbol);
//    theNode->description = &gxTokenDescriptions[theToken];
    return theNode;
  }
  if (aToken == XS_TOKEN_ARRAY_BINDING) {
    txNodeList* list = ((txArrayBindingNode*)theNode)->items;
    txNode** address = &(list->first);
    txNode* item;
    while ((item = *address)) {
      txNode* binding = *address = fxBindingFromExpression(parser, item, theToken);
      binding->next = item->next;
      address = &(binding->next);
    }
    return theNode;
  }
  if (aToken == XS_TOKEN_OBJECT_BINDING) {
    txNodeList* list = ((txObjectBindingNode*)theNode)->items;
    txNode** address = &(list->first);
    txNode* item;
    while ((item = *address)) {
      txNode* binding = *address = fxBindingFromExpression(parser, item, theToken);
      binding->next = item->next;
      address = &(binding->next);
    }
    return theNode;
  }
  if (aToken == XS_TOKEN_PROPERTY_BINDING) {
    ((txPropertyBindingNode*)theNode)->binding = fxBindingFromExpression(parser, ((txPropertyBindingNode*)theNode)->binding, theToken);
    return theNode;
  }
  if (aToken == XS_TOKEN_PROPERTY_BINDING_AT) {
    ((txPropertyBindingAtNode*)theNode)->binding = fxBindingFromExpression(parser, ((txPropertyBindingAtNode*)theNode)->binding, theToken);
    return theNode;
  }
  if (aToken == XS_TOKEN_REST_BINDING) {
    ((txRestBindingNode*)theNode)->binding = fxBindingFromExpression(parser, ((txRestBindingNode*)theNode)->binding, theToken);
    return theNode;
  }
  if (aToken == XS_TOKEN_SKIP_BINDING)
    return theNode;
  
  if (aToken == XS_TOKEN_ACCESS) {
    fxCheckStrictSymbol(parser, ((txAccessNode*)theNode)->symbol);
    if (theToken == XS_TOKEN_ACCESS)
      return theNode;
    fxPushSymbol(parser, ((txAccessNode*)theNode)->symbol);
    fxPushNodeStruct(parser, 1, theToken, ((txAccessNode*)theNode)->line);
    return fxPopNode(parser);
  }
  if ((aToken == XS_TOKEN_MEMBER) || (aToken == XS_TOKEN_MEMBER_AT) || (aToken == XS_TOKEN_PRIVATE_MEMBER) || (aToken == XS_TOKEN_UNDEFINED)) {
    return theNode;
  }
  if (aToken == XS_TOKEN_ASSIGN) {
    binding = fxBindingFromExpression(parser, ((txAssignNode*)theNode)->reference, theToken);
    if (!binding)
      return NULL;
    ((txBindingNode*)theNode)->description = &gxTokenDescriptions[XS_TOKEN_BINDING];
    ((txBindingNode*)theNode)->target = binding;
    ((txBindingNode*)theNode)->initializer = ((txAssignNode*)theNode)->value;
    return theNode;
  }
  
  if (aToken == XS_TOKEN_ARRAY)
    return fxArrayBindingFromExpression(parser, theNode, theToken);
  if (aToken == XS_TOKEN_OBJECT)
    return fxObjectBindingFromExpression(parser, theNode, theToken);
  return NULL;
}

void fxArrayBinding(txParser* parser, txToken theToken)
{
  txInteger aCount = 0;
  txInteger aLine = parser->states[0].line;
  int elision = 1;
  fxCheckParserStack(parser, aLine);
  fxMatchToken(parser, XS_TOKEN_LEFT_BRACKET);
  while ((parser->states[0].token == XS_TOKEN_COMMA) || (gxTokenFlags[parser->states[0].token] & XS_TOKEN_BEGIN_BINDING)) {
    txInteger anItemLine = parser->states[0].line;
    if (parser->states[0].token == XS_TOKEN_COMMA) {
      fxGetNextToken(parser);
      if (elision) {
        fxPushNodeStruct(parser, 0, XS_TOKEN_SKIP_BINDING, anItemLine);
        aCount++;
      }
      else
        elision = 1;
    }
    else {
      if (!elision)
        fxReportParserError(parser, parser->states[0].line, "missing ,");
      if (parser->states[0].token == XS_TOKEN_SPREAD) {
        fxRestBinding(parser, theToken, 0);
        aCount++;
        break;
      }
      fxBinding(parser, theToken, 1);
      aCount++;
      elision = 0;
    }
  }
  fxMatchToken(parser, XS_TOKEN_RIGHT_BRACKET);
  fxPushNodeList(parser, aCount);
  fxPushNodeStruct(parser, 1, XS_TOKEN_ARRAY_BINDING, aLine);
}

txNode* fxArrayBindingFromExpression(txParser* parser, txNode* theNode, txToken theToken)
{
  txNodeList* list = ((txArrayNode*)theNode)->items;
  txNode** address = &(list->first);
  txNode* item;
  txNode* binding;
  while ((item = *address)) {
        if (!item->description) {
            parser->errorSymbol = parser->SyntaxErrorSymbol;
            return NULL;
        }
    if (item->description->token == XS_TOKEN_SPREAD) {
      if (theNode->flags & mxElisionFlag) {
        parser->errorSymbol = parser->SyntaxErrorSymbol;
        return NULL;
      }
      binding = fxRestBindingFromExpression(parser, item, theToken, 0);
      if (!binding) {
        parser->errorSymbol = parser->SyntaxErrorSymbol;
        return NULL;
      }
      break;
    }
    if (item->description->token == XS_TOKEN_ELISION) {
      item->description = &gxTokenDescriptions[XS_TOKEN_SKIP_BINDING];
    }
    else {
//      if ((theToken == XS_TOKEN_BINDING) && ((item->description->token== XS_TOKEN_MEMBER) || (item->description->token == XS_TOKEN_MEMBER_AT)))
//        binding = item;
//      else {      
        binding = fxBindingFromExpression(parser, item, theToken);
        if (!binding) {
          parser->errorSymbol = parser->SyntaxErrorSymbol;
          return NULL;
        }
        binding->next = item->next;
        item = *address = binding;
//      }
    }
    address = &(item->next);
  }
  fxPushNode(parser, (txNode*)list);
  fxPushNodeStruct(parser, 1, XS_TOKEN_ARRAY_BINDING, theNode->line);
  return fxPopNode(parser);
}

txUnsigned fxObjectBinding(txParser* parser, txToken theToken)
{
  txUnsigned flags = 0;
  txInteger aCount = 0;
  txInteger aLine = parser->states[0].line;
  txSymbol* aSymbol;
  txToken aToken;
  txIndex index;
  fxMatchToken(parser, XS_TOKEN_LEFT_BRACE);
  for (;;) {
    txInteger aPropertyLine = parser->states[0].line;
    if (parser->states[0].token == XS_TOKEN_RIGHT_BRACE)
      break;
    aSymbol = NULL;
    aToken = XS_TOKEN_PROPERTY_BINDING;
    if ((gxTokenFlags[parser->states[0].token] & XS_TOKEN_IDENTIFIER_NAME)) {
      aSymbol = parser->states[0].symbol;
      fxPushSymbol(parser, aSymbol);
      aToken = XS_TOKEN_PROPERTY_BINDING;
    }
    else if (parser->states[0].token == XS_TOKEN_INTEGER) {
      if (fxIntegerToIndex(parser->console, parser->states[0].integer, &index)) {
        fxPushIndexNode(parser, index, aPropertyLine);
        aToken = XS_TOKEN_PROPERTY_BINDING_AT;
      }
      else {
        aSymbol = fxNewParserSymbol(parser, fxIntegerToString(parser->console, parser->states[0].integer, parser->buffer, parser->bufferSize));
        fxPushSymbol(parser, aSymbol);
        aToken = XS_TOKEN_PROPERTY_BINDING;
      }
    }
    else if (parser->states[0].token == XS_TOKEN_NUMBER) {
      if (fxNumberToIndex(parser->console, parser->states[0].number, &index)) {
        fxPushIndexNode(parser, index, aPropertyLine);
        aToken = XS_TOKEN_PROPERTY_BINDING_AT;
      }
      else {
        aSymbol = fxNewParserSymbol(parser, fxNumberToString(parser->console, parser->states[0].number, parser->buffer, parser->bufferSize, 0, 0));
        fxPushSymbol(parser, aSymbol);
        aToken = XS_TOKEN_PROPERTY_BINDING;
      }
    }
    else if (parser->states[0].token == XS_TOKEN_STRING) {
      if (fxStringToIndex(parser->console, parser->states[0].string, &index)) {
        fxPushIndexNode(parser, index, aPropertyLine);
        aToken = XS_TOKEN_PROPERTY_BINDING_AT;
      }
      else {
        aSymbol = fxNewParserSymbol(parser, parser->states[0].string);
        fxPushSymbol(parser, aSymbol);
        aToken = XS_TOKEN_PROPERTY_BINDING;
      }
    }
    else if (parser->states[0].token == XS_TOKEN_LEFT_BRACKET) {
      fxGetNextToken(parser);
      fxCommaExpression(parser);
      if (parser->states[0].token != XS_TOKEN_RIGHT_BRACKET) {
        fxReportParserError(parser, parser->states[0].line, "missing ]");
      }
      aToken = XS_TOKEN_PROPERTY_BINDING_AT;
    }
    else if (parser->states[0].token == XS_TOKEN_SPREAD) {
      flags |= mxSpreadFlag;
      fxRestBinding(parser, theToken, 1);
      aCount++;
            break;
    }
    else {
      fxReportParserError(parser, parser->states[0].line, "missing identifier");
      fxPushNULL(parser);
    }
    fxLookAheadOnce(parser);
    if (parser->states[1].token == XS_TOKEN_COLON) {
      fxGetNextToken(parser);
      fxGetNextToken(parser);
      fxBinding(parser, theToken, 1);
    }
    else if (aSymbol) {
      fxBinding(parser, theToken, 1);
    }
    else {
      fxReportParserError(parser, parser->states[0].line, "missing :");
      fxPushNULL(parser);
    }
    fxPushNodeStruct(parser, 2, aToken, aPropertyLine);
    aCount++;
        if (parser->states[0].token == XS_TOKEN_RIGHT_BRACE)
            break;
    if (parser->states[0].token == XS_TOKEN_COMMA)
      fxGetNextToken(parser);
    else
            break;
  }
  fxMatchToken(parser, XS_TOKEN_RIGHT_BRACE);
  fxPushNodeList(parser, aCount);
  fxPushNodeStruct(parser, 1, XS_TOKEN_OBJECT_BINDING, aLine);
  parser->root->flags |= flags;
  return flags;
}

txNode* fxObjectBindingFromExpression(txParser* parser, txNode* theNode, txToken theToken)
{
  txNodeList* list = ((txObjectNode*)theNode)->items;
  txNode* property = list->first;
  txNode* binding;
  txUnsigned flags = 0;
  while (property) {
    if (!property->description) {
      parser->errorSymbol = parser->SyntaxErrorSymbol;
      return NULL;
    }
    if (property->description->token == XS_TOKEN_PROPERTY) {
      binding = fxBindingFromExpression(parser, ((txPropertyNode*)property)->value, theToken);
      if (!binding) {
        parser->errorSymbol = parser->SyntaxErrorSymbol;
        return NULL;
      }
      property->description = &gxTokenDescriptions[XS_TOKEN_PROPERTY_BINDING];
      ((txPropertyBindingNode*)property)->binding = binding;
    }
    else if (property->description->token == XS_TOKEN_PROPERTY_AT) {
      binding = fxBindingFromExpression(parser, ((txPropertyAtNode*)property)->value, theToken);
      if (!binding) {
        parser->errorSymbol = parser->SyntaxErrorSymbol;
        return NULL;
      }
      property->description = &gxTokenDescriptions[XS_TOKEN_PROPERTY_BINDING_AT];
      ((txPropertyBindingAtNode*)property)->binding = binding;
    }
    else if (property->description->token == XS_TOKEN_SPREAD) {
      binding = fxRestBindingFromExpression(parser, property, theToken, 1);
      if (!binding) {
        parser->errorSymbol = parser->SyntaxErrorSymbol;
        return NULL;
      }
      flags |= mxSpreadFlag;
      break;
    }
    property = property->next;
  }
  fxPushNode(parser, (txNode*)list);
  fxPushNodeStruct(parser, 1, XS_TOKEN_OBJECT_BINDING, theNode->line);
  parser->root->flags |= flags;
  return fxPopNode(parser);
}

void fxParametersBinding(txParser* parser)
{
  txInteger aCount = 0;
  txInteger aLine = parser->states[0].line;
  txBindingNode* binding;
  if (parser->states[0].token == XS_TOKEN_LEFT_PARENTHESIS) {
    fxGetNextToken(parser);
    while (gxTokenFlags[parser->states[0].token] & XS_TOKEN_BEGIN_BINDING) {
      if (parser->states[0].token == XS_TOKEN_SPREAD) {
        parser->flags |= mxNotSimpleParametersFlag;
        fxRestBinding(parser, XS_TOKEN_ARG, 0);
        aCount++;
        break;
      }
      fxBinding(parser, XS_TOKEN_ARG, 1);
      binding = (txBindingNode*)parser->root;
      if (binding->description->token != XS_TOKEN_ARG)
        parser->flags |= mxNotSimpleParametersFlag;
      aCount++;
      if (parser->states[0].token != XS_TOKEN_RIGHT_PARENTHESIS)
        fxMatchToken(parser, XS_TOKEN_COMMA);
    }
    fxMatchToken(parser, XS_TOKEN_RIGHT_PARENTHESIS);
  }
  else
    fxReportParserError(parser, parser->states[0].line, "missing (");
  fxPushNodeList(parser, aCount);
  fxPushNodeStruct(parser, 1, XS_TOKEN_PARAMS_BINDING, aLine);
}

txNode* fxParametersBindingFromExpressions(txParser* parser, txNode* theNode)
{
  txNodeList* list = ((txParamsNode*)theNode)->items;
  txNode** address = &(list->first);
  txNode* item;
  txBindingNode* binding;
  while ((item = *address)) {
    txToken aToken = (item && item->description) ? item->description->token : XS_NO_TOKEN;
    if (aToken == XS_TOKEN_SPREAD) {
      binding = (txBindingNode*)fxRestBindingFromExpression(parser, item, XS_TOKEN_ARG, 0);
      if (!binding)
        return NULL;
      parser->flags |= mxNotSimpleParametersFlag;
      break;
    }
    binding = (txBindingNode*)fxBindingFromExpression(parser, item, XS_TOKEN_ARG);
    if (!binding)
      return NULL;
    if (binding->description->token != XS_TOKEN_ARG)
      parser->flags |= mxNotSimpleParametersFlag;
    binding->next = item->next;
    item = *address = (txNode*)binding;
    address = &(item->next);
  }
  theNode->description = &gxTokenDescriptions[XS_TOKEN_PARAMS_BINDING];
  return theNode;
}

void fxRestBinding(txParser* parser, txToken theToken, txUnsigned flag)
{
  txInteger aLine = parser->states[0].line;
  fxMatchToken(parser, XS_TOKEN_SPREAD);
  fxBinding(parser, theToken, 0);
  if (flag && ((parser->root->description->token == XS_TOKEN_ARRAY_BINDING) || (parser->root->description->token == XS_TOKEN_OBJECT_BINDING))) {
    fxReportParserError(parser, parser->states[0].line, "invalid rest");
  }
  fxPushNodeStruct(parser, 1, XS_TOKEN_REST_BINDING, aLine);
}

txNode* fxRestBindingFromExpression(txParser* parser, txNode* theNode, txToken theToken, txUnsigned flag)
{
  txNode* expression = ((txSpreadNode*)theNode)->expression;
  txNode* binding;
  if (theNode->next) {
    parser->errorSymbol = parser->SyntaxErrorSymbol;
    return NULL;
  }
  if (!expression)
    return NULL;
/*  if ((theToken == XS_TOKEN_BINDING) && ((expression->description->token == XS_TOKEN_MEMBER) || (expression->description->token == XS_TOKEN_MEMBER_AT)))
    binding = expression;
  else */
  {
    binding = fxBindingFromExpression(parser, expression, theToken);
    if (!binding) {
      parser->errorSymbol = parser->SyntaxErrorSymbol;
      return NULL;
    }
    if (binding->description->token == XS_TOKEN_BINDING) {
      fxReportParserError(parser, parser->states[0].line, "invalid rest");
      return NULL;
    }
    if (flag && ((binding->description->token == XS_TOKEN_ARRAY_BINDING) || (binding->description->token == XS_TOKEN_OBJECT_BINDING))) {
      fxReportParserError(parser, parser->states[0].line, "invalid rest");
      return NULL;
    }
  }
  theNode->description = &gxTokenDescriptions[XS_TOKEN_REST_BINDING];
  ((txRestBindingNode*)theNode)->binding = binding;
  return theNode;
}

void fxCheckArrowFunction(txParser* parser, txInteger count)
{
  txNode* node = parser->root;
  while (count) {
    if (node->flags & mxArrowFlag)
      fxReportParserError(parser, parser->states[0].line, "invalid arrow function");
    count--;
    node = node->next;
  }
}

static void fxReportWarning(txParser* parser, txInteger line, txString theFormat, ...)
{
  c_va_list arguments;
  c_va_start(arguments, theFormat);
    (*parser->reportWarning)(parser->console, parser->path ? parser->path->string : C_NULL, line, theFormat, arguments);
  c_va_end(arguments);
}

void fxCheckNativeConstructor(txParser* parser)
{
  txClassNode* root = (txClassNode*)(parser->root);
  if (root->description != &gxTokenDescriptions[XS_TOKEN_CLASS])
    return;
  if (root->symbol != C_NULL)
    return;
  txHostNode* host = (txHostNode*)(root->heritage);
  if (host == C_NULL)
    return;
  if (host->description != &gxTokenDescriptions[XS_TOKEN_HOST])
    return;
  if (root->constructorInit != C_NULL)
    return;
  if (root->instanceInit != C_NULL)
    return;
  txFunctionNode* constructor = (txFunctionNode*)(root->constructor);
  if (constructor->description != &gxTokenDescriptions[XS_TOKEN_FUNCTION])
    return;
  txParamsBindingNode* args = (txParamsBindingNode*)(constructor->params);
  if (args->description != &gxTokenDescriptions[XS_TOKEN_PARAMS_BINDING])
    return;
  if (args->items->length != 0)
    return;
  txBodyNode* body = (txBodyNode*)(constructor->body);
  if (body->description != &gxTokenDescriptions[XS_TOKEN_BODY])
    return;
  txStatementNode* statement = (txStatementNode*)(body->statement);
  if (statement->description != &gxTokenDescriptions[XS_TOKEN_STATEMENT])
    return;
  txNode* undefined = (txNode*)(statement->expression);
  if (undefined->description != &gxTokenDescriptions[XS_TOKEN_UNDEFINED])
    return;
  fxPopNode(parser);
  fxPushNode(parser, (txNode*)host);
}

void fxCheckNativeFunction(txParser* parser)
{
  txFunctionNode* function = (txFunctionNode*)(parser->root);
  txBodyNode* body = (txBodyNode*)(function->body);
  if (body->description != &gxTokenDescriptions[XS_TOKEN_BODY])
    goto bail;
  txStatementNode* statement = (txStatementNode*)(body->statement);
  if ((function->flags & mxDerivedFlag) && (function->flags & mxHostFlag)) {
    txStatementsNode* statements = (txStatementsNode*)(statement);
    if (statements->description != &gxTokenDescriptions[XS_TOKEN_STATEMENTS])
      goto bail;
    if (statements->items->length != 2)
      goto bail;
    statement = (txStatementNode*)(statements->items->first);
    if (statement->description != &gxTokenDescriptions[XS_TOKEN_STATEMENT])
      goto bail;
    txSuperNode* super = (txSuperNode*)(statement->expression);
    if (super->description != &gxTokenDescriptions[XS_TOKEN_SUPER])
      goto bail;
    txParamsNode* params = (txParamsNode*)(super->params);
    if (params->items->length != 0)
      goto bail;
    statement = (txStatementNode*)(statement->next);
  }
  if ((statement->description != &gxTokenDescriptions[XS_TOKEN_RETURN]) && (statement->description != &gxTokenDescriptions[XS_TOKEN_STATEMENT]))
    goto bail;
  txCallNewNode* call = (txCallNewNode*)(statement->expression);
  if (call->description != &gxTokenDescriptions[XS_TOKEN_CALL])
    goto bail;
  txMemberNode* member = (txMemberNode*)(call->reference);
  if (member->description != &gxTokenDescriptions[XS_TOKEN_MEMBER])
    goto bail;
  if (member->symbol != parser->callSymbol)
    goto bail;
  txHostNode* host = (txHostNode*)(member->reference);
  if (host->description != &gxTokenDescriptions[XS_TOKEN_HOST])
    goto bail;
  txParamsNode* params = (txParamsNode*)(call->params);
  if (params->description != &gxTokenDescriptions[XS_TOKEN_PARAMS])
    goto bail;
  txParamsBindingNode* args = (txParamsBindingNode*)(function->params);
  if (args->description != &gxTokenDescriptions[XS_TOKEN_PARAMS_BINDING])
    goto bail;
  if (params->items->length != args->items->length + 1)
    goto bail;
  txNode* arg = args->items->first;
  txNode* param = params->items->first;
  if (param->description != &gxTokenDescriptions[XS_TOKEN_THIS])
    goto bail;
  param = param->next;
  while (arg) {
    txDeclareNode* binding;
    txAccessNode* access;
    if (arg->description == &gxTokenDescriptions[XS_TOKEN_REST_BINDING]) {
      if (param->description != &gxTokenDescriptions[XS_TOKEN_SPREAD])
        goto bail;
      binding = (txDeclareNode*)(((txRestBindingNode*)arg)->binding);
      access = (txAccessNode*)(((txSpreadNode*)param)->expression);
    }
    else {
      binding = (txDeclareNode*)arg;
      access = (txAccessNode*)param;
    }
    if (binding->description != &gxTokenDescriptions[XS_TOKEN_ARG])
      goto bail;
    if (access->description != &gxTokenDescriptions[XS_TOKEN_ACCESS])
      goto bail;
    if (binding->symbol != access->symbol)
      goto bail;
    arg = arg->next;
    param = param->next;
  }
  host->flags |= function->flags;
  host->params = (txNode*)args;
  fxPopNode(parser);
  fxPushNode(parser, (txNode*)host);
  return;
bail:
    fxReportWarning(parser, function->line, "cannot optimize native");
}

txBoolean fxCheckReference(txParser* parser, txToken theToken)
{
  txNode* node = parser->root;
  txToken aToken = (node && node->description) ? node->description->token : XS_NO_TOKEN;
  if (aToken == XS_TOKEN_EXPRESSIONS) {
    txNode* item;
  again:
    item = ((txExpressionsNode*)node)->items->first;
    if (item && !item->next) {
      aToken = (item->description) ? item->description->token : XS_NO_TOKEN;
      if ((aToken == XS_TOKEN_ACCESS) || (aToken == XS_TOKEN_MEMBER) || (aToken == XS_TOKEN_MEMBER_AT) || (aToken == XS_TOKEN_PRIVATE_MEMBER) || (aToken == XS_TOKEN_UNDEFINED)) {
        item->next = node->next;
        node = parser->root = item;
      }
      else if (aToken == XS_TOKEN_EXPRESSIONS) {
        item->next = node->next;
        node = item;
        goto again;
      }
      else
        aToken = XS_TOKEN_EXPRESSIONS;
    }
  }
  if (aToken == XS_TOKEN_ACCESS) {
    fxCheckStrictSymbol(parser, ((txAccessNode*)node)->symbol);
    return 1;
  }
  if ((aToken == XS_TOKEN_MEMBER) || (aToken == XS_TOKEN_MEMBER_AT) || (aToken == XS_TOKEN_PRIVATE_MEMBER) || (aToken == XS_TOKEN_UNDEFINED))
    return 1;
    
  if (theToken == XS_TOKEN_ASSIGN) {
    if (aToken == XS_TOKEN_ARRAY) {
      txNode* binding = fxArrayBindingFromExpression(parser, node, XS_TOKEN_ACCESS);
            if (binding) {
                binding->next = node->next;
                parser->root = binding;
        return 1;
           }
        }
    else if (aToken == XS_TOKEN_OBJECT) {
      txNode* binding = fxObjectBindingFromExpression(parser, node, XS_TOKEN_ACCESS);
            if (binding) {
                binding->next = node->next;
                parser->root = binding;
        return 1;
            }
        }
  }
  else if (theToken == XS_TOKEN_DELETE)
    return 1;
  return 0;
}

void fxCheckStrictBinding(txParser* parser, txNode* node)
{
  if (node && node->description) {
    if (node->description->token == XS_TOKEN_ACCESS) {
      fxCheckStrictSymbol(parser, ((txAccessNode*)node)->symbol);
    }
    else if (node->description->token == XS_TOKEN_ARG) {
      fxCheckStrictSymbol(parser, ((txDeclareNode*)node)->symbol);
    }
    else if (node->description->token == XS_TOKEN_CONST) {
      fxCheckStrictSymbol(parser, ((txDeclareNode*)node)->symbol);
    }
    else if (node->description->token == XS_TOKEN_LET) {
      fxCheckStrictSymbol(parser, ((txDeclareNode*)node)->symbol);
    }
    else if (node->description->token == XS_TOKEN_USING) {
      fxCheckStrictSymbol(parser, ((txDeclareNode*)node)->symbol);
    }
    else if (node->description->token == XS_TOKEN_VAR) {
      fxCheckStrictSymbol(parser, ((txDeclareNode*)node)->symbol);
    }
    else if (node->description->token == XS_TOKEN_BINDING) {
      fxCheckStrictBinding(parser, ((txBindingNode*)node)->target);
    }
    else if (node->description->token == XS_TOKEN_ARRAY_BINDING) {
      node = ((txArrayBindingNode*)node)->items->first;
      while (node) {
        fxCheckStrictBinding(parser, node);
        node = node->next;
      }
    }
    else if (node->description->token == XS_TOKEN_OBJECT_BINDING) {
      node = ((txObjectBindingNode*)node)->items->first;
      while (node) {
        fxCheckStrictBinding(parser, node);
        node = node->next;
      }
    }
    else if (node->description->token == XS_TOKEN_PARAMS_BINDING) {
      node = ((txParamsBindingNode*)node)->items->first;
      while (node) {
        fxCheckStrictBinding(parser, node);
        node = node->next;
      }
    }
    else if (node->description->token == XS_TOKEN_PROPERTY_BINDING)
      fxCheckStrictBinding(parser, ((txPropertyBindingNode*)node)->binding);
    else if (node->description->token == XS_TOKEN_PROPERTY_BINDING_AT)
      fxCheckStrictBinding(parser, ((txPropertyBindingAtNode*)node)->binding);
    else if (node->description->token == XS_TOKEN_REST_BINDING)
      fxCheckStrictBinding(parser, ((txRestBindingNode*)node)->binding);
  }
}

void fxCheckStrictFunction(txParser* parser, txFunctionNode* function)
{
  parser->states[0].line = function->line;
  fxCheckStrictSymbol(parser, function->symbol);
  fxCheckStrictBinding(parser, function->params);
}

void fxCheckStrictSymbol(txParser* parser, txSymbol* symbol)
{
  if (parser->flags & mxStrictFlag) {
    if (symbol == parser->argumentsSymbol)
      fxReportParserError(parser, parser->states[0].line, "invalid arguments (strict mode)");
    else if (symbol == parser->evalSymbol)
      fxReportParserError(parser, parser->states[0].line, "invalid eval (strict mode)");
    else if (symbol == parser->yieldSymbol)
      fxReportParserError(parser, parser->states[0].line, "invalid yield (strict mode)");
  }
  else if (parser->flags & mxYieldFlag) {
    if (symbol == parser->yieldSymbol)
      fxReportParserError(parser, parser->states[0].line, "invalid yield");
  }
}

void fxCheckUniqueProperty(txParser* parser, txNode* base, txNode* current)
{
  return; // no more!
  if (current->description->token == XS_TOKEN_PROPERTY) {
    txPropertyNode* currentNode = (txPropertyNode*)current;
    while (base != current) {
      txPropertyNode* baseNode = (txPropertyNode*)base;
      if (baseNode->description->token == XS_TOKEN_PROPERTY) {
        if (baseNode->symbol == currentNode->symbol) {
          fxCheckUniquePropertyAux(parser, (txNode*)baseNode, (txNode*)currentNode);      
        }
      }
      base = base->next;
    }
  }
  else {
    txPropertyAtNode* currentNode = (txPropertyAtNode*)current;
    txIntegerNode* currentAt = (txIntegerNode*)(currentNode->at);
    if (currentAt->description->token == XS_TOKEN_INTEGER) {
      while (base != current) {
        txPropertyAtNode* baseNode = (txPropertyAtNode*)base;
        if (baseNode->description->token == XS_TOKEN_PROPERTY_AT) {
          txIntegerNode* baseAt = (txIntegerNode*)(baseNode->at);
          if (baseAt->description->token == XS_TOKEN_INTEGER) {
            if (baseAt->value == currentAt->value) {
              fxCheckUniquePropertyAux(parser, (txNode*)baseNode, (txNode*)currentNode);      
            }
          }
        }
        base = base->next;
      }
    }
  }
}

void fxCheckUniquePropertyAux(txParser* parser, txNode* baseNode, txNode* currentNode)
{
  if (currentNode->flags & mxGetterFlag) {
    if (baseNode->flags & mxGetterFlag)
      fxReportParserError(parser, parser->states[0].line, "getter already defined");
    else if (!(baseNode->flags & mxSetterFlag))
      fxReportParserError(parser, parser->states[0].line, "property already defined");
  }
  else if (currentNode->flags & mxSetterFlag) {
    if (baseNode->flags & mxSetterFlag)
      fxReportParserError(parser, parser->states[0].line, "setter already defined");
    else if (!(baseNode->flags & mxGetterFlag))
      fxReportParserError(parser, parser->states[0].line, "property already defined");
  }
  else {
    if (baseNode->flags & mxGetterFlag)
      fxReportParserError(parser, parser->states[0].line, "getter already defined");
    else if (baseNode->flags & mxSetterFlag)
      fxReportParserError(parser, parser->states[0].line, "setter already defined");
    else if (parser->flags & mxStrictFlag)
      fxReportParserError(parser, parser->states[0].line, "property already defined (strict mode)");
  }
}


void fxJSONValue(txParser* parser)
{
  switch (parser->states[0].token) {
  case XS_TOKEN_FALSE:
    fxPushNodeStruct(parser, 0, parser->states[0].token, parser->states[0].line);
    fxGetNextTokenJSON(parser);
    break;
  case XS_TOKEN_TRUE:
    fxPushNodeStruct(parser, 0, parser->states[0].token, parser->states[0].line);
    fxGetNextTokenJSON(parser);
    break;
  case XS_TOKEN_NULL:
    fxPushNodeStruct(parser, 0, parser->states[0].token, parser->states[0].line);
    fxGetNextTokenJSON(parser);
    break;
  case XS_TOKEN_INTEGER:
    fxPushIntegerNode(parser, parser->states[0].integer, parser->states[0].line);
    fxGetNextTokenJSON(parser);
    break;
  case XS_TOKEN_NUMBER:
    fxPushNumberNode(parser, parser->states[0].number, parser->states[0].line);
    fxGetNextTokenJSON(parser);
    break;
  case XS_TOKEN_STRING:
    fxPushStringNode(parser, parser->states[0].stringLength, parser->states[0].string, parser->states[0].line);
    fxGetNextTokenJSON(parser);
    break;
  case XS_TOKEN_LEFT_BRACE:
    fxJSONObject(parser);
    break;
  case XS_TOKEN_LEFT_BRACKET:
    fxJSONArray(parser);
    break;
  default:
    fxPushNULL(parser);
    fxReportParserError(parser, parser->states[0].line, "invalid value");
    break;
  }
}

void fxJSONObject(txParser* parser)
{
  txIndex aLength = 0;
  txInteger aLine = parser->states[0].line;
  fxGetNextTokenJSON(parser);
  for (;;) {
    if (parser->states[0].token == XS_TOKEN_RIGHT_BRACE)
      break;
    if (parser->states[0].token != XS_TOKEN_STRING) {
      fxReportParserError(parser, parser->states[0].line, "missing name");
      break;
    }
    fxPushStringNode(parser, parser->states[0].stringLength, parser->states[0].string, parser->states[0].line);
    fxGetNextTokenJSON(parser);
    if (parser->states[0].token != XS_TOKEN_COLON) {
      fxReportParserError(parser, parser->states[0].line, "missing :");
      break;
    }
    fxGetNextTokenJSON(parser);
    fxJSONValue(parser);
    fxPushNodeStruct(parser, 2, XS_TOKEN_PROPERTY_AT, parser->states[0].line);
    aLength++;
    if (parser->states[0].token != XS_TOKEN_COMMA)
      break;
    fxGetNextTokenJSON(parser);
  }
  if (parser->states[0].token != XS_TOKEN_RIGHT_BRACE)
    fxReportParserError(parser, parser->states[0].line, "missing }");
  fxGetNextTokenJSON(parser);
  fxPushNodeList(parser, aLength);
  fxPushNodeStruct(parser, 1, XS_TOKEN_OBJECT, aLine);
}

void fxJSONArray(txParser* parser)
{
  txIndex aLength = 0;
  txInteger aLine = parser->states[0].line;
  fxGetNextTokenJSON(parser);
  for (;;) {
    if (parser->states[0].token == XS_TOKEN_RIGHT_BRACKET)
      break;
    fxJSONValue(parser);
    aLength++;
    if (parser->states[0].token != XS_TOKEN_COMMA)
      break;
    fxGetNextTokenJSON(parser);
  }
  if (parser->states[0].token != XS_TOKEN_RIGHT_BRACKET)
    fxReportParserError(parser, parser->states[0].line, "missing ]");
  fxGetNextTokenJSON(parser);
  fxPushNodeList(parser, aLength);
  fxPushNodeStruct(parser, 1, XS_TOKEN_ARRAY, aLine);
}

void fxJSONModule(txParser* parser)
{
  fxJSONValue(parser);
  
  fxPushSymbol(parser, parser->defaultSymbol);
  fxPushNULL(parser);
  fxPushNodeStruct(parser, 2, XS_TOKEN_CONST, 1);
  fxSwapNodes(parser);
  fxPushNodeStruct(parser, 2, XS_TOKEN_ASSIGN, 1);
  fxPushNodeStruct(parser, 1, XS_TOKEN_STATEMENT, 1);
  
  fxPushSymbol(parser, parser->defaultSymbol);
  fxPushNULL(parser);
  fxPushNodeStruct(parser, 2, XS_TOKEN_SPECIFIER, 1);
  fxPushNodeList(parser, 1);
  fxPushNULL(parser);
  fxPushNULL(parser);
  fxPushNodeStruct(parser, 3, XS_TOKEN_EXPORT, 1);
  
  fxPushNodeList(parser, 2);
  fxPushNodeStruct(parser, 1, XS_TOKEN_STATEMENTS, 1);
  
  fxPushNodeStruct(parser, 1, XS_TOKEN_MODULE, 1);
}

static txSymbol* fxJSXName(txParser* parser, txSymbol* before, txSymbol* after)
{
  txSize beforeLength = before->length;
  txSize afterLength = after->length;
  txSize length = beforeLength + 1 + afterLength + 1;
  txString string = fxNewParserChunk(parser, length);
  snprintf(string, length, "%s-%s", before->string, after->string);
  return fxNewParserSymbol(parser, string);
}

void fxJSXAttributeName(txParser* parser)
{
  txSymbol* symbol = parser->states[0].symbol;
  fxGetNextToken(parser);
  while (parser->states[0].token == XS_TOKEN_SUBTRACT) {
    fxGetNextToken(parser);
    if (gxTokenFlags[parser->states[0].token] & XS_TOKEN_IDENTIFIER_NAME)
      symbol = fxJSXName(parser, symbol, parser->states[0].symbol);
    else
      fxReportParserError(parser, parser->states[0].line, "missing name");
    fxGetNextToken(parser);
  }
  if (parser->states[0].token == XS_TOKEN_COLON) {
    fxGetNextToken(parser);
    if (gxTokenFlags[parser->states[0].token] & XS_TOKEN_IDENTIFIER_NAME)
      symbol = fxJSXNamespace(parser, symbol, parser->states[0].symbol);
    else
      fxReportParserError(parser, parser->states[0].line, "missing name");
    fxGetNextToken(parser);
    while (parser->states[0].token == XS_TOKEN_SUBTRACT) {
      fxGetNextToken(parser);
      if (gxTokenFlags[parser->states[0].token] & XS_TOKEN_IDENTIFIER_NAME)
        symbol = fxJSXName(parser, symbol, parser->states[0].symbol);
      else
        fxReportParserError(parser, parser->states[0].line, "missing name");
      fxGetNextToken(parser);
    }  
  }
  fxPushSymbol(parser, symbol);
}

void fxJSXAttributeValue(txParser* parser)
{
  txInteger line = parser->states[0].line;
  fxGetNextTokenJSXAttribute(parser);
  if (parser->states[0].token == XS_TOKEN_STRING) {
    fxPushStringNode(parser, parser->states[0].stringLength, parser->states[0].string, line);
    fxGetNextToken(parser);
  }
  else if (parser->states[0].token == XS_TOKEN_LEFT_BRACE) {
    fxGetNextToken(parser);
    if (parser->states[0].token == XS_TOKEN_RIGHT_BRACE) {
      fxGetNextToken(parser);
      fxReportParserError(parser, parser->states[0].line, "missing expression");
      fxPushNodeStruct(parser, 0, XS_TOKEN_UNDEFINED, line);
    }
    else {
      fxAssignmentExpression(parser);
      if (parser->states[0].token == XS_TOKEN_RIGHT_BRACE)
        fxGetNextToken(parser);
      else
        fxReportParserError(parser, parser->states[0].line, "missing }");
    }
  }
  else {
    fxReportParserError(parser, parser->states[0].line, "invalid %s", gxTokenNames[parser->states[0].token]);
    fxPushNodeStruct(parser, 0, XS_TOKEN_UNDEFINED, line);
  }
}

void fxJSXElement(txParser* parser)
{
  txBoolean closed = 0;
  txInteger line = parser->states[0].line;
  txNode* name = NULL;
  txInteger nodeCount = parser->nodeCount;
  txInteger propertyCount = 0;
  fxCheckParserStack(parser, line);
  fxPushSymbol(parser, parser->__jsx__Symbol);
  fxPushNodeStruct(parser, 1, XS_TOKEN_ACCESS, parser->states[0].line);
  if (parser->states[0].token == XS_TOKEN_IDENTIFIER) {
    fxJSXElementName(parser);
    name = parser->root;
  }
  else {
    fxReportParserError(parser, parser->states[0].line, "missing identifier");
    fxPushNULL(parser);
  }
  for (;;) {
    if (parser->states[0].token == XS_TOKEN_MORE)
      break;
    if (parser->states[0].token == XS_TOKEN_DIVIDE) {
      fxGetNextToken(parser);
      if (parser->states[0].token != XS_TOKEN_MORE)
        fxReportParserError(parser, parser->states[0].line, "missing >");
      closed = 1;
      break;
    }
    if (gxTokenFlags[parser->states[0].token] & XS_TOKEN_IDENTIFIER_NAME) {
      fxJSXAttributeName(parser);
      if (parser->states[0].token == XS_TOKEN_ASSIGN)
        fxJSXAttributeValue(parser);
      else
        fxPushNodeStruct(parser, 0, XS_TOKEN_TRUE, parser->states[0].line);
      fxPushNodeStruct(parser, 2, XS_TOKEN_PROPERTY, parser->states[0].line);
      propertyCount++;
    }
    else if (parser->states[0].token == XS_TOKEN_LEFT_BRACE) {
      fxGetNextToken(parser);
      if (parser->states[0].token == XS_TOKEN_SPREAD) {
        fxGetNextToken(parser);
        fxAssignmentExpression(parser);
        if (parser->states[0].token == XS_TOKEN_RIGHT_BRACE)
          fxGetNextToken(parser);
        else
          fxReportParserError(parser, parser->states[0].line, "missing }");
        fxPushNodeStruct(parser, 1, XS_TOKEN_SPREAD, parser->states[0].line);
        propertyCount++;
      }
      else
        fxReportParserError(parser, parser->states[0].line, "invalid %s", gxTokenNames[parser->states[0].token]);
    }
    else {
      fxReportParserError(parser, parser->states[0].line, "invalid %s", gxTokenNames[parser->states[0].token]);
      break;
    }
  }
  if (propertyCount > 0) {
    fxPushNodeList(parser, propertyCount);
    fxPushNodeStruct(parser, 1, XS_TOKEN_OBJECT, parser->states[0].line);
  }
  else
    fxPushNodeStruct(parser, 0, XS_TOKEN_NULL, parser->states[0].line);
  if (!closed) {
    for (;;) {
      fxGetNextTokenJSXChild(parser);
      if (parser->states[0].stringLength)
        fxPushStringNode(parser, parser->states[0].stringLength, parser->states[0].string, parser->states[0].line);
      if (parser->states[0].token == XS_TOKEN_LEFT_BRACE) {
        fxGetNextToken(parser);
        if (parser->states[0].token == XS_TOKEN_RIGHT_BRACE)
          fxGetNextToken(parser);
        else {
          fxAssignmentExpression(parser);
          if (parser->states[0].token != XS_TOKEN_RIGHT_BRACE)
            fxReportParserError(parser, parser->states[0].line, "missing }");
        }
      }
      else if (parser->states[0].token == XS_TOKEN_LESS) {
        fxGetNextToken(parser);
        if (parser->states[0].token == XS_TOKEN_DIVIDE) {
          fxGetNextToken(parser);
          if (parser->states[0].token == XS_TOKEN_IDENTIFIER) {
            fxJSXElementName(parser);
            if (!fxJSXMatch(parser, name, parser->root)) {
              fxReportParserError(parser, parser->states[0].line, "invalid element");
              fxPushNULL(parser);
            }
          }
          else {
            fxReportParserError(parser, parser->states[0].line, "missing identifier");
            fxPushNULL(parser);
          }
          if (parser->states[0].token != XS_TOKEN_MORE)
            fxReportParserError(parser, parser->states[0].line, "missing >");
          fxPopNode(parser);
          break;
        }
        else
          fxJSXElement(parser);
      }
      else {
        fxReportParserError(parser, parser->states[0].line, "invalid %s", gxTokenNames[parser->states[0].token]);
        break;
      }
    }
  }
  fxPushNodeList(parser, parser->nodeCount - nodeCount - 1);
  fxPushNodeStruct(parser, 1, XS_TOKEN_PARAMS, line);
  fxPushNodeStruct(parser, 2, XS_TOKEN_CALL, line);
}

void fxJSXElementName(txParser* parser)
{
  txInteger line = parser->states[0].line;
  txSymbol* symbol = parser->states[0].symbol;
  fxGetNextToken(parser);
  if (parser->states[0].token == XS_TOKEN_COLON) {
    fxGetNextToken(parser);
    if (parser->states[0].token == XS_TOKEN_IDENTIFIER)
      symbol = fxJSXNamespace(parser, symbol, parser->states[0].symbol);
    else
      fxReportParserError(parser, parser->states[0].line, "missing name");
    fxPushSymbol(parser, symbol);
    fxPushNodeStruct(parser, 1, XS_TOKEN_ACCESS, line);
    fxGetNextToken(parser);
  }
  else {
    fxPushSymbol(parser, symbol);
    fxPushNodeStruct(parser, 1, XS_TOKEN_ACCESS, line);
    while (parser->states[0].token == XS_TOKEN_DOT) {
      fxGetNextToken(parser);
      if (parser->states[0].token == XS_TOKEN_IDENTIFIER) {
        fxPushSymbol(parser, parser->states[0].symbol);
        fxPushNodeStruct(parser, 2, XS_TOKEN_MEMBER, parser->states[0].line);
        fxGetNextToken(parser);
      }
      else
        fxReportParserError(parser, parser->states[0].line, "missing property");
    }
  }
}

txBoolean fxJSXMatch(txParser* parser, txNode* opening, txNode* closing)
{
  if (opening && closing) {
    while (opening->description->token == XS_TOKEN_MEMBER) {
      if (closing->description->token != XS_TOKEN_MEMBER)
        return 0;
      if (((txMemberNode*)opening)->symbol != ((txMemberNode*)closing)->symbol)
        return 0;
      opening = ((txMemberNode*)opening)->reference;
      closing = ((txMemberNode*)closing)->reference;
    }
    if (opening->description->token == XS_TOKEN_ACCESS) {
      if (closing->description->token != XS_TOKEN_ACCESS)
        return 0;
      if (((txAccessNode*)opening)->symbol != ((txAccessNode*)closing)->symbol)
        return 0;
      return 1;
    }
  }
  return 0;
}

txSymbol* fxJSXNamespace(txParser* parser, txSymbol* namespace, txSymbol* name)
{
  txSize namespaceLength = namespace->length;
  txSize nameLength = name->length;
  txSize length = namespaceLength + 1 + nameLength + 1;
  txString string = fxNewParserChunk(parser, length);
  snprintf(string, length, "%s:%s", namespace->string, name->string);
  return fxNewParserSymbol(parser, string);
}

Coverage Report

Created: 2026-09-03 07:12