Coverage Report

Created: 2025-10-28 07:25

next uncovered line (L), next uncovered region (R), next uncovered branch (B)
/src/moddable/xs/sources/xsSyntaxical.c
Line
Count
Source
1
/*
2
 * Copyright (c) 2016-2017  Moddable Tech, Inc.
3
 *
4
 *   This file is part of the Moddable SDK Runtime.
5
 * 
6
 *   The Moddable SDK Runtime is free software: you can redistribute it and/or modify
7
 *   it under the terms of the GNU Lesser General Public License as published by
8
 *   the Free Software Foundation, either version 3 of the License, or
9
 *   (at your option) any later version.
10
 * 
11
 *   The Moddable SDK Runtime is distributed in the hope that it will be useful,
12
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of
13
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14
 *   GNU Lesser General Public License for more details.
15
 * 
16
 *   You should have received a copy of the GNU Lesser General Public License
17
 *   along with the Moddable SDK Runtime.  If not, see <http://www.gnu.org/licenses/>.
18
 *
19
 * This file incorporates work covered by the following copyright and  
20
 * permission notice:  
21
 *
22
 *       Copyright (C) 2010-2016 Marvell International Ltd.
23
 *       Copyright (C) 2002-2010 Kinoma, Inc.
24
 *
25
 *       Licensed under the Apache License, Version 2.0 (the "License");
26
 *       you may not use this file except in compliance with the License.
27
 *       You may obtain a copy of the License at
28
 *
29
 *        http://www.apache.org/licenses/LICENSE-2.0
30
 *
31
 *       Unless required by applicable law or agreed to in writing, software
32
 *       distributed under the License is distributed on an "AS IS" BASIS,
33
 *       WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
34
 *       See the License for the specific language governing permissions and
35
 *       limitations under the License.
36
 */
37
38
#include "xsScript.h"
39
40
static txBoolean fxIsKeyword(txParser* parser, txSymbol* keyword);
41
static txBoolean fxIsToken(txParser* parser, txToken theToken);
42
static void fxMatchToken(txParser* parser, txToken theToken);
43
static txNode* fxPopNode(txParser* parser);
44
static void fxPushNode(txParser* parser, txNode* node);
45
static void fxPushBigIntNode(txParser* parser, txBigInt* value, txInteger line);
46
static void fxPushIndexNode(txParser* parser, txIndex value, txInteger line);
47
static void fxPushIntegerNode(txParser* parser, txInteger value, txInteger line);
48
static void fxPushNodeStruct(txParser* parser, txInteger count, txToken token, txInteger line);
49
static void fxPushNodeList(txParser* parser, txInteger count);
50
static void fxPushNULL(txParser* parser);
51
static void fxPushNumberNode(txParser* parser, txNumber value, txInteger line);
52
static void fxPushRawNode(txParser* parser, txInteger length, txString value, txInteger line);
53
static void fxPushStringNode(txParser* parser, txInteger length, txString value, txInteger line);
54
static void fxPushSymbol(txParser* parser, txSymbol* symbol);
55
static void fxSwapNodes(txParser* parser);
56
57
static void fxExportDeclaration(txParser* parser);
58
static void fxExportBinding(txParser* parser, txNode* node);
59
static void fxImportDeclaration(txParser* parser);
60
static void fxWithAttributes(txParser* parser);
61
static void fxSpecifiers(txParser* parser);
62
63
static void fxBody(txParser* parser);
64
static void fxStatements(txParser* parser);
65
static void fxBlock(txParser* parser);
66
static void fxStatement(txParser* parser, txInteger blockIt);
67
static void fxSemicolon(txParser* parser);
68
69
static void fxBreakStatement(txParser* parser);
70
static void fxContinueStatement(txParser* parser);
71
static void fxDebuggerStatement(txParser* parser);
72
static void fxDoStatement(txParser* parser);
73
static void fxForStatement(txParser* parser);
74
static void fxIfStatement(txParser* parser);
75
static void fxReturnStatement(txParser* parser);
76
static void fxSwitchStatement(txParser* parser);
77
static void fxThrowStatement(txParser* parser);
78
static void fxTryStatement(txParser* parser);
79
static void fxVariableStatement(txParser* parser, txToken theToken, txUnsigned flags);
80
static void fxWhileStatement(txParser* parser);
81
static void fxWithStatement(txParser* parser);
82
83
static void fxCommaExpression(txParser* parser);
84
static void fxAssignmentExpression(txParser* parser);
85
static void fxConditionalExpression(txParser* parser);
86
static void fxOrExpression(txParser* parser);
87
static void fxAndExpression(txParser* parser);
88
static void fxCoalesceExpression(txParser* parser);
89
static void fxBitOrExpression(txParser* parser);
90
static void fxBitXorExpression(txParser* parser);
91
static void fxBitAndExpression(txParser* parser);
92
static void fxEqualExpression(txParser* parser);
93
static void fxRelationalExpression(txParser* parser);
94
static void fxShiftExpression(txParser* parser);
95
static void fxAdditiveExpression(txParser* parser);
96
static void fxMultiplicativeExpression(txParser* parser);
97
static void fxExponentiationExpression(txParser* parser);
98
static void fxUnaryExpression(txParser* parser);
99
static void fxPrefixExpression(txParser* parser);
100
static void fxPostfixExpression(txParser* parser);
101
static void fxCallExpression(txParser* parser);
102
103
static void fxLiteralExpression(txParser* parser, txUnsigned flag);
104
static void fxArrayExpression(txParser* parser);
105
static void fxArrowExpression(txParser* parser, txUnsigned flag);
106
static void fxClassExpression(txParser* parser, txInteger theLine, txSymbol** theSymbol);
107
static void fxFunctionExpression(txParser* parser, txInteger theLine, txSymbol** theSymbol, txUnsigned flag);
108
static void fxGeneratorExpression(txParser* parser, txInteger theLine, txSymbol** theSymbol, txUnsigned flag);
109
static void fxGroupExpression(txParser* parser, txUnsigned flag);
110
static void fxObjectExpression(txParser* parser);
111
static void fxNewExpression(txParser* parser);
112
static void fxTemplateExpression(txParser* parser);
113
static void fxYieldExpression(txParser* parser);
114
115
static void fxParameters(txParser* parser);
116
static void fxPropertyName(txParser* parser, txSymbol** theSymbol, txToken* theToken0, txToken* theToken1, txToken* theToken2, txUnsigned* flag);
117
118
static void fxBinding(txParser* parser, txToken theToken, txUnsigned flags);
119
static txNode* fxBindingFromExpression(txParser* parser, txNode* theNode, txToken theToken);
120
static void fxArrayBinding(txParser* parser, txToken theToken);
121
static txNode* fxArrayBindingFromExpression(txParser* parser, txNode* theNode, txToken theToken);
122
static txUnsigned fxObjectBinding(txParser* parser, txToken theToken);
123
static txNode* fxObjectBindingFromExpression(txParser* parser, txNode* theNode, txToken theToken);
124
static void fxParametersBinding(txParser* parser);
125
static txNode* fxParametersBindingFromExpressions(txParser* parser, txNode* theNode);
126
static void fxRestBinding(txParser* parser, txToken theToken, txUnsigned flag);
127
static txNode* fxRestBindingFromExpression(txParser* parser, txNode* theNode, txToken theToken, txUnsigned flag);
128
129
static void fxCheckArrowFunction(txParser* parser, txInteger count);
130
static txBoolean fxCheckReference(txParser* parser, txToken theToken);
131
static void fxCheckStrictBinding(txParser* parser, txNode* node);
132
static void fxCheckStrictFunction(txParser* parser, txFunctionNode* function);
133
static void fxCheckStrictSymbol(txParser* parser, txSymbol* symbol);
134
static void fxCheckUniqueProperty(txParser* parser, txNode* base, txNode* current);
135
static void fxCheckUniquePropertyAux(txParser* parser, txNode* baseNode, txNode* currentNode);
136
137
static void fxJSONObject(txParser* parser);
138
static void fxJSONArray(txParser* parser);
139
140
static void fxJSXAttributeName(txParser* parser);
141
static void fxJSXAttributeValue(txParser* parser);
142
static void fxJSXElement(txParser* parser);
143
static void fxJSXElementName(txParser* parser);
144
static txBoolean fxJSXMatch(txParser* parser, txNode* opening, txNode* closing);
145
static txSymbol* fxJSXNamespace(txParser* parser, txSymbol* namespace, txSymbol* name);
146
147
3.81k
#define XS_TOKEN_BEGIN_STATEMENT 1
148
2.34M
#define XS_TOKEN_BEGIN_EXPRESSION 2
149
1.69M
#define XS_TOKEN_ASSIGN_EXPRESSION 4
150
1.65M
#define XS_TOKEN_EQUAL_EXPRESSION 8
151
1.70M
#define XS_TOKEN_RELATIONAL_EXPRESSION 16
152
1.71M
#define XS_TOKEN_SHIFT_EXPRESSION 32
153
6.25M
#define XS_TOKEN_ADDITIVE_EXPRESSION 64
154
6.32M
#define XS_TOKEN_MULTIPLICATIVE_EXPRESSION 128
155
6.26M
#define XS_TOKEN_EXPONENTIATION_EXPRESSION 256
156
6.42M
#define XS_TOKEN_PREFIX_EXPRESSION 512
157
5.75M
#define XS_TOKEN_POSTFIX_EXPRESSION 1024
158
297k
#define XS_TOKEN_END_STATEMENT 2048
159
#define XS_TOKEN_REFERENCE_EXPRESSION 4096
160
282k
#define XS_TOKEN_BEGIN_BINDING 16384
161
147k
#define XS_TOKEN_IDENTIFIER_NAME 32768
162
6.61M
#define XS_TOKEN_UNARY_EXPRESSION 65536
163
6.31M
#define XS_TOKEN_CALL_EXPRESSION 131072
164
165
static txTokenFlag gxTokenFlags[XS_TOKEN_COUNT] = {
166
  /* XS_NO_TOKEN */ 0,
167
  /* XS_TOKEN_ACCESS */ 0,
168
  /* XS_TOKEN_ADD */ XS_TOKEN_BEGIN_STATEMENT | XS_TOKEN_BEGIN_EXPRESSION | XS_TOKEN_ADDITIVE_EXPRESSION | XS_TOKEN_UNARY_EXPRESSION,
169
  /* XS_TOKEN_ADD_ASSIGN */ XS_TOKEN_ASSIGN_EXPRESSION,
170
  /* XS_TOKEN_AND */ 0,
171
  /* XS_TOKEN_AND_ASSIGN */ XS_TOKEN_ASSIGN_EXPRESSION,
172
  /* XS_TOKEN_ARG */ 0,
173
  /* XS_TOKEN_ARGUMENTS */ 0,
174
  /* XS_TOKEN_ARGUMENTS_SLOPPY */ 0,
175
  /* XS_TOKEN_ARGUMENTS_STRICT */ 0,
176
  /* XS_TOKEN_ARRAY */ 0,
177
  /* XS_TOKEN_ARRAY_BINDING */ 0,
178
  /* XS_TOKEN_ARROW */ 0,
179
  /* XS_TOKEN_ASSIGN */ XS_TOKEN_ASSIGN_EXPRESSION,
180
  /* XS_TOKEN_AWAIT */ XS_TOKEN_BEGIN_STATEMENT | XS_TOKEN_BEGIN_EXPRESSION | XS_TOKEN_UNARY_EXPRESSION | XS_TOKEN_IDENTIFIER_NAME,
181
  /* XS_TOKEN_BIGINT */ XS_TOKEN_BEGIN_STATEMENT | XS_TOKEN_BEGIN_EXPRESSION,
182
  /* XS_TOKEN_BINDING */ 0,
183
  /* XS_TOKEN_BIT_AND */ 0,
184
  /* XS_TOKEN_BIT_AND_ASSIGN */ XS_TOKEN_ASSIGN_EXPRESSION,
185
  /* XS_TOKEN_BIT_NOT */ XS_TOKEN_BEGIN_STATEMENT | XS_TOKEN_BEGIN_EXPRESSION | XS_TOKEN_UNARY_EXPRESSION,
186
  /* XS_TOKEN_BIT_OR */ 0,
187
  /* XS_TOKEN_BIT_OR_ASSIGN */ XS_TOKEN_ASSIGN_EXPRESSION,
188
  /* XS_TOKEN_BIT_XOR */ 0,
189
  /* XS_TOKEN_BIT_XOR_ASSIGN */ XS_TOKEN_ASSIGN_EXPRESSION,
190
  /* XS_TOKEN_BLOCK */ 0,
191
  /* XS_TOKEN_BODY */ 0,
192
  /* XS_TOKEN_BREAK */ XS_TOKEN_BEGIN_STATEMENT | XS_TOKEN_IDENTIFIER_NAME,
193
  /* XS_TOKEN_CALL */ 0,
194
  /* XS_TOKEN_CASE */ XS_TOKEN_IDENTIFIER_NAME,
195
  /* XS_TOKEN_CATCH */ XS_TOKEN_IDENTIFIER_NAME,
196
  /* XS_TOKEN_CHAIN */ XS_TOKEN_CALL_EXPRESSION,
197
  /* XS_TOKEN_CLASS */ XS_TOKEN_BEGIN_STATEMENT | XS_TOKEN_BEGIN_EXPRESSION | XS_TOKEN_IDENTIFIER_NAME,
198
  /* XS_TOKEN_COALESCE */ 0,
199
  /* XS_TOKEN_COALESCE_ASSIGN */ XS_TOKEN_ASSIGN_EXPRESSION,
200
  /* XS_TOKEN_COLON */ 0,
201
  /* XS_TOKEN_COMMA */ XS_TOKEN_END_STATEMENT,
202
  /* XS_TOKEN_CONST */ XS_TOKEN_BEGIN_STATEMENT | XS_TOKEN_IDENTIFIER_NAME,
203
  /* XS_TOKEN_CONTINUE */ XS_TOKEN_BEGIN_STATEMENT | XS_TOKEN_IDENTIFIER_NAME,
204
  /* XS_TOKEN_CURRENT */ 0,
205
  /* XS_TOKEN_DEBUGGER */ XS_TOKEN_BEGIN_STATEMENT | XS_TOKEN_IDENTIFIER_NAME,
206
  /* XS_TOKEN_DECREMENT */ XS_TOKEN_BEGIN_STATEMENT | XS_TOKEN_BEGIN_EXPRESSION | XS_TOKEN_PREFIX_EXPRESSION | XS_TOKEN_POSTFIX_EXPRESSION,
207
  /* XS_TOKEN_DEFAULT */ XS_TOKEN_IDENTIFIER_NAME,
208
  /* XS_TOKEN_DEFINE */ 0,
209
  /* XS_TOKEN_DELEGATE */ 0,
210
  /* XS_TOKEN_DELETE */ XS_TOKEN_BEGIN_STATEMENT | XS_TOKEN_BEGIN_EXPRESSION | XS_TOKEN_UNARY_EXPRESSION | XS_TOKEN_IDENTIFIER_NAME,
211
  /* XS_TOKEN_DIVIDE */ XS_TOKEN_BEGIN_EXPRESSION | XS_TOKEN_MULTIPLICATIVE_EXPRESSION,
212
  /* XS_TOKEN_DIVIDE_ASSIGN */ XS_TOKEN_BEGIN_EXPRESSION | XS_TOKEN_ASSIGN_EXPRESSION,
213
  /* XS_TOKEN_DO */ XS_TOKEN_BEGIN_STATEMENT | XS_TOKEN_IDENTIFIER_NAME,
214
  /* XS_TOKEN_DOT */ XS_TOKEN_CALL_EXPRESSION,
215
  /* XS_TOKEN_ELISION */ 0,
216
  /* XS_TOKEN_ELSE */ XS_TOKEN_IDENTIFIER_NAME,
217
  /* XS_TOKEN_ENUM */ XS_TOKEN_IDENTIFIER_NAME,
218
  /* XS_TOKEN_EOF */ XS_TOKEN_END_STATEMENT,
219
  /* XS_TOKEN_EQUAL */ XS_TOKEN_EQUAL_EXPRESSION,
220
  /* XS_TOKEN_EVAL */ 0,
221
  /* XS_TOKEN_EXPONENTIATION */ XS_TOKEN_EXPONENTIATION_EXPRESSION,
222
  /* XS_TOKEN_EXPONENTIATION_ASSIGN */ XS_TOKEN_ASSIGN_EXPRESSION,
223
  /* XS_TOKEN_EXPORT */ XS_TOKEN_IDENTIFIER_NAME,
224
  /* XS_TOKEN_EXPRESSIONS */ 0,
225
  /* XS_TOKEN_EXTENDS */ XS_TOKEN_IDENTIFIER_NAME,
226
  /* XS_TOKEN_FALSE */ XS_TOKEN_BEGIN_STATEMENT | XS_TOKEN_BEGIN_EXPRESSION | XS_TOKEN_IDENTIFIER_NAME,
227
  /* XS_TOKEN_FIELD */ 0,
228
  /* XS_TOKEN_FINALLY */ XS_TOKEN_IDENTIFIER_NAME | XS_TOKEN_IDENTIFIER_NAME,
229
  /* XS_TOKEN_FOR */ XS_TOKEN_BEGIN_STATEMENT | XS_TOKEN_IDENTIFIER_NAME,
230
  /* XS_TOKEN_FOR_AWAIT_OF */ 0,
231
  /* XS_TOKEN_FOR_IN */ 0,
232
  /* XS_TOKEN_FOR_OF */ 0,
233
  /* XS_TOKEN_FUNCTION */ XS_TOKEN_BEGIN_STATEMENT | XS_TOKEN_BEGIN_EXPRESSION | XS_TOKEN_IDENTIFIER_NAME,
234
  /* XS_TOKEN_GENERATOR */ 0,
235
  /* XS_TOKEN_GETTER */ 0,
236
  /* XS_TOKEN_HOST */ XS_TOKEN_BEGIN_EXPRESSION,
237
  /* XS_TOKEN_IDENTIFIER */ XS_TOKEN_BEGIN_STATEMENT | XS_TOKEN_BEGIN_EXPRESSION | XS_TOKEN_BEGIN_BINDING | XS_TOKEN_IDENTIFIER_NAME,
238
  /* XS_TOKEN_IF */ XS_TOKEN_BEGIN_STATEMENT | XS_TOKEN_IDENTIFIER_NAME,
239
  /* XS_TOKEN_IMPLEMENTS */ XS_TOKEN_IDENTIFIER_NAME,
240
  /* XS_TOKEN_IMPORT */ XS_TOKEN_BEGIN_EXPRESSION | XS_TOKEN_IDENTIFIER_NAME,
241
  /* XS_TOKEN_IMPORT_CALL */ 0,
242
  /* XS_TOKEN_IMPORT_META */ 0,
243
  /* XS_TOKEN_IN */ XS_TOKEN_RELATIONAL_EXPRESSION | XS_TOKEN_IDENTIFIER_NAME,
244
  /* XS_TOKEN_INCLUDE */ 0,
245
  /* XS_TOKEN_INCREMENT */ XS_TOKEN_BEGIN_STATEMENT | XS_TOKEN_BEGIN_EXPRESSION | XS_TOKEN_PREFIX_EXPRESSION | XS_TOKEN_POSTFIX_EXPRESSION,
246
  /* XS_TOKEN_INSTANCEOF */ XS_TOKEN_RELATIONAL_EXPRESSION | XS_TOKEN_IDENTIFIER_NAME,
247
  /* XS_TOKEN_INTEGER */ XS_TOKEN_BEGIN_STATEMENT | XS_TOKEN_BEGIN_EXPRESSION,
248
  /* XS_TOKEN_INTERFACE */ XS_TOKEN_IDENTIFIER_NAME,
249
  /* XS_TOKEN_ITEMS */ 0,
250
  /* XS_TOKEN_LABEL */ 0,
251
  /* XS_TOKEN_LEFT_BRACE */ XS_TOKEN_BEGIN_STATEMENT | XS_TOKEN_BEGIN_EXPRESSION | XS_TOKEN_BEGIN_BINDING,
252
  /* XS_TOKEN_LEFT_BRACKET */ XS_TOKEN_BEGIN_STATEMENT | XS_TOKEN_BEGIN_EXPRESSION | XS_TOKEN_BEGIN_BINDING | XS_TOKEN_CALL_EXPRESSION,
253
  /* XS_TOKEN_LEFT_PARENTHESIS */ XS_TOKEN_BEGIN_STATEMENT | XS_TOKEN_BEGIN_EXPRESSION | XS_TOKEN_CALL_EXPRESSION,
254
  /* XS_TOKEN_LEFT_SHIFT */ XS_TOKEN_SHIFT_EXPRESSION,
255
  /* XS_TOKEN_LEFT_SHIFT_ASSIGN */ XS_TOKEN_ASSIGN_EXPRESSION,
256
  /* XS_TOKEN_LESS */ XS_TOKEN_BEGIN_EXPRESSION | XS_TOKEN_RELATIONAL_EXPRESSION,
257
  /* XS_TOKEN_LESS_EQUAL */ XS_TOKEN_RELATIONAL_EXPRESSION,
258
  /* XS_TOKEN_LET */ XS_TOKEN_BEGIN_STATEMENT | XS_TOKEN_IDENTIFIER_NAME,
259
  /* XS_TOKEN_MEMBER */ 0,
260
  /* XS_TOKEN_MEMBER_AT */ 0,
261
  /* XS_TOKEN_MINUS */ 0,
262
  /* XS_TOKEN_MODULE */ 0,
263
  /* XS_TOKEN_MODULO */ XS_TOKEN_MULTIPLICATIVE_EXPRESSION,
264
  /* XS_TOKEN_MODULO_ASSIGN */ XS_TOKEN_ASSIGN_EXPRESSION,
265
  /* XS_TOKEN_MORE */ XS_TOKEN_RELATIONAL_EXPRESSION,
266
  /* XS_TOKEN_MORE_EQUAL */ XS_TOKEN_RELATIONAL_EXPRESSION,
267
  /* XS_TOKEN_MULTIPLY */ XS_TOKEN_MULTIPLICATIVE_EXPRESSION,
268
  /* XS_TOKEN_MULTIPLY_ASSIGN */ XS_TOKEN_ASSIGN_EXPRESSION,
269
  /* XS_TOKEN_NEW */ XS_TOKEN_BEGIN_STATEMENT | XS_TOKEN_BEGIN_EXPRESSION | XS_TOKEN_IDENTIFIER_NAME, 
270
  /* XS_TOKEN_NOT */ XS_TOKEN_BEGIN_STATEMENT | XS_TOKEN_BEGIN_EXPRESSION | XS_TOKEN_UNARY_EXPRESSION,
271
  /* XS_TOKEN_NOT_EQUAL */ XS_TOKEN_EQUAL_EXPRESSION,
272
  /* XS_TOKEN_NULL */ XS_TOKEN_BEGIN_STATEMENT | XS_TOKEN_BEGIN_EXPRESSION | XS_TOKEN_IDENTIFIER_NAME, 
273
  /* XS_TOKEN_NUMBER */ XS_TOKEN_BEGIN_STATEMENT | XS_TOKEN_BEGIN_EXPRESSION,
274
  /* XS_TOKEN_OBJECT */ 0,
275
  /* XS_TOKEN_OBJECT_BINDING */ 0,
276
  /* XS_TOKEN_OPTION */ 0,
277
  /* XS_TOKEN_OR */ 0,
278
  /* XS_TOKEN_OR_ASSIGN */ XS_TOKEN_ASSIGN_EXPRESSION,
279
  /* XS_TOKEN_PACKAGE */ XS_TOKEN_IDENTIFIER_NAME,
280
  /* XS_TOKEN_PARAMS */ 0,
281
  /* XS_TOKEN_PARAMS_BINDING */ 0,
282
  /* XS_TOKEN_PLUS */ 0,
283
  /* XS_TOKEN_PRIVATE */ XS_TOKEN_IDENTIFIER_NAME,
284
  /* XS_TOKEN_PRIVATE_IDENTIFIER */ XS_TOKEN_BEGIN_EXPRESSION,
285
  /* XS_TOKEN_PRIVATE_MEMBER */ 0,
286
  /* XS_TOKEN_PRIVATE_PROPERTY */ 0,
287
  /* XS_TOKEN_PROGRAM */ 0,
288
  /* XS_TOKEN_PROPERTY */ 0,
289
  /* XS_TOKEN_PROPERTY_AT */ 0,
290
  /* XS_TOKEN_PROPERTY_BINDING */ 0,
291
  /* XS_TOKEN_PROPERTY_BINDING_AT */ 0,
292
  /* XS_TOKEN_PROTECTED */ XS_TOKEN_IDENTIFIER_NAME,
293
  /* XS_TOKEN_PUBLIC */ XS_TOKEN_IDENTIFIER_NAME,
294
  /* XS_TOKEN_QUESTION_MARK */ 0,
295
  /* XS_TOKEN_REGEXP */ XS_TOKEN_BEGIN_STATEMENT | XS_TOKEN_BEGIN_EXPRESSION,
296
  /* XS_TOKEN_REST_BINDING */ 0,
297
  /* XS_TOKEN_RETURN */ XS_TOKEN_BEGIN_STATEMENT | XS_TOKEN_IDENTIFIER_NAME,
298
  /* XS_TOKEN_RIGHT_BRACE */ XS_TOKEN_END_STATEMENT,
299
  /* XS_TOKEN_RIGHT_BRACKET */ 0,
300
  /* XS_TOKEN_RIGHT_PARENTHESIS */ 0,
301
  /* XS_TOKEN_SEMICOLON */ XS_TOKEN_BEGIN_STATEMENT | XS_TOKEN_END_STATEMENT,
302
  /* XS_TOKEN_SETTER */ 0,
303
  /* XS_TOKEN_SHORT */ 0,
304
  /* XS_TOKEN_SIGNED_RIGHT_SHIFT */ XS_TOKEN_SHIFT_EXPRESSION,
305
  /* XS_TOKEN_SIGNED_RIGHT_SHIFT_ASSIGN */ XS_TOKEN_ASSIGN_EXPRESSION,
306
  /* XS_TOKEN_SKIP_BINDING */ 0,
307
  /* XS_TOKEN_SPECIFIER */ 0,
308
  /* XS_TOKEN_SPREAD */ XS_TOKEN_BEGIN_BINDING,
309
  /* XS_TOKEN_STATEMENT */ 0,
310
  /* XS_TOKEN_STATEMENTS */ 0,
311
  /* XS_TOKEN_STATIC */ XS_TOKEN_IDENTIFIER_NAME,
312
  /* XS_TOKEN_STRICT_EQUAL */ XS_TOKEN_EQUAL_EXPRESSION,
313
  /* XS_TOKEN_STRICT_NOT_EQUAL */ XS_TOKEN_EQUAL_EXPRESSION,
314
  /* XS_TOKEN_STRING */ XS_TOKEN_BEGIN_STATEMENT | XS_TOKEN_BEGIN_EXPRESSION,
315
  /* XS_TOKEN_SUBTRACT */ XS_TOKEN_BEGIN_STATEMENT | XS_TOKEN_BEGIN_EXPRESSION | XS_TOKEN_ADDITIVE_EXPRESSION | XS_TOKEN_UNARY_EXPRESSION,
316
  /* XS_TOKEN_SUBTRACT_ASSIGN */ XS_TOKEN_ASSIGN_EXPRESSION,
317
  /* XS_TOKEN_SUPER */ XS_TOKEN_BEGIN_STATEMENT | XS_TOKEN_BEGIN_EXPRESSION | XS_TOKEN_IDENTIFIER_NAME,
318
  /* XS_TOKEN_SWITCH */ XS_TOKEN_BEGIN_STATEMENT | XS_TOKEN_IDENTIFIER_NAME,
319
  /* XS_TOKEN_TARGET */ 0,
320
  /* XS_TOKEN_TEMPLATE */ XS_TOKEN_BEGIN_STATEMENT | XS_TOKEN_BEGIN_EXPRESSION | XS_TOKEN_CALL_EXPRESSION,
321
  /* XS_TOKEN_TEMPLATE_HEAD */ XS_TOKEN_BEGIN_STATEMENT | XS_TOKEN_BEGIN_EXPRESSION | XS_TOKEN_CALL_EXPRESSION,
322
  /* XS_TOKEN_TEMPLATE_MIDDLE */ 0,
323
  /* XS_TOKEN_TEMPLATE_TAIL */ 0,
324
  /* XS_TOKEN_THIS */ XS_TOKEN_BEGIN_STATEMENT | XS_TOKEN_BEGIN_EXPRESSION | XS_TOKEN_IDENTIFIER_NAME,
325
  /* XS_TOKEN_THROW */ XS_TOKEN_BEGIN_STATEMENT | XS_TOKEN_IDENTIFIER_NAME,
326
  /* XS_TOKEN_TRUE */ XS_TOKEN_BEGIN_STATEMENT | XS_TOKEN_BEGIN_EXPRESSION | XS_TOKEN_IDENTIFIER_NAME,
327
  /* XS_TOKEN_TRY */ XS_TOKEN_BEGIN_STATEMENT | XS_TOKEN_IDENTIFIER_NAME,
328
  /* XS_TOKEN_TYPEOF */ XS_TOKEN_BEGIN_STATEMENT | XS_TOKEN_BEGIN_EXPRESSION | XS_TOKEN_UNARY_EXPRESSION | XS_TOKEN_IDENTIFIER_NAME,
329
  /* XS_TOKEN_UNDEFINED */ 0,
330
  /* XS_TOKEN_UNSIGNED_RIGHT_SHIFT */ XS_TOKEN_SHIFT_EXPRESSION,
331
  /* XS_TOKEN_UNSIGNED_RIGHT_SHIFT_ASSIGN */ XS_TOKEN_ASSIGN_EXPRESSION,
332
  /* XS_TOKEN_USING */ XS_TOKEN_BEGIN_STATEMENT | XS_TOKEN_IDENTIFIER_NAME,
333
  /* XS_TOKEN_VAR */ XS_TOKEN_BEGIN_STATEMENT | XS_TOKEN_IDENTIFIER_NAME,
334
  /* XS_TOKEN_VOID */ XS_TOKEN_BEGIN_STATEMENT | XS_TOKEN_BEGIN_EXPRESSION | XS_TOKEN_UNARY_EXPRESSION | XS_TOKEN_IDENTIFIER_NAME,
335
  /* XS_TOKEN_WHILE */ XS_TOKEN_BEGIN_STATEMENT | XS_TOKEN_IDENTIFIER_NAME,
336
  /* XS_TOKEN_WITH */ XS_TOKEN_BEGIN_STATEMENT | XS_TOKEN_IDENTIFIER_NAME,
337
  /* XS_TOKEN_YIELD */ XS_TOKEN_BEGIN_STATEMENT | XS_TOKEN_BEGIN_EXPRESSION | XS_TOKEN_IDENTIFIER_NAME
338
};
339
340
static txString const gxTokenNames[XS_TOKEN_COUNT] ICACHE_FLASH_ATTR = {
341
  /* XS_NO_TOKEN */ "",
342
  /* XS_TOKEN_ACCESS */ "access",
343
  /* XS_TOKEN_ADD */ "+",
344
  /* XS_TOKEN_ADD_ASSIGN */ "+=",
345
  /* XS_TOKEN_AND */ "&&",
346
  /* XS_TOKEN_AND_ASSIGN */ "&&=",
347
  /* XS_TOKEN_ARG */ "arg",
348
  /* XS_TOKEN_ARGUMENTS */ "arguments",
349
  /* XS_TOKEN_ARGUMENTS_SLOPPY */ "arguments_sloppy",
350
  /* XS_TOKEN_ARGUMENTS_STRICT */ "arguments_strict",
351
  /* XS_TOKEN_ARRAY */ "array",
352
  /* XS_TOKEN_ARRAY_BINDING */ "array_binding",
353
  /* XS_TOKEN_ARROW */ "=>",
354
  /* XS_TOKEN_ASSIGN */ "=",
355
  /* XS_TOKEN_AWAIT */ "await",
356
  /* XS_TOKEN_BIGINT */ "bigint",
357
  /* XS_TOKEN_BINDING */ "binding",
358
  /* XS_TOKEN_BIT_AND */ "&",
359
  /* XS_TOKEN_BIT_AND_ASSIGN */ "&=",
360
  /* XS_TOKEN_BIT_NOT */ "~",
361
  /* XS_TOKEN_BIT_OR */ "|",
362
  /* XS_TOKEN_BIT_OR_ASSIGN */ "|=",
363
  /* XS_TOKEN_BIT_XOR */ "^",
364
  /* XS_TOKEN_BIT_XOR_ASSIGN */ "^=",
365
  /* XS_TOKEN_BLOCK */ "block",
366
  /* XS_TOKEN_BODY */ "body",
367
  /* XS_TOKEN_BREAK */ "break",
368
  /* XS_TOKEN_CALL */ "call",
369
  /* XS_TOKEN_CASE */ "case",
370
  /* XS_TOKEN_CATCH */ "catch",
371
  /* XS_TOKEN_CHAIN */ "?.",
372
  /* XS_TOKEN_CLASS */ "class",
373
  /* XS_TOKEN_COALESCE */ "??",
374
  /* XS_TOKEN_COALESCE_ASSIGN */ "\?\?=",
375
  /* XS_TOKEN_COLON */ ":",
376
  /* XS_TOKEN_COMMA */ ",",
377
  /* XS_TOKEN_CONST */ "const",
378
  /* XS_TOKEN_CONTINUE */ "continue",
379
  /* XS_TOKEN_CURRENT */ "current",
380
  /* XS_TOKEN_DEBUGGER */ "debugger",
381
  /* XS_TOKEN_DECREMENT */ "--",
382
  /* XS_TOKEN_DEFAULT */ "default",
383
  /* XS_TOKEN_DEFINE */ "define",
384
  /* XS_TOKEN_DELEGATE */ "delegate",
385
  /* XS_TOKEN_DELETE */ "delete",
386
  /* XS_TOKEN_DIVIDE */ "/",
387
  /* XS_TOKEN_DIVIDE_ASSIGN */ "/=",
388
  /* XS_TOKEN_DO */ "do",
389
  /* XS_TOKEN_DOT */ ".",
390
  /* XS_TOKEN_ELISION */ "elision",
391
  /* XS_TOKEN_ELSE */ "else",
392
  /* XS_TOKEN_ENUM */ "enum",
393
  /* XS_TOKEN_EOF */ "",
394
  /* XS_TOKEN_EQUAL */ "==",
395
  /* XS_TOKEN_EVAL */ "eval",
396
  /* XS_TOKEN_EXPONENTIATION */ "**",
397
  /* XS_TOKEN_EXPONENTIATION_ASSIGN */ "**=",
398
  /* XS_TOKEN_EXPORT */ "export",
399
  /* XS_TOKEN_EXPRESSIONS */ "expressions",
400
  /* XS_TOKEN_EXTENDS */ "extends",
401
  /* XS_TOKEN_FALSE */ "false",
402
  /* XS_TOKEN_FIELD */ "field",
403
  /* XS_TOKEN_FINALLY */ "finally",
404
  /* XS_TOKEN_FOR */ "for",
405
  /* XS_TOKEN_FOR_AWAIT_OF */ "for_await_of",
406
  /* XS_TOKEN_FOR_IN */ "for_in",
407
  /* XS_TOKEN_FOR_OF */ "for_of",
408
  /* XS_TOKEN_FUNCTION */ "function",
409
  /* XS_TOKEN_GENERATOR */ "generator",
410
  /* XS_TOKEN_GETTER */ "getter",
411
  /* XS_TOKEN_HOST */ "host", 
412
  /* XS_TOKEN_IDENTIFIER */ "identifier",
413
  /* XS_TOKEN_IF */ "if",
414
  /* XS_TOKEN_IMPLEMENTS */ "implements",
415
  /* XS_TOKEN_IMPORT */ "import",
416
  /* XS_TOKEN_IMPORT_CALL */ "import",
417
  /* XS_TOKEN_IMPORT_META */ "import.meta",
418
  /* XS_TOKEN_IN */ "in",
419
  /* XS_TOKEN_INCLUDE */ "include",
420
  /* XS_TOKEN_INCREMENT */ "++",
421
  /* XS_TOKEN_INSTANCEOF */ "instanceof",
422
  /* XS_TOKEN_INTEGER */ "integer",
423
  /* XS_TOKEN_INTERFACE */ "interface",
424
  /* XS_TOKEN_ITEMS */ "items",
425
  /* XS_TOKEN_LABEL */ "label",
426
  /* XS_TOKEN_LEFT_BRACE */ "{",
427
  /* XS_TOKEN_LEFT_BRACKET */ "[",
428
  /* XS_TOKEN_LEFT_PARENTHESIS */ "(",
429
  /* XS_TOKEN_LEFT_SHIFT */ "<<",
430
  /* XS_TOKEN_LEFT_SHIFT_ASSIGN */ "<<=",
431
  /* XS_TOKEN_LESS */ "<",
432
  /* XS_TOKEN_LESS_EQUAL */ "<=",
433
  /* XS_TOKEN_LET */ "let",
434
  /* XS_TOKEN_MEMBER */ "member",
435
  /* XS_TOKEN_MEMBER_AT */ "member_at",
436
  /* XS_TOKEN_MINUS */ "minus",
437
  /* XS_TOKEN_MODULE */ "module",
438
  /* XS_TOKEN_MODULO */ "%",
439
  /* XS_TOKEN_MODULO_ASSIGN */ "%=",
440
  /* XS_TOKEN_MORE */ ">",
441
  /* XS_TOKEN_MORE_EQUAL */ ">=",
442
  /* XS_TOKEN_MULTIPLY */ "*",
443
  /* XS_TOKEN_MULTIPLY_ASSIGN */ "*=",
444
  /* XS_TOKEN_NEW */ "new", 
445
  /* XS_TOKEN_NOT */ "!",
446
  /* XS_TOKEN_NOT_EQUAL */ "!=",
447
  /* XS_TOKEN_NULL */ "null", 
448
  /* XS_TOKEN_NUMBER */ "number",
449
  /* XS_TOKEN_OBJECT */ "object",
450
  /* XS_TOKEN_OBJECT_BINDING */ "object_binding",
451
  /* XS_TOKEN_OPTION */ "?.",
452
  /* XS_TOKEN_OR */ "||",
453
  /* XS_TOKEN_OR_ASSIGN */ "||=",
454
  /* XS_TOKEN_PACKAGE */ "package",
455
  /* XS_TOKEN_PARAMS */ "params",
456
  /* XS_TOKEN_PARAMS_BINDING */ "params_binding",
457
  /* XS_TOKEN_PLUS */ "plus",
458
  /* XS_TOKEN_PRIVATE */ "private",
459
  /* XS_TOKEN_PRIVATE_IDENTIFIER */ "private_identifier",
460
  /* XS_TOKEN_PRIVATE_MEMBER */ "private_member",
461
  /* XS_TOKEN_PRIVATE_PROPERTY */ "private_property",
462
  /* XS_TOKEN_PROGRAM */ "program",
463
  /* XS_TOKEN_PROPERTY */ "property",
464
  /* XS_TOKEN_PROPERTY_AT */ "property_at",
465
  /* XS_TOKEN_PROPERTY_BINDING */ "property_binding",
466
  /* XS_TOKEN_PROPERTY_BINDING_AT */ "property_binding_at",
467
  /* XS_TOKEN_PROTECTED */ "protected",
468
  /* XS_TOKEN_PUBLIC */ "public",
469
  /* XS_TOKEN_QUESTION_MARK */ "?",
470
  /* XS_TOKEN_REGEXP */ "regexp",
471
  /* XS_TOKEN_REST_BINDING */ "rest_binding",
472
  /* XS_TOKEN_RETURN */ "return",
473
  /* XS_TOKEN_RIGHT_BRACE */ "}",
474
  /* XS_TOKEN_RIGHT_BRACKET */ "]",
475
  /* XS_TOKEN_RIGHT_PARENTHESIS */ ")",
476
  /* XS_TOKEN_SEMICOLON */ ";",
477
  /* XS_TOKEN_SETTER */ "setter",
478
  /* XS_TOKEN_SHORT */ "short",
479
  /* XS_TOKEN_SIGNED_RIGHT_SHIFT */ ">>",
480
  /* XS_TOKEN_SIGNED_RIGHT_SHIFT_ASSIGN */ ">>=",
481
  /* XS_TOKEN_SKIP_BINDING */ "skip_binding",
482
  /* XS_TOKEN_SPECIFIER */ "specifier",
483
  /* XS_TOKEN_SPREAD */ "...",
484
  /* XS_TOKEN_STATEMENT */ "statement",
485
  /* XS_TOKEN_STATEMENTS */ "statements",
486
  /* XS_TOKEN_STATIC */ "static",
487
  /* XS_TOKEN_STRICT_EQUAL */ "===",
488
  /* XS_TOKEN_STRICT_NOT_EQUAL */ "!==",
489
  /* XS_TOKEN_STRING */ "string",
490
  /* XS_TOKEN_SUBTRACT */ "-",
491
  /* XS_TOKEN_SUBTRACT_ASSIGN */ "-=",
492
  /* XS_TOKEN_SUPER */ "super",
493
  /* XS_TOKEN_SWITCH */ "switch",
494
  /* XS_TOKEN_TARGET */ "target",
495
  /* XS_TOKEN_TEMPLATE */ "template",
496
  /* XS_TOKEN_TEMPLATE_HEAD */ "template_head",
497
  /* XS_TOKEN_TEMPLATE_MIDDLE */ "template_middle",
498
  /* XS_TOKEN_TEMPLATE_TAIL */ "template_tail",
499
  /* XS_TOKEN_THIS */ "this",
500
  /* XS_TOKEN_THROW */ "throw",
501
  /* XS_TOKEN_TRUE */ "true",
502
  /* XS_TOKEN_TRY */ "try",
503
  /* XS_TOKEN_TYPEOF */ "typeof",
504
  /* XS_TOKEN_UNDEFINED */ "undefined",
505
  /* XS_TOKEN_UNSIGNED_RIGHT_SHIFT */ ">>>",
506
  /* XS_TOKEN_UNSIGNED_RIGHT_SHIFT_ASSIGN */ ">>>=",
507
  /* XS_TOKEN_USIGN */ "using",
508
  /* XS_TOKEN_VAR */ "var",
509
  /* XS_TOKEN_VOID */ "void",
510
  /* XS_TOKEN_WHILE */ "while",
511
  /* XS_TOKEN_WITH */ "with",
512
  /* XS_TOKEN_YIELD */ "yield",
513
};
514
515
txBoolean fxIsKeyword(txParser* parser, txSymbol* keyword)
516
109k
{
517
109k
  txBoolean result = ((parser->states[0].token == XS_TOKEN_IDENTIFIER) && (parser->states[0].symbol == keyword)) ? 1 : 0;
518
109k
  if (result) {
519
7.22k
    if (parser->states[0].escaped)
520
0
      fxReportParserError(parser, parser->states[0].line, "escaped keyword");
521
7.22k
  }
522
109k
  return result;
523
109k
}
524
525
txBoolean fxIsToken(txParser* parser, txToken theToken)
526
25.4k
{
527
25.4k
  txBoolean result = (parser->states[0].token == theToken) ? 1 : 0;
528
25.4k
  if (result) {
529
12.0k
    if (parser->states[0].escaped)
530
0
      fxReportParserError(parser, parser->states[0].line, "escaped keyword");
531
12.0k
  }
532
25.4k
  return result;
533
25.4k
}
534
535
void fxMatchToken(txParser* parser, txToken theToken)
536
2.42M
{
537
2.42M
  if (parser->states[0].token == theToken) {
538
2.39M
    if (parser->states[0].escaped)
539
0
      fxReportParserError(parser, parser->states[0].line, "escaped keyword");
540
2.39M
    fxGetNextToken(parser);
541
2.39M
  }
542
35.1k
  else
543
35.1k
    fxReportParserError(parser, parser->states[0].line, "missing %s", gxTokenNames[theToken]);
544
2.42M
}
545
546
txNode* fxPopNode(txParser* parser)
547
8.61k
{
548
8.61k
  txNode* node = parser->root;
549
8.61k
  parser->root = node->next;
550
8.61k
  node->next = NULL;
551
8.61k
  parser->nodeCount--;
552
8.61k
  return node;
553
8.61k
}
554
555
void fxPushNode(txParser* parser, txNode* node)
556
16.6M
{
557
16.6M
  node->next = parser->root;
558
16.6M
  parser->root = (txNode*)node;
559
16.6M
  parser->nodeCount++;
560
16.6M
}
561
562
void fxPushBigIntNode(txParser* parser, txBigInt* value, txInteger line)
563
29.4k
{
564
29.4k
  txBigIntNode* node = fxNewParserChunk(parser, sizeof(txBigIntNode));
565
29.4k
  node->description = &gxTokenDescriptions[XS_TOKEN_BIGINT];
566
29.4k
  node->path = parser->path;
567
29.4k
  node->line = line;
568
29.4k
  node->flags = 0;
569
29.4k
  node->value = *value;
570
29.4k
  fxPushNode(parser, (txNode*)node);
571
29.4k
}
572
573
void fxPushIndexNode(txParser* parser, txIndex value, txInteger line)
574
11.8k
{
575
11.8k
  if (((txInteger)value) >= 0)
576
11.7k
    fxPushIntegerNode(parser, (txInteger)value, line);
577
47
  else
578
47
    fxPushNumberNode(parser, value, line);
579
11.8k
}
580
581
void fxPushIntegerNode(txParser* parser, txInteger value, txInteger line)
582
4.82M
{
583
4.82M
  txIntegerNode* node = fxNewParserChunk(parser, sizeof(txIntegerNode));
584
4.82M
  node->description = &gxTokenDescriptions[XS_TOKEN_INTEGER];
585
4.82M
  node->path = parser->path;
586
4.82M
  node->line = line;
587
4.82M
  node->flags = 0;
588
4.82M
  node->value = value;
589
4.82M
  fxPushNode(parser, (txNode*)node);
590
4.82M
}
591
592
void fxPushNodeStruct(txParser* parser, txInteger count, txToken token, txInteger line)
593
8.50M
{
594
8.50M
  const txNodeDescription* description = &gxTokenDescriptions[token];
595
8.50M
  txNode* node;
596
8.50M
  if ((count > parser->nodeCount) || ((sizeof(txNode) + (count * sizeof(txNode*))) > (size_t)(description->size))) {
597
0
    fxReportParserError(parser, parser->states[0].line, "invalid %s", gxTokenNames[token]);
598
0
  }
599
8.50M
    node = fxNewParserChunkClear(parser, description->size);
600
8.50M
  node->description = description;
601
8.50M
  node->flags |= parser->flags & (mxStrictFlag | mxGeneratorFlag | mxAsyncFlag);
602
8.50M
  node->path = parser->path;
603
8.50M
  node->line = line;
604
8.50M
    parser->nodeCount -= count;
605
8.50M
  if (count) {
606
8.27M
    txNode** dst = (txNode**)&node[1];
607
8.27M
    txNode* src = parser->root;
608
22.6M
    while (count) {
609
14.3M
      txNode* next = src->next;
610
14.3M
      src->next = NULL;
611
14.3M
      count--;
612
14.3M
      if (src->description)
613
12.8M
        dst[count] = src;
614
1.44M
      else if (src->path)
615
1.31M
        dst[count] = (txNode*)(src->path);
616
14.3M
      src = next;
617
14.3M
    }
618
8.27M
    parser->root = src;
619
8.27M
  }
620
8.50M
  fxPushNode(parser, node);
621
8.50M
}
622
623
void fxPushNodeList(txParser* parser, txInteger count)
624
826k
{
625
826k
  txNodeList* list = fxNewParserChunk(parser, sizeof(txNodeList));
626
826k
  txNode* previous = NULL;
627
826k
  txNode* current = parser->root;
628
826k
  txNode* next;
629
826k
    parser->nodeCount -= count;
630
826k
  list->length = count;
631
1.96M
  while (count) {
632
1.13M
    next = current->next;
633
1.13M
    current->next = previous;
634
1.13M
    previous = current;
635
1.13M
    current = next;
636
1.13M
    count--;
637
1.13M
  }
638
826k
  parser->root = current;
639
826k
  list->description = &gxTokenDescriptions[XS_NO_TOKEN];
640
826k
  list->first = previous;
641
826k
  fxPushNode(parser, (txNode*)list);
642
826k
}
643
644
void fxPushNULL(txParser* parser)
645
319k
{
646
319k
    txNodeLink* node = fxNewParserChunkClear(parser, sizeof(txNodeLink));
647
319k
  fxPushNode(parser, (txNode*)node);
648
319k
}
649
650
void fxPushNumberNode(txParser* parser, txNumber value, txInteger line)
651
25.9k
{
652
25.9k
  txNumberNode* node = fxNewParserChunk(parser, sizeof(txNumberNode));
653
25.9k
  node->description = &gxTokenDescriptions[XS_TOKEN_NUMBER];
654
25.9k
  node->path = parser->path;
655
25.9k
  node->line = line;
656
25.9k
  node->flags = 0;
657
25.9k
  node->value = value;
658
25.9k
  fxPushNode(parser, (txNode*)node);
659
25.9k
}
660
661
void fxPushRawNode(txParser* parser, txInteger length, txString value, txInteger line)
662
242k
{
663
242k
  txStringNode* node = fxNewParserChunk(parser, sizeof(txStringNode));
664
242k
  node->description = &gxTokenDescriptions[XS_TOKEN_STRING];
665
242k
  node->path = parser->path;
666
242k
  node->line = line;
667
242k
  node->flags = 0;
668
242k
  node->length = length;
669
242k
  node->value = value;
670
242k
  fxPushNode(parser, (txNode*)node);
671
242k
}
672
673
void fxPushStringNode(txParser* parser, txInteger length, txString value, txInteger line)
674
434k
{
675
434k
  txStringNode* node = fxNewParserChunk(parser, sizeof(txStringNode));
676
434k
  node->description = &gxTokenDescriptions[XS_TOKEN_STRING];
677
434k
  node->path = parser->path;
678
434k
  node->line = line;
679
434k
  node->flags = parser->states[0].escaped;
680
434k
  node->length = length;
681
434k
  node->value = value;
682
434k
  fxPushNode(parser, (txNode*)node);
683
434k
}
684
685
void fxPushSymbol(txParser* parser, txSymbol* symbol)
686
1.40M
{
687
1.40M
    txNodeLink* node = fxNewParserChunkClear(parser, sizeof(txNodeLink));
688
1.40M
  node->symbol = symbol;  
689
1.40M
  fxPushNode(parser, (txNode*)node);
690
1.40M
}
691
692
void fxSwapNodes(txParser* parser)
693
39.6k
{
694
39.6k
  txNode* previous = parser->root;
695
39.6k
  txNode* current = previous->next;
696
39.6k
  previous->next = current->next;
697
39.6k
  current->next = previous;
698
39.6k
  parser->root = current;
699
39.6k
}
700
701
void fxModule(txParser* parser)
702
2.30k
{
703
2.30k
  txInteger aCount = parser->nodeCount;
704
2.30k
  txInteger aLine = parser->states[0].line;
705
7.20k
  while ((parser->states[0].token != XS_TOKEN_EOF)) {
706
4.89k
    if (parser->states[0].token == XS_TOKEN_EXPORT)
707
2.40k
      fxExportDeclaration(parser);
708
2.48k
    else if (parser->states[0].token == XS_TOKEN_IMPORT) {
709
233
      fxLookAheadOnce(parser);
710
233
      if ((parser->states[1].token == XS_TOKEN_DOT) || (parser->states[1].token == XS_TOKEN_LEFT_PARENTHESIS))
711
78
        fxStatement(parser, 1);
712
155
      else
713
155
        fxImportDeclaration(parser);
714
233
    }
715
2.25k
    else if (parser->states[0].token == XS_TOKEN_RETURN) {
716
1
      fxReportParserError(parser, parser->states[0].line, "invalid return");
717
1
      fxGetNextToken(parser);
718
1
    }
719
2.25k
    else if (parser->states[0].token == XS_TOKEN_YIELD) {
720
1
      fxReportParserError(parser, parser->states[0].line, "invalid yield");
721
1
      fxGetNextToken(parser);
722
1
    }
723
2.25k
    else {
724
2.25k
      fxStatement(parser, 1);
725
2.25k
    }
726
4.89k
  }
727
2.30k
  aCount = parser->nodeCount - aCount;
728
2.30k
  if (aCount > 1) {
729
205
    fxPushNodeList(parser, aCount);
730
205
    fxPushNodeStruct(parser, 1, XS_TOKEN_STATEMENTS, aLine);
731
205
  }
732
2.10k
  else if (aCount == 0) {
733
1
    fxPushNodeStruct(parser, 0, XS_TOKEN_UNDEFINED, aLine);
734
1
    fxPushNodeStruct(parser, 1, XS_TOKEN_STATEMENT, aLine);
735
1
  }
736
2.30k
  fxPushNodeStruct(parser, 1, XS_TOKEN_MODULE, aLine);
737
2.30k
  parser->root->flags = parser->flags & (mxStrictFlag | mxAwaitingFlag);
738
2.30k
}
739
740
void fxExportDeclaration(txParser* parser)
741
2.40k
{
742
2.40k
  txSymbol* symbol = C_NULL;
743
2.40k
  txInteger count;
744
2.40k
  txInteger line = parser->states[0].line;
745
2.40k
  txUnsigned flag = 0;
746
2.40k
  txToken aToken;
747
2.40k
  fxMatchToken(parser, XS_TOKEN_EXPORT);
748
2.40k
  switch (parser->states[0].token) {
749
20
  case XS_TOKEN_MULTIPLY:
750
20
    fxPushNULL(parser);
751
20
    fxGetNextToken(parser);
752
20
    if (fxIsKeyword(parser, parser->asSymbol)) {
753
15
      fxGetNextToken(parser);
754
15
      if (gxTokenFlags[parser->states[0].token] & XS_TOKEN_IDENTIFIER_NAME) {
755
15
        fxPushSymbol(parser, parser->states[0].symbol);
756
15
        fxGetNextToken(parser);
757
15
      }
758
0
      else {
759
0
        fxPushNULL(parser);
760
0
        fxReportParserError(parser, parser->states[0].line, "missing identifier");
761
0
      }
762
15
    }
763
5
    else {
764
5
      fxPushNULL(parser);
765
5
    }
766
20
    if (fxIsKeyword(parser, parser->fromSymbol)) {
767
18
      fxGetNextToken(parser);
768
18
      if (parser->states[0].token == XS_TOKEN_STRING) {
769
17
        fxPushNodeStruct(parser, 2, XS_TOKEN_SPECIFIER, line);
770
17
        fxPushNodeList(parser, 1);
771
17
        fxPushStringNode(parser, parser->states[0].stringLength, parser->states[0].string, line);
772
17
        fxGetNextToken(parser);
773
17
        if (!parser->states[0].crlf && (parser->states[0].token == XS_TOKEN_WITH)) {
774
0
          fxGetNextToken(parser);
775
0
          fxWithAttributes(parser);
776
0
        }
777
17
        else
778
17
          fxPushNULL(parser);
779
17
        fxPushNodeStruct(parser, 3, XS_TOKEN_EXPORT, line);
780
17
        fxSemicolon(parser);
781
17
      }
782
1
      else
783
1
        fxReportParserError(parser, parser->states[0].line, "missing module");
784
18
    }
785
2
    else
786
2
      fxReportParserError(parser, parser->states[0].line, "missing from");
787
20
    break;
788
144
  case XS_TOKEN_DEFAULT:
789
144
    fxMatchToken(parser, XS_TOKEN_DEFAULT);
790
144
    if (parser->flags & mxDefaultFlag)
791
1
      fxReportParserError(parser, parser->states[0].line, "invalid default");
792
144
    parser->flags |= mxDefaultFlag;
793
144
    if (parser->states[0].token == XS_TOKEN_CLASS) {
794
0
      fxClassExpression(parser, line, &symbol);
795
0
      if (symbol)
796
0
        fxPushSymbol(parser, symbol);
797
0
      else
798
0
        fxPushSymbol(parser, parser->defaultSymbol);
799
0
      fxPushNodeStruct(parser, 1, XS_TOKEN_LET, line);
800
0
      fxSwapNodes(parser);
801
0
      fxPushNodeStruct(parser, 2, XS_TOKEN_BINDING, line);
802
0
    }
803
144
    else if (parser->states[0].token == XS_TOKEN_FUNCTION) {
804
0
  again:
805
0
      fxMatchToken(parser, XS_TOKEN_FUNCTION);
806
0
      if (parser->states[0].token == XS_TOKEN_MULTIPLY) {
807
0
        fxGetNextToken(parser);
808
0
        fxGeneratorExpression(parser, line, &symbol, flag);
809
0
      }
810
0
      else
811
0
        fxFunctionExpression(parser, line, &symbol, flag);
812
0
      if (symbol) {
813
0
        txDefineNode* node = fxDefineNodeNew(parser, XS_TOKEN_DEFINE, symbol);
814
0
        node->initializer = fxPopNode(parser);
815
0
        fxPushNode(parser, (txNode*)node);
816
0
      }
817
0
      else {
818
0
        txDefineNode* node = fxDefineNodeNew(parser, XS_TOKEN_DEFINE, parser->defaultSymbol);
819
0
        node->initializer = fxPopNode(parser);
820
0
        fxPushNode(parser, (txNode*)node);
821
0
      }
822
0
    }
823
144
    else {
824
144
      if ((parser->states[0].token == XS_TOKEN_IDENTIFIER) && (parser->states[0].symbol == parser->asyncSymbol) && (!parser->states[0].escaped)) {
825
0
        fxLookAheadOnce(parser);
826
0
        if ((!parser->states[1].crlf) && (parser->states[1].token == XS_TOKEN_FUNCTION)) {
827
0
          fxGetNextToken(parser);
828
0
          flag = mxAsyncFlag;
829
0
          goto again;         
830
0
        }
831
0
      }
832
144
      fxAssignmentExpression(parser);
833
144
      fxSemicolon(parser);
834
144
      fxPushSymbol(parser, parser->defaultSymbol);
835
144
      fxPushNULL(parser);
836
144
      fxPushNodeStruct(parser, 2, XS_TOKEN_CONST, line);
837
144
      fxSwapNodes(parser);
838
144
      fxPushNodeStruct(parser, 2, XS_TOKEN_ASSIGN, line);
839
144
      fxPushNodeStruct(parser, 1, XS_TOKEN_STATEMENT, line);
840
144
    }
841
144
    if (symbol) {
842
0
      fxPushSymbol(parser, symbol);
843
0
      fxPushSymbol(parser, parser->defaultSymbol);
844
0
    }
845
144
    else {
846
144
      fxPushSymbol(parser, parser->defaultSymbol);
847
144
      fxPushNULL(parser);
848
144
    }
849
144
    fxPushNodeStruct(parser, 2, XS_TOKEN_SPECIFIER, line);
850
144
    fxPushNodeList(parser, 1);
851
144
    fxPushNULL(parser);
852
144
    fxPushNULL(parser);
853
144
    fxPushNodeStruct(parser, 3, XS_TOKEN_EXPORT, line);
854
144
    break;
855
0
  case XS_TOKEN_CLASS:
856
0
    fxClassExpression(parser, line, &symbol);
857
0
    if (symbol) {
858
0
      fxPushSymbol(parser, symbol);
859
0
      fxPushNodeStruct(parser, 1, XS_TOKEN_LET, line);
860
0
      fxSwapNodes(parser);
861
0
      fxPushNodeStruct(parser, 2, XS_TOKEN_BINDING, line);
862
      
863
0
      fxPushSymbol(parser, symbol);
864
0
      fxPushNULL(parser);
865
0
      fxPushNodeStruct(parser, 2, XS_TOKEN_SPECIFIER, line);
866
0
      fxPushNodeList(parser, 1);
867
0
      fxPushNULL(parser);
868
0
      fxPushNULL(parser);
869
0
      fxPushNodeStruct(parser, 3, XS_TOKEN_EXPORT, line);
870
0
    }
871
0
    else
872
0
      fxReportParserError(parser, parser->states[0].line, "missing identifier");
873
0
    break;
874
0
  case XS_TOKEN_FUNCTION:
875
0
  again2:
876
0
    fxMatchToken(parser, XS_TOKEN_FUNCTION);
877
0
    if (parser->states[0].token == XS_TOKEN_MULTIPLY) {
878
0
      fxGetNextToken(parser);
879
0
      fxGeneratorExpression(parser, line, &symbol, flag);
880
0
    }
881
0
    else
882
0
      fxFunctionExpression(parser, line, &symbol, flag);
883
0
    if (symbol) {
884
0
      txDefineNode* node = fxDefineNodeNew(parser, XS_TOKEN_DEFINE, symbol);
885
0
      node->initializer = fxPopNode(parser);
886
0
      fxPushNode(parser, (txNode*)node);
887
0
      fxPushSymbol(parser, symbol);
888
0
      fxPushNULL(parser);
889
0
      fxPushNodeStruct(parser, 2, XS_TOKEN_SPECIFIER, line);
890
0
      fxPushNodeList(parser, 1);
891
0
      fxPushNULL(parser);
892
0
      fxPushNULL(parser);
893
0
      fxPushNodeStruct(parser, 3, XS_TOKEN_EXPORT, line);
894
0
    }
895
0
    else
896
0
      fxReportParserError(parser, parser->states[0].line, "missing identifier");
897
0
    break;
898
73
  case XS_TOKEN_CONST:
899
140
  case XS_TOKEN_LET:
900
177
  case XS_TOKEN_VAR:
901
177
    aToken = parser->states[0].token;
902
177
    fxVariableStatement(parser, aToken, 0);
903
177
    count = parser->nodeCount;
904
177
    fxExportBinding(parser, parser->root);
905
177
    fxPushNodeList(parser, parser->nodeCount - count);
906
177
    fxPushNULL(parser);
907
177
    fxPushNULL(parser);
908
177
    fxPushNodeStruct(parser, 3, XS_TOKEN_EXPORT, line);
909
177
    fxSemicolon(parser);
910
177
    break;
911
1.83k
  case XS_TOKEN_LEFT_BRACE:
912
1.83k
    count = parser->nodeCount;
913
1.83k
    fxSpecifiers(parser);
914
1.83k
    fxPushNodeList(parser, parser->nodeCount - count);
915
1.83k
    if (fxIsKeyword(parser, parser->fromSymbol)) {
916
21
      fxGetNextToken(parser);
917
21
      if (parser->states[0].token == XS_TOKEN_STRING) {
918
20
        fxPushStringNode(parser, parser->states[0].stringLength, parser->states[0].string, line);
919
20
        fxGetNextToken(parser);
920
20
      }
921
1
      else {
922
1
        fxPushNULL(parser);
923
1
        fxReportParserError(parser, parser->states[0].line, "missing module");
924
1
      }
925
21
      if (!parser->states[0].crlf && (parser->states[0].token == XS_TOKEN_WITH)) {
926
0
        fxGetNextToken(parser);
927
0
        fxWithAttributes(parser);
928
0
      }
929
21
      else
930
21
        fxPushNULL(parser);
931
21
    }
932
1.81k
    else {
933
1.81k
      fxPushNULL(parser);
934
1.81k
      fxPushNULL(parser);
935
1.81k
    }
936
1.83k
    fxPushNodeStruct(parser, 3, XS_TOKEN_EXPORT, line);
937
1.83k
    fxSemicolon(parser);
938
1.83k
    break;
939
233
  default:
940
233
    if ((parser->states[0].token == XS_TOKEN_IDENTIFIER) && (parser->states[0].symbol == parser->asyncSymbol) && (!parser->states[0].escaped)) {
941
0
      fxLookAheadOnce(parser);
942
0
      if ((!parser->states[1].crlf) && (parser->states[1].token == XS_TOKEN_FUNCTION)) {
943
0
        fxGetNextToken(parser);
944
0
        flag = mxAsyncFlag;
945
0
        goto again2;          
946
0
      }
947
0
    }
948
233
    fxReportParserError(parser, parser->states[0].line, "invalid export %s", gxTokenNames[parser->states[0].token]);
949
233
    fxGetNextToken(parser);
950
233
    break;
951
2.40k
  }
952
2.40k
}
953
954
void fxExportBinding(txParser* parser, txNode* node)
955
329
{
956
329
  txToken token = node->description->token;
957
329
  if ((token == XS_TOKEN_CONST) || (token == XS_TOKEN_LET) || (token == XS_TOKEN_VAR)) {
958
183
    fxPushSymbol(parser, ((txDeclareNode*)node)->symbol);
959
183
    fxPushNULL(parser);
960
183
    fxPushNodeStruct(parser, 2, XS_TOKEN_SPECIFIER, node->line);
961
183
  }
962
146
  else if (token == XS_TOKEN_BINDING) {
963
136
    fxExportBinding(parser, ((txBindingNode*)node)->target);
964
136
  }
965
10
  else if (token == XS_TOKEN_ARRAY_BINDING) {
966
0
    node = ((txArrayBindingNode*)node)->items->first;
967
0
    while (node) {
968
0
      fxExportBinding(parser, node);
969
0
      node = node->next;
970
0
    }
971
0
  }
972
10
  else if (token == XS_TOKEN_OBJECT_BINDING) {
973
2
    node = ((txObjectBindingNode*)node)->items->first;
974
3
    while (node) {
975
1
      fxExportBinding(parser, node);
976
1
      node = node->next;
977
1
    }
978
2
  }
979
8
  else if (token == XS_TOKEN_PROPERTY_BINDING)
980
0
    fxExportBinding(parser, ((txPropertyBindingNode*)node)->binding);
981
8
  else if (token == XS_TOKEN_PROPERTY_BINDING_AT)
982
1
    fxExportBinding(parser, ((txPropertyBindingAtNode*)node)->binding);
983
7
  else if (token == XS_TOKEN_REST_BINDING)
984
0
    fxExportBinding(parser, ((txRestBindingNode*)node)->binding);
985
7
  else if (token == XS_TOKEN_STATEMENTS) {
986
7
    node = ((txStatementsNode*)node)->items->first;
987
22
    while (node) {
988
15
      fxExportBinding(parser, node);
989
15
      node = node->next;
990
15
    }
991
7
  }
992
329
}
993
994
995
void fxImportDeclaration(txParser* parser)
996
155
{
997
155
  txBoolean asFlag = 1;
998
155
  txBoolean fromFlag = 0;
999
155
  txInteger count = parser->nodeCount;
1000
155
  fxMatchToken(parser, XS_TOKEN_IMPORT);
1001
155
  if (parser->states[0].token == XS_TOKEN_IDENTIFIER) {
1002
78
    fxPushSymbol(parser, parser->defaultSymbol);
1003
78
    fxPushSymbol(parser, parser->states[0].symbol);
1004
78
    fxPushNodeStruct(parser, 2, XS_TOKEN_SPECIFIER, parser->states[0].line);
1005
78
    fxGetNextToken(parser);
1006
78
    if (parser->states[0].token == XS_TOKEN_COMMA)
1007
3
      fxGetNextToken(parser);
1008
75
    else
1009
75
      asFlag = 0;
1010
78
    fromFlag = 1;
1011
78
  }
1012
155
  if (asFlag) {
1013
80
    if (parser->states[0].token == XS_TOKEN_MULTIPLY) {
1014
37
      fxGetNextToken(parser);
1015
37
      if (fxIsKeyword(parser, parser->asSymbol)) {
1016
35
        fxGetNextToken(parser);
1017
35
        if (parser->states[0].token == XS_TOKEN_IDENTIFIER) {
1018
34
          fxPushNULL(parser);
1019
34
          fxPushSymbol(parser, parser->states[0].symbol);
1020
34
          fxPushNodeStruct(parser, 2, XS_TOKEN_SPECIFIER, parser->states[0].line);
1021
34
          fxGetNextToken(parser);
1022
34
        }
1023
1
        else {
1024
1
          fxReportParserError(parser, parser->states[0].line, "missing identifier");
1025
1
        }
1026
35
      }
1027
2
      else {
1028
2
        fxReportParserError(parser, parser->states[0].line, "missing as");
1029
2
      }
1030
37
      fromFlag = 1;
1031
37
    }
1032
43
    else if (parser->states[0].token == XS_TOKEN_LEFT_BRACE) {
1033
17
      fxSpecifiers(parser);
1034
17
      fromFlag = 1;
1035
17
    }
1036
80
  }
1037
155
  fxPushNodeList(parser, parser->nodeCount - count);
1038
155
  if (fromFlag) {
1039
128
    if (fxIsKeyword(parser, parser->fromSymbol)) {
1040
126
      fxGetNextToken(parser);
1041
126
      if (parser->states[0].token == XS_TOKEN_STRING) {
1042
125
        fxPushStringNode(parser, parser->states[0].stringLength, parser->states[0].string, parser->states[0].line);
1043
125
        fxGetNextToken(parser);
1044
125
      }
1045
1
      else {
1046
1
        fxPushNULL(parser);
1047
1
        fxReportParserError(parser, parser->states[0].line, "missing module");
1048
1
      }
1049
126
    }
1050
2
    else {
1051
2
      fxPushNULL(parser);
1052
2
      fxReportParserError(parser, parser->states[0].line, "missing from");
1053
2
    }
1054
128
  }
1055
27
  else if (parser->states[0].token == XS_TOKEN_STRING) {
1056
22
    fxPushStringNode(parser, parser->states[0].stringLength, parser->states[0].string, parser->states[0].line);
1057
22
    fxGetNextToken(parser);
1058
22
  }
1059
5
  else {
1060
5
    fxPushNULL(parser);
1061
5
    fxReportParserError(parser, parser->states[0].line, "missing module");
1062
5
  }
1063
155
  if (!parser->states[0].crlf && (parser->states[0].token == XS_TOKEN_WITH)) {
1064
0
    fxGetNextToken(parser);
1065
0
    fxWithAttributes(parser);
1066
0
  }
1067
155
  else
1068
155
    fxPushNULL(parser);
1069
155
  fxPushNodeStruct(parser, 3, XS_TOKEN_IMPORT, parser->states[0].line);
1070
155
  fxSemicolon(parser);
1071
155
}
1072
1073
void fxSpecifiers(txParser* parser)
1074
1.85k
{
1075
//  txInteger aCount = 0;
1076
1.85k
  fxMatchToken(parser, XS_TOKEN_LEFT_BRACE);
1077
2.69k
  while (gxTokenFlags[parser->states[0].token] & XS_TOKEN_IDENTIFIER_NAME) {
1078
1.84k
    fxPushSymbol(parser, parser->states[0].symbol);
1079
1.84k
    fxGetNextToken(parser);
1080
1.84k
    if (fxIsKeyword(parser, parser->asSymbol)) {
1081
1.41k
      fxGetNextToken(parser);
1082
1.41k
      if (gxTokenFlags[parser->states[0].token] & XS_TOKEN_IDENTIFIER_NAME) {
1083
583
        fxPushSymbol(parser, parser->states[0].symbol);
1084
583
        fxGetNextToken(parser);
1085
583
      }
1086
834
      else {
1087
834
        fxPushNULL(parser);
1088
834
        fxReportParserError(parser, parser->states[0].line, "missing identifier");
1089
834
      }
1090
1.41k
    }
1091
423
    else
1092
423
      fxPushNULL(parser);
1093
1.84k
    fxPushNodeStruct(parser, 2, XS_TOKEN_SPECIFIER, parser->states[0].line);
1094
//    aCount++;
1095
1.84k
    if (parser->states[0].token != XS_TOKEN_COMMA) 
1096
999
      break;
1097
841
    fxGetNextToken(parser);
1098
841
  }
1099
1.85k
  fxMatchToken(parser, XS_TOKEN_RIGHT_BRACE);
1100
1.85k
}
1101
1102
void fxWithAttributes(txParser* parser)
1103
0
{
1104
0
  txBoolean flag = 0;
1105
0
  txString string;
1106
0
  fxMatchToken(parser, XS_TOKEN_LEFT_BRACE);
1107
0
  while (parser->states[0].token != XS_TOKEN_RIGHT_BRACE) {
1108
0
    if ((gxTokenFlags[parser->states[0].token] & XS_TOKEN_IDENTIFIER_NAME))
1109
0
      string = parser->states[0].symbol->string;
1110
0
    else if (parser->states[0].token == XS_TOKEN_STRING)
1111
0
      string = parser->states[0].string;
1112
0
    else {
1113
0
      fxReportParserError(parser, parser->states[0].line, "missing attribute key");
1114
0
      break;
1115
0
    }
1116
0
    if (c_strcmp(string, "type"))
1117
0
      fxReportParserError(parser, parser->states[0].line, "invalid attribute key");
1118
0
    else if (flag)
1119
0
      fxReportParserError(parser, parser->states[0].line, "duplicate attribute");
1120
0
    fxGetNextToken(parser);
1121
0
    if (parser->states[0].token != XS_TOKEN_COLON) {
1122
0
      fxReportParserError(parser, parser->states[0].line, "missing :");
1123
0
      break;
1124
0
    }
1125
0
        fxGetNextToken(parser);
1126
0
    if (parser->states[0].token == XS_TOKEN_STRING)
1127
0
      string = parser->states[0].string;
1128
0
    else {
1129
0
      fxReportParserError(parser, parser->states[0].line, "missing attribute value");
1130
0
      break;
1131
0
    }
1132
0
    if (c_strcmp(string, "json"))
1133
0
      fxReportParserError(parser, parser->states[0].line, "invalid attribute value");
1134
0
    flag = 1;
1135
0
    fxGetNextToken(parser);
1136
0
    if (parser->states[0].token != XS_TOKEN_COMMA)
1137
0
      break;
1138
0
    fxGetNextToken(parser);
1139
0
  }
1140
0
  fxMatchToken(parser, XS_TOKEN_RIGHT_BRACE);
1141
0
  if (flag)
1142
0
    fxPushSymbol(parser, parser->jsonSymbol);
1143
0
  else
1144
0
    fxPushNULL(parser);
1145
0
}
1146
1147
void fxProgram(txParser* parser)
1148
317k
{
1149
317k
  txInteger count = parser->nodeCount;
1150
317k
  txInteger line = parser->states[0].line;
1151
317k
  txNode* node;
1152
447k
  while (parser->states[0].token != XS_TOKEN_EOF) {
1153
323k
    fxStatement(parser, -1);
1154
323k
    node = parser->root;
1155
323k
    if (!node || !node->description || (node->description->token != XS_TOKEN_STATEMENT))
1156
56.7k
      break;
1157
266k
    node = ((txStatementNode*)node)->expression;
1158
266k
    if (!node || !node->description || (node->description->token != XS_TOKEN_STRING))
1159
136k
      break;
1160
130k
    if (!(node->flags & mxStringEscapeFlag) && (c_strcmp(((txStringNode*)node)->value, "use strict") == 0)) {
1161
7.44k
      if (!(parser->flags & mxStrictFlag)) {
1162
7.39k
        parser->flags |= mxStrictFlag;
1163
7.39k
        if (parser->states[0].token == XS_TOKEN_IDENTIFIER)
1164
6.88k
          fxCheckStrictKeyword(parser);
1165
7.39k
      }
1166
7.44k
    }
1167
130k
  }
1168
593k
  while (parser->states[0].token != XS_TOKEN_EOF) {
1169
275k
    fxStatement(parser, -1);
1170
275k
  }
1171
317k
  count = parser->nodeCount - count;
1172
317k
  if (count > 1) {
1173
21.7k
    fxPushNodeList(parser, count);
1174
21.7k
    fxPushNodeStruct(parser, 1, XS_TOKEN_STATEMENTS, line);
1175
21.7k
  }
1176
295k
  else if (count == 0) {
1177
3.12k
    fxPushNodeStruct(parser, 0, XS_TOKEN_UNDEFINED, line);
1178
3.12k
    fxPushNodeStruct(parser, 1, XS_TOKEN_STATEMENT, line);
1179
3.12k
  }
1180
317k
  fxPushNodeStruct(parser, 1, XS_TOKEN_PROGRAM, line);
1181
317k
  if (parser->flags & mxFieldFlag)
1182
0
    if (parser->flags & mxArgumentsFlag)
1183
0
      fxReportParserError(parser, parser->states[0].line, "invalid arguments");
1184
317k
  parser->root->flags = parser->flags & mxStrictFlag;
1185
317k
}
1186
1187
void fxBody(txParser* parser)
1188
146k
{
1189
146k
  txInteger count = parser->nodeCount;
1190
146k
  txInteger line = parser->states[0].line;
1191
146k
  txNode* node;
1192
146k
    fxCheckParserStack(parser, line);
1193
203k
  while ((parser->states[0].token != XS_TOKEN_EOF) && (parser->states[0].token != XS_TOKEN_RIGHT_BRACE)) {
1194
134k
    fxStatement(parser, 1);
1195
134k
    node = parser->root;
1196
134k
    if (!node || !node->description || (node->description->token != XS_TOKEN_STATEMENT))
1197
23.0k
      break;
1198
111k
    node = ((txStatementNode*)node)->expression;
1199
111k
    if (!node || !node->description || (node->description->token != XS_TOKEN_STRING))
1200
55.4k
      break;
1201
56.3k
    if (!(node->flags & mxStringEscapeFlag) && (c_strcmp(((txStringNode*)node)->value, "use strict") == 0)) {
1202
1.17k
      if (parser->flags & mxNotSimpleParametersFlag)
1203
0
        fxReportParserError(parser, parser->states[0].line, "invalid directive");
1204
1.17k
      if (!(parser->flags & mxStrictFlag)) {
1205
1.13k
        parser->flags |= mxStrictFlag;
1206
1.13k
        if (parser->states[0].token == XS_TOKEN_IDENTIFIER)
1207
280
          fxCheckStrictKeyword(parser);
1208
1.13k
      }
1209
1.17k
    }
1210
56.3k
  }
1211
279k
  while ((parser->states[0].token != XS_TOKEN_EOF) && (parser->states[0].token != XS_TOKEN_RIGHT_BRACE)) {
1212
132k
    fxStatement(parser, 1);
1213
132k
  }
1214
146k
  count = parser->nodeCount - count;
1215
146k
  if (count > 1) {
1216
12.9k
    fxPushNodeList(parser, count);
1217
12.9k
    fxPushNodeStruct(parser, 1, XS_TOKEN_STATEMENTS, line);
1218
12.9k
  }
1219
133k
  else if (count == 0) {
1220
13.5k
    fxPushNodeStruct(parser, 0, XS_TOKEN_UNDEFINED, line);
1221
13.5k
    fxPushNodeStruct(parser, 1, XS_TOKEN_STATEMENT, line);
1222
13.5k
  }
1223
146k
}
1224
1225
void fxBlock(txParser* parser)
1226
78.7k
{
1227
78.7k
  txInteger aLine = parser->states[0].line;
1228
78.7k
  fxCheckParserStack(parser, aLine);
1229
78.7k
  fxMatchToken(parser, XS_TOKEN_LEFT_BRACE);
1230
78.7k
  fxStatements(parser);
1231
78.7k
  fxMatchToken(parser, XS_TOKEN_RIGHT_BRACE);
1232
78.7k
  fxPushNodeStruct(parser, 1, XS_TOKEN_BLOCK, aLine);
1233
78.7k
}
1234
1235
void fxStatements(txParser* parser)
1236
110k
{
1237
110k
  txInteger count = parser->nodeCount;
1238
110k
  txInteger line = parser->states[0].line;
1239
226k
  while ((parser->states[0].token != XS_TOKEN_EOF) && (parser->states[0].token != XS_TOKEN_RIGHT_BRACE)) {
1240
115k
    fxStatement(parser, 1);
1241
115k
  }
1242
110k
  count = parser->nodeCount - count;
1243
110k
  fxPushNodeList(parser, count);
1244
110k
  fxPushNodeStruct(parser, 1, XS_TOKEN_STATEMENTS, line);
1245
110k
}
1246
1247
void fxStatement(txParser* parser, txInteger blockIt)
1248
1.10M
{
1249
1.10M
  txInteger line = parser->states[0].line;
1250
1.10M
  txSymbol* symbol = C_NULL;
1251
1.10M
  txUnsigned flag = 0;
1252
1.10M
  switch (parser->states[0].token) {
1253
//  case XS_TOKEN_COMMA:
1254
59.2k
  case XS_TOKEN_SEMICOLON:
1255
59.2k
    fxGetNextToken(parser);
1256
59.2k
    if (!blockIt) {
1257
956
      fxPushNodeStruct(parser, 0, XS_TOKEN_UNDEFINED, line);
1258
956
      fxPushNodeStruct(parser, 1, XS_TOKEN_STATEMENT, line);
1259
956
    }
1260
59.2k
    break;
1261
1.35k
  case XS_TOKEN_BREAK:
1262
1.35k
    fxBreakStatement(parser);
1263
1.35k
    fxSemicolon(parser);
1264
1.35k
    break;
1265
37.4k
  case XS_TOKEN_CLASS:
1266
37.4k
    if (!blockIt)
1267
397
      fxReportParserError(parser, parser->states[0].line, "no block");
1268
37.4k
    fxClassExpression(parser, line, &symbol);
1269
37.4k
    if (symbol) {
1270
2.82k
      fxPushSymbol(parser, symbol);
1271
2.82k
      fxPushNodeStruct(parser, 1, XS_TOKEN_LET, line);
1272
2.82k
      fxSwapNodes(parser);
1273
2.82k
      fxPushNodeStruct(parser, 2, XS_TOKEN_BINDING, line);
1274
2.82k
    }
1275
34.6k
    else
1276
34.6k
      fxReportParserError(parser, parser->states[0].line, "missing identifier");
1277
37.4k
    break;
1278
8.67k
  case XS_TOKEN_CONST:
1279
8.67k
    if (!blockIt)
1280
3
      fxReportParserError(parser, parser->states[0].line, "no block");
1281
8.67k
    fxVariableStatement(parser, XS_TOKEN_CONST, 0);
1282
8.67k
    fxSemicolon(parser);
1283
8.67k
    break;
1284
4.99k
  case XS_TOKEN_CONTINUE:
1285
4.99k
    fxContinueStatement(parser);
1286
4.99k
    fxSemicolon(parser);
1287
4.99k
    break;
1288
81
  case XS_TOKEN_DEBUGGER:
1289
81
    fxDebuggerStatement(parser);
1290
81
    fxSemicolon(parser);
1291
81
    break;
1292
54.7k
  case XS_TOKEN_DO:
1293
54.7k
    fxDoStatement(parser);
1294
54.7k
    break;
1295
34.8k
  case XS_TOKEN_FOR:
1296
34.8k
    fxForStatement(parser);
1297
34.8k
    break;
1298
5.24k
  case XS_TOKEN_FUNCTION:
1299
    //if ((parser->flags & mxStrictFlag) && !blockIt) BROWSER
1300
5.50k
  again:
1301
5.50k
    if (!blockIt)
1302
636
      fxReportParserError(parser, parser->states[0].line, "no block (strict code)");
1303
5.50k
    fxMatchToken(parser, XS_TOKEN_FUNCTION);
1304
5.50k
    if (parser->states[0].token == XS_TOKEN_MULTIPLY) {
1305
1.30k
      fxGetNextToken(parser);
1306
1.30k
      fxGeneratorExpression(parser, line, &symbol, flag);
1307
1.30k
    }
1308
4.20k
    else
1309
4.20k
      fxFunctionExpression(parser, line, &symbol, flag);
1310
5.50k
    if (symbol) {
1311
2.07k
      txDefineNode* node = fxDefineNodeNew(parser, XS_TOKEN_DEFINE, symbol);
1312
2.07k
      node->initializer = fxPopNode(parser);
1313
2.07k
      fxPushNode(parser, (txNode*)node);
1314
2.07k
    }
1315
3.43k
    else
1316
3.43k
      fxReportParserError(parser, parser->states[0].line, "missing identifier");
1317
5.50k
    break;
1318
3.57k
  case XS_TOKEN_IF:
1319
3.57k
    fxIfStatement(parser);
1320
3.57k
    break;
1321
7.33k
  case XS_TOKEN_RETURN:
1322
7.33k
    if (!(parser->flags & (mxArrowFlag | mxFunctionFlag | mxGeneratorFlag)))
1323
805
      fxReportParserError(parser, parser->states[0].line, "invalid return");
1324
7.33k
    fxReturnStatement(parser);
1325
7.33k
    fxSemicolon(parser);
1326
7.33k
    break;
1327
74.4k
  case XS_TOKEN_LEFT_BRACE:
1328
74.4k
    fxBlock(parser);
1329
74.4k
    break;
1330
2.20k
  case XS_TOKEN_LET:
1331
2.20k
    if (!blockIt)
1332
14
      fxReportParserError(parser, parser->states[0].line, "no block");
1333
2.20k
    fxVariableStatement(parser, XS_TOKEN_LET, 0);
1334
2.20k
    fxSemicolon(parser);
1335
2.20k
    break;
1336
4.10k
  case XS_TOKEN_SWITCH:
1337
4.10k
    fxSwitchStatement(parser);
1338
4.10k
    break;
1339
9.65k
  case XS_TOKEN_THROW:
1340
9.65k
    fxThrowStatement(parser);
1341
9.65k
    fxSemicolon(parser);
1342
9.65k
    break;
1343
4.48k
  case XS_TOKEN_TRY:
1344
4.48k
    fxTryStatement(parser);
1345
4.48k
    break;
1346
47.9k
  case XS_TOKEN_VAR:
1347
47.9k
    fxVariableStatement(parser, XS_TOKEN_VAR, 0);
1348
47.9k
    fxSemicolon(parser);
1349
47.9k
    break;
1350
2.61k
  case XS_TOKEN_WHILE:
1351
2.61k
    fxWhileStatement(parser);
1352
2.61k
    break;
1353
2.06k
  case XS_TOKEN_WITH:
1354
2.06k
    if (parser->flags & mxStrictFlag)
1355
1
      fxReportParserError(parser, parser->states[0].line, "with (strict code)");
1356
2.06k
    fxWithStatement(parser);
1357
2.06k
    break;
1358
0
#if mxExplicitResourceManagement
1359
71
  case XS_TOKEN_AWAIT:
1360
71
    fxLookAheadOnce(parser);
1361
71
    if ((!parser->states[1].crlf) && (parser->states[1].token == XS_TOKEN_IDENTIFIER) && (parser->states[1].symbol == parser->usingSymbol) && (!parser->states[1].escaped)) {
1362
0
      fxLookAheadTwice(parser);
1363
0
      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))) {
1364
0
        fxGetNextToken(parser);
1365
0
        parser->states[0].token = XS_TOKEN_USING;
1366
0
        if (blockIt <= 0)
1367
0
          fxReportParserError(parser, parser->states[0].line, "no block");
1368
0
        fxVariableStatement(parser, XS_TOKEN_USING, mxAwaitingFlag);
1369
0
        parser->flags |= mxAwaitingFlag;
1370
0
        fxSemicolon(parser);
1371
0
        break;
1372
0
      }
1373
0
    }
1374
71
    fxCommaExpression(parser);
1375
71
    fxPushNodeStruct(parser, 1, XS_TOKEN_STATEMENT, line);
1376
71
    fxSemicolon(parser);
1377
71
    break;
1378
0
#endif
1379
490k
  case XS_TOKEN_IDENTIFIER:
1380
490k
    fxLookAheadOnce(parser);
1381
490k
    if (parser->states[1].token == XS_TOKEN_COLON) {
1382
37.8k
      fxPushSymbol(parser, parser->states[0].symbol);
1383
37.8k
      fxGetNextToken(parser);
1384
37.8k
      fxMatchToken(parser, XS_TOKEN_COLON);
1385
      //if ((parser->flags & mxStrictFlag) && (parser->states[0].token == XS_TOKEN_FUNCTION)) BROWSER
1386
      //  fxReportParserError(parser, parser->states[0].line, "labeled function (strict code)");
1387
37.8k
      if (parser->states[0].token == XS_TOKEN_FUNCTION)
1388
1.06k
        fxReportParserError(parser, parser->states[0].line, "labeled function");
1389
37.8k
      fxCheckParserStack(parser, line);
1390
37.8k
      fxStatement(parser, 0);
1391
37.8k
      fxPushNodeStruct(parser, 2, XS_TOKEN_LABEL, line);
1392
37.8k
      break;
1393
37.8k
    }
1394
453k
    if ((parser->states[0].symbol == parser->asyncSymbol) && (!parser->states[0].escaped) 
1395
1.64k
        && (!parser->states[1].crlf) && (parser->states[1].token == XS_TOKEN_FUNCTION)) {
1396
257
      fxGetNextToken(parser);
1397
257
      flag = mxAsyncFlag;
1398
257
      goto again;
1399
257
    }
1400
452k
    if ((parser->states[0].symbol == parser->letSymbol) && (!parser->states[0].escaped) 
1401
24.2k
        && ((gxTokenFlags[parser->states[1].token] & XS_TOKEN_BEGIN_BINDING) || (parser->states[1].token == XS_TOKEN_AWAIT) || (parser->states[1].token == XS_TOKEN_YIELD))
1402
21.5k
        && (blockIt || (!parser->states[1].crlf) || (parser->states[1].token == XS_TOKEN_LEFT_BRACKET))) {
1403
21.5k
      parser->states[0].token = XS_TOKEN_LET;
1404
21.5k
      if (!blockIt)
1405
8
        fxReportParserError(parser, parser->states[0].line, "no block");
1406
21.5k
      fxVariableStatement(parser, XS_TOKEN_LET, 0);
1407
21.5k
      fxSemicolon(parser);
1408
21.5k
      break;
1409
21.5k
    }
1410
431k
#if mxExplicitResourceManagement
1411
431k
    if ((parser->states[0].symbol == parser->usingSymbol) && (!parser->states[0].escaped)
1412
2.14k
        && (!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))) {
1413
1.17k
      parser->states[0].token = XS_TOKEN_USING;
1414
1.17k
      if (blockIt <= 0)
1415
9
        fxReportParserError(parser, parser->states[0].line, "no block");
1416
1.17k
      fxVariableStatement(parser, XS_TOKEN_USING, 0);
1417
1.17k
      fxSemicolon(parser);
1418
1.17k
      break;
1419
1.17k
    }
1420
430k
#endif
1421
    /* continue */
1422
676k
  default:
1423
676k
    if (gxTokenFlags[parser->states[0].token] & XS_TOKEN_BEGIN_EXPRESSION) {
1424
642k
      fxCommaExpression(parser);
1425
642k
      fxPushNodeStruct(parser, 1, XS_TOKEN_STATEMENT, line);
1426
642k
      fxSemicolon(parser);
1427
642k
    }
1428
34.0k
    else {
1429
34.0k
      fxReportParserError(parser, parser->states[0].line, "invalid token %s", gxTokenNames[parser->states[0].token]);
1430
34.0k
      fxPushNULL(parser);
1431
34.0k
      fxGetNextToken(parser);
1432
34.0k
    }
1433
676k
    break;
1434
1.10M
  }
1435
1.10M
}
1436
1437
void fxSemicolon(txParser* parser)
1438
577k
{
1439
577k
  if ((parser->states[0].crlf) || (gxTokenFlags[parser->states[0].token] & XS_TOKEN_END_STATEMENT)) {
1440
553k
    if (parser->states[0].token == XS_TOKEN_SEMICOLON)
1441
169k
      fxGetNextToken(parser);
1442
553k
  }
1443
23.3k
  else
1444
23.3k
    fxReportParserError(parser, parser->states[0].line, "missing ;");
1445
577k
}
1446
1447
void fxBreakStatement(txParser* parser)
1448
1.35k
{
1449
1.35k
  txInteger aLine = parser->states[0].line;
1450
1.35k
  fxMatchToken(parser, XS_TOKEN_BREAK);
1451
1.35k
  if ((!parser->states[0].crlf) && (parser->states[0].token == XS_TOKEN_IDENTIFIER)) {
1452
47
    fxPushSymbol(parser, parser->states[0].symbol);
1453
47
    fxGetNextToken(parser);
1454
47
  }
1455
1.30k
  else {
1456
1.30k
    fxPushNULL(parser);
1457
1.30k
  }
1458
1.35k
  fxPushNodeStruct(parser, 1, XS_TOKEN_BREAK, aLine);
1459
1.35k
}
1460
1461
void fxContinueStatement(txParser* parser)
1462
4.99k
{
1463
4.99k
  txInteger aLine = parser->states[0].line;
1464
4.99k
  fxMatchToken(parser, XS_TOKEN_CONTINUE);
1465
4.99k
  if ((!parser->states[0].crlf) && (parser->states[0].token == XS_TOKEN_IDENTIFIER)) {
1466
1.68k
    fxPushSymbol(parser, parser->states[0].symbol);
1467
1.68k
    fxGetNextToken(parser);
1468
1.68k
  }
1469
3.31k
  else {
1470
3.31k
    fxPushNULL(parser);
1471
3.31k
  }
1472
4.99k
  fxPushNodeStruct(parser, 1, XS_TOKEN_CONTINUE, aLine);
1473
4.99k
}
1474
1475
void fxDebuggerStatement(txParser* parser)
1476
81
{
1477
81
  txInteger aLine = parser->states[0].line;
1478
81
  fxMatchToken(parser, XS_TOKEN_DEBUGGER);
1479
81
  fxPushNodeStruct(parser, 0, XS_TOKEN_DEBUGGER, aLine);
1480
81
}
1481
1482
void fxDoStatement(txParser* parser)
1483
54.7k
{
1484
54.7k
  txInteger aLine = parser->states[0].line;
1485
54.7k
  fxCheckParserStack(parser, aLine);
1486
54.7k
  fxPushNULL(parser);
1487
54.7k
  fxMatchToken(parser, XS_TOKEN_DO);
1488
54.7k
  fxStatement(parser, 0);
1489
54.7k
  fxMatchToken(parser, XS_TOKEN_WHILE);
1490
54.7k
  fxMatchToken(parser, XS_TOKEN_LEFT_PARENTHESIS);
1491
54.7k
  fxCommaExpression(parser);
1492
54.7k
  fxMatchToken(parser, XS_TOKEN_RIGHT_PARENTHESIS);
1493
54.7k
  if (parser->states[0].token == XS_TOKEN_SEMICOLON)
1494
131
    fxGetNextToken(parser);
1495
54.7k
  fxPushNodeStruct(parser, 2, XS_TOKEN_DO, aLine);
1496
54.7k
  fxPushNodeStruct(parser, 2, XS_TOKEN_LABEL, aLine);
1497
54.7k
}
1498
1499
void fxForStatement(txParser* parser)
1500
34.8k
{
1501
34.8k
  txInteger aLine = parser->states[0].line;
1502
34.8k
  txBoolean awaitFlag = 0;
1503
34.8k
  txBoolean expressionFlag = 0;
1504
34.8k
  txToken aToken;
1505
34.8k
  fxPushNULL(parser);
1506
34.8k
  fxMatchToken(parser, XS_TOKEN_FOR);
1507
34.8k
  if (parser->states[0].token == XS_TOKEN_AWAIT) {
1508
13
    awaitFlag = 1;
1509
13
    fxMatchToken(parser, XS_TOKEN_AWAIT);
1510
13
  }
1511
34.8k
  fxMatchToken(parser, XS_TOKEN_LEFT_PARENTHESIS);
1512
34.8k
  fxLookAheadOnce(parser);
1513
34.8k
  parser->flags |= mxForFlag;
1514
34.8k
  if (parser->states[0].token == XS_TOKEN_SEMICOLON) {
1515
174
    fxPushNULL(parser);
1516
174
  }
1517
34.7k
  else if (parser->states[0].token == XS_TOKEN_CONST) {
1518
473
    fxVariableStatement(parser, XS_TOKEN_CONST, 0);
1519
473
  }
1520
34.2k
  else if (parser->states[0].token == XS_TOKEN_LET) {
1521
7
    fxVariableStatement(parser, XS_TOKEN_LET, 0);
1522
7
  }
1523
34.2k
  else if (fxIsKeyword(parser, parser->letSymbol) && (gxTokenFlags[parser->states[1].token] & XS_TOKEN_BEGIN_BINDING)) {
1524
932
    parser->states[0].token = XS_TOKEN_LET;
1525
932
    fxVariableStatement(parser, XS_TOKEN_LET, 0);
1526
932
  }
1527
33.2k
#if mxExplicitResourceManagement
1528
33.2k
  else if ((parser->states[0].token == XS_TOKEN_IDENTIFIER) && (parser->states[0].symbol == parser->usingSymbol) && (!parser->states[0].escaped)
1529
15
        && (!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))) {
1530
5
    parser->states[0].token = XS_TOKEN_USING;
1531
5
    fxVariableStatement(parser, XS_TOKEN_USING, 0);
1532
5
  }
1533
33.2k
  else if ((parser->states[0].token == XS_TOKEN_AWAIT)
1534
1.31k
        && (!parser->states[1].crlf) && (parser->states[1].token == XS_TOKEN_IDENTIFIER) && (parser->states[1].symbol == parser->usingSymbol) && (!parser->states[1].escaped)) {
1535
0
    fxLookAheadTwice(parser);
1536
0
    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))) {
1537
0
      fxGetNextToken(parser);
1538
0
      parser->states[0].token = XS_TOKEN_USING;
1539
0
      fxVariableStatement(parser, XS_TOKEN_USING, mxAwaitingFlag);
1540
0
      parser->flags |= mxAwaitingFlag;
1541
0
    }
1542
0
    else {
1543
0
      fxCommaExpression(parser);
1544
0
      expressionFlag = 1;
1545
0
    }
1546
0
  }
1547
33.2k
#endif
1548
33.2k
  else if (parser->states[0].token == XS_TOKEN_VAR) {
1549
8.24k
    fxVariableStatement(parser, XS_TOKEN_VAR, 0);
1550
8.24k
  }
1551
25.0k
  else {
1552
25.0k
    fxCommaExpression(parser);
1553
25.0k
    expressionFlag = 1;
1554
25.0k
  }
1555
34.8k
  parser->flags &= ~mxForFlag;
1556
34.8k
  if (awaitFlag && !fxIsKeyword(parser, parser->ofSymbol))
1557
2
    fxReportParserError(parser, parser->states[0].line, "invalid for await");
1558
34.8k
  if (fxIsToken(parser, XS_TOKEN_IN) || fxIsKeyword(parser, parser->ofSymbol)) {
1559
6.58k
    if (expressionFlag) {
1560
356
      if (!fxCheckReference(parser, XS_TOKEN_ASSIGN)) {
1561
2
        fxReportParserError(parser, parser->states[0].line, "no reference");
1562
2
      }
1563
356
    }
1564
6.22k
    else {
1565
6.22k
      aToken = parser->root->description->token;
1566
6.22k
      if (aToken == XS_TOKEN_BINDING) {
1567
1
        if (((txBindingNode*)(parser->root))->initializer)
1568
1
          fxReportParserError(parser, parser->states[0].line, "invalid binding initializer");
1569
1
      }
1570
6.22k
      if (fxIsToken(parser, XS_TOKEN_IN) && (aToken == XS_TOKEN_USING))
1571
1
        fxReportParserError(parser, parser->states[0].line, "invalid using in");
1572
      
1573
//      else if (aToken == XS_TOKEN_ARRAY_BINDING) {
1574
//        if (((txArrayBindingNode*)(parser->root))->initializer)
1575
//          fxReportParserError(parser, parser->states[0].line, "invalid array binding initializer");
1576
//      }
1577
//      else if (aToken == XS_TOKEN_OBJECT_BINDING) {
1578
//        if (((txObjectBindingNode*)(parser->root))->initializer)
1579
//          fxReportParserError(parser, parser->states[0].line, "invalid object binding initializer");
1580
//      }
1581
//      else
1582
//        fxReportParserError(parser, parser->states[0].line, "no reference %s", gxTokenNames[aToken]);
1583
6.22k
    }
1584
6.58k
    aToken = parser->states[0].token;
1585
6.58k
    fxGetNextToken(parser);
1586
6.58k
    if (aToken == XS_TOKEN_IN)
1587
6.18k
      fxCommaExpression(parser);
1588
397
    else
1589
397
      fxAssignmentExpression(parser);
1590
6.58k
    fxMatchToken(parser, XS_TOKEN_RIGHT_PARENTHESIS);
1591
6.58k
    fxStatement(parser, 0);
1592
6.58k
    if (awaitFlag)
1593
11
      fxPushNodeStruct(parser, 3, XS_TOKEN_FOR_AWAIT_OF, aLine);
1594
6.57k
    else if (aToken == XS_TOKEN_IN)
1595
6.14k
      fxPushNodeStruct(parser, 3, XS_TOKEN_FOR_IN, aLine);
1596
425
    else
1597
425
      fxPushNodeStruct(parser, 3, XS_TOKEN_FOR_OF, aLine);
1598
6.58k
  }
1599
28.2k
  else {
1600
28.2k
    if (expressionFlag)
1601
11.4k
      fxPushNodeStruct(parser, 1, XS_TOKEN_STATEMENT, aLine);
1602
28.2k
    fxMatchToken(parser, XS_TOKEN_SEMICOLON);
1603
28.2k
    if (gxTokenFlags[parser->states[0].token] & XS_TOKEN_BEGIN_EXPRESSION) {
1604
11.7k
      fxCommaExpression(parser);
1605
11.7k
    }
1606
16.5k
    else {
1607
16.5k
      fxPushNULL(parser);
1608
16.5k
    }
1609
28.2k
    fxMatchToken(parser, XS_TOKEN_SEMICOLON);
1610
28.2k
    if (gxTokenFlags[parser->states[0].token] & XS_TOKEN_BEGIN_EXPRESSION) {
1611
11.4k
      fxCommaExpression(parser);
1612
11.4k
    }
1613
16.8k
    else {
1614
16.8k
      fxPushNULL(parser);
1615
16.8k
    }
1616
28.2k
    fxMatchToken(parser, XS_TOKEN_RIGHT_PARENTHESIS);
1617
28.2k
    fxCheckParserStack(parser, aLine);
1618
28.2k
    fxStatement(parser, 0);
1619
28.2k
    fxPushNodeStruct(parser, 4, XS_TOKEN_FOR, aLine);
1620
28.2k
  }
1621
34.8k
  fxPushNodeStruct(parser, 2, XS_TOKEN_LABEL, aLine);
1622
34.8k
}
1623
1624
void fxIfStatement(txParser* parser)
1625
3.57k
{
1626
3.57k
  txInteger aLine = parser->states[0].line;
1627
3.57k
  fxMatchToken(parser, XS_TOKEN_IF);
1628
3.57k
  fxMatchToken(parser, XS_TOKEN_LEFT_PARENTHESIS);
1629
3.57k
  fxCommaExpression(parser);
1630
3.57k
  fxMatchToken(parser, XS_TOKEN_RIGHT_PARENTHESIS);
1631
3.57k
  fxStatement(parser, 0);
1632
3.57k
  if (parser->states[0].token == XS_TOKEN_ELSE) {
1633
503
    fxMatchToken(parser, XS_TOKEN_ELSE);
1634
503
    fxStatement(parser, 0);
1635
503
  }
1636
3.06k
  else {
1637
3.06k
    fxPushNULL(parser);
1638
3.06k
  }
1639
3.57k
  fxPushNodeStruct(parser, 3, XS_TOKEN_IF, aLine);
1640
3.57k
}
1641
1642
void fxReturnStatement(txParser* parser)
1643
6.53k
{
1644
6.53k
  txInteger aLine = parser->states[0].line;
1645
6.53k
  fxMatchToken(parser, XS_TOKEN_RETURN);
1646
6.53k
  if ((!parser->states[0].crlf) && (gxTokenFlags[parser->states[0].token] & XS_TOKEN_BEGIN_EXPRESSION)) {
1647
4.72k
    fxCommaExpression(parser);
1648
4.72k
  }
1649
1.81k
  else {
1650
1.81k
    fxPushNULL(parser);
1651
1.81k
  }
1652
6.53k
  fxPushNodeStruct(parser, 1, XS_TOKEN_RETURN, aLine);
1653
6.53k
}
1654
1655
void fxSwitchStatement(txParser* parser)
1656
4.10k
{
1657
4.10k
  txInteger aCount = 0;
1658
4.10k
  txBoolean aDefaultFlag = 0;
1659
4.10k
  txInteger aLine = parser->states[0].line;
1660
4.10k
  fxMatchToken(parser, XS_TOKEN_SWITCH);
1661
4.10k
  fxMatchToken(parser, XS_TOKEN_LEFT_PARENTHESIS);
1662
4.10k
  fxCommaExpression(parser);
1663
4.10k
  fxMatchToken(parser, XS_TOKEN_RIGHT_PARENTHESIS);
1664
4.10k
  fxMatchToken(parser, XS_TOKEN_LEFT_BRACE);
1665
6.17k
  while ((parser->states[0].token == XS_TOKEN_CASE) || (parser->states[0].token == XS_TOKEN_DEFAULT)) {
1666
2.06k
    txInteger aCaseCount;
1667
2.06k
    txInteger aCaseLine = parser->states[0].line;
1668
2.06k
    if (parser->states[0].token == XS_TOKEN_CASE) {
1669
2.02k
      fxMatchToken(parser, XS_TOKEN_CASE);
1670
2.02k
      fxCommaExpression(parser);
1671
2.02k
      fxMatchToken(parser, XS_TOKEN_COLON);
1672
2.02k
      aCaseCount = parser->nodeCount;
1673
3.70k
      while (gxTokenFlags[parser->states[0].token] & XS_TOKEN_BEGIN_STATEMENT)
1674
1.67k
        fxStatement(parser, 1);
1675
2.02k
      aCaseCount = parser->nodeCount - aCaseCount;
1676
2.02k
      if (aCaseCount > 1) {
1677
66
        fxPushNodeList(parser, aCaseCount);
1678
66
        fxPushNodeStruct(parser, 1, XS_TOKEN_STATEMENTS, aCaseLine);
1679
66
      }
1680
1.95k
      else if (aCaseCount == 0) {
1681
440
        fxPushNULL(parser);
1682
440
      }
1683
2.02k
      fxPushNodeStruct(parser, 2, XS_TOKEN_CASE, aCaseLine);
1684
2.02k
    }
1685
42
    else {
1686
42
      fxMatchToken(parser, XS_TOKEN_DEFAULT);
1687
42
      if (aDefaultFlag) 
1688
1
        fxReportParserError(parser, parser->states[0].line, "invalid default");
1689
42
      fxPushNULL(parser);
1690
42
      fxMatchToken(parser, XS_TOKEN_COLON);
1691
42
      aCaseCount = parser->nodeCount;
1692
117
      while (gxTokenFlags[parser->states[0].token] & XS_TOKEN_BEGIN_STATEMENT)
1693
75
        fxStatement(parser, 1);
1694
42
      aCaseCount = parser->nodeCount - aCaseCount;
1695
42
      if (aCaseCount > 1) {
1696
5
        fxPushNodeList(parser, aCaseCount);
1697
5
        fxPushNodeStruct(parser, 1, XS_TOKEN_STATEMENTS, aLine);
1698
5
      }
1699
37
      else if (aCaseCount == 0) {
1700
1
        fxPushNULL(parser);
1701
1
      }
1702
42
      fxPushNodeStruct(parser, 2, XS_TOKEN_CASE, aCaseLine);
1703
42
      aDefaultFlag = 1;
1704
42
    }
1705
2.06k
    aCount++;
1706
2.06k
  }
1707
4.10k
  fxMatchToken(parser, XS_TOKEN_RIGHT_BRACE);
1708
4.10k
  fxPushNodeList(parser, aCount);
1709
4.10k
  fxPushNodeStruct(parser, 2, XS_TOKEN_SWITCH, aLine);
1710
4.10k
}
1711
1712
void fxThrowStatement(txParser* parser)
1713
9.65k
{
1714
9.65k
  txInteger aLine = parser->states[0].line;
1715
9.65k
  fxMatchToken(parser, XS_TOKEN_THROW);
1716
9.65k
  if ((!parser->states[0].crlf) && (gxTokenFlags[parser->states[0].token] & XS_TOKEN_BEGIN_EXPRESSION)) {
1717
9.37k
    fxCommaExpression(parser);
1718
9.37k
  }
1719
280
  else {
1720
280
    fxReportParserError(parser, parser->states[0].line, "missing expression");
1721
280
    fxPushNodeStruct(parser, 0, XS_TOKEN_UNDEFINED, aLine);
1722
280
  }
1723
9.65k
  fxPushNodeStruct(parser, 1, XS_TOKEN_THROW, aLine);
1724
9.65k
}
1725
1726
void fxTryStatement(txParser* parser)
1727
4.48k
{
1728
4.48k
  txInteger aLine = parser->states[0].line;
1729
4.48k
  txBoolean ok = 0;
1730
4.48k
  fxMatchToken(parser, XS_TOKEN_TRY);
1731
4.48k
  fxBlock(parser);
1732
4.48k
  if (parser->states[0].token == XS_TOKEN_CATCH) {
1733
1.69k
    txInteger aCatchLine = parser->states[0].line;
1734
1.69k
    fxMatchToken(parser, XS_TOKEN_CATCH);
1735
1.69k
    if (parser->states[0].token == XS_TOKEN_LEFT_PARENTHESIS) {
1736
1.56k
      fxMatchToken(parser, XS_TOKEN_LEFT_PARENTHESIS);
1737
1.56k
      fxBinding(parser, XS_TOKEN_LET, 1);
1738
1.56k
      fxMatchToken(parser, XS_TOKEN_RIGHT_PARENTHESIS);
1739
1.56k
    }
1740
126
    else
1741
126
      fxPushNULL(parser);
1742
1.69k
    fxMatchToken(parser, XS_TOKEN_LEFT_BRACE);
1743
1.69k
    fxStatements(parser);
1744
1.69k
    fxMatchToken(parser, XS_TOKEN_RIGHT_BRACE);
1745
1.69k
    fxPushNodeStruct(parser, 2, XS_TOKEN_CATCH, aCatchLine);
1746
1.69k
    ok = 1;
1747
1.69k
  }
1748
2.78k
  else {
1749
2.78k
    fxPushNULL(parser);
1750
2.78k
  }
1751
4.48k
  if (parser->states[0].token == XS_TOKEN_FINALLY) {
1752
40
    fxMatchToken(parser, XS_TOKEN_FINALLY);
1753
40
    fxBlock(parser);
1754
40
    ok = 1;
1755
40
  }
1756
4.44k
  else {
1757
4.44k
    fxPushNULL(parser);
1758
4.44k
  }
1759
4.48k
  if (!ok)
1760
828
    fxReportParserError(parser, parser->states[0].line, "missing catch or finally");
1761
4.48k
  fxPushNodeStruct(parser, 3, XS_TOKEN_TRY, aLine);
1762
4.48k
}
1763
1764
void fxVariableStatement(txParser* parser, txToken theToken, txUnsigned flags)
1765
91.4k
{
1766
91.4k
  txBoolean commaFlag = 0;
1767
91.4k
  txInteger aCount = 0;
1768
91.4k
  txInteger aLine = parser->states[0].line;
1769
91.4k
  fxMatchToken(parser, theToken);
1770
93.7k
  while (gxTokenFlags[parser->states[0].token] & XS_TOKEN_BEGIN_BINDING) {
1771
90.1k
    commaFlag = 0;
1772
90.1k
    fxBinding(parser, theToken, 1 | flags);
1773
//    if (parser->states[0].token == XS_TOKEN_ASSIGN) {
1774
//      parser->flags &= ~mxForFlag;
1775
//      fxGetNextToken(parser);
1776
//      fxAssignmentExpression(parser);
1777
//      fxPushNodeStruct(parser, 2, XS_TOKEN_ASSIGN, aLine);
1778
//      fxPushNodeStruct(parser, 1, XS_TOKEN_STATEMENT, aLine);
1779
//    }
1780
90.1k
    aCount++;
1781
90.1k
    if (parser->states[0].token == XS_TOKEN_COMMA) {
1782
2.31k
      parser->flags &= ~mxForFlag;
1783
2.31k
      fxGetNextToken(parser);
1784
2.31k
      commaFlag = 1;
1785
2.31k
    }
1786
87.8k
    else
1787
87.8k
      break;
1788
90.1k
  }
1789
91.4k
    if ((aCount == 0) || commaFlag) {
1790
1.94k
    fxPushNULL(parser);
1791
1.94k
    fxPushNULL(parser);
1792
1.94k
    fxPushNodeStruct(parser, 2, theToken, aLine);
1793
1.94k
    fxReportParserError(parser, parser->states[0].line, "missing identifier");
1794
1.94k
  }
1795
91.4k
  if (aCount > 1) {
1796
1.45k
    fxPushNodeList(parser, aCount);
1797
1.45k
    fxPushNodeStruct(parser, 1, XS_TOKEN_STATEMENTS, aLine);
1798
1.45k
  }
1799
91.4k
}
1800
1801
void fxWhileStatement(txParser* parser)
1802
2.61k
{
1803
2.61k
  txInteger aLine = parser->states[0].line;
1804
2.61k
  fxPushNULL(parser);
1805
2.61k
  fxMatchToken(parser, XS_TOKEN_WHILE);
1806
2.61k
  fxMatchToken(parser, XS_TOKEN_LEFT_PARENTHESIS);
1807
2.61k
  fxCommaExpression(parser);
1808
2.61k
  fxMatchToken(parser, XS_TOKEN_RIGHT_PARENTHESIS);
1809
2.61k
  fxStatement(parser, 0);
1810
2.61k
  fxPushNodeStruct(parser, 2, XS_TOKEN_WHILE, aLine);
1811
2.61k
  fxPushNodeStruct(parser, 2, XS_TOKEN_LABEL, aLine);
1812
2.61k
}
1813
1814
void fxWithStatement(txParser* parser)
1815
2.06k
{
1816
2.06k
  txInteger aLine = parser->states[0].line;
1817
2.06k
  fxMatchToken(parser, XS_TOKEN_WITH);
1818
2.06k
  fxMatchToken(parser, XS_TOKEN_LEFT_PARENTHESIS);
1819
2.06k
  fxCommaExpression(parser);
1820
2.06k
  fxMatchToken(parser, XS_TOKEN_RIGHT_PARENTHESIS);
1821
2.06k
  fxStatement(parser, 0);
1822
2.06k
  fxPushNodeStruct(parser, 2, XS_TOKEN_WITH, aLine);
1823
2.06k
}
1824
1825
void fxCommaExpression(txParser* parser)
1826
729k
{
1827
729k
  txInteger aCount = 0;
1828
729k
  txInteger aLine = parser->states[0].line;
1829
729k
  if (gxTokenFlags[parser->states[0].token] & XS_TOKEN_BEGIN_EXPRESSION) {
1830
728k
    fxAssignmentExpression(parser);
1831
728k
    aCount++;
1832
777k
    while (parser->states[0].token == XS_TOKEN_COMMA) {
1833
49.2k
      fxGetNextToken(parser);
1834
49.2k
      fxAssignmentExpression(parser);
1835
49.2k
      aCount++;
1836
49.2k
    }
1837
728k
  }
1838
729k
  if (aCount > 1) {
1839
19.8k
    fxPushNodeList(parser, aCount);
1840
19.8k
    fxPushNodeStruct(parser, 1, XS_TOKEN_EXPRESSIONS, aLine);
1841
19.8k
  }
1842
709k
  else if (aCount == 0) {
1843
1.04k
    fxPushNULL(parser);
1844
1.04k
    fxReportParserError(parser, parser->states[0].line, "missing expression");
1845
1.04k
  }
1846
729k
}
1847
1848
void fxAssignmentExpression(txParser* parser)
1849
1.61M
{
1850
1.61M
  if (parser->states[0].token == XS_TOKEN_YIELD)
1851
830
    fxYieldExpression(parser);
1852
1.61M
  else {
1853
1.61M
    fxConditionalExpression(parser);
1854
1.69M
    while (gxTokenFlags[parser->states[0].token] & XS_TOKEN_ASSIGN_EXPRESSION) {
1855
75.3k
      txToken aToken = parser->states[0].token;
1856
75.3k
      txInteger aLine = parser->states[0].line;
1857
75.3k
      if (!fxCheckReference(parser, aToken)) 
1858
2.83k
        fxReportParserError(parser, parser->states[0].line, "no reference");
1859
75.3k
      fxGetNextToken(parser);
1860
75.3k
      fxAssignmentExpression(parser);
1861
75.3k
      fxPushNodeStruct(parser, 2, aToken, aLine);
1862
75.3k
    }
1863
1.61M
  }
1864
1.61M
}
1865
1866
void fxConditionalExpression(txParser* parser)
1867
1.61M
{
1868
1.61M
  fxCoalesceExpression(parser);
1869
1.61M
  if (parser->states[0].token == XS_TOKEN_QUESTION_MARK) {
1870
3.62k
    txInteger aLine = parser->states[0].line;
1871
3.62k
    txUnsigned flags;
1872
3.62k
    fxCheckArrowFunction(parser, 1);
1873
3.62k
    fxGetNextToken(parser);
1874
3.62k
    flags = parser->flags & mxForFlag;
1875
3.62k
    parser->flags &= ~mxForFlag;
1876
3.62k
    fxAssignmentExpression(parser);
1877
3.62k
    parser->flags |= flags;
1878
3.62k
    fxMatchToken(parser, XS_TOKEN_COLON);
1879
3.62k
    fxAssignmentExpression(parser);
1880
3.62k
    fxPushNodeStruct(parser, 3, XS_TOKEN_QUESTION_MARK, aLine);
1881
3.62k
  }
1882
1.61M
}
1883
1884
void fxCoalesceExpression(txParser* parser)
1885
1.61M
{
1886
1.61M
  fxOrExpression(parser);
1887
1.61M
  while (parser->states[0].token == XS_TOKEN_COALESCE) {
1888
1.24k
    txInteger aLine = parser->states[0].line;
1889
1.24k
    fxGetNextToken(parser);
1890
1.24k
    fxOrExpression(parser);
1891
1.24k
    fxCheckArrowFunction(parser, 2);
1892
1.24k
    fxPushNodeStruct(parser, 2, XS_TOKEN_COALESCE, aLine);
1893
1.24k
  }
1894
1.61M
}
1895
1896
void fxOrExpression(txParser* parser)
1897
1.61M
{
1898
1.61M
  fxAndExpression(parser);
1899
1.61M
  while (parser->states[0].token == XS_TOKEN_OR) {
1900
1.35k
    txInteger aLine = parser->states[0].line;
1901
1.35k
    fxGetNextToken(parser);
1902
1.35k
    fxAndExpression(parser);
1903
1.35k
    fxCheckArrowFunction(parser, 2);
1904
1.35k
    fxPushNodeStruct(parser, 2, XS_TOKEN_OR, aLine);
1905
1.35k
  }
1906
1.61M
}
1907
1908
void fxAndExpression(txParser* parser)
1909
1.61M
{
1910
1.61M
  fxBitOrExpression(parser);
1911
1.62M
  while (parser->states[0].token == XS_TOKEN_AND) {
1912
4.68k
    txInteger aLine = parser->states[0].line;
1913
4.68k
    fxGetNextToken(parser);
1914
4.68k
    fxBitOrExpression(parser);
1915
4.68k
    fxCheckArrowFunction(parser, 2);
1916
4.68k
    fxPushNodeStruct(parser, 2, XS_TOKEN_AND, aLine);
1917
4.68k
  }
1918
1.61M
}
1919
1920
void fxBitOrExpression(txParser* parser)
1921
1.62M
{
1922
1.62M
  fxBitXorExpression(parser);
1923
1.62M
  while (parser->states[0].token == XS_TOKEN_BIT_OR) {
1924
4.52k
    txInteger aLine = parser->states[0].line;
1925
4.52k
    fxGetNextToken(parser);
1926
4.52k
    fxBitXorExpression(parser);
1927
4.52k
    fxCheckArrowFunction(parser, 2);
1928
4.52k
    fxPushNodeStruct(parser, 2, XS_TOKEN_BIT_OR, aLine);
1929
4.52k
  }
1930
1.62M
}
1931
1932
void fxBitXorExpression(txParser* parser)
1933
1.62M
{
1934
1.62M
  fxBitAndExpression(parser);
1935
1.62M
  while (parser->states[0].token == XS_TOKEN_BIT_XOR) {
1936
3.00k
    txInteger aLine = parser->states[0].line;
1937
3.00k
    fxGetNextToken(parser);
1938
3.00k
    fxBitAndExpression(parser);
1939
3.00k
    fxCheckArrowFunction(parser, 2);
1940
3.00k
    fxPushNodeStruct(parser, 2, XS_TOKEN_BIT_XOR, aLine);
1941
3.00k
  }
1942
1.62M
}
1943
1944
void fxBitAndExpression(txParser* parser)
1945
1.62M
{
1946
1.62M
  fxEqualExpression(parser);
1947
1.65M
  while (parser->states[0].token == XS_TOKEN_BIT_AND) {
1948
21.7k
    txInteger aLine = parser->states[0].line;
1949
21.7k
    fxGetNextToken(parser);
1950
21.7k
    fxEqualExpression(parser);
1951
21.7k
    fxCheckArrowFunction(parser, 2);
1952
21.7k
    fxPushNodeStruct(parser, 2, XS_TOKEN_BIT_AND, aLine);
1953
21.7k
  }
1954
1.62M
}
1955
1956
void fxEqualExpression(txParser* parser)
1957
1.65M
{
1958
1.65M
  fxRelationalExpression(parser);
1959
1.65M
  while (gxTokenFlags[parser->states[0].token] & XS_TOKEN_EQUAL_EXPRESSION) {
1960
6.36k
    txToken aToken = parser->states[0].token;
1961
6.36k
    txInteger aLine = parser->states[0].line;
1962
6.36k
    fxGetNextToken(parser);
1963
6.36k
    fxRelationalExpression(parser);
1964
6.36k
    fxCheckArrowFunction(parser, 2);
1965
6.36k
    fxPushNodeStruct(parser, 2, aToken, aLine);
1966
6.36k
  }
1967
1.65M
}
1968
1969
void fxRelationalExpression(txParser* parser)
1970
1.65M
{
1971
1.65M
  if (parser->states[0].token == XS_TOKEN_PRIVATE_IDENTIFIER) {
1972
1.47k
    txInteger aLine = parser->states[0].line;
1973
1.47k
    fxPushSymbol(parser, parser->states[0].symbol);
1974
1.47k
    fxGetNextToken(parser);
1975
1.47k
    fxMatchToken(parser, XS_TOKEN_IN);
1976
1.47k
    if (parser->flags & mxForFlag)
1977
1
      fxReportParserError(parser, parser->states[0].line, "invalid %s", gxTokenNames[XS_TOKEN_IN]);
1978
1.47k
    fxShiftExpression(parser);
1979
1.47k
    fxCheckArrowFunction(parser, 2);
1980
1.47k
    fxPushNodeStruct(parser, 2, XS_TOKEN_PRIVATE_IDENTIFIER, aLine);
1981
1.47k
  }
1982
1.65M
  else {
1983
1.65M
    fxShiftExpression(parser);
1984
1.65M
    if ((parser->flags & mxForFlag) && ((parser->states[0].token == XS_TOKEN_IN) || fxIsKeyword(parser, parser->ofSymbol)))
1985
356
      return;
1986
1.70M
    while (gxTokenFlags[parser->states[0].token] & XS_TOKEN_RELATIONAL_EXPRESSION) {
1987
45.0k
      txToken aToken = parser->states[0].token;
1988
45.0k
      txInteger aLine = parser->states[0].line;
1989
45.0k
      fxMatchToken(parser, aToken);
1990
45.0k
      fxShiftExpression(parser);
1991
45.0k
      fxCheckArrowFunction(parser, 2);
1992
45.0k
      fxPushNodeStruct(parser, 2, aToken, aLine);
1993
45.0k
    }
1994
1.65M
  }
1995
1.65M
}
1996
1997
void fxShiftExpression(txParser* parser)
1998
1.70M
{
1999
1.70M
  fxAdditiveExpression(parser);
2000
1.71M
  while (gxTokenFlags[parser->states[0].token] & XS_TOKEN_SHIFT_EXPRESSION) {
2001
12.1k
    txToken aToken = parser->states[0].token;
2002
12.1k
    txInteger aLine = parser->states[0].line;
2003
12.1k
    fxGetNextToken(parser);
2004
12.1k
    fxAdditiveExpression(parser);
2005
12.1k
    fxCheckArrowFunction(parser, 2);
2006
12.1k
    fxPushNodeStruct(parser, 2, aToken, aLine);
2007
12.1k
  }
2008
1.70M
}
2009
2010
void fxAdditiveExpression(txParser* parser)
2011
1.71M
{
2012
1.71M
  fxMultiplicativeExpression(parser);
2013
6.25M
  while (gxTokenFlags[parser->states[0].token] & XS_TOKEN_ADDITIVE_EXPRESSION) {
2014
4.54M
    txToken aToken = parser->states[0].token;
2015
4.54M
    txInteger aLine = parser->states[0].line;
2016
4.54M
    fxGetNextToken(parser);
2017
4.54M
    fxMultiplicativeExpression(parser);
2018
4.54M
    fxCheckArrowFunction(parser, 2);
2019
4.54M
    fxPushNodeStruct(parser, 2, aToken, aLine);
2020
4.54M
  }
2021
1.71M
}
2022
2023
void fxMultiplicativeExpression(txParser* parser)
2024
6.25M
{
2025
6.25M
  fxExponentiationExpression(parser);
2026
6.32M
  while (gxTokenFlags[parser->states[0].token] & XS_TOKEN_MULTIPLICATIVE_EXPRESSION) {
2027
69.6k
    txToken aToken = parser->states[0].token;
2028
69.6k
    txInteger aLine = parser->states[0].line;
2029
69.6k
    fxGetNextToken(parser);
2030
69.6k
    fxExponentiationExpression(parser);
2031
69.6k
    fxCheckArrowFunction(parser, 2);
2032
69.6k
    fxPushNodeStruct(parser, 2, aToken, aLine);
2033
69.6k
  }
2034
6.25M
}
2035
2036
void fxExponentiationExpression(txParser* parser)
2037
6.32M
{
2038
6.32M
  if (gxTokenFlags[parser->states[0].token] & XS_TOKEN_UNARY_EXPRESSION)
2039
59.9k
    fxUnaryExpression(parser);
2040
6.26M
  else {
2041
6.26M
    fxPrefixExpression(parser);
2042
6.26M
    if (gxTokenFlags[parser->states[0].token] & XS_TOKEN_EXPONENTIATION_EXPRESSION) {
2043
1.96k
      txToken aToken = parser->states[0].token;
2044
1.96k
      txInteger aLine = parser->states[0].line;
2045
1.96k
      fxGetNextToken(parser);
2046
1.96k
            fxExponentiationExpression(parser);
2047
1.96k
      fxCheckArrowFunction(parser, 2);
2048
1.96k
      fxPushNodeStruct(parser, 2, aToken, aLine);
2049
1.96k
    }
2050
6.26M
  }
2051
6.32M
}
2052
2053
void fxUnaryExpression(txParser* parser)
2054
290k
{
2055
290k
  if (gxTokenFlags[parser->states[0].token] & XS_TOKEN_UNARY_EXPRESSION) {
2056
231k
    txToken aToken = parser->states[0].token;
2057
231k
    txInteger aLine = parser->states[0].line;
2058
231k
    fxCheckParserStack(parser, aLine);
2059
231k
    fxMatchToken(parser, aToken);
2060
231k
    fxUnaryExpression(parser);
2061
231k
    fxCheckArrowFunction(parser, 1);
2062
231k
    if (aToken == XS_TOKEN_ADD)
2063
5.13k
      fxPushNodeStruct(parser, 1, XS_TOKEN_PLUS, aLine);
2064
226k
    else if (aToken == XS_TOKEN_SUBTRACT)
2065
27.3k
      fxPushNodeStruct(parser, 1, XS_TOKEN_MINUS, aLine);
2066
199k
    else if (aToken == XS_TOKEN_DELETE) {
2067
      //if ((parser->flags & mxStrictFlag) && (parser->root->description->token == XS_TOKEN_ACCESS)) {
2068
      //  fxReportParserError(parser, parser->states[0].line, "no reference (strict mode)");
2069
      //}
2070
9.41k
      if (!fxCheckReference(parser, aToken)) 
2071
0
        fxReportParserError(parser, parser->states[0].line, "no reference");
2072
9.41k
      fxPushNodeStruct(parser, 1, aToken, aLine);
2073
9.41k
    }
2074
189k
    else if (aToken == XS_TOKEN_AWAIT) {
2075
213
      if ((parser->flags & mxGeneratorFlag) && !(parser->flags & mxYieldFlag))
2076
3
        fxReportParserError(parser, parser->states[0].line, "invalid await");
2077
210
      else
2078
210
        parser->flags |= mxAwaitingFlag;
2079
213
      fxPushNodeStruct(parser, 1, aToken, aLine);
2080
213
    }
2081
189k
    else
2082
189k
      fxPushNodeStruct(parser, 1, aToken, aLine);
2083
      
2084
231k
  }
2085
59.1k
  else
2086
59.1k
    fxPrefixExpression(parser);
2087
290k
}
2088
2089
void fxPrefixExpression(txParser* parser)
2090
6.42M
{
2091
6.42M
  if (gxTokenFlags[parser->states[0].token] & XS_TOKEN_PREFIX_EXPRESSION) {
2092
105k
    txToken aToken = parser->states[0].token;
2093
105k
    txInteger aLine = parser->states[0].line;
2094
105k
    fxCheckParserStack(parser, aLine);
2095
105k
    fxGetNextToken(parser);
2096
105k
    fxPrefixExpression(parser);
2097
105k
    fxCheckArrowFunction(parser, 1);
2098
105k
    if (!fxCheckReference(parser, aToken)) 
2099
585
      fxReportParserError(parser, parser->states[0].line, "no reference");
2100
105k
    fxPushNodeStruct(parser, 1, aToken, aLine);
2101
105k
    parser->root->flags = mxExpressionNoValue;
2102
105k
  }
2103
6.31M
  else
2104
6.31M
    fxPostfixExpression(parser);
2105
6.42M
}
2106
2107
void fxPostfixExpression(txParser* parser)
2108
6.31M
{
2109
6.31M
  fxCallExpression(parser);
2110
6.31M
  if ((!parser->states[0].crlf) && (gxTokenFlags[parser->states[0].token] & XS_TOKEN_POSTFIX_EXPRESSION)) {
2111
15.1k
    fxCheckArrowFunction(parser, 1);
2112
15.1k
    if (!fxCheckReference(parser, parser->states[0].token)) 
2113
548
      fxReportParserError(parser, parser->states[0].line, "no reference");
2114
15.1k
    fxPushNodeStruct(parser, 1, parser->states[0].token, parser->states[0].line);
2115
15.1k
    fxGetNextToken(parser);
2116
15.1k
  }
2117
6.31M
}
2118
2119
void fxCallExpression(txParser* parser)
2120
6.31M
{
2121
6.31M
  txInteger chainLine = parser->states[0].line;
2122
6.31M
  fxLiteralExpression(parser, 0);
2123
6.31M
  if (gxTokenFlags[parser->states[0].token] & XS_TOKEN_CALL_EXPRESSION) {
2124
243k
    txBoolean chainFlag = 0;
2125
243k
    fxCheckArrowFunction(parser, 1);
2126
783k
    for (;;) {
2127
783k
      txInteger aLine = parser->states[0].line;
2128
783k
      if (parser->states[0].token == XS_TOKEN_DOT) {
2129
182k
        fxGetNextToken(parser);
2130
182k
        if (parser->states[0].token == XS_TOKEN_IDENTIFIER) {
2131
179k
          fxPushSymbol(parser, parser->states[0].symbol);
2132
179k
          fxPushNodeStruct(parser, 2, XS_TOKEN_MEMBER, aLine);
2133
179k
          fxGetNextToken(parser);
2134
179k
        }
2135
2.80k
        else if (parser->states[0].token == XS_TOKEN_PRIVATE_IDENTIFIER) {
2136
1.86k
          if (parser->root->flags & mxSuperFlag)
2137
0
            fxReportParserError(parser, parser->states[0].line, "invalid super");
2138
1.86k
          fxPushSymbol(parser, parser->states[0].symbol);
2139
1.86k
          fxSwapNodes(parser);
2140
1.86k
          fxPushNodeStruct(parser, 2, XS_TOKEN_PRIVATE_MEMBER, aLine);
2141
1.86k
          fxGetNextToken(parser);
2142
1.86k
        }
2143
942
        else
2144
942
          fxReportParserError(parser, parser->states[0].line, "missing property");
2145
182k
      }
2146
      //else if (parser->states[0].crlf)
2147
      //  break;
2148
600k
      else if (parser->states[0].token == XS_TOKEN_LEFT_BRACKET) {
2149
12.4k
        fxGetNextToken(parser);
2150
12.4k
        fxCommaExpression(parser);
2151
12.4k
        fxPushNodeStruct(parser, 2, XS_TOKEN_MEMBER_AT, aLine);
2152
12.4k
        fxMatchToken(parser, XS_TOKEN_RIGHT_BRACKET);
2153
12.4k
      }
2154
588k
      else if (parser->states[0].token == XS_TOKEN_LEFT_PARENTHESIS) {
2155
168k
        if (parser->root->description && (parser->root->description->token == XS_TOKEN_ACCESS)) {
2156
45.1k
          txAccessNode* access = (txAccessNode*)parser->root;
2157
45.1k
          if (access->symbol == parser->evalSymbol) {
2158
2.24k
            parser->flags |= mxEvalFlag;
2159
2.24k
          }
2160
45.1k
        }
2161
168k
        fxParameters(parser);
2162
168k
        fxPushNodeStruct(parser, 2, XS_TOKEN_CALL, aLine);
2163
168k
      }
2164
420k
      else if (parser->states[0].token == XS_TOKEN_TEMPLATE) {
2165
223k
        if (chainFlag)
2166
1
          fxReportParserError(parser, parser->states[0].line, "invalid template");
2167
223k
        fxPushStringNode(parser, parser->states[0].stringLength, parser->states[0].string, aLine);
2168
223k
        fxPushRawNode(parser, parser->states[0].rawLength, parser->states[0].raw, aLine);
2169
223k
        fxPushNodeStruct(parser, 2, XS_TOKEN_TEMPLATE_MIDDLE, aLine);
2170
223k
        fxGetNextToken(parser);
2171
223k
        fxPushNodeList(parser, 1);
2172
223k
        fxPushNodeStruct(parser, 2, XS_TOKEN_TEMPLATE, aLine);
2173
223k
      }
2174
196k
      else if (parser->states[0].token == XS_TOKEN_TEMPLATE_HEAD) {
2175
151
        if (chainFlag)
2176
1
          fxReportParserError(parser, parser->states[0].line, "invalid template");
2177
151
        fxTemplateExpression(parser);
2178
151
        fxPushNodeStruct(parser, 2, XS_TOKEN_TEMPLATE, aLine);
2179
151
      }
2180
196k
      else if (parser->states[0].token == XS_TOKEN_CHAIN) {
2181
4.62k
        fxGetNextToken(parser);
2182
4.62k
        chainFlag = 1;
2183
4.62k
        if (parser->states[0].token == XS_TOKEN_IDENTIFIER) {
2184
3.34k
          fxPushNodeStruct(parser, 1, XS_TOKEN_OPTION, aLine);
2185
3.34k
          fxPushSymbol(parser, parser->states[0].symbol);
2186
3.34k
          fxPushNodeStruct(parser, 2, XS_TOKEN_MEMBER, aLine);
2187
3.34k
          fxGetNextToken(parser);
2188
3.34k
        }
2189
1.27k
        else if (parser->states[0].token == XS_TOKEN_PRIVATE_IDENTIFIER) {
2190
116
          fxPushNodeStruct(parser, 1, XS_TOKEN_OPTION, aLine);
2191
116
          fxPushSymbol(parser, parser->states[0].symbol);
2192
116
          fxSwapNodes(parser);
2193
116
          fxPushNodeStruct(parser, 2, XS_TOKEN_PRIVATE_MEMBER, aLine);
2194
116
          fxGetNextToken(parser);
2195
116
        }
2196
1.16k
        else if (parser->states[0].token == XS_TOKEN_LEFT_BRACKET) {
2197
235
          fxPushNodeStruct(parser, 1, XS_TOKEN_OPTION, aLine);
2198
235
          fxGetNextToken(parser);
2199
235
          fxCommaExpression(parser);
2200
235
          fxPushNodeStruct(parser, 2, XS_TOKEN_MEMBER_AT, aLine);
2201
235
          fxMatchToken(parser, XS_TOKEN_RIGHT_BRACKET);
2202
235
        }
2203
927
        else if (parser->states[0].token == XS_TOKEN_LEFT_PARENTHESIS) {
2204
48
          fxPushNodeStruct(parser, 1, XS_TOKEN_OPTION, aLine);
2205
48
          fxParameters(parser);
2206
48
          fxPushNodeStruct(parser, 2, XS_TOKEN_CALL, aLine);
2207
48
        }
2208
879
        else
2209
879
          fxReportParserError(parser, parser->states[0].line, "invalid ?.");
2210
4.62k
      }
2211
192k
      else
2212
192k
        break;
2213
783k
    } 
2214
243k
    if (chainFlag)
2215
3.35k
      fxPushNodeStruct(parser, 1, XS_TOKEN_CHAIN, chainLine);
2216
243k
  } 
2217
6.31M
}
2218
2219
void fxLiteralExpression(txParser* parser, txUnsigned flag)
2220
6.34M
{
2221
6.34M
  int escaped;
2222
6.34M
  txSymbol* aSymbol;
2223
6.34M
  txInteger aLine = parser->states[0].line;
2224
6.34M
  txUnsigned flags = 0;
2225
6.34M
  char c = 0;
2226
6.34M
  fxCheckParserStack(parser, aLine);
2227
6.34M
  switch (parser->states[0].token) {
2228
4.05k
  case XS_TOKEN_NULL:
2229
11.4k
  case XS_TOKEN_TRUE:
2230
15.4k
  case XS_TOKEN_FALSE:
2231
15.4k
    fxPushNodeStruct(parser, 0, parser->states[0].token, aLine);
2232
15.4k
    fxMatchToken(parser, parser->states[0].token);
2233
15.4k
    break;
2234
3.38k
  case XS_TOKEN_IMPORT:
2235
3.38k
    fxMatchToken(parser, XS_TOKEN_IMPORT);
2236
3.38k
    if (!flag && (parser->states[0].token == XS_TOKEN_LEFT_PARENTHESIS)) {
2237
2.38k
      txUnsigned flags = parser->flags & mxForFlag;
2238
2.38k
      fxGetNextToken(parser);
2239
2.38k
      parser->flags &= ~mxForFlag;
2240
2.38k
      fxAssignmentExpression(parser);
2241
2.38k
      if (parser->states[0].token == XS_TOKEN_COMMA) {
2242
110
        fxGetNextToken(parser);
2243
110
        if (gxTokenFlags[parser->states[0].token] & XS_TOKEN_BEGIN_EXPRESSION) {
2244
100
          fxAssignmentExpression(parser);
2245
100
          if (parser->states[0].token == XS_TOKEN_COMMA)
2246
1
            fxGetNextToken(parser);
2247
100
        }
2248
10
        else
2249
10
          fxPushNULL(parser);
2250
110
      }
2251
2.27k
      else
2252
2.27k
        fxPushNULL(parser);
2253
2.38k
      parser->flags |= flags;
2254
2.38k
      fxMatchToken(parser, XS_TOKEN_RIGHT_PARENTHESIS);
2255
2.38k
      fxPushNodeStruct(parser, 2, XS_TOKEN_IMPORT_CALL, aLine);
2256
2.38k
    }
2257
1.00k
    else if (parser->states[0].token == XS_TOKEN_DOT) {
2258
81
      fxGetNextToken(parser);
2259
81
      if ((parser->states[0].token == XS_TOKEN_IDENTIFIER) && (parser->states[0].symbol == parser->metaSymbol) && (!parser->states[0].escaped)) { 
2260
80
        fxGetNextToken(parser);
2261
80
        if (parser->flags & mxProgramFlag)
2262
1
          fxReportParserError(parser, parser->states[0].line, "invalid import.meta");
2263
79
        else
2264
79
          fxPushNodeStruct(parser, 0, XS_TOKEN_IMPORT_META, aLine);
2265
80
      }
2266
1
      else
2267
1
        fxReportParserError(parser, parser->states[0].line, "invalid import.");
2268
81
    }
2269
919
    else
2270
919
      fxReportParserError(parser, parser->states[0].line, "invalid import");
2271
3.38k
    break;
2272
1.42k
  case XS_TOKEN_SUPER:
2273
1.42k
    fxMatchToken(parser, XS_TOKEN_SUPER);
2274
1.42k
    if (parser->states[0].token == XS_TOKEN_LEFT_PARENTHESIS) {
2275
20
      if (parser->flags & mxDerivedFlag) {
2276
19
        fxParameters(parser);
2277
19
        fxPushNodeStruct(parser, 1, XS_TOKEN_SUPER, aLine);
2278
19
      }
2279
1
      else {
2280
1
        fxPushNodeStruct(parser, 0, XS_TOKEN_UNDEFINED, aLine);
2281
1
        fxReportParserError(parser, parser->states[0].line, "invalid super");
2282
1
      }
2283
20
    }
2284
1.40k
    else if ((parser->states[0].token == XS_TOKEN_DOT) || (parser->states[0].token == XS_TOKEN_LEFT_BRACKET)) {
2285
633
      if (parser->flags & mxSuperFlag) {
2286
301
        fxPushNodeStruct(parser, 0, XS_TOKEN_THIS, aLine);
2287
301
        parser->root->flags |= parser->flags & (mxDerivedFlag | mxSuperFlag);
2288
301
      }
2289
332
      else {
2290
332
        fxPushNodeStruct(parser, 0, XS_TOKEN_UNDEFINED, aLine);
2291
332
        fxReportParserError(parser, parser->states[0].line, "invalid super");
2292
332
      }
2293
633
    }
2294
774
    else
2295
774
      fxReportParserError(parser, parser->states[0].line, "invalid super");
2296
1.42k
    parser->flags |= mxSuperFlag;
2297
1.42k
    break;
2298
2.91k
  case XS_TOKEN_THIS:
2299
2.91k
    fxPushNodeStruct(parser, 0, parser->states[0].token, aLine);
2300
2.91k
    parser->root->flags |= parser->flags & mxDerivedFlag;
2301
2.91k
    fxMatchToken(parser, XS_TOKEN_THIS);
2302
2.91k
    break;
2303
4.81M
  case XS_TOKEN_INTEGER:
2304
4.81M
    fxPushIntegerNode(parser, parser->states[0].integer, aLine);
2305
4.81M
    fxGetNextToken(parser);
2306
4.81M
    break;
2307
25.9k
  case XS_TOKEN_NUMBER:
2308
25.9k
    fxPushNumberNode(parser, parser->states[0].number, aLine);
2309
25.9k
    fxGetNextToken(parser);
2310
25.9k
    break;
2311
29.4k
  case XS_TOKEN_BIGINT:
2312
29.4k
    fxPushBigIntNode(parser, &parser->states[0].bigint, aLine);
2313
29.4k
    fxGetNextToken(parser);
2314
29.4k
    break;
2315
576
  case XS_TOKEN_DIVIDE_ASSIGN:
2316
576
    c = '=';
2317
    // continue
2318
13.5k
  case XS_TOKEN_DIVIDE:
2319
13.5k
    fxGetNextRegExp(parser, c);
2320
13.5k
    fxPushStringNode(parser, parser->states[0].modifierLength, parser->states[0].modifier, aLine);
2321
13.5k
    fxPushStringNode(parser, parser->states[0].stringLength, parser->states[0].string, aLine);
2322
13.5k
    fxPushNodeStruct(parser, 2, XS_TOKEN_REGEXP, aLine);
2323
13.5k
    fxGetNextToken(parser);
2324
13.5k
    break;
2325
168k
  case XS_TOKEN_STRING:
2326
168k
    fxPushStringNode(parser, parser->states[0].stringLength, parser->states[0].string, aLine);
2327
168k
    fxGetNextToken(parser);
2328
168k
    break;
2329
825k
  case XS_TOKEN_IDENTIFIER:
2330
825k
    escaped = parser->states[0].escaped;
2331
825k
    aSymbol = parser->states[0].symbol;
2332
825k
    fxGetNextToken(parser);
2333
//    if (aSymbol == parser->undefinedSymbol) {
2334
//      fxPushNodeStruct(parser, 0, XS_TOKEN_UNDEFINED, aLine);
2335
//      break;
2336
//    }
2337
825k
    flags = 0;
2338
825k
    if ((aSymbol == parser->asyncSymbol) && (!escaped) && (!parser->states[0].crlf)) {
2339
15.2k
      if (parser->states[0].token == XS_TOKEN_FUNCTION) {
2340
177
        fxMatchToken(parser, XS_TOKEN_FUNCTION);
2341
177
        if (parser->states[0].token == XS_TOKEN_MULTIPLY) {
2342
79
          fxGetNextToken(parser);
2343
79
          fxGeneratorExpression(parser, aLine, C_NULL, mxAsyncFlag);
2344
79
        }
2345
98
        else
2346
98
          fxFunctionExpression(parser, aLine, C_NULL, mxAsyncFlag);
2347
177
        break;
2348
177
      }
2349
15.0k
      if (parser->states[0].token == XS_TOKEN_LEFT_PARENTHESIS) {
2350
13.3k
        fxGroupExpression(parser, mxAsyncFlag);
2351
13.3k
        break;
2352
13.3k
      }
2353
1.78k
      if (parser->states[0].token == XS_TOKEN_IDENTIFIER) {
2354
//        if (!(parser->flags & mxForFlag) || !fxIsKeyword(parser, parser->ofSymbol)) {
2355
589
          aSymbol = parser->states[0].symbol;
2356
589
          fxGetNextToken(parser);
2357
589
          flags = mxAsyncFlag;
2358
//        }
2359
589
      }
2360
1.78k
    }
2361
811k
    if (aSymbol == parser->awaitSymbol)
2362
264
      parser->flags |= mxAwaitingFlag;
2363
811k
    if ((!parser->states[0].crlf) && (parser->states[0].token == XS_TOKEN_ARROW)) {
2364
11.1k
      fxCheckStrictSymbol(parser, aSymbol);
2365
11.1k
      if (flags && (aSymbol == parser->awaitSymbol))
2366
0
        fxReportParserError(parser, parser->states[0].line, "invalid await");
2367
11.1k
      fxPushSymbol(parser, aSymbol);
2368
11.1k
      fxPushNULL(parser);
2369
11.1k
      fxPushNodeStruct(parser, 2, XS_TOKEN_ARG, aLine);
2370
11.1k
      fxPushNodeList(parser, 1);
2371
11.1k
      fxPushNodeStruct(parser, 1, XS_TOKEN_PARAMS_BINDING, aLine);
2372
11.1k
      fxArrowExpression(parser, flags);
2373
11.1k
      break;
2374
11.1k
    }
2375
800k
    if (aSymbol == parser->argumentsSymbol)
2376
1.35k
      parser->flags |= mxArgumentsFlag;
2377
800k
    fxPushSymbol(parser, aSymbol);
2378
800k
    fxPushNodeStruct(parser, 1, XS_TOKEN_ACCESS, aLine);
2379
800k
    break;
2380
10.8k
  case XS_TOKEN_CLASS:
2381
10.8k
    flags = parser->flags & mxForFlag;
2382
10.8k
    parser->flags &= ~mxForFlag;
2383
10.8k
    fxClassExpression(parser, aLine, C_NULL);
2384
10.8k
    parser->flags |= flags;
2385
10.8k
    break;
2386
119k
  case XS_TOKEN_FUNCTION:
2387
119k
    fxMatchToken(parser, XS_TOKEN_FUNCTION);
2388
119k
    if (parser->states[0].token == XS_TOKEN_MULTIPLY) {
2389
314
      fxGetNextToken(parser);
2390
314
      fxGeneratorExpression(parser, aLine, C_NULL, 0);
2391
314
    }
2392
119k
    else
2393
119k
      fxFunctionExpression(parser, aLine, C_NULL, 0);
2394
119k
    break;
2395
26.8k
  case XS_TOKEN_NEW:
2396
26.8k
    fxNewExpression(parser);
2397
26.8k
    break;
2398
50.4k
  case XS_TOKEN_LEFT_BRACE:
2399
50.4k
    flags = parser->flags & mxForFlag;
2400
50.4k
    parser->flags &= ~mxForFlag;
2401
50.4k
    fxObjectExpression(parser);
2402
50.4k
    parser->flags |= flags;
2403
50.4k
    break;
2404
86.6k
  case XS_TOKEN_LEFT_BRACKET:
2405
86.6k
    flags = parser->flags & mxForFlag;
2406
86.6k
    parser->flags &= ~mxForFlag;
2407
86.6k
    fxArrayExpression(parser);
2408
86.6k
    parser->flags |= flags;
2409
86.6k
    break;
2410
119k
  case XS_TOKEN_LEFT_PARENTHESIS:
2411
119k
    fxGroupExpression(parser, 0);
2412
119k
    break;
2413
15.3k
  case XS_TOKEN_TEMPLATE:
2414
15.3k
    fxPushNULL(parser);
2415
15.3k
    fxPushStringNode(parser, parser->states[0].stringLength, parser->states[0].string, aLine);
2416
15.3k
    fxPushRawNode(parser, parser->states[0].rawLength, parser->states[0].raw, aLine);
2417
15.3k
    fxPushNodeStruct(parser, 2, XS_TOKEN_TEMPLATE_MIDDLE, aLine);
2418
15.3k
    fxGetNextToken(parser);
2419
15.3k
    fxPushNodeList(parser, 1);
2420
15.3k
    fxPushNodeStruct(parser, 2, XS_TOKEN_TEMPLATE, aLine);
2421
15.3k
    break;
2422
513
  case XS_TOKEN_TEMPLATE_HEAD:
2423
513
    fxPushNULL(parser);
2424
513
    fxTemplateExpression(parser);
2425
513
    fxPushNodeStruct(parser, 2, XS_TOKEN_TEMPLATE, aLine);
2426
513
    break;
2427
0
  case XS_TOKEN_HOST:
2428
0
    fxGetNextToken(parser);
2429
0
    fxPushNULL(parser);
2430
0
    fxPushNULL(parser);
2431
0
    if (parser->states[0].token == XS_TOKEN_STRING) {
2432
0
      fxPushStringNode(parser, parser->states[0].stringLength, parser->states[0].string, aLine);
2433
0
      fxGetNextToken(parser);
2434
0
    }
2435
0
    else {
2436
0
      fxReportParserError(parser, parser->states[0].line, "invalid host object");
2437
0
      fxPushNULL(parser);
2438
0
    }
2439
0
    fxPushNodeStruct(parser, 3, XS_TOKEN_HOST, aLine);
2440
0
    break;
2441
10.1k
  case XS_TOKEN_LESS:
2442
10.1k
    fxGetNextToken(parser);
2443
10.1k
    fxJSXElement(parser);
2444
10.1k
    fxGetNextToken(parser);
2445
10.1k
    break;
2446
8.14k
  default:
2447
8.14k
    fxPushNodeStruct(parser, 0, XS_TOKEN_UNDEFINED, aLine);
2448
8.14k
    fxReportParserError(parser, parser->states[0].line, "missing expression");
2449
8.14k
    break;
2450
6.34M
  }
2451
6.34M
}
2452
2453
void fxArrayExpression(txParser* parser)
2454
86.6k
{
2455
86.6k
  txInteger aCount = 0;
2456
86.6k
  int elision = 1;
2457
86.6k
  txInteger aLine = parser->states[0].line;
2458
86.6k
  txBoolean aSpreadFlag = 0;
2459
86.6k
  fxMatchToken(parser, XS_TOKEN_LEFT_BRACKET);
2460
570k
  while ((parser->states[0].token == XS_TOKEN_COMMA) || (parser->states[0].token == XS_TOKEN_SPREAD) || (gxTokenFlags[parser->states[0].token] & XS_TOKEN_BEGIN_EXPRESSION)) {
2461
483k
    txInteger anItemLine = parser->states[0].line;
2462
483k
    if (parser->states[0].token == XS_TOKEN_COMMA) {
2463
261k
      fxGetNextToken(parser);
2464
261k
      if (elision) {
2465
122k
        fxPushNodeStruct(parser, 0, XS_TOKEN_ELISION, anItemLine);
2466
122k
        aCount++;
2467
122k
      }
2468
139k
      else
2469
139k
        elision = 1;
2470
261k
    }
2471
222k
    else if (parser->states[0].token == XS_TOKEN_SPREAD) {
2472
2.43k
      fxGetNextToken(parser);
2473
2.43k
      if (!elision)
2474
1.77k
        fxReportParserError(parser, parser->states[0].line, "missing ,");
2475
2.43k
      fxAssignmentExpression(parser);
2476
2.43k
      fxPushNodeStruct(parser, 1, XS_TOKEN_SPREAD, anItemLine);
2477
2.43k
      aCount++;
2478
2.43k
      elision = 0;
2479
2.43k
      aSpreadFlag = 1;
2480
2.43k
    }
2481
219k
    else {
2482
219k
      if (!elision)
2483
1.02k
        fxReportParserError(parser, parser->states[0].line, "missing ,");
2484
219k
      fxAssignmentExpression(parser);
2485
219k
      aCount++;
2486
219k
      elision = 0;
2487
219k
    }
2488
483k
  }
2489
86.6k
  fxMatchToken(parser, XS_TOKEN_RIGHT_BRACKET);
2490
86.6k
  fxPushNodeList(parser, aCount);
2491
86.6k
  fxPushNodeStruct(parser, 1, XS_TOKEN_ARRAY, aLine);
2492
86.6k
  if (aCount && elision)
2493
988
    parser->root->flags |= mxElisionFlag;
2494
86.6k
  if (aSpreadFlag)
2495
597
    parser->root->flags |= mxSpreadFlag;
2496
86.6k
}
2497
2498
void fxArrowExpression(txParser* parser, txUnsigned flag)
2499
34.3k
{
2500
34.3k
  txInteger aLine = parser->states[0].line;
2501
34.3k
  txUnsigned flags = parser->flags;
2502
34.3k
  parser->flags &= ~(mxAsyncFlag | mxGeneratorFlag);
2503
34.3k
  parser->flags |= mxArrowFlag | flag;
2504
34.3k
  fxMatchToken(parser, XS_TOKEN_ARROW);
2505
34.3k
  fxPushNULL(parser);
2506
34.3k
  fxSwapNodes(parser);  
2507
34.3k
  if (parser->states[0].token == XS_TOKEN_LEFT_BRACE) {
2508
19.8k
    fxMatchToken(parser, XS_TOKEN_LEFT_BRACE);
2509
19.8k
    fxBody(parser);
2510
19.8k
    fxPushNodeStruct(parser, 1, XS_TOKEN_BODY, aLine);
2511
19.8k
    fxMatchToken(parser, XS_TOKEN_RIGHT_BRACE);
2512
19.8k
  }
2513
14.4k
  else {
2514
14.4k
    fxAssignmentExpression(parser);
2515
14.4k
    fxPushNodeStruct(parser, 1, XS_TOKEN_RETURN, aLine);
2516
14.4k
    fxPushNodeStruct(parser, 1, XS_TOKEN_BODY, aLine);
2517
14.4k
    if (!(flags & mxAsyncFlag) && (flag & mxAsyncFlag)) {
2518
364
      if (parser->states[0].token == XS_TOKEN_AWAIT) {
2519
1
        parser->states[0].token = XS_TOKEN_IDENTIFIER;
2520
1
      }
2521
364
    }
2522
14.4k
  }
2523
34.3k
  fxPushNodeStruct(parser, 3, XS_TOKEN_FUNCTION, aLine);
2524
34.3k
  parser->root->flags = parser->flags & (mxStrictFlag | mxFieldFlag | mxNotSimpleParametersFlag | mxArrowFlag | mxSuperFlag | flag);
2525
34.3k
  if (!(flags & mxStrictFlag) && (parser->flags & mxStrictFlag))
2526
210
    fxCheckStrictFunction(parser, (txFunctionNode*)parser->root);
2527
34.3k
  parser->flags = flags | (parser->flags & (mxArgumentsFlag | mxEvalFlag));
2528
34.3k
}
2529
2530
void fxClassExpression(txParser* parser, txInteger theLine, txSymbol** theSymbol)
2531
47.9k
{
2532
47.9k
  txBoolean heritageFlag = 0;
2533
//  txBoolean hostFlag = 0;
2534
47.9k
  txNode* constructor = NULL;
2535
47.9k
  txInteger aCount = 0;
2536
47.9k
  txInteger aLine = parser->states[0].line;
2537
47.9k
  txUnsigned flags = parser->flags;
2538
47.9k
  txInteger constructorInitCount = 0;
2539
47.9k
  txInteger instanceInitCount = 0;
2540
47.9k
  parser->flags |= mxStrictFlag;
2541
47.9k
  fxMatchToken(parser, XS_TOKEN_CLASS);
2542
47.9k
  if (parser->states[0].token == XS_TOKEN_IDENTIFIER) {
2543
6.72k
    fxPushSymbol(parser, parser->states[0].symbol);
2544
6.72k
    if (theSymbol)
2545
5.59k
      *theSymbol = parser->states[0].symbol;
2546
6.72k
    fxGetNextToken(parser);
2547
6.72k
  }
2548
41.2k
  else
2549
41.2k
    fxPushNULL(parser);
2550
47.9k
  if (parser->states[0].token == XS_TOKEN_EXTENDS) {
2551
349
    fxMatchToken(parser, XS_TOKEN_EXTENDS);
2552
349
    fxCallExpression(parser);
2553
349
    fxCheckArrowFunction(parser, 1);
2554
349
    flags |= parser->flags & mxAwaitingFlag;
2555
349
    heritageFlag = 1;
2556
349
  }
2557
47.5k
  else if (parser->states[0].token == XS_TOKEN_HOST) {
2558
0
    fxGetNextToken(parser);
2559
0
    fxPushNULL(parser);
2560
0
    fxPushNULL(parser);
2561
0
    if (parser->states[0].token == XS_TOKEN_STRING) {
2562
0
      fxPushStringNode(parser, parser->states[0].stringLength, parser->states[0].string, aLine);
2563
0
      fxGetNextToken(parser);
2564
0
    }
2565
0
    else {
2566
0
      fxReportParserError(parser, parser->states[0].line, "invalid host class");
2567
0
      fxPushNULL(parser);
2568
0
    }
2569
0
    fxPushNodeStruct(parser, 3, XS_TOKEN_HOST, aLine);
2570
//    hostFlag = 1;
2571
0
  }
2572
47.5k
  else {
2573
47.5k
    fxPushNULL(parser);
2574
47.5k
  }
2575
47.9k
  if (parser->states[0].token == XS_TOKEN_LEFT_BRACE) {
2576
46.1k
    fxMatchToken(parser, XS_TOKEN_LEFT_BRACE);
2577
71.5k
    for (;;) {
2578
71.5k
      txBoolean aStaticFlag;
2579
71.5k
      txInteger aPropertyLine = parser->states[0].line;
2580
71.5k
      txSymbol* aSymbol;
2581
71.5k
      txToken aToken0;
2582
71.5k
      txToken aToken1;
2583
71.5k
      txToken aToken2;
2584
71.5k
      txUnsigned flag;
2585
78.6k
      while (parser->states[0].token == XS_TOKEN_SEMICOLON)
2586
7.09k
        fxGetNextToken(parser);
2587
71.5k
      if (parser->states[0].token == XS_TOKEN_RIGHT_BRACE)
2588
4.83k
        break;
2589
66.6k
      aStaticFlag = 0;
2590
66.6k
      if ((parser->states[0].token == XS_TOKEN_STATIC) && (!parser->states[0].escaped)) {
2591
40.1k
        fxGetNextToken(parser);
2592
40.1k
        if ((parser->states[0].token == XS_TOKEN_ASSIGN) || parser->states[0].token == XS_TOKEN_SEMICOLON) {
2593
5.19k
          fxPushSymbol(parser, parser->staticSymbol);
2594
5.19k
          aToken1 = XS_TOKEN_PROPERTY;
2595
5.19k
          goto field;
2596
5.19k
        }
2597
34.9k
        if (parser->states[0].token == XS_TOKEN_LEFT_BRACE) {
2598
31.2k
          txUnsigned flags = parser->flags;
2599
31.2k
          parser->flags = (flags & (mxParserFlags | mxStrictFlag)) | mxSuperFlag | mxTargetFlag | mxFieldFlag | mxAsyncFlag;
2600
31.2k
          fxCheckParserStack(parser, aPropertyLine);
2601
31.2k
          fxGetNextToken(parser);
2602
31.2k
          fxStatements(parser);
2603
31.2k
          fxMatchToken(parser, XS_TOKEN_RIGHT_BRACE);
2604
31.2k
          fxPushNodeStruct(parser, 1, XS_TOKEN_BODY, aPropertyLine);
2605
31.2k
          if (parser->flags & mxArgumentsFlag)
2606
0
            fxReportParserError(parser, parser->states[0].line, "invalid arguments");
2607
31.2k
          if (parser->flags & mxAwaitingFlag)
2608
0
            fxReportParserError(parser, parser->states[0].line, "invalid await");
2609
31.2k
          parser->flags = flags;
2610
31.2k
          parser->root->flags |= mxStaticFlag;
2611
31.2k
          constructorInitCount++;
2612
31.2k
          aCount++;
2613
31.2k
          continue;
2614
31.2k
        }
2615
3.69k
        aStaticFlag = 1;
2616
3.69k
      }
2617
30.2k
      fxPropertyName(parser, &aSymbol, &aToken0, &aToken1, &aToken2, &flag);
2618
30.2k
      if ((aStaticFlag == 0) && (aSymbol == parser->constructorSymbol)) {
2619
191
        fxPopNode(parser); // symbol
2620
191
        if (constructor || (aToken2 == XS_TOKEN_GENERATOR) || (aToken2 == XS_TOKEN_GETTER) || (aToken2 == XS_TOKEN_SETTER) || (flag & mxAsyncFlag)) 
2621
3
          fxReportParserError(parser, parser->states[0].line, "invalid constructor");
2622
191
        fxFunctionExpression(parser, aPropertyLine, C_NULL, mxSuperFlag | ((heritageFlag) ? mxDerivedFlag : mxBaseFlag));
2623
191
        constructor = fxPopNode(parser);
2624
191
      }
2625
30.0k
      else if (parser->states[0].token == XS_TOKEN_LEFT_PARENTHESIS) {
2626
4.78k
        if ((aToken1 == XS_TOKEN_PRIVATE_PROPERTY) && (aSymbol == parser->privateConstructorSymbol))
2627
1
          fxReportParserError(parser, parser->states[0].line, "invalid method: #constructor");
2628
4.78k
        if (aStaticFlag && (aSymbol == parser->prototypeSymbol))
2629
0
          fxReportParserError(parser, parser->states[0].line, "invalid static method: prototype");
2630
4.78k
        if (aStaticFlag)
2631
1.66k
          flag |= mxStaticFlag;
2632
4.78k
        if (aToken2 == XS_TOKEN_GETTER) 
2633
140
          flag |= mxGetterFlag;
2634
4.64k
        else if (aToken2 == XS_TOKEN_SETTER) 
2635
40
          flag |= mxSetterFlag;
2636
4.60k
        else
2637
4.60k
          flag |= mxMethodFlag;
2638
4.78k
        if (aToken2 == XS_TOKEN_GENERATOR)
2639
1.07k
          fxGeneratorExpression(parser, aPropertyLine, C_NULL, mxSuperFlag | flag);
2640
3.71k
        else
2641
3.71k
          fxFunctionExpression(parser, aPropertyLine, C_NULL, mxSuperFlag | flag);
2642
4.78k
        fxPushNodeStruct(parser, 2, aToken1, aPropertyLine);
2643
4.78k
        parser->root->flags |= flag & (mxStaticFlag | mxGetterFlag | mxSetterFlag | mxMethodFlag);
2644
4.78k
        if (aToken1 == XS_TOKEN_PRIVATE_PROPERTY) {
2645
1.11k
          if (aStaticFlag)
2646
11
            constructorInitCount++;
2647
1.10k
          else
2648
1.10k
            instanceInitCount++;
2649
1.11k
        }
2650
4.78k
        aCount++;
2651
4.78k
      }
2652
25.2k
      else {
2653
25.2k
        if ((aToken1 == XS_TOKEN_PRIVATE_PROPERTY) && (aSymbol == parser->privateConstructorSymbol))
2654
0
          fxReportParserError(parser, parser->states[0].line, "invalid field: #constructor");
2655
25.2k
        if (aSymbol == parser->constructorSymbol)
2656
0
          fxReportParserError(parser, parser->states[0].line, "invalid field: constructor");
2657
25.2k
        if (aSymbol == parser->prototypeSymbol)
2658
1
          fxReportParserError(parser, parser->states[0].line, "invalid field: prototype");
2659
27.0k
      field:
2660
27.0k
        if (parser->states[0].token == XS_TOKEN_ASSIGN) {
2661
3.99k
          txUnsigned flags = parser->flags;
2662
3.99k
          parser->flags = (flags & (mxParserFlags | mxStrictFlag)) | mxSuperFlag | mxTargetFlag | mxFieldFlag;
2663
3.99k
          fxGetNextToken(parser);
2664
3.99k
          fxAssignmentExpression(parser);
2665
3.99k
          if (parser->flags & mxArgumentsFlag)
2666
0
            fxReportParserError(parser, parser->states[0].line, "invalid arguments");
2667
3.99k
          parser->flags = flags;
2668
3.99k
        }
2669
23.0k
        else {
2670
23.0k
          fxPushNodeStruct(parser, 0, XS_TOKEN_UNDEFINED, aLine);
2671
23.0k
        }
2672
27.0k
        fxPushNodeStruct(parser, 2, aToken1, aPropertyLine);
2673
27.0k
        if (aStaticFlag) {
2674
824
          parser->root->flags |= mxStaticFlag;
2675
824
          constructorInitCount++;
2676
824
        }
2677
26.1k
        else
2678
26.1k
          instanceInitCount++;
2679
27.0k
        fxSemicolon(parser);
2680
27.0k
        aCount++;
2681
27.0k
      }
2682
30.2k
    }
2683
46.1k
  }
2684
44.5k
  fxMatchToken(parser, XS_TOKEN_RIGHT_BRACE);
2685
44.5k
  fxPushNodeList(parser, aCount);
2686
  
2687
44.5k
  if (constructorInitCount || instanceInitCount) {
2688
3.06k
    txNodeList* itemsList = (txNodeList*)(parser->root);
2689
3.06k
    txNodeList* constructorInitList = C_NULL;
2690
3.06k
    txNode** constructorInitAddress = C_NULL;
2691
3.06k
    txNodeList* instanceInitList = C_NULL;
2692
3.06k
    txNode** instanceInitAddress = C_NULL;
2693
3.06k
    txNode** address;
2694
3.06k
    txNode* item;
2695
3.06k
    if (constructorInitCount) {
2696
700
      fxPushNULL(parser);
2697
700
      fxPushNodeList(parser, 0);
2698
700
      fxPushNodeStruct(parser, 1, XS_TOKEN_PARAMS_BINDING, aLine);
2699
700
      fxPushNodeList(parser, 0);
2700
700
      constructorInitList = (txNodeList*)(parser->root);
2701
700
      constructorInitList->length = constructorInitCount;
2702
700
      constructorInitAddress = &(((txNodeList*)(parser->root))->first);
2703
700
      fxPushNodeStruct(parser, 1, XS_TOKEN_STATEMENTS, aLine);
2704
700
      fxPushNodeStruct(parser, 1, XS_TOKEN_BODY, aLine);
2705
700
      fxPushNodeStruct(parser, 3, XS_TOKEN_FUNCTION, aLine);
2706
700
      parser->root->flags = mxStrictFlag | mxSuperFlag | mxFieldFlag;
2707
700
    }
2708
2.36k
    else 
2709
2.36k
      fxPushNULL(parser);
2710
3.06k
    if (instanceInitCount) {
2711
2.38k
      fxPushNULL(parser);
2712
2.38k
      fxPushNodeList(parser, 0);
2713
2.38k
      fxPushNodeStruct(parser, 1, XS_TOKEN_PARAMS_BINDING, aLine);
2714
2.38k
      fxPushNodeList(parser, 0);
2715
2.38k
      instanceInitList = (txNodeList*)(parser->root);
2716
2.38k
      instanceInitList->length = instanceInitCount;
2717
2.38k
      instanceInitAddress = &(((txNodeList*)(parser->root))->first);
2718
2.38k
      fxPushNodeStruct(parser, 1, XS_TOKEN_STATEMENTS, aLine);
2719
2.38k
      fxPushNodeStruct(parser, 1, XS_TOKEN_BODY, aLine);
2720
2.38k
      fxPushNodeStruct(parser, 3, XS_TOKEN_FUNCTION, aLine);
2721
2.38k
      parser->root->flags = mxStrictFlag | mxSuperFlag | mxFieldFlag;
2722
2.38k
    }
2723
684
    else 
2724
684
      fxPushNULL(parser);
2725
3.06k
    address = &(itemsList->first);
2726
14.0k
    while ((item = *address)) {
2727
11.0k
      if (item->flags & (mxMethodFlag | mxGetterFlag | mxSetterFlag)) {
2728
1.30k
        if (item->description->token == XS_TOKEN_PRIVATE_PROPERTY) {
2729
1.09k
          txFieldNode* field = fxFieldNodeNew(parser, XS_TOKEN_FIELD);
2730
1.09k
          field->item = item;
2731
1.09k
          if (item->flags & mxStaticFlag) {
2732
9
            *constructorInitAddress = (txNode*)field;
2733
9
            constructorInitAddress = &field->next;
2734
9
          }
2735
1.08k
          else {
2736
1.08k
            *instanceInitAddress = (txNode*)field;
2737
1.08k
            instanceInitAddress = &field->next;
2738
1.08k
          }
2739
1.09k
        }
2740
1.30k
      }
2741
11.0k
      address = &(item->next);
2742
11.0k
    }
2743
3.06k
    address = &(itemsList->first);
2744
14.0k
    while ((item = *address)) {
2745
11.0k
      if (item->description->token == XS_TOKEN_BODY) {
2746
638
        *address = item->next;
2747
638
        item->next = C_NULL;
2748
638
        itemsList->length--;
2749
638
        *constructorInitAddress = (txNode*)item;
2750
638
        constructorInitAddress = &item->next;
2751
638
      }
2752
10.3k
      else if (item->flags & (mxMethodFlag | mxGetterFlag | mxSetterFlag)) {
2753
1.30k
        address = &(item->next);
2754
1.30k
      }
2755
9.07k
      else {
2756
9.07k
        txFieldNode* field = fxFieldNodeNew(parser, XS_TOKEN_FIELD);
2757
9.07k
        field->item = item;
2758
9.07k
        if (item->description->token == XS_TOKEN_PROPERTY) {
2759
3.64k
          field->value = ((txPropertyNode*)item)->value;
2760
3.64k
          ((txPropertyNode*)item)->value = C_NULL;
2761
3.64k
        }
2762
5.42k
        else if (item->description->token == XS_TOKEN_PROPERTY_AT) {
2763
3.90k
          field->value = ((txPropertyAtNode*)item)->value;
2764
3.90k
          ((txPropertyAtNode*)item)->value = C_NULL;
2765
3.90k
        }
2766
1.52k
        else {
2767
1.52k
          field->value = ((txPrivatePropertyNode*)item)->value;
2768
1.52k
          ((txPrivatePropertyNode*)item)->value = C_NULL;
2769
1.52k
        }
2770
9.07k
        if (item->flags & mxStaticFlag) {
2771
54
          *constructorInitAddress = (txNode*)field;
2772
54
          constructorInitAddress = &field->next;
2773
54
        }
2774
9.01k
        else {
2775
9.01k
          *instanceInitAddress = (txNode*)field;
2776
9.01k
          instanceInitAddress = &field->next;
2777
9.01k
        }
2778
9.07k
        address = &(item->next);
2779
9.07k
      }
2780
11.0k
    }
2781
3.06k
  }
2782
41.4k
  else {
2783
41.4k
    fxPushNULL(parser);
2784
41.4k
    fxPushNULL(parser);
2785
41.4k
  }
2786
44.5k
  if (constructor) {
2787
90
    fxPushNode(parser, constructor);
2788
90
  }
2789
44.4k
  else {
2790
44.4k
    if (heritageFlag) {
2791
266
      fxPushNULL(parser);
2792
    
2793
266
      fxPushSymbol(parser, parser->argsSymbol);
2794
266
      fxPushNULL(parser);
2795
266
      fxPushNodeStruct(parser, 2, XS_TOKEN_ARG, aLine);
2796
266
      fxPushNodeStruct(parser, 1, XS_TOKEN_REST_BINDING, aLine);
2797
266
      fxPushNodeList(parser, 1);
2798
266
      fxPushNodeStruct(parser, 1, XS_TOKEN_PARAMS_BINDING, aLine);
2799
      
2800
266
      fxPushSymbol(parser, parser->argsSymbol);
2801
266
      fxPushNodeStruct(parser, 1, XS_TOKEN_ACCESS, aLine);
2802
266
      fxPushNodeStruct(parser, 1, XS_TOKEN_SPREAD, aLine);
2803
266
      fxPushNodeList(parser, 1);
2804
266
      fxPushNodeStruct(parser, 1, XS_TOKEN_PARAMS, aLine);
2805
266
      parser->root->flags |= mxSpreadFlag;
2806
266
      fxPushNodeStruct(parser, 1, XS_TOKEN_SUPER, aLine);
2807
266
      fxPushNodeStruct(parser, 1, XS_TOKEN_STATEMENT, aLine);
2808
266
      fxPushNodeStruct(parser, 1, XS_TOKEN_BODY, aLine);
2809
      
2810
266
      fxPushNodeStruct(parser, 3, XS_TOKEN_FUNCTION, aLine);
2811
266
      parser->root->flags = mxStrictFlag | mxDerivedFlag | mxMethodFlag | mxTargetFlag | mxSuperFlag;
2812
266
    }
2813
44.1k
    else {
2814
44.1k
      fxPushNULL(parser);
2815
    
2816
44.1k
      fxPushNodeList(parser, 0);
2817
44.1k
      fxPushNodeStruct(parser, 1, XS_TOKEN_PARAMS_BINDING, aLine);
2818
      
2819
44.1k
      fxPushNodeStruct(parser, 0, XS_TOKEN_UNDEFINED, aLine);
2820
44.1k
      fxPushNodeStruct(parser, 1, XS_TOKEN_STATEMENT, aLine);
2821
44.1k
      fxPushNodeStruct(parser, 1, XS_TOKEN_BODY, aLine);
2822
      
2823
44.1k
      fxPushNodeStruct(parser, 3, XS_TOKEN_FUNCTION, aLine);
2824
44.1k
      parser->root->flags = mxStrictFlag | mxBaseFlag | mxMethodFlag | mxTargetFlag;
2825
44.1k
    }
2826
44.4k
  }
2827
44.5k
  fxPushNodeStruct(parser, 6, XS_TOKEN_CLASS, aLine);
2828
44.5k
  parser->flags = flags | (parser->flags & (mxArgumentsFlag));
2829
44.5k
}
2830
2831
void fxFunctionExpression(txParser* parser, txInteger theLine, txSymbol** theSymbol, txUnsigned flag)
2832
128k
{
2833
128k
  txUnsigned flags = parser->flags;
2834
128k
  parser->flags = (flags & (mxParserFlags | mxStrictFlag)) | mxFunctionFlag | mxTargetFlag | flag;
2835
128k
  if ((parser->states[0].token == XS_TOKEN_IDENTIFIER)
2836
37.3k
      || ((flags & mxGeneratorFlag) && !(flags & mxStrictFlag) && (parser->states[0].token == XS_TOKEN_YIELD))
2837
91.5k
      || ((theSymbol == C_NULL) && (parser->states[0].token == XS_TOKEN_AWAIT))) {
2838
91.5k
    fxPushSymbol(parser, parser->states[0].symbol);
2839
91.5k
    if (theSymbol)
2840
1.75k
      *theSymbol = parser->states[0].symbol;
2841
91.5k
    fxCheckStrictSymbol(parser, parser->states[0].symbol);
2842
91.5k
    fxGetNextToken(parser);
2843
91.5k
  }
2844
37.3k
  else
2845
37.3k
    fxPushNULL(parser);
2846
128k
  fxParametersBinding(parser);
2847
128k
  if (parser->states[0].token == XS_TOKEN_HOST) {
2848
0
    fxGetNextToken(parser);
2849
0
    if (parser->states[0].token == XS_TOKEN_STRING) {
2850
0
      fxPushStringNode(parser, parser->states[0].stringLength, parser->states[0].string, theLine);
2851
0
      fxGetNextToken(parser);
2852
0
    }
2853
0
    else {
2854
0
      fxReportParserError(parser, parser->states[0].line, "invalid host function");
2855
0
      fxPushNULL(parser);
2856
0
    }
2857
0
    fxPushNodeStruct(parser, 3, XS_TOKEN_HOST, theLine);
2858
0
        parser->root->flags = parser->flags & (mxStrictFlag | mxNotSimpleParametersFlag | mxTargetFlag | mxArgumentsFlag | mxEvalFlag | flag);
2859
0
        if (!(flags & mxStrictFlag) && (parser->flags & mxStrictFlag))
2860
0
            fxCheckStrictFunction(parser, (txFunctionNode*)parser->root);
2861
0
        parser->flags = flags;
2862
0
  }
2863
128k
  else {
2864
128k
    fxMatchToken(parser, XS_TOKEN_LEFT_BRACE);
2865
128k
    fxBody(parser);
2866
128k
    fxPushNodeStruct(parser, 1, XS_TOKEN_BODY, theLine);
2867
128k
    fxPushNodeStruct(parser, 3, XS_TOKEN_FUNCTION, theLine);
2868
128k
        parser->root->flags = parser->flags & (mxStrictFlag | mxNotSimpleParametersFlag | mxTargetFlag | mxArgumentsFlag | mxEvalFlag | flag);
2869
128k
        if (!(flags & mxStrictFlag) && (parser->flags & mxStrictFlag))
2870
672
            fxCheckStrictFunction(parser, (txFunctionNode*)parser->root);
2871
128k
        parser->flags = flags;
2872
128k
        fxMatchToken(parser, XS_TOKEN_RIGHT_BRACE);
2873
128k
  }
2874
128k
}
2875
2876
void fxGeneratorExpression(txParser* parser, txInteger theLine, txSymbol** theSymbol, txUnsigned flag)
2877
3.24k
{
2878
3.24k
  txUnsigned flags = parser->flags;
2879
3.24k
  parser->flags = (flags & (mxParserFlags | mxStrictFlag)) | mxGeneratorFlag | mxTargetFlag | flag;
2880
3.24k
  if ((parser->states[0].token == XS_TOKEN_IDENTIFIER)
2881
2.19k
      || ((theSymbol == C_NULL) && (parser->states[0].token == XS_TOKEN_AWAIT))) {
2882
1.05k
    fxPushSymbol(parser, parser->states[0].symbol);
2883
1.05k
    if (theSymbol)
2884
760
      *theSymbol = parser->states[0].symbol;
2885
294
    else if (parser->states[0].symbol == parser->yieldSymbol)
2886
1
      fxReportParserError(parser, parser->states[0].line, "invalid yield");
2887
293
    else if ((parser->flags & mxAsyncFlag) && (parser->states[0].symbol == parser->awaitSymbol))
2888
0
      fxReportParserError(parser, parser->states[0].line, "invalid await");
2889
1.05k
    fxCheckStrictSymbol(parser, parser->states[0].symbol);
2890
1.05k
    fxGetNextToken(parser);
2891
1.05k
  }
2892
2.19k
  else
2893
2.19k
    fxPushNULL(parser);
2894
3.24k
  fxParametersBinding(parser);
2895
3.24k
  fxMatchToken(parser, XS_TOKEN_LEFT_BRACE);
2896
3.24k
  parser->flags |= mxYieldFlag;
2897
3.24k
    fxBody(parser);
2898
3.24k
  parser->flags &= ~mxYieldFlag;
2899
3.24k
  fxPushNodeStruct(parser, 1, XS_TOKEN_BODY, theLine);
2900
3.24k
  fxPushNodeStruct(parser, 3, XS_TOKEN_GENERATOR, theLine);
2901
3.24k
  parser->root->flags = parser->flags & (mxStrictFlag | mxNotSimpleParametersFlag | mxGeneratorFlag | mxArgumentsFlag | mxEvalFlag | flag);
2902
3.24k
  if (!(flags & mxStrictFlag) && (parser->flags & mxStrictFlag))
2903
199
    fxCheckStrictFunction(parser, (txFunctionNode*)parser->root);
2904
3.24k
  parser->flags = flags;
2905
3.24k
    fxMatchToken(parser, XS_TOKEN_RIGHT_BRACE);
2906
3.24k
}
2907
2908
void fxGroupExpression(txParser* parser, txUnsigned flag)
2909
132k
{
2910
132k
  txBoolean commaFlag = 0;
2911
132k
  txBoolean spreadFlag = 0;
2912
132k
  txInteger aCount = 0;
2913
132k
  txInteger aLine;
2914
132k
  txUnsigned formerAwaitingYieldingFlags = parser->flags & (mxAwaitingFlag | mxYieldingFlag);
2915
132k
  parser->flags &= ~(mxAwaitingFlag | mxYieldingFlag);
2916
132k
  fxMatchToken(parser, XS_TOKEN_LEFT_PARENTHESIS);
2917
206k
  while ((parser->states[0].token == XS_TOKEN_SPREAD) || (gxTokenFlags[parser->states[0].token] & XS_TOKEN_BEGIN_EXPRESSION)) {
2918
112k
    aLine = parser->states[0].line;
2919
112k
    commaFlag = 0;
2920
112k
    if (parser->states[0].token == XS_TOKEN_SPREAD) {
2921
17
      fxGetNextToken(parser);
2922
17
      fxAssignmentExpression(parser);
2923
17
      fxPushNodeStruct(parser, 1, XS_TOKEN_SPREAD, aLine);
2924
17
      spreadFlag = 1;
2925
17
    }
2926
112k
    else
2927
112k
      fxAssignmentExpression(parser);
2928
112k
    aCount++;
2929
112k
    if (parser->states[0].token != XS_TOKEN_COMMA) 
2930
38.5k
      break;
2931
73.5k
    fxGetNextToken(parser);
2932
73.5k
    commaFlag = 1;
2933
73.5k
  }
2934
132k
  aLine = parser->states[0].line;
2935
132k
  fxMatchToken(parser, XS_TOKEN_RIGHT_PARENTHESIS);
2936
132k
  if ((!parser->states[0].crlf) && (parser->states[0].token == XS_TOKEN_ARROW)) {
2937
23.1k
    fxPushNodeList(parser, aCount);
2938
23.1k
    fxPushNodeStruct(parser, 1, XS_TOKEN_EXPRESSIONS, aLine);
2939
23.1k
    if (commaFlag && spreadFlag)
2940
0
      fxReportParserError(parser, parser->states[0].line, "invalid parameters");
2941
23.1k
    if (!fxParametersBindingFromExpressions(parser, parser->root))
2942
27
      fxReportParserError(parser, parser->states[0].line, "no parameters");
2943
23.1k
    fxCheckStrictBinding(parser, parser->root);
2944
23.1k
    parser->root->flags |= flag;
2945
23.1k
    if (parser->flags & mxAwaitingFlag) {
2946
7
      if (flag || (parser->flags & mxAsyncFlag))
2947
0
        fxReportParserError(parser, parser->states[0].line, "invalid await");
2948
7
      else
2949
7
        formerAwaitingYieldingFlags |= mxAwaitingFlag;
2950
7
    }
2951
23.1k
    if (parser->flags & mxYieldingFlag)
2952
0
      fxReportParserError(parser, parser->states[0].line, "invalid yield");
2953
23.1k
    fxArrowExpression(parser, flag);
2954
23.1k
  }
2955
109k
  else if (flag) {
2956
585
    fxPushNodeList(parser, aCount);
2957
585
    fxPushNodeStruct(parser, 1, XS_TOKEN_PARAMS, aLine);
2958
585
    if (spreadFlag)
2959
1
      parser->root->flags |= mxSpreadFlag;
2960
    
2961
585
    fxPushSymbol(parser, parser->asyncSymbol);
2962
585
    fxPushNodeStruct(parser, 1, XS_TOKEN_ACCESS, aLine);
2963
585
    fxSwapNodes(parser);
2964
585
    fxPushNodeStruct(parser, 2, XS_TOKEN_CALL, aLine);
2965
585
  }
2966
108k
  else {
2967
108k
        if ((aCount == 0) || commaFlag) {
2968
1.39k
            fxPushNULL(parser);
2969
1.39k
      fxReportParserError(parser, parser->states[0].line, "missing expression");
2970
1.39k
        }
2971
107k
    else /*if (aCount > 1)*/ {
2972
107k
      fxPushNodeList(parser, aCount);
2973
107k
      fxPushNodeStruct(parser, 1, XS_TOKEN_EXPRESSIONS, aLine);
2974
107k
    }
2975
108k
  }
2976
132k
  parser->flags |= formerAwaitingYieldingFlags;
2977
132k
}
2978
2979
void fxNewExpression(txParser* parser)
2980
26.8k
{
2981
26.8k
  txInteger aLine = parser->states[0].line;
2982
26.8k
  fxMatchToken(parser, XS_TOKEN_NEW);
2983
26.8k
  if (parser->states[0].token == XS_TOKEN_DOT) {
2984
528
    fxGetNextToken(parser);
2985
528
    if (fxIsKeyword(parser, parser->targetSymbol)) {
2986
5
      if (!(parser->flags & mxTargetFlag))
2987
1
        fxReportParserError(parser, parser->states[0].line, "invalid new.target");
2988
5
      fxGetNextToken(parser);
2989
5
      fxPushNodeStruct(parser, 0, XS_TOKEN_TARGET, aLine);
2990
5
    }
2991
523
    else
2992
523
      fxReportParserError(parser, parser->states[0].line, "missing target");
2993
528
    return;
2994
528
  }
2995
26.3k
  fxLiteralExpression(parser, 1);
2996
26.3k
  fxCheckArrowFunction(parser, 1);
2997
27.7k
  for (;;) {
2998
27.7k
    txInteger aMemberLine = parser->states[0].line;
2999
27.7k
    if (parser->states[0].token == XS_TOKEN_DOT) {
3000
2.63k
      fxGetNextToken(parser);
3001
2.63k
      if (parser->states[0].token == XS_TOKEN_IDENTIFIER) {
3002
2.28k
        fxPushSymbol(parser, parser->states[0].symbol);
3003
2.28k
        fxPushNodeStruct(parser, 2, XS_TOKEN_MEMBER, aMemberLine);
3004
2.28k
        fxGetNextToken(parser);
3005
2.28k
      }
3006
356
      else if (parser->states[0].token == XS_TOKEN_PRIVATE_IDENTIFIER) {
3007
351
        fxPushSymbol(parser, parser->states[0].symbol);
3008
351
        fxSwapNodes(parser);
3009
351
        fxPushNodeStruct(parser, 2, XS_TOKEN_PRIVATE_MEMBER, aMemberLine);
3010
351
        fxGetNextToken(parser);
3011
351
      }
3012
5
      else
3013
5
        fxReportParserError(parser, parser->states[0].line, "missing property");
3014
2.63k
    }
3015
25.1k
    else if (parser->states[0].token == XS_TOKEN_LEFT_BRACKET) {
3016
16
      fxGetNextToken(parser);
3017
16
      fxCommaExpression(parser);
3018
16
      fxPushNodeStruct(parser, 2, XS_TOKEN_MEMBER_AT, aMemberLine);
3019
16
      fxMatchToken(parser, XS_TOKEN_RIGHT_BRACKET);
3020
16
    }
3021
25.1k
    else if (parser->states[0].token == XS_TOKEN_TEMPLATE) {
3022
182
      fxPushStringNode(parser, parser->states[0].stringLength, parser->states[0].string, aLine);
3023
182
      fxPushRawNode(parser, parser->states[0].rawLength, parser->states[0].raw, aLine);
3024
182
      fxPushNodeStruct(parser, 2, XS_TOKEN_TEMPLATE_MIDDLE, aLine);
3025
182
      fxGetNextToken(parser);
3026
182
      fxPushNodeList(parser, 1);
3027
182
      fxPushNodeStruct(parser, 2, XS_TOKEN_TEMPLATE, aLine);
3028
182
    }
3029
24.9k
    else if (parser->states[0].token == XS_TOKEN_TEMPLATE_HEAD) {
3030
6
      fxTemplateExpression(parser);
3031
6
      fxPushNodeStruct(parser, 2, XS_TOKEN_TEMPLATE, aLine);
3032
6
    }
3033
24.9k
    else
3034
24.9k
      break;
3035
27.7k
  } 
3036
26.3k
  if (parser->states[0].token == XS_TOKEN_LEFT_PARENTHESIS)
3037
21.1k
    fxParameters(parser);
3038
5.21k
  else {
3039
5.21k
    fxPushNodeList(parser, 0);
3040
5.21k
    fxPushNodeStruct(parser, 1, XS_TOKEN_PARAMS, aLine);
3041
5.21k
  }
3042
26.3k
  fxPushNodeStruct(parser, 2, XS_TOKEN_NEW, aLine);
3043
26.3k
}
3044
3045
void fxObjectExpression(txParser* parser)
3046
50.4k
{
3047
50.4k
  txInteger aCount = 0;
3048
50.4k
  txSymbol* aSymbol;
3049
50.4k
  txToken aToken0;
3050
50.4k
  txToken aToken1;
3051
50.4k
  txToken aToken2;
3052
50.4k
  txInteger aLine = parser->states[0].line;
3053
50.4k
  txNode* base = parser->root;
3054
50.4k
  fxMatchToken(parser, XS_TOKEN_LEFT_BRACE);
3055
108k
  for (;;) {
3056
108k
    txInteger aPropertyLine = parser->states[0].line;
3057
108k
    txUnsigned flags = 0;
3058
108k
        if (parser->states[0].token == XS_TOKEN_RIGHT_BRACE)
3059
13.0k
            break;
3060
95.1k
        if (parser->states[0].token == XS_TOKEN_SPREAD) {
3061
686
      fxGetNextToken(parser);
3062
686
      fxAssignmentExpression(parser);
3063
686
      fxPushNodeStruct(parser, 1, XS_TOKEN_SPREAD, aPropertyLine);
3064
686
        }
3065
94.4k
        else {
3066
94.4k
      fxPropertyName(parser, &aSymbol, &aToken0, &aToken1, &aToken2, &flags);
3067
94.4k
      if (aToken1 == XS_TOKEN_PRIVATE_PROPERTY) {
3068
298
        fxReportParserError(parser, parser->states[0].line, "invalid private property");
3069
298
      }
3070
94.1k
      else if ((aToken2 == XS_TOKEN_GETTER) || (aToken2 == XS_TOKEN_SETTER)) {
3071
394
        flags |= mxShorthandFlag;
3072
394
        if (aToken2 == XS_TOKEN_GETTER)
3073
292
          flags |= mxGetterFlag;
3074
102
        else if (aToken2 == XS_TOKEN_SETTER)
3075
102
          flags |= mxSetterFlag;
3076
394
        if (parser->states[0].token == XS_TOKEN_LEFT_PARENTHESIS)
3077
394
          fxFunctionExpression(parser, aPropertyLine, C_NULL, mxSuperFlag);
3078
0
        else
3079
0
          fxReportParserError(parser, parser->states[0].line, "missing (");
3080
394
      }
3081
93.7k
      else if (aToken2 == XS_TOKEN_GENERATOR) {
3082
1.33k
        flags |= mxShorthandFlag | mxMethodFlag;
3083
1.33k
        if (parser->states[0].token == XS_TOKEN_LEFT_PARENTHESIS)
3084
478
          fxGeneratorExpression(parser, aPropertyLine, C_NULL, mxSuperFlag | flags);
3085
860
        else
3086
860
          fxReportParserError(parser, parser->states[0].line, "missing (");
3087
1.33k
      }
3088
92.4k
      else if (aToken2 == XS_TOKEN_FUNCTION) {
3089
30
        flags |= mxShorthandFlag | mxMethodFlag;
3090
30
        if (parser->states[0].token == XS_TOKEN_LEFT_PARENTHESIS)
3091
29
          fxFunctionExpression(parser, aPropertyLine, C_NULL, mxSuperFlag | flags);
3092
1
        else
3093
1
          fxReportParserError(parser, parser->states[0].line, "missing (");
3094
30
      }
3095
92.3k
      else if (parser->states[0].token == XS_TOKEN_LEFT_PARENTHESIS) {
3096
2.05k
        flags |= mxShorthandFlag | mxMethodFlag;
3097
2.05k
        fxFunctionExpression(parser, aPropertyLine, C_NULL, mxSuperFlag | flags);
3098
2.05k
      }
3099
90.3k
      else if (parser->states[0].token == XS_TOKEN_COLON) {
3100
84.8k
        fxGetNextToken(parser);
3101
84.8k
        fxAssignmentExpression(parser);
3102
84.8k
      }
3103
5.45k
      else if (aToken1 == XS_TOKEN_PROPERTY) {
3104
2.92k
        flags |= mxShorthandFlag;
3105
2.92k
        fxPushSymbol(parser, aSymbol);
3106
2.92k
        if (parser->states[0].token == XS_TOKEN_ASSIGN) {
3107
869
          fxPushNodeStruct(parser, 1, XS_TOKEN_ACCESS, aPropertyLine);
3108
869
          fxGetNextToken(parser);
3109
869
          fxAssignmentExpression(parser);
3110
869
          fxPushNodeStruct(parser, 2, XS_TOKEN_BINDING, aPropertyLine);
3111
869
        }
3112
2.06k
        else if (aToken0 == XS_TOKEN_IDENTIFIER) {
3113
923
          fxPushNodeStruct(parser, 1, XS_TOKEN_ACCESS, aPropertyLine);
3114
923
        }
3115
1.13k
        else {
3116
1.13k
          fxReportParserError(parser, parser->states[0].line, "invalid identifier");
3117
1.13k
          fxPushNodeStruct(parser, 0, XS_TOKEN_UNDEFINED, aPropertyLine);
3118
1.13k
        }
3119
2.92k
      }
3120
2.52k
      else {
3121
2.52k
        fxReportParserError(parser, parser->states[0].line, "missing :");
3122
2.52k
        fxPushNodeStruct(parser, 0, XS_TOKEN_UNDEFINED, aPropertyLine);
3123
2.52k
      }
3124
94.4k
      fxPushNodeStruct(parser, 2, aToken1, aPropertyLine);
3125
94.4k
      parser->root->flags |= flags;
3126
94.4k
      fxCheckUniqueProperty(parser, base, parser->root); 
3127
94.4k
    }
3128
95.1k
    aCount++;
3129
95.1k
        if (parser->states[0].token == XS_TOKEN_RIGHT_BRACE)
3130
25.6k
            break;
3131
69.4k
    fxMatchToken(parser, XS_TOKEN_COMMA);
3132
69.4k
  }
3133
50.4k
  fxMatchToken(parser, XS_TOKEN_RIGHT_BRACE);
3134
50.4k
  fxPushNodeList(parser, aCount);
3135
50.4k
  fxPushNodeStruct(parser, 1, XS_TOKEN_OBJECT, aLine);
3136
50.4k
}
3137
3138
void fxTemplateExpression(txParser* parser)
3139
669
{
3140
669
  txInteger aCount = 0;
3141
669
  txInteger aLine = parser->states[0].line;
3142
669
  fxPushStringNode(parser, parser->states[0].stringLength, parser->states[0].string, aLine);
3143
669
  fxPushRawNode(parser, parser->states[0].rawLength, parser->states[0].raw, aLine);
3144
669
  fxPushNodeStruct(parser, 2, XS_TOKEN_TEMPLATE_MIDDLE, aLine);
3145
669
  aCount++;
3146
3.43k
  for (;;) {
3147
3.43k
    fxGetNextToken(parser);
3148
3.43k
        if (parser->states[0].token != XS_TOKEN_RIGHT_BRACE) {
3149
2.45k
            fxCommaExpression(parser);
3150
2.45k
            aCount++;
3151
2.45k
        }
3152
3.43k
    if (parser->states[0].token != XS_TOKEN_RIGHT_BRACE) {
3153
1
      fxReportParserError(parser, parser->states[0].line, "missing }");
3154
1
    }
3155
3.43k
    fxGetNextTokenTemplate(parser);
3156
3.43k
    fxPushStringNode(parser, parser->states[0].stringLength, parser->states[0].string, aLine);
3157
3.43k
    fxPushRawNode(parser, parser->states[0].rawLength, parser->states[0].raw, aLine);
3158
3.43k
    fxPushNodeStruct(parser, 2, XS_TOKEN_TEMPLATE_MIDDLE, aLine);
3159
3.43k
    aCount++;
3160
3.43k
    if (parser->states[0].token == XS_TOKEN_TEMPLATE_TAIL) {
3161
656
      fxGetNextToken(parser);
3162
656
      break;
3163
656
    }
3164
3.43k
  }
3165
669
  fxPushNodeList(parser, aCount);
3166
669
}
3167
3168
void fxYieldExpression(txParser* parser)
3169
830
{
3170
830
  txInteger aLine = parser->states[0].line;
3171
830
  if (!(parser->flags & mxYieldFlag))
3172
6
    fxReportParserError(parser, parser->states[0].line, "invalid yield");
3173
824
  else
3174
824
    parser->flags |= mxYieldingFlag;
3175
830
  fxMatchToken(parser, XS_TOKEN_YIELD);
3176
830
  if ((!parser->states[0].crlf) && (parser->states[0].token == XS_TOKEN_MULTIPLY)) {
3177
36
    fxGetNextToken(parser);
3178
36
    fxAssignmentExpression(parser);
3179
36
    fxPushNodeStruct(parser, 1, XS_TOKEN_DELEGATE, aLine);
3180
36
    return;
3181
36
  }
3182
794
  if ((!parser->states[0].crlf) && (gxTokenFlags[parser->states[0].token] & XS_TOKEN_BEGIN_EXPRESSION)) {
3183
754
    fxAssignmentExpression(parser);
3184
754
  }
3185
40
  else {
3186
40
    fxPushNodeStruct(parser, 0, XS_TOKEN_UNDEFINED, aLine);
3187
40
  }
3188
794
  fxPushNodeStruct(parser, 1, XS_TOKEN_YIELD, aLine);
3189
794
}
3190
3191
void fxParameters(txParser* parser)
3192
189k
{
3193
189k
  txInteger aCount = 0;
3194
189k
  txInteger aLine = parser->states[0].line;
3195
189k
  txBoolean aSpreadFlag = 0;
3196
189k
  fxMatchToken(parser, XS_TOKEN_LEFT_PARENTHESIS);
3197
463k
  while ((parser->states[0].token == XS_TOKEN_SPREAD) || (gxTokenFlags[parser->states[0].token] & XS_TOKEN_BEGIN_EXPRESSION)) {
3198
273k
    txInteger aParamLine = parser->states[0].line;
3199
273k
    if (parser->states[0].token == XS_TOKEN_SPREAD) {
3200
120
      fxGetNextToken(parser);
3201
120
      fxAssignmentExpression(parser);
3202
120
      fxPushNodeStruct(parser, 1, XS_TOKEN_SPREAD, aParamLine);
3203
120
      aSpreadFlag = 1;
3204
120
    }
3205
273k
    else
3206
273k
      fxAssignmentExpression(parser);
3207
273k
    aCount++;
3208
273k
    if (parser->states[0].token != XS_TOKEN_RIGHT_PARENTHESIS)
3209
115k
      fxMatchToken(parser, XS_TOKEN_COMMA);
3210
273k
  }
3211
189k
  fxMatchToken(parser, XS_TOKEN_RIGHT_PARENTHESIS);
3212
189k
  fxPushNodeList(parser, aCount);
3213
189k
  fxPushNodeStruct(parser, 1, XS_TOKEN_PARAMS, aLine);
3214
189k
  if (aSpreadFlag)
3215
107
    parser->root->flags |= mxSpreadFlag;
3216
189k
}
3217
3218
void fxPropertyName(txParser* parser, txSymbol** theSymbol, txToken* theToken0, txToken* theToken1, txToken* theToken2, txUnsigned* flag)
3219
123k
{
3220
123k
  txSymbol* aSymbol = C_NULL;
3221
123k
  txToken aToken0 = XS_NO_TOKEN;
3222
123k
  txToken aToken1 = XS_NO_TOKEN;
3223
123k
  txToken aToken2 = XS_NO_TOKEN;
3224
123k
  txInteger aLine = parser->states[0].line;
3225
123k
  txIndex index;
3226
123k
  *flag = 0;
3227
123k
  fxLookAheadOnce(parser);
3228
123k
  aToken0 = parser->states[0].token;
3229
123k
  if ((gxTokenFlags[aToken0] & XS_TOKEN_IDENTIFIER_NAME)) {
3230
99.0k
    aSymbol = parser->states[0].symbol;
3231
99.0k
    if (parser->states[1].token == XS_TOKEN_COLON) {
3232
81.5k
      fxPushSymbol(parser, aSymbol);
3233
81.5k
      aToken1 = XS_TOKEN_PROPERTY;
3234
81.5k
    }
3235
17.5k
    else if (fxIsKeyword(parser, parser->asyncSymbol) && (!parser->states[1].crlf)) {
3236
2.16k
      *flag = mxAsyncFlag;
3237
2.16k
      fxGetNextToken(parser);
3238
2.16k
      if (parser->states[0].token == XS_TOKEN_MULTIPLY) {
3239
1.33k
        aToken2 = XS_TOKEN_GENERATOR;
3240
1.33k
        fxGetNextToken(parser);
3241
1.33k
      }
3242
823
      else
3243
823
        aToken2 = XS_TOKEN_FUNCTION;
3244
2.16k
    }
3245
15.3k
    else if (fxIsKeyword(parser, parser->getSymbol)) {
3246
745
      aToken2 = XS_TOKEN_GETTER;
3247
745
      fxGetNextToken(parser);
3248
745
    }
3249
14.6k
    else if (fxIsKeyword(parser, parser->setSymbol)) {
3250
1.20k
      aToken2 = XS_TOKEN_SETTER;
3251
1.20k
      fxGetNextToken(parser);
3252
1.20k
    }
3253
13.4k
    else {
3254
13.4k
      fxPushSymbol(parser, aSymbol);
3255
13.4k
      aToken1 = XS_TOKEN_PROPERTY;
3256
13.4k
    }
3257
99.0k
  }
3258
24.8k
  else if (parser->states[0].token == XS_TOKEN_MULTIPLY) {
3259
4.63k
    aToken2 = XS_TOKEN_GENERATOR;
3260
4.63k
    fxGetNextToken(parser);
3261
4.63k
  }
3262
20.2k
  else if (parser->states[0].token == XS_TOKEN_PRIVATE_IDENTIFIER) {
3263
3.77k
    aSymbol = parser->states[0].symbol;
3264
3.77k
    fxPushSymbol(parser, aSymbol);
3265
3.77k
    aToken1 = XS_TOKEN_PRIVATE_PROPERTY;
3266
3.77k
  }
3267
16.4k
  else if (parser->states[0].token == XS_TOKEN_INTEGER) {
3268
6.95k
    if (fxIntegerToIndex(parser->console, parser->states[0].integer, &index)) {
3269
6.95k
      fxPushIndexNode(parser, index, aLine);
3270
6.95k
      aToken1 = XS_TOKEN_PROPERTY_AT;
3271
6.95k
    }
3272
0
    else {
3273
0
      aSymbol = fxNewParserSymbol(parser, fxIntegerToString(parser->console, parser->states[0].integer, parser->buffer, parser->bufferSize));
3274
0
      fxPushSymbol(parser, aSymbol);
3275
0
      aToken1 = XS_TOKEN_PROPERTY;
3276
0
    }
3277
6.95k
  }
3278
9.53k
  else if (parser->states[0].token == XS_TOKEN_NUMBER) {
3279
530
    if (fxNumberToIndex(parser->console, parser->states[0].number, &index)) {
3280
46
      fxPushIndexNode(parser, index, aLine);
3281
46
      aToken1 = XS_TOKEN_PROPERTY_AT;
3282
46
    }
3283
484
    else {
3284
484
      aSymbol = fxNewParserSymbol(parser, fxNumberToString(parser->console, parser->states[0].number, parser->buffer, parser->bufferSize, 0, 0));
3285
484
      fxPushSymbol(parser, aSymbol);
3286
484
      aToken1 = XS_TOKEN_PROPERTY;
3287
484
    }
3288
530
  }
3289
9.00k
  else if (parser->states[0].token == XS_TOKEN_STRING) {
3290
4.19k
    if (fxStringToIndex(parser->console, parser->states[0].string, &index)) {
3291
959
      fxPushIndexNode(parser, index, aLine);
3292
959
      aToken1 = XS_TOKEN_PROPERTY_AT;
3293
959
    }
3294
3.23k
    else {
3295
3.23k
      aSymbol = fxNewParserSymbol(parser, parser->states[0].string);
3296
3.23k
      fxPushSymbol(parser, aSymbol);
3297
3.23k
      aToken1 = XS_TOKEN_PROPERTY;
3298
3.23k
    }
3299
4.19k
  }
3300
4.81k
  else if (parser->states[0].token == XS_TOKEN_LEFT_BRACKET) {
3301
1.88k
    fxGetNextToken(parser);
3302
1.88k
    fxCommaExpression(parser);
3303
1.88k
    if (parser->states[0].token != XS_TOKEN_RIGHT_BRACKET) {
3304
460
      fxReportParserError(parser, parser->states[0].line, "missing ]");
3305
460
    }
3306
1.88k
    aToken1 = XS_TOKEN_PROPERTY_AT;
3307
1.88k
  }
3308
2.92k
  else {
3309
2.92k
    fxReportParserError(parser, parser->states[0].line, "missing identifier");
3310
2.92k
    fxPushNULL(parser);
3311
2.92k
  }
3312
123k
  if (aToken2 != XS_NO_TOKEN) {
3313
8.74k
    if ((gxTokenFlags[parser->states[0].token] & XS_TOKEN_IDENTIFIER_NAME)) {
3314
2.88k
      aSymbol = parser->states[0].symbol;
3315
2.88k
      fxPushSymbol(parser, aSymbol);
3316
2.88k
      aToken1 = XS_TOKEN_PROPERTY;
3317
2.88k
      fxGetNextToken(parser);
3318
2.88k
    }
3319
5.85k
    else if (parser->states[0].token == XS_TOKEN_PRIVATE_IDENTIFIER) {
3320
527
      aSymbol = parser->states[0].symbol;
3321
527
      fxPushSymbol(parser, aSymbol);
3322
527
      aToken1 = XS_TOKEN_PRIVATE_PROPERTY;
3323
527
      fxGetNextToken(parser);
3324
527
    }
3325
5.32k
    else if (parser->states[0].token == XS_TOKEN_INTEGER) {
3326
672
      if (fxIntegerToIndex(parser->console, parser->states[0].integer, &index)) {
3327
672
        fxPushIndexNode(parser, index, aLine);
3328
672
        aToken1 = XS_TOKEN_PROPERTY_AT;
3329
672
      }
3330
0
      else {
3331
0
        aSymbol = fxNewParserSymbol(parser, fxIntegerToString(parser->console, parser->states[0].integer, parser->buffer, parser->bufferSize));
3332
0
        fxPushSymbol(parser, aSymbol);
3333
0
        aToken1 = XS_TOKEN_PROPERTY;
3334
0
      }
3335
672
      fxGetNextToken(parser);
3336
672
    }
3337
4.65k
    else if (parser->states[0].token == XS_TOKEN_NUMBER) {
3338
2.36k
      if (fxNumberToIndex(parser->console, parser->states[0].number, &index)) {
3339
2.35k
        fxPushIndexNode(parser, index, aLine);
3340
2.35k
        aToken1 = XS_TOKEN_PROPERTY_AT;
3341
2.35k
      }
3342
5
      else {
3343
5
        aSymbol = fxNewParserSymbol(parser, fxNumberToString(parser->console, parser->states[0].number, parser->buffer, parser->bufferSize, 0, 0));
3344
5
        fxPushSymbol(parser, aSymbol);
3345
5
        aToken1 = XS_TOKEN_PROPERTY;
3346
5
      }
3347
2.36k
      fxGetNextToken(parser);
3348
2.36k
    }
3349
2.29k
    else if (parser->states[0].token == XS_TOKEN_STRING) {
3350
297
      if (fxStringToIndex(parser->console, parser->states[0].string, &index)) {
3351
23
        fxPushIndexNode(parser, index, aLine);
3352
23
        aToken1 = XS_TOKEN_PROPERTY_AT;
3353
23
      }
3354
274
      else {
3355
274
        aSymbol = fxNewParserSymbol(parser, parser->states[0].string);
3356
274
        fxPushSymbol(parser, aSymbol);
3357
274
        aToken1 = XS_TOKEN_PROPERTY;
3358
274
      }
3359
297
      fxGetNextToken(parser);
3360
297
    }
3361
1.99k
    else if (parser->states[0].token == XS_TOKEN_LEFT_BRACKET) {
3362
55
      fxGetNextToken(parser);
3363
55
      fxCommaExpression(parser);
3364
55
      if (parser->states[0].token != XS_TOKEN_RIGHT_BRACKET) {
3365
0
        fxReportParserError(parser, parser->states[0].line, "missing ]");
3366
0
      }
3367
55
      aToken1 = XS_TOKEN_PROPERTY_AT;
3368
55
      fxGetNextToken(parser);
3369
55
    }
3370
1.94k
    else if (aToken2 == XS_TOKEN_GETTER) {
3371
310
      fxPushSymbol(parser, aSymbol);
3372
310
      aToken1 = XS_TOKEN_PROPERTY;
3373
310
      aToken2 = XS_NO_TOKEN;
3374
310
    }
3375
1.63k
    else if (aToken2 == XS_TOKEN_SETTER) {
3376
534
      fxPushSymbol(parser, aSymbol);
3377
534
      aToken1 = XS_TOKEN_PROPERTY;
3378
534
      aToken2 = XS_NO_TOKEN;
3379
534
    }
3380
1.10k
    else {
3381
1.10k
      fxReportParserError(parser, parser->states[0].line, "missing identifier");
3382
1.10k
      fxPushNULL(parser);
3383
1.10k
    }
3384
8.74k
  }
3385
115k
  else
3386
115k
    fxGetNextToken(parser);
3387
123k
  *theSymbol = aSymbol;
3388
123k
  *theToken0 = aToken0;
3389
123k
  *theToken1 = aToken1;
3390
123k
  *theToken2 = aToken2;
3391
123k
}
3392
3393
void fxBinding(txParser* parser, txToken theToken, txUnsigned flags)
3394
113k
{
3395
113k
  txInteger aLine = parser->states[0].line;
3396
113k
  fxCheckParserStack(parser, aLine);
3397
113k
  if (parser->states[0].token == XS_TOKEN_IDENTIFIER) {
3398
91.6k
    fxCheckStrictSymbol(parser, parser->states[0].symbol);
3399
91.6k
    if (((theToken == XS_TOKEN_CONST) || (theToken == XS_TOKEN_LET) || (theToken == XS_TOKEN_USING)) && (parser->states[0].symbol == parser->letSymbol))
3400
17
      fxReportParserError(parser, parser->states[0].line, "invalid identifier");
3401
91.6k
    fxPushSymbol(parser, parser->states[0].symbol);
3402
91.6k
    fxPushNodeStruct(parser, 1, theToken, aLine);
3403
91.6k
    if (flags & mxAwaitingFlag)
3404
0
      parser->root->flags |= mxAwaitingFlag;
3405
91.6k
    fxGetNextToken(parser);
3406
91.6k
  }
3407
21.7k
  else if (parser->states[0].token == XS_TOKEN_LEFT_BRACE) {
3408
5.69k
    if (theToken == XS_TOKEN_USING)
3409
1
      fxReportParserError(parser, parser->states[0].line, "invalid using");
3410
5.69k
    fxObjectBinding(parser, theToken);
3411
5.69k
  }
3412
16.0k
  else if (parser->states[0].token == XS_TOKEN_LEFT_BRACKET) {
3413
13.9k
    if (theToken == XS_TOKEN_USING)
3414
1
      fxReportParserError(parser, parser->states[0].line, "invalid using");
3415
13.9k
    fxArrayBinding(parser, theToken);
3416
13.9k
  }
3417
2.15k
  else {
3418
2.15k
    fxReportParserError(parser, parser->states[0].line, "missing identifier");
3419
2.15k
    fxPushNULL(parser);
3420
2.15k
  }
3421
113k
  if ((flags & 1) && (parser->states[0].token == XS_TOKEN_ASSIGN)) {
3422
49.9k
    parser->flags &= ~mxForFlag;
3423
49.9k
    fxGetNextToken(parser);
3424
49.9k
    fxAssignmentExpression(parser);
3425
49.9k
    fxPushNodeStruct(parser, 2, XS_TOKEN_BINDING, aLine);
3426
49.9k
  }
3427
113k
}
3428
3429
txNode* fxBindingFromExpression(txParser* parser, txNode* theNode, txToken theToken)
3430
6.84k
{
3431
6.84k
  txToken aToken = (theNode && theNode->description) ? theNode->description->token : XS_NO_TOKEN;
3432
6.84k
  txNode* binding;
3433
6.85k
again:
3434
6.85k
  if (aToken == XS_TOKEN_EXPRESSIONS) {
3435
149
    txNode* item = ((txExpressionsNode*)theNode)->items->first;
3436
149
    if (item && !item->next) {
3437
148
      aToken = item->description->token;
3438
148
      if ((aToken == XS_TOKEN_ACCESS) || (aToken == XS_TOKEN_MEMBER) || (aToken == XS_TOKEN_MEMBER_AT) || (aToken == XS_TOKEN_PRIVATE_MEMBER) || (aToken == XS_TOKEN_UNDEFINED)) {
3439
134
        item->next = theNode->next;
3440
134
        theNode = item;
3441
134
      }
3442
14
      else if (aToken == XS_TOKEN_EXPRESSIONS) {
3443
13
        item->next = theNode->next;
3444
13
        theNode = item;
3445
13
        goto again;
3446
13
      }
3447
1
      else
3448
1
        return NULL;
3449
148
    }
3450
149
  }
3451
6.84k
  if (aToken == XS_TOKEN_BINDING) {
3452
408
    binding = fxBindingFromExpression(parser, ((txBindingNode*)theNode)->target, theToken);
3453
408
    ((txBindingNode*)theNode)->target = binding;
3454
//    fxCheckStrictBinding(parser, theNode);
3455
//    fxCheckStrictSymbol(parser, ((txBindingNode*)theNode)->symbol);
3456
//    theNode->description = &gxTokenDescriptions[theToken];
3457
408
    return theNode;
3458
408
  }
3459
6.43k
  if (aToken == XS_TOKEN_ARRAY_BINDING) {
3460
198
    txNodeList* list = ((txArrayBindingNode*)theNode)->items;
3461
198
    txNode** address = &(list->first);
3462
198
    txNode* item;
3463
2.85k
    while ((item = *address)) {
3464
2.65k
      txNode* binding = *address = fxBindingFromExpression(parser, item, theToken);
3465
2.65k
      binding->next = item->next;
3466
2.65k
      address = &(binding->next);
3467
2.65k
    }
3468
198
    return theNode;
3469
198
  }
3470
6.23k
  if (aToken == XS_TOKEN_OBJECT_BINDING) {
3471
15
    txNodeList* list = ((txObjectBindingNode*)theNode)->items;
3472
15
    txNode** address = &(list->first);
3473
15
    txNode* item;
3474
22
    while ((item = *address)) {
3475
7
      txNode* binding = *address = fxBindingFromExpression(parser, item, theToken);
3476
7
      binding->next = item->next;
3477
7
      address = &(binding->next);
3478
7
    }
3479
15
    return theNode;
3480
15
  }
3481
6.22k
  if (aToken == XS_TOKEN_PROPERTY_BINDING) {
3482
7
    ((txPropertyBindingNode*)theNode)->binding = fxBindingFromExpression(parser, ((txPropertyBindingNode*)theNode)->binding, theToken);
3483
7
    return theNode;
3484
7
  }
3485
6.21k
  if (aToken == XS_TOKEN_PROPERTY_BINDING_AT) {
3486
0
    ((txPropertyBindingAtNode*)theNode)->binding = fxBindingFromExpression(parser, ((txPropertyBindingAtNode*)theNode)->binding, theToken);
3487
0
    return theNode;
3488
0
  }
3489
6.21k
  if (aToken == XS_TOKEN_REST_BINDING) {
3490
19
    ((txRestBindingNode*)theNode)->binding = fxBindingFromExpression(parser, ((txRestBindingNode*)theNode)->binding, theToken);
3491
19
    return theNode;
3492
19
  }
3493
6.19k
  if (aToken == XS_TOKEN_SKIP_BINDING)
3494
1.99k
    return theNode;
3495
  
3496
4.19k
  if (aToken == XS_TOKEN_ACCESS) {
3497
3.10k
    fxCheckStrictSymbol(parser, ((txAccessNode*)theNode)->symbol);
3498
3.10k
    if (theToken == XS_TOKEN_ACCESS)
3499
1.34k
      return theNode;
3500
1.75k
    fxPushSymbol(parser, ((txAccessNode*)theNode)->symbol);
3501
1.75k
    fxPushNodeStruct(parser, 1, theToken, ((txAccessNode*)theNode)->line);
3502
1.75k
    return fxPopNode(parser);
3503
3.10k
  }
3504
1.09k
  if ((aToken == XS_TOKEN_MEMBER) || (aToken == XS_TOKEN_MEMBER_AT) || (aToken == XS_TOKEN_PRIVATE_MEMBER) || (aToken == XS_TOKEN_UNDEFINED)) {
3505
209
    return theNode;
3506
209
  }
3507
886
  if (aToken == XS_TOKEN_ASSIGN) {
3508
115
    binding = fxBindingFromExpression(parser, ((txAssignNode*)theNode)->reference, theToken);
3509
115
    if (!binding)
3510
0
      return NULL;
3511
115
    ((txBindingNode*)theNode)->description = &gxTokenDescriptions[XS_TOKEN_BINDING];
3512
115
    ((txBindingNode*)theNode)->target = binding;
3513
115
    ((txBindingNode*)theNode)->initializer = ((txAssignNode*)theNode)->value;
3514
115
    return theNode;
3515
115
  }
3516
  
3517
771
  if (aToken == XS_TOKEN_ARRAY)
3518
213
    return fxArrayBindingFromExpression(parser, theNode, theToken);
3519
558
  if (aToken == XS_TOKEN_OBJECT)
3520
457
    return fxObjectBindingFromExpression(parser, theNode, theToken);
3521
101
  return NULL;
3522
558
}
3523
3524
void fxArrayBinding(txParser* parser, txToken theToken)
3525
13.9k
{
3526
13.9k
  txInteger aCount = 0;
3527
13.9k
  txInteger aLine = parser->states[0].line;
3528
13.9k
  int elision = 1;
3529
13.9k
  fxCheckParserStack(parser, aLine);
3530
13.9k
  fxMatchToken(parser, XS_TOKEN_LEFT_BRACKET);
3531
48.0k
  while ((parser->states[0].token == XS_TOKEN_COMMA) || (gxTokenFlags[parser->states[0].token] & XS_TOKEN_BEGIN_BINDING)) {
3532
34.1k
    txInteger anItemLine = parser->states[0].line;
3533
34.1k
    if (parser->states[0].token == XS_TOKEN_COMMA) {
3534
24.8k
      fxGetNextToken(parser);
3535
24.8k
      if (elision) {
3536
17.5k
        fxPushNodeStruct(parser, 0, XS_TOKEN_SKIP_BINDING, anItemLine);
3537
17.5k
        aCount++;
3538
17.5k
      }
3539
7.36k
      else
3540
7.36k
        elision = 1;
3541
24.8k
    }
3542
9.24k
    else {
3543
9.24k
      if (!elision)
3544
283
        fxReportParserError(parser, parser->states[0].line, "missing ,");
3545
9.24k
      if (parser->states[0].token == XS_TOKEN_SPREAD) {
3546
4
        fxRestBinding(parser, theToken, 0);
3547
4
        aCount++;
3548
4
        break;
3549
4
      }
3550
9.23k
      fxBinding(parser, theToken, 1);
3551
9.23k
      aCount++;
3552
9.23k
      elision = 0;
3553
9.23k
    }
3554
34.1k
  }
3555
13.9k
  fxMatchToken(parser, XS_TOKEN_RIGHT_BRACKET);
3556
13.9k
  fxPushNodeList(parser, aCount);
3557
13.9k
  fxPushNodeStruct(parser, 1, XS_TOKEN_ARRAY_BINDING, aLine);
3558
13.9k
}
3559
3560
txNode* fxArrayBindingFromExpression(txParser* parser, txNode* theNode, txToken theToken)
3561
832
{
3562
832
  txNodeList* list = ((txArrayNode*)theNode)->items;
3563
832
  txNode** address = &(list->first);
3564
832
  txNode* item;
3565
832
  txNode* binding;
3566
3.21k
  while ((item = *address)) {
3567
2.45k
        if (!item->description) {
3568
0
            parser->errorSymbol = parser->SyntaxErrorSymbol;
3569
0
            return NULL;
3570
0
        }
3571
2.45k
    if (item->description->token == XS_TOKEN_SPREAD) {
3572
33
      if (theNode->flags & mxElisionFlag) {
3573
1
        parser->errorSymbol = parser->SyntaxErrorSymbol;
3574
1
        return NULL;
3575
1
      }
3576
32
      binding = fxRestBindingFromExpression(parser, item, theToken, 0);
3577
32
      if (!binding) {
3578
4
        parser->errorSymbol = parser->SyntaxErrorSymbol;
3579
4
        return NULL;
3580
4
      }
3581
28
      break;
3582
32
    }
3583
2.42k
    if (item->description->token == XS_TOKEN_ELISION) {
3584
1.06k
      item->description = &gxTokenDescriptions[XS_TOKEN_SKIP_BINDING];
3585
1.06k
    }
3586
1.35k
    else {
3587
//      if ((theToken == XS_TOKEN_BINDING) && ((item->description->token== XS_TOKEN_MEMBER) || (item->description->token == XS_TOKEN_MEMBER_AT)))
3588
//        binding = item;
3589
//      else {      
3590
1.35k
        binding = fxBindingFromExpression(parser, item, theToken);
3591
1.35k
        if (!binding) {
3592
35
          parser->errorSymbol = parser->SyntaxErrorSymbol;
3593
35
          return NULL;
3594
35
        }
3595
1.32k
        binding->next = item->next;
3596
1.32k
        item = *address = binding;
3597
//      }
3598
1.32k
    }
3599
2.38k
    address = &(item->next);
3600
2.38k
  }
3601
792
  fxPushNode(parser, (txNode*)list);
3602
792
  fxPushNodeStruct(parser, 1, XS_TOKEN_ARRAY_BINDING, theNode->line);
3603
792
  return fxPopNode(parser);
3604
832
}
3605
3606
txUnsigned fxObjectBinding(txParser* parser, txToken theToken)
3607
5.69k
{
3608
5.69k
  txUnsigned flags = 0;
3609
5.69k
  txInteger aCount = 0;
3610
5.69k
  txInteger aLine = parser->states[0].line;
3611
5.69k
  txSymbol* aSymbol;
3612
5.69k
  txToken aToken;
3613
5.69k
  txIndex index;
3614
5.69k
  fxMatchToken(parser, XS_TOKEN_LEFT_BRACE);
3615
6.07k
  for (;;) {
3616
6.07k
    txInteger aPropertyLine = parser->states[0].line;
3617
6.07k
    if (parser->states[0].token == XS_TOKEN_RIGHT_BRACE)
3618
16
      break;
3619
6.06k
    aSymbol = NULL;
3620
6.06k
    aToken = XS_TOKEN_PROPERTY_BINDING;
3621
6.06k
    if ((gxTokenFlags[parser->states[0].token] & XS_TOKEN_IDENTIFIER_NAME)) {
3622
1.57k
      aSymbol = parser->states[0].symbol;
3623
1.57k
      fxPushSymbol(parser, aSymbol);
3624
1.57k
      aToken = XS_TOKEN_PROPERTY_BINDING;
3625
1.57k
    }
3626
4.48k
    else if (parser->states[0].token == XS_TOKEN_INTEGER) {
3627
810
      if (fxIntegerToIndex(parser->console, parser->states[0].integer, &index)) {
3628
810
        fxPushIndexNode(parser, index, aPropertyLine);
3629
810
        aToken = XS_TOKEN_PROPERTY_BINDING_AT;
3630
810
      }
3631
0
      else {
3632
0
        aSymbol = fxNewParserSymbol(parser, fxIntegerToString(parser->console, parser->states[0].integer, parser->buffer, parser->bufferSize));
3633
0
        fxPushSymbol(parser, aSymbol);
3634
0
        aToken = XS_TOKEN_PROPERTY_BINDING;
3635
0
      }
3636
810
    }
3637
3.67k
    else if (parser->states[0].token == XS_TOKEN_NUMBER) {
3638
2.35k
      if (fxNumberToIndex(parser->console, parser->states[0].number, &index)) {
3639
1
        fxPushIndexNode(parser, index, aPropertyLine);
3640
1
        aToken = XS_TOKEN_PROPERTY_BINDING_AT;
3641
1
      }
3642
2.35k
      else {
3643
2.35k
        aSymbol = fxNewParserSymbol(parser, fxNumberToString(parser->console, parser->states[0].number, parser->buffer, parser->bufferSize, 0, 0));
3644
2.35k
        fxPushSymbol(parser, aSymbol);
3645
2.35k
        aToken = XS_TOKEN_PROPERTY_BINDING;
3646
2.35k
      }
3647
2.35k
    }
3648
1.31k
    else if (parser->states[0].token == XS_TOKEN_STRING) {
3649
50
      if (fxStringToIndex(parser->console, parser->states[0].string, &index)) {
3650
3
        fxPushIndexNode(parser, index, aPropertyLine);
3651
3
        aToken = XS_TOKEN_PROPERTY_BINDING_AT;
3652
3
      }
3653
47
      else {
3654
47
        aSymbol = fxNewParserSymbol(parser, parser->states[0].string);
3655
47
        fxPushSymbol(parser, aSymbol);
3656
47
        aToken = XS_TOKEN_PROPERTY_BINDING;
3657
47
      }
3658
50
    }
3659
1.26k
    else if (parser->states[0].token == XS_TOKEN_LEFT_BRACKET) {
3660
1.07k
      fxGetNextToken(parser);
3661
1.07k
      fxCommaExpression(parser);
3662
1.07k
      if (parser->states[0].token != XS_TOKEN_RIGHT_BRACKET) {
3663
1
        fxReportParserError(parser, parser->states[0].line, "missing ]");
3664
1
      }
3665
1.07k
      aToken = XS_TOKEN_PROPERTY_BINDING_AT;
3666
1.07k
    }
3667
195
    else if (parser->states[0].token == XS_TOKEN_SPREAD) {
3668
28
      flags |= mxSpreadFlag;
3669
28
      fxRestBinding(parser, theToken, 1);
3670
28
      aCount++;
3671
28
            break;
3672
28
    }
3673
167
    else {
3674
167
      fxReportParserError(parser, parser->states[0].line, "missing identifier");
3675
167
      fxPushNULL(parser);
3676
167
    }
3677
6.03k
    fxLookAheadOnce(parser);
3678
6.03k
    if (parser->states[1].token == XS_TOKEN_COLON) {
3679
1.88k
      fxGetNextToken(parser);
3680
1.88k
      fxGetNextToken(parser);
3681
1.88k
      fxBinding(parser, theToken, 1);
3682
1.88k
    }
3683
4.15k
    else if (aSymbol) {
3684
1.57k
      fxBinding(parser, theToken, 1);
3685
1.57k
    }
3686
2.57k
    else {
3687
2.57k
      fxReportParserError(parser, parser->states[0].line, "missing :");
3688
2.57k
      fxPushNULL(parser);
3689
2.57k
    }
3690
6.03k
    fxPushNodeStruct(parser, 2, aToken, aPropertyLine);
3691
6.03k
    aCount++;
3692
6.03k
        if (parser->states[0].token == XS_TOKEN_RIGHT_BRACE)
3693
110
            break;
3694
5.92k
    if (parser->states[0].token == XS_TOKEN_COMMA)
3695
383
      fxGetNextToken(parser);
3696
5.53k
    else
3697
5.53k
            break;
3698
5.92k
  }
3699
5.69k
  fxMatchToken(parser, XS_TOKEN_RIGHT_BRACE);
3700
5.69k
  fxPushNodeList(parser, aCount);
3701
5.69k
  fxPushNodeStruct(parser, 1, XS_TOKEN_OBJECT_BINDING, aLine);
3702
5.69k
  parser->root->flags |= flags;
3703
5.69k
  return flags;
3704
5.69k
}
3705
3706
txNode* fxObjectBindingFromExpression(txParser* parser, txNode* theNode, txToken theToken)
3707
3.78k
{
3708
3.78k
  txNodeList* list = ((txObjectNode*)theNode)->items;
3709
3.78k
  txNode* property = list->first;
3710
3.78k
  txNode* binding;
3711
3.78k
  txUnsigned flags = 0;
3712
4.34k
  while (property) {
3713
825
    if (!property->description) {
3714
0
      parser->errorSymbol = parser->SyntaxErrorSymbol;
3715
0
      return NULL;
3716
0
    }
3717
825
    if (property->description->token == XS_TOKEN_PROPERTY) {
3718
495
      binding = fxBindingFromExpression(parser, ((txPropertyNode*)property)->value, theToken);
3719
495
      if (!binding) {
3720
65
        parser->errorSymbol = parser->SyntaxErrorSymbol;
3721
65
        return NULL;
3722
65
      }
3723
430
      property->description = &gxTokenDescriptions[XS_TOKEN_PROPERTY_BINDING];
3724
430
      ((txPropertyBindingNode*)property)->binding = binding;
3725
430
    }
3726
330
    else if (property->description->token == XS_TOKEN_PROPERTY_AT) {
3727
131
      binding = fxBindingFromExpression(parser, ((txPropertyAtNode*)property)->value, theToken);
3728
131
      if (!binding) {
3729
3
        parser->errorSymbol = parser->SyntaxErrorSymbol;
3730
3
        return NULL;
3731
3
      }
3732
128
      property->description = &gxTokenDescriptions[XS_TOKEN_PROPERTY_BINDING_AT];
3733
128
      ((txPropertyBindingAtNode*)property)->binding = binding;
3734
128
    }
3735
199
    else if (property->description->token == XS_TOKEN_SPREAD) {
3736
199
      binding = fxRestBindingFromExpression(parser, property, theToken, 1);
3737
199
      if (!binding) {
3738
4
        parser->errorSymbol = parser->SyntaxErrorSymbol;
3739
4
        return NULL;
3740
4
      }
3741
195
      flags |= mxSpreadFlag;
3742
195
      break;
3743
199
    }
3744
558
    property = property->next;
3745
558
  }
3746
3.71k
  fxPushNode(parser, (txNode*)list);
3747
3.71k
  fxPushNodeStruct(parser, 1, XS_TOKEN_OBJECT_BINDING, theNode->line);
3748
3.71k
  parser->root->flags |= flags;
3749
3.71k
  return fxPopNode(parser);
3750
3.78k
}
3751
3752
void fxParametersBinding(txParser* parser)
3753
132k
{
3754
132k
  txInteger aCount = 0;
3755
132k
  txInteger aLine = parser->states[0].line;
3756
132k
  txBindingNode* binding;
3757
132k
  if (parser->states[0].token == XS_TOKEN_LEFT_PARENTHESIS) {
3758
131k
    fxGetNextToken(parser);
3759
140k
    while (gxTokenFlags[parser->states[0].token] & XS_TOKEN_BEGIN_BINDING) {
3760
9.25k
      if (parser->states[0].token == XS_TOKEN_SPREAD) {
3761
144
        parser->flags |= mxNotSimpleParametersFlag;
3762
144
        fxRestBinding(parser, XS_TOKEN_ARG, 0);
3763
144
        aCount++;
3764
144
        break;
3765
144
      }
3766
9.11k
      fxBinding(parser, XS_TOKEN_ARG, 1);
3767
9.11k
      binding = (txBindingNode*)parser->root;
3768
9.11k
      if (binding->description->token != XS_TOKEN_ARG)
3769
419
        parser->flags |= mxNotSimpleParametersFlag;
3770
9.11k
      aCount++;
3771
9.11k
      if (parser->states[0].token != XS_TOKEN_RIGHT_PARENTHESIS)
3772
4.30k
        fxMatchToken(parser, XS_TOKEN_COMMA);
3773
9.11k
    }
3774
131k
    fxMatchToken(parser, XS_TOKEN_RIGHT_PARENTHESIS);
3775
131k
  }
3776
701
  else
3777
701
    fxReportParserError(parser, parser->states[0].line, "missing (");
3778
132k
  fxPushNodeList(parser, aCount);
3779
132k
  fxPushNodeStruct(parser, 1, XS_TOKEN_PARAMS_BINDING, aLine);
3780
132k
}
3781
3782
txNode* fxParametersBindingFromExpressions(txParser* parser, txNode* theNode)
3783
23.1k
{
3784
23.1k
  txNodeList* list = ((txParamsNode*)theNode)->items;
3785
23.1k
  txNode** address = &(list->first);
3786
23.1k
  txNode* item;
3787
23.1k
  txBindingNode* binding;
3788
24.5k
  while ((item = *address)) {
3789
1.42k
    txToken aToken = (item && item->description) ? item->description->token : XS_NO_TOKEN;
3790
1.42k
    if (aToken == XS_TOKEN_SPREAD) {
3791
9
      binding = (txBindingNode*)fxRestBindingFromExpression(parser, item, XS_TOKEN_ARG, 0);
3792
9
      if (!binding)
3793
1
        return NULL;
3794
8
      parser->flags |= mxNotSimpleParametersFlag;
3795
8
      break;
3796
9
    }
3797
1.41k
    binding = (txBindingNode*)fxBindingFromExpression(parser, item, XS_TOKEN_ARG);
3798
1.41k
    if (!binding)
3799
26
      return NULL;
3800
1.38k
    if (binding->description->token != XS_TOKEN_ARG)
3801
170
      parser->flags |= mxNotSimpleParametersFlag;
3802
1.38k
    binding->next = item->next;
3803
1.38k
    item = *address = (txNode*)binding;
3804
1.38k
    address = &(item->next);
3805
1.38k
  }
3806
23.1k
  theNode->description = &gxTokenDescriptions[XS_TOKEN_PARAMS_BINDING];
3807
23.1k
  return theNode;
3808
23.1k
}
3809
3810
void fxRestBinding(txParser* parser, txToken theToken, txUnsigned flag)
3811
176
{
3812
176
  txInteger aLine = parser->states[0].line;
3813
176
  fxMatchToken(parser, XS_TOKEN_SPREAD);
3814
176
  fxBinding(parser, theToken, 0);
3815
176
  if (flag && ((parser->root->description->token == XS_TOKEN_ARRAY_BINDING) || (parser->root->description->token == XS_TOKEN_OBJECT_BINDING))) {
3816
7
    fxReportParserError(parser, parser->states[0].line, "invalid rest");
3817
7
  }
3818
176
  fxPushNodeStruct(parser, 1, XS_TOKEN_REST_BINDING, aLine);
3819
176
}
3820
3821
txNode* fxRestBindingFromExpression(txParser* parser, txNode* theNode, txToken theToken, txUnsigned flag)
3822
240
{
3823
240
  txNode* expression = ((txSpreadNode*)theNode)->expression;
3824
240
  txNode* binding;
3825
240
  if (theNode->next) {
3826
2
    parser->errorSymbol = parser->SyntaxErrorSymbol;
3827
2
    return NULL;
3828
2
  }
3829
238
  if (!expression)
3830
0
    return NULL;
3831
//  if ((theToken == XS_TOKEN_BINDING) && ((expression->description->token == XS_TOKEN_MEMBER) || (expression->description->token == XS_TOKEN_MEMBER_AT)))
3832
//    binding = expression;
3833
//  else {      
3834
238
    binding = fxBindingFromExpression(parser, expression, theToken);
3835
238
    if (!binding) {
3836
7
      parser->errorSymbol = parser->SyntaxErrorSymbol;
3837
7
      return NULL;
3838
7
    }
3839
231
    if (binding->description->token == XS_TOKEN_BINDING) {
3840
8
      fxReportParserError(parser, parser->states[0].line, "invalid rest");
3841
8
      return NULL;
3842
8
    }
3843
223
    if (flag && ((binding->description->token == XS_TOKEN_ARRAY_BINDING) || (binding->description->token == XS_TOKEN_OBJECT_BINDING))) {
3844
18
      fxReportParserError(parser, parser->states[0].line, "invalid rest");
3845
18
      return NULL;
3846
18
    }
3847
//  }
3848
205
  theNode->description = &gxTokenDescriptions[XS_TOKEN_REST_BINDING];
3849
205
  ((txRestBindingNode*)theNode)->binding = binding;
3850
205
  return theNode;
3851
223
}
3852
3853
void fxCheckArrowFunction(txParser* parser, txInteger count)
3854
5.01M
{
3855
5.01M
  txNode* node = parser->root;
3856
14.7M
  while (count) {
3857
9.68M
    if (node->flags & mxArrowFlag)
3858
7.87k
      fxReportParserError(parser, parser->states[0].line, "invalid arrow function");
3859
9.68M
    count--;
3860
9.68M
    node = node->next;
3861
9.68M
  }
3862
5.01M
}
3863
3864
txBoolean fxCheckReference(txParser* parser, txToken theToken)
3865
101k
{
3866
101k
  txNode* node = parser->root;
3867
101k
  txToken aToken = (node && node->description) ? node->description->token : XS_NO_TOKEN;
3868
101k
  if (aToken == XS_TOKEN_EXPRESSIONS) {
3869
1.40k
    txNode* item;
3870
1.64k
  again:
3871
1.64k
    item = ((txExpressionsNode*)node)->items->first;
3872
1.64k
    if (item && !item->next) {
3873
1.45k
      aToken = (item->description) ? item->description->token : XS_NO_TOKEN;
3874
1.45k
      if ((aToken == XS_TOKEN_ACCESS) || (aToken == XS_TOKEN_MEMBER) || (aToken == XS_TOKEN_MEMBER_AT) || (aToken == XS_TOKEN_PRIVATE_MEMBER) || (aToken == XS_TOKEN_UNDEFINED)) {
3875
70
        item->next = node->next;
3876
70
        node = parser->root = item;
3877
70
      }
3878
1.38k
      else if (aToken == XS_TOKEN_EXPRESSIONS) {
3879
241
        item->next = node->next;
3880
241
        node = item;
3881
241
        goto again;
3882
241
      }
3883
1.14k
      else
3884
1.14k
        aToken = XS_TOKEN_EXPRESSIONS;
3885
1.45k
    }
3886
1.64k
  }
3887
101k
  if (aToken == XS_TOKEN_ACCESS) {
3888
81.6k
    fxCheckStrictSymbol(parser, ((txAccessNode*)node)->symbol);
3889
81.6k
    return 1;
3890
81.6k
  }
3891
20.1k
  if ((aToken == XS_TOKEN_MEMBER) || (aToken == XS_TOKEN_MEMBER_AT) || (aToken == XS_TOKEN_PRIVATE_MEMBER) || (aToken == XS_TOKEN_UNDEFINED))
3892
11.2k
    return 1;
3893
    
3894
8.95k
  if (theToken == XS_TOKEN_ASSIGN) {
3895
6.14k
    if (aToken == XS_TOKEN_ARRAY) {
3896
619
      txNode* binding = fxArrayBindingFromExpression(parser, node, XS_TOKEN_ACCESS);
3897
619
            if (binding) {
3898
610
                binding->next = node->next;
3899
610
                parser->root = binding;
3900
610
        return 1;
3901
610
           }
3902
619
        }
3903
5.53k
    else if (aToken == XS_TOKEN_OBJECT) {
3904
3.33k
      txNode* binding = fxObjectBindingFromExpression(parser, node, XS_TOKEN_ACCESS);
3905
3.33k
            if (binding) {
3906
3.23k
                binding->next = node->next;
3907
3.23k
                parser->root = binding;
3908
3.23k
        return 1;
3909
3.23k
            }
3910
3.33k
        }
3911
6.14k
  }
3912
2.80k
  else if (theToken == XS_TOKEN_DELETE)
3913
1.11k
    return 1;
3914
4.00k
  return 0;
3915
8.95k
}
3916
3917
void fxCheckStrictBinding(txParser* parser, txNode* node)
3918
26.6k
{
3919
26.6k
  if (node && node->description) {
3920
26.6k
    if (node->description->token == XS_TOKEN_ACCESS) {
3921
0
      fxCheckStrictSymbol(parser, ((txAccessNode*)node)->symbol);
3922
0
    }
3923
26.6k
    else if (node->description->token == XS_TOKEN_ARG) {
3924
2.18k
      fxCheckStrictSymbol(parser, ((txDeclareNode*)node)->symbol);
3925
2.18k
    }
3926
24.4k
    else if (node->description->token == XS_TOKEN_CONST) {
3927
0
      fxCheckStrictSymbol(parser, ((txDeclareNode*)node)->symbol);
3928
0
    }
3929
24.4k
    else if (node->description->token == XS_TOKEN_LET) {
3930
0
      fxCheckStrictSymbol(parser, ((txDeclareNode*)node)->symbol);
3931
0
    }
3932
24.4k
    else if (node->description->token == XS_TOKEN_USING) {
3933
0
      fxCheckStrictSymbol(parser, ((txDeclareNode*)node)->symbol);
3934
0
    }
3935
24.4k
    else if (node->description->token == XS_TOKEN_VAR) {
3936
0
      fxCheckStrictSymbol(parser, ((txDeclareNode*)node)->symbol);
3937
0
    }
3938
24.4k
    else if (node->description->token == XS_TOKEN_BINDING) {
3939
6
      fxCheckStrictBinding(parser, ((txBindingNode*)node)->target);
3940
6
    }
3941
24.4k
    else if (node->description->token == XS_TOKEN_ARRAY_BINDING) {
3942
143
      node = ((txArrayBindingNode*)node)->items->first;
3943
645
      while (node) {
3944
502
        fxCheckStrictBinding(parser, node);
3945
502
        node = node->next;
3946
502
      }
3947
143
    }
3948
24.2k
    else if (node->description->token == XS_TOKEN_OBJECT_BINDING) {
3949
17
      node = ((txObjectBindingNode*)node)->items->first;
3950
30
      while (node) {
3951
13
        fxCheckStrictBinding(parser, node);
3952
13
        node = node->next;
3953
13
      }
3954
17
    }
3955
24.2k
    else if (node->description->token == XS_TOKEN_PARAMS_BINDING) {
3956
24.2k
      node = ((txParamsBindingNode*)node)->items->first;
3957
26.0k
      while (node) {
3958
1.84k
        fxCheckStrictBinding(parser, node);
3959
1.84k
        node = node->next;
3960
1.84k
      }
3961
24.2k
    }
3962
37
    else if (node->description->token == XS_TOKEN_PROPERTY_BINDING)
3963
13
      fxCheckStrictBinding(parser, ((txPropertyBindingNode*)node)->binding);
3964
24
    else if (node->description->token == XS_TOKEN_PROPERTY_BINDING_AT)
3965
0
      fxCheckStrictBinding(parser, ((txPropertyBindingAtNode*)node)->binding);
3966
24
    else if (node->description->token == XS_TOKEN_REST_BINDING)
3967
8
      fxCheckStrictBinding(parser, ((txRestBindingNode*)node)->binding);
3968
26.6k
  }
3969
26.6k
}
3970
3971
void fxCheckStrictFunction(txParser* parser, txFunctionNode* function)
3972
1.08k
{
3973
1.08k
  parser->states[0].line = function->line;
3974
1.08k
  fxCheckStrictSymbol(parser, function->symbol);
3975
1.08k
  fxCheckStrictBinding(parser, function->params);
3976
1.08k
}
3977
3978
void fxCheckStrictSymbol(txParser* parser, txSymbol* symbol)
3979
283k
{
3980
283k
  if (parser->flags & mxStrictFlag) {
3981
8.55k
    if (symbol == parser->argumentsSymbol)
3982
1
      fxReportParserError(parser, parser->states[0].line, "invalid arguments (strict mode)");
3983
8.55k
    else if (symbol == parser->evalSymbol)
3984
1
      fxReportParserError(parser, parser->states[0].line, "invalid eval (strict mode)");
3985
8.55k
    else if (symbol == parser->yieldSymbol)
3986
0
      fxReportParserError(parser, parser->states[0].line, "invalid yield (strict mode)");
3987
8.55k
  }
3988
274k
  else if (parser->flags & mxYieldFlag) {
3989
846
    if (symbol == parser->yieldSymbol)
3990
0
      fxReportParserError(parser, parser->states[0].line, "invalid yield");
3991
846
  }
3992
283k
}
3993
3994
void fxCheckUniqueProperty(txParser* parser, txNode* base, txNode* current)
3995
84.2k
{
3996
84.2k
  return; // no more!
3997
0
  if (current->description->token == XS_TOKEN_PROPERTY) {
3998
0
    txPropertyNode* currentNode = (txPropertyNode*)current;
3999
0
    while (base != current) {
4000
0
      txPropertyNode* baseNode = (txPropertyNode*)base;
4001
0
      if (baseNode->description->token == XS_TOKEN_PROPERTY) {
4002
0
        if (baseNode->symbol == currentNode->symbol) {
4003
0
          fxCheckUniquePropertyAux(parser, (txNode*)baseNode, (txNode*)currentNode);      
4004
0
        }
4005
0
      }
4006
0
      base = base->next;
4007
0
    }
4008
0
  }
4009
0
  else {
4010
0
    txPropertyAtNode* currentNode = (txPropertyAtNode*)current;
4011
0
    txIntegerNode* currentAt = (txIntegerNode*)(currentNode->at);
4012
0
    if (currentAt->description->token == XS_TOKEN_INTEGER) {
4013
0
      while (base != current) {
4014
0
        txPropertyAtNode* baseNode = (txPropertyAtNode*)base;
4015
0
        if (baseNode->description->token == XS_TOKEN_PROPERTY_AT) {
4016
0
          txIntegerNode* baseAt = (txIntegerNode*)(baseNode->at);
4017
0
          if (baseAt->description->token == XS_TOKEN_INTEGER) {
4018
0
            if (baseAt->value == currentAt->value) {
4019
0
              fxCheckUniquePropertyAux(parser, (txNode*)baseNode, (txNode*)currentNode);      
4020
0
            }
4021
0
          }
4022
0
        }
4023
0
        base = base->next;
4024
0
      }
4025
0
    }
4026
0
  }
4027
0
}
4028
4029
void fxCheckUniquePropertyAux(txParser* parser, txNode* baseNode, txNode* currentNode)
4030
0
{
4031
0
  if (currentNode->flags & mxGetterFlag) {
4032
0
    if (baseNode->flags & mxGetterFlag)
4033
0
      fxReportParserError(parser, parser->states[0].line, "getter already defined");
4034
0
    else if (!(baseNode->flags & mxSetterFlag))
4035
0
      fxReportParserError(parser, parser->states[0].line, "property already defined");
4036
0
  }
4037
0
  else if (currentNode->flags & mxSetterFlag) {
4038
0
    if (baseNode->flags & mxSetterFlag)
4039
0
      fxReportParserError(parser, parser->states[0].line, "setter already defined");
4040
0
    else if (!(baseNode->flags & mxGetterFlag))
4041
0
      fxReportParserError(parser, parser->states[0].line, "property already defined");
4042
0
  }
4043
0
  else {
4044
0
    if (baseNode->flags & mxGetterFlag)
4045
0
      fxReportParserError(parser, parser->states[0].line, "getter already defined");
4046
0
    else if (baseNode->flags & mxSetterFlag)
4047
0
      fxReportParserError(parser, parser->states[0].line, "setter already defined");
4048
0
    else if (parser->flags & mxStrictFlag)
4049
0
      fxReportParserError(parser, parser->states[0].line, "property already defined (strict mode)");
4050
0
  }
4051
0
}
4052
4053
4054
void fxJSONValue(txParser* parser)
4055
0
{
4056
0
  switch (parser->states[0].token) {
4057
0
  case XS_TOKEN_FALSE:
4058
0
    fxPushNodeStruct(parser, 0, parser->states[0].token, parser->states[0].line);
4059
0
    fxGetNextTokenJSON(parser);
4060
0
    break;
4061
0
  case XS_TOKEN_TRUE:
4062
0
    fxPushNodeStruct(parser, 0, parser->states[0].token, parser->states[0].line);
4063
0
    fxGetNextTokenJSON(parser);
4064
0
    break;
4065
0
  case XS_TOKEN_NULL:
4066
0
    fxPushNodeStruct(parser, 0, parser->states[0].token, parser->states[0].line);
4067
0
    fxGetNextTokenJSON(parser);
4068
0
    break;
4069
0
  case XS_TOKEN_INTEGER:
4070
0
    fxPushIntegerNode(parser, parser->states[0].integer, parser->states[0].line);
4071
0
    fxGetNextTokenJSON(parser);
4072
0
    break;
4073
0
  case XS_TOKEN_NUMBER:
4074
0
    fxPushNumberNode(parser, parser->states[0].number, parser->states[0].line);
4075
0
    fxGetNextTokenJSON(parser);
4076
0
    break;
4077
0
  case XS_TOKEN_STRING:
4078
0
    fxPushStringNode(parser, parser->states[0].stringLength, parser->states[0].string, parser->states[0].line);
4079
0
    fxGetNextTokenJSON(parser);
4080
0
    break;
4081
0
  case XS_TOKEN_LEFT_BRACE:
4082
0
    fxJSONObject(parser);
4083
0
    break;
4084
0
  case XS_TOKEN_LEFT_BRACKET:
4085
0
    fxJSONArray(parser);
4086
0
    break;
4087
0
  default:
4088
0
    fxPushNULL(parser);
4089
0
    fxReportParserError(parser, parser->states[0].line, "invalid value");
4090
0
    break;
4091
0
  }
4092
0
}
4093
4094
void fxJSONObject(txParser* parser)
4095
0
{
4096
0
  txIndex aLength = 0;
4097
0
  txInteger aLine = parser->states[0].line;
4098
0
  fxGetNextTokenJSON(parser);
4099
0
  for (;;) {
4100
0
    if (parser->states[0].token == XS_TOKEN_RIGHT_BRACE)
4101
0
      break;
4102
0
    if (parser->states[0].token != XS_TOKEN_STRING) {
4103
0
      fxReportParserError(parser, parser->states[0].line, "missing name");
4104
0
      break;
4105
0
    }
4106
0
    fxPushStringNode(parser, parser->states[0].stringLength, parser->states[0].string, parser->states[0].line);
4107
0
    fxGetNextTokenJSON(parser);
4108
0
    if (parser->states[0].token != XS_TOKEN_COLON) {
4109
0
      fxReportParserError(parser, parser->states[0].line, "missing :");
4110
0
      break;
4111
0
    }
4112
0
    fxGetNextTokenJSON(parser);
4113
0
    fxJSONValue(parser);
4114
0
    fxPushNodeStruct(parser, 2, XS_TOKEN_PROPERTY_AT, parser->states[0].line);
4115
0
    aLength++;
4116
0
    if (parser->states[0].token != XS_TOKEN_COMMA)
4117
0
      break;
4118
0
    fxGetNextTokenJSON(parser);
4119
0
  }
4120
0
  if (parser->states[0].token != XS_TOKEN_RIGHT_BRACE)
4121
0
    fxReportParserError(parser, parser->states[0].line, "missing }");
4122
0
  fxGetNextTokenJSON(parser);
4123
0
  fxPushNodeList(parser, aLength);
4124
0
  fxPushNodeStruct(parser, 1, XS_TOKEN_OBJECT, aLine);
4125
0
}
4126
4127
void fxJSONArray(txParser* parser)
4128
0
{
4129
0
  txIndex aLength = 0;
4130
0
  txInteger aLine = parser->states[0].line;
4131
0
  fxGetNextTokenJSON(parser);
4132
0
  for (;;) {
4133
0
    if (parser->states[0].token == XS_TOKEN_RIGHT_BRACKET)
4134
0
      break;
4135
0
    fxJSONValue(parser);
4136
0
    aLength++;
4137
0
    if (parser->states[0].token != XS_TOKEN_COMMA)
4138
0
      break;
4139
0
    fxGetNextTokenJSON(parser);
4140
0
  }
4141
0
  if (parser->states[0].token != XS_TOKEN_RIGHT_BRACKET)
4142
0
    fxReportParserError(parser, parser->states[0].line, "missing ]");
4143
0
  fxGetNextTokenJSON(parser);
4144
0
  fxPushNodeList(parser, aLength);
4145
0
  fxPushNodeStruct(parser, 1, XS_TOKEN_ARRAY, aLine);
4146
0
}
4147
4148
void fxJSONModule(txParser* parser)
4149
0
{
4150
0
  fxJSONValue(parser);
4151
  
4152
0
  fxPushSymbol(parser, parser->defaultSymbol);
4153
0
  fxPushNULL(parser);
4154
0
  fxPushNodeStruct(parser, 2, XS_TOKEN_CONST, 1);
4155
0
  fxSwapNodes(parser);
4156
0
  fxPushNodeStruct(parser, 2, XS_TOKEN_ASSIGN, 1);
4157
0
  fxPushNodeStruct(parser, 1, XS_TOKEN_STATEMENT, 1);
4158
  
4159
0
  fxPushSymbol(parser, parser->defaultSymbol);
4160
0
  fxPushNULL(parser);
4161
0
  fxPushNodeStruct(parser, 2, XS_TOKEN_SPECIFIER, 1);
4162
0
  fxPushNodeList(parser, 1);
4163
0
  fxPushNULL(parser);
4164
0
  fxPushNULL(parser);
4165
0
  fxPushNodeStruct(parser, 3, XS_TOKEN_EXPORT, 1);
4166
  
4167
0
  fxPushNodeList(parser, 2);
4168
0
  fxPushNodeStruct(parser, 1, XS_TOKEN_STATEMENTS, 1);
4169
  
4170
0
  fxPushNodeStruct(parser, 1, XS_TOKEN_MODULE, 1);
4171
0
}
4172
4173
static txSymbol* fxJSXName(txParser* parser, txSymbol* before, txSymbol* after)
4174
35
{
4175
35
  txSize beforeLength = before->length;
4176
35
  txSize afterLength = after->length;
4177
35
  txSize length = beforeLength + 1 + afterLength + 1;
4178
35
  txString string = fxNewParserChunk(parser, length);
4179
35
  snprintf(string, length, "%s-%s", before->string, after->string);
4180
35
  return fxNewParserSymbol(parser, string);
4181
35
}
4182
4183
void fxJSXAttributeName(txParser* parser)
4184
3.28k
{
4185
3.28k
  txSymbol* symbol = parser->states[0].symbol;
4186
3.28k
  fxGetNextToken(parser);
4187
3.30k
  while (parser->states[0].token == XS_TOKEN_SUBTRACT) {
4188
22
    fxGetNextToken(parser);
4189
22
    if (gxTokenFlags[parser->states[0].token] & XS_TOKEN_IDENTIFIER_NAME)
4190
19
      symbol = fxJSXName(parser, symbol, parser->states[0].symbol);
4191
3
    else
4192
3
      fxReportParserError(parser, parser->states[0].line, "missing name");
4193
22
    fxGetNextToken(parser);
4194
22
  }
4195
3.28k
  if (parser->states[0].token == XS_TOKEN_COLON) {
4196
449
    fxGetNextToken(parser);
4197
449
    if (gxTokenFlags[parser->states[0].token] & XS_TOKEN_IDENTIFIER_NAME)
4198
251
      symbol = fxJSXNamespace(parser, symbol, parser->states[0].symbol);
4199
198
    else
4200
198
      fxReportParserError(parser, parser->states[0].line, "missing name");
4201
449
    fxGetNextToken(parser);
4202
476
    while (parser->states[0].token == XS_TOKEN_SUBTRACT) {
4203
27
      fxGetNextToken(parser);
4204
27
      if (gxTokenFlags[parser->states[0].token] & XS_TOKEN_IDENTIFIER_NAME)
4205
16
        symbol = fxJSXName(parser, symbol, parser->states[0].symbol);
4206
11
      else
4207
11
        fxReportParserError(parser, parser->states[0].line, "missing name");
4208
27
      fxGetNextToken(parser);
4209
27
    }  
4210
449
  }
4211
3.28k
  fxPushSymbol(parser, symbol);
4212
3.28k
}
4213
4214
void fxJSXAttributeValue(txParser* parser)
4215
1.67k
{
4216
1.67k
  txInteger line = parser->states[0].line;
4217
1.67k
  fxGetNextTokenJSXAttribute(parser);
4218
1.67k
  if (parser->states[0].token == XS_TOKEN_STRING) {
4219
793
    fxPushStringNode(parser, parser->states[0].stringLength, parser->states[0].string, line);
4220
793
    fxGetNextToken(parser);
4221
793
  }
4222
877
  else if (parser->states[0].token == XS_TOKEN_LEFT_BRACE) {
4223
12
    fxGetNextToken(parser);
4224
12
    if (parser->states[0].token == XS_TOKEN_RIGHT_BRACE) {
4225
0
      fxGetNextToken(parser);
4226
0
      fxReportParserError(parser, parser->states[0].line, "missing expression");
4227
0
      fxPushNodeStruct(parser, 0, XS_TOKEN_UNDEFINED, line);
4228
0
    }
4229
12
    else {
4230
12
      fxAssignmentExpression(parser);
4231
12
      if (parser->states[0].token == XS_TOKEN_RIGHT_BRACE)
4232
1
        fxGetNextToken(parser);
4233
11
      else
4234
11
        fxReportParserError(parser, parser->states[0].line, "missing }");
4235
12
    }
4236
12
  }
4237
865
  else {
4238
865
    fxReportParserError(parser, parser->states[0].line, "invalid %s", gxTokenNames[parser->states[0].token]);
4239
865
    fxPushNodeStruct(parser, 0, XS_TOKEN_UNDEFINED, line);
4240
865
  }
4241
1.67k
}
4242
4243
void fxJSXElement(txParser* parser)
4244
21.2k
{
4245
21.2k
  txBoolean closed = 0;
4246
21.2k
  txInteger line = parser->states[0].line;
4247
21.2k
  txNode* name = NULL;
4248
21.2k
  txInteger nodeCount = parser->nodeCount;
4249
21.2k
  txInteger propertyCount = 0;
4250
21.2k
  fxPushSymbol(parser, parser->__jsx__Symbol);
4251
21.2k
  fxPushNodeStruct(parser, 1, XS_TOKEN_ACCESS, parser->states[0].line);
4252
21.2k
  if (parser->states[0].token == XS_TOKEN_IDENTIFIER) {
4253
20.3k
    fxJSXElementName(parser);
4254
20.3k
    name = parser->root;
4255
20.3k
  }
4256
904
  else {
4257
904
    fxReportParserError(parser, parser->states[0].line, "missing identifier");
4258
904
    fxPushNULL(parser);
4259
904
  }
4260
21.2k
  for (;;) {
4261
20.9k
    if (parser->states[0].token == XS_TOKEN_MORE)
4262
7.01k
      break;
4263
13.8k
    if (parser->states[0].token == XS_TOKEN_DIVIDE) {
4264
9.64k
      fxGetNextToken(parser);
4265
9.64k
      if (parser->states[0].token != XS_TOKEN_MORE)
4266
1.02k
        fxReportParserError(parser, parser->states[0].line, "missing >");
4267
9.64k
      closed = 1;
4268
9.64k
      break;
4269
9.64k
    }
4270
4.25k
    if (gxTokenFlags[parser->states[0].token] & XS_TOKEN_IDENTIFIER_NAME) {
4271
3.28k
      fxJSXAttributeName(parser);
4272
3.28k
      if (parser->states[0].token == XS_TOKEN_ASSIGN)
4273
1.67k
        fxJSXAttributeValue(parser);
4274
1.61k
      else
4275
1.61k
        fxPushNodeStruct(parser, 0, XS_TOKEN_TRUE, parser->states[0].line);
4276
3.28k
      fxPushNodeStruct(parser, 2, XS_TOKEN_PROPERTY, parser->states[0].line);
4277
3.28k
      propertyCount++;
4278
3.28k
    }
4279
966
    else if (parser->states[0].token == XS_TOKEN_LEFT_BRACE) {
4280
27
      fxGetNextToken(parser);
4281
27
      if (parser->states[0].token == XS_TOKEN_SPREAD) {
4282
4
        fxGetNextToken(parser);
4283
4
        fxAssignmentExpression(parser);
4284
4
        if (parser->states[0].token == XS_TOKEN_RIGHT_BRACE)
4285
3
          fxGetNextToken(parser);
4286
1
        else
4287
1
          fxReportParserError(parser, parser->states[0].line, "missing }");
4288
4
        fxPushNodeStruct(parser, 1, XS_TOKEN_SPREAD, parser->states[0].line);
4289
4
        propertyCount++;
4290
4
      }
4291
23
      else
4292
23
        fxReportParserError(parser, parser->states[0].line, "invalid %s", gxTokenNames[parser->states[0].token]);
4293
27
    }
4294
939
    else {
4295
939
      fxReportParserError(parser, parser->states[0].line, "invalid %s", gxTokenNames[parser->states[0].token]);
4296
939
      break;
4297
939
    }
4298
4.25k
  }
4299
21.2k
  if (propertyCount > 0) {
4300
1.16k
    fxPushNodeList(parser, propertyCount);
4301
1.16k
    fxPushNodeStruct(parser, 1, XS_TOKEN_OBJECT, parser->states[0].line);
4302
1.16k
  }
4303
20.0k
  else
4304
20.0k
    fxPushNodeStruct(parser, 0, XS_TOKEN_NULL, parser->states[0].line);
4305
21.2k
  if (!closed) {
4306
16.7k
    for (;;) {
4307
16.7k
      fxGetNextTokenJSXChild(parser);
4308
16.7k
      if (parser->states[0].stringLength)
4309
5.90k
        fxPushStringNode(parser, parser->states[0].stringLength, parser->states[0].string, parser->states[0].line);
4310
16.7k
      if (parser->states[0].token == XS_TOKEN_LEFT_BRACE) {
4311
1.55k
        fxGetNextToken(parser);
4312
1.55k
        if (parser->states[0].token == XS_TOKEN_RIGHT_BRACE)
4313
557
          fxGetNextToken(parser);
4314
997
        else {
4315
997
          fxAssignmentExpression(parser);
4316
997
          if (parser->states[0].token != XS_TOKEN_RIGHT_BRACE)
4317
288
            fxReportParserError(parser, parser->states[0].line, "missing }");
4318
997
        }
4319
1.55k
      }
4320
15.2k
      else if (parser->states[0].token == XS_TOKEN_LESS) {
4321
13.6k
        fxGetNextToken(parser);
4322
13.6k
        if (parser->states[0].token == XS_TOKEN_DIVIDE) {
4323
2.42k
          fxGetNextToken(parser);
4324
2.42k
          if (parser->states[0].token == XS_TOKEN_IDENTIFIER) {
4325
1.85k
            fxJSXElementName(parser);
4326
1.85k
            if (!fxJSXMatch(parser, name, parser->root)) {
4327
1.83k
              fxReportParserError(parser, parser->states[0].line, "invalid element");
4328
1.83k
              fxPushNULL(parser);
4329
1.83k
            }
4330
1.85k
          }
4331
571
          else {
4332
571
            fxReportParserError(parser, parser->states[0].line, "missing identifier");
4333
571
            fxPushNULL(parser);
4334
571
          }
4335
2.42k
          if (parser->states[0].token != XS_TOKEN_MORE)
4336
2
            fxReportParserError(parser, parser->states[0].line, "missing >");
4337
2.42k
          fxPopNode(parser);
4338
2.42k
          break;
4339
2.42k
        }
4340
11.1k
        else
4341
11.1k
          fxJSXElement(parser);
4342
13.6k
      }
4343
1.60k
      else {
4344
1.60k
        fxReportParserError(parser, parser->states[0].line, "invalid %s", gxTokenNames[parser->states[0].token]);
4345
1.60k
        break;
4346
1.60k
      }
4347
16.7k
    }
4348
7.01k
  }
4349
21.2k
  fxPushNodeList(parser, parser->nodeCount - nodeCount - 1);
4350
21.2k
  fxPushNodeStruct(parser, 1, XS_TOKEN_PARAMS, line);
4351
21.2k
  fxPushNodeStruct(parser, 2, XS_TOKEN_CALL, line);
4352
21.2k
}
4353
4354
void fxJSXElementName(txParser* parser)
4355
22.1k
{
4356
22.1k
  txInteger line = parser->states[0].line;
4357
22.1k
  txSymbol* symbol = parser->states[0].symbol;
4358
22.1k
  fxGetNextToken(parser);
4359
22.1k
  if (parser->states[0].token == XS_TOKEN_COLON) {
4360
269
    fxGetNextToken(parser);
4361
269
    if (parser->states[0].token == XS_TOKEN_IDENTIFIER)
4362
10
      symbol = fxJSXNamespace(parser, symbol, parser->states[0].symbol);
4363
259
    else
4364
259
      fxReportParserError(parser, parser->states[0].line, "missing name");
4365
269
    fxPushSymbol(parser, symbol);
4366
269
    fxPushNodeStruct(parser, 1, XS_TOKEN_ACCESS, line);
4367
269
    fxGetNextToken(parser);
4368
269
  }
4369
21.9k
  else {
4370
21.9k
    fxPushSymbol(parser, symbol);
4371
21.9k
    fxPushNodeStruct(parser, 1, XS_TOKEN_ACCESS, line);
4372
25.8k
    while (parser->states[0].token == XS_TOKEN_DOT) {
4373
3.87k
      fxGetNextToken(parser);
4374
3.87k
      if (parser->states[0].token == XS_TOKEN_IDENTIFIER) {
4375
3.81k
        fxPushSymbol(parser, parser->states[0].symbol);
4376
3.81k
        fxPushNodeStruct(parser, 2, XS_TOKEN_MEMBER, parser->states[0].line);
4377
3.81k
        fxGetNextToken(parser);
4378
3.81k
      }
4379
63
      else
4380
63
        fxReportParserError(parser, parser->states[0].line, "missing property");
4381
3.87k
    }
4382
21.9k
  }
4383
22.1k
}
4384
4385
txBoolean fxJSXMatch(txParser* parser, txNode* opening, txNode* closing)
4386
1.85k
{
4387
1.85k
  if (opening && closing) {
4388
1.85k
    while (opening->description->token == XS_TOKEN_MEMBER) {
4389
697
      if (closing->description->token != XS_TOKEN_MEMBER)
4390
693
        return 0;
4391
4
      if (((txMemberNode*)opening)->symbol != ((txMemberNode*)closing)->symbol)
4392
1
        return 0;
4393
3
      opening = ((txMemberNode*)opening)->reference;
4394
3
      closing = ((txMemberNode*)closing)->reference;
4395
3
    }
4396
1.16k
    if (opening->description->token == XS_TOKEN_ACCESS) {
4397
1.16k
      if (closing->description->token != XS_TOKEN_ACCESS)
4398
511
        return 0;
4399
649
      if (((txAccessNode*)opening)->symbol != ((txAccessNode*)closing)->symbol)
4400
628
        return 0;
4401
21
      return 1;
4402
649
    }
4403
1.16k
  }
4404
0
  return 0;
4405
1.85k
}
4406
4407
txSymbol* fxJSXNamespace(txParser* parser, txSymbol* namespace, txSymbol* name)
4408
261
{
4409
261
  txSize namespaceLength = namespace->length;
4410
261
  txSize nameLength = name->length;
4411
261
  txSize length = namespaceLength + 1 + nameLength + 1;
4412
261
  txString string = fxNewParserChunk(parser, length);
4413
261
  snprintf(string, length, "%s:%s", namespace->string, name->string);
4414
261
  return fxNewParserSymbol(parser, string);
4415
261
}