« back to all changes in this revision
Viewing changes to kjs/grammar.cpp
- browse files at revision 267
- compare with another revision
- download diff
- download tarball
- view history from revision 267
- Committer: Package Import Robot
- Author(s): Felix Geyer, Scott Kitterman, Felix Geyer
- Date: 2012-09-07 16:47:08 UTC
- mfrom: (1.14.19) (264.1.1 precise-security)
- Revision ID: package-import@ubuntu.com-20120907164708-ya6uihqramqby4q0
Tags: 4:4.8.5-0ubuntu0.1
[ Scott Kitterman ]
* New upstream bugfix release (LP: #1047417)
- Drop patches cherrypicked from upstrea:
Revert_disconnect_before_re-connecting.diff
Revert_Always_rec-connect_if_forced.diff
[ Felix Geyer ]
* Install new kdoctools language customizations.
* Update libkdeui5 symbols file.
* New upstream bugfix release (LP: #1047417)
- Drop patches cherrypicked from upstrea:
Revert_disconnect_before_re-connecting.diff
Revert_Always_rec-connect_if_forced.diff
[ Felix Geyer ]
* Install new kdoctools language customizations.
* Update libkdeui5 symbols file.
- files added:
- interfaces/terminal/example
- files removed:
- .pc/Revert_Always_rec-connect_if_forced.diff
- .pc/Revert_Always_rec-connect_if_forced.diff/nepomuk
- .pc/Revert_Always_rec-connect_if_forced.diff/nepomuk/core
- .pc/Revert_disconnect_before_re-connecting.diff
- .pc/Revert_disconnect_before_re-connecting.diff/nepomuk
- .pc/Revert_disconnect_before_re-connecting.diff/nepomuk/core
- interfaces/terminal/test
added
removed
kjs/grammar.cpp
1
/* A Bison parser, made by GNU Bison 2.3. */
2
3
/* Skeleton implementation for Bison's Yacc-like parsers in C
4
5
Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002, 2003, 2004, 2005, 2006
6
Free Software Foundation, Inc.
7
8
This program is free software; you can redistribute it and/or modify
1
/* A Bison parser, made by GNU Bison 2.5. */
2
3
/* Bison implementation for Yacc-like parsers in C
4
5
Copyright (C) 1984, 1989-1990, 2000-2011 Free Software Foundation, Inc.
6
7
This program is free software: you can redistribute it and/or modify
9
8
it under the terms of the GNU General Public License as published by
10
the Free Software Foundation; either version 2, or (at your option)
11
any later version.
12
9
the Free Software Foundation, either version 3 of the License, or
10
(at your option) any later version.
11
13
12
This program is distributed in the hope that it will be useful,
14
13
but WITHOUT ANY WARRANTY; without even the implied warranty of
15
14
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16
15
GNU General Public License for more details.
17
16
18
17
You should have received a copy of the GNU General Public License
19
along with this program; if not, write to the Free Software
20
Foundation, Inc., 51 Franklin Street, Fifth Floor,
21
Boston, MA 02110-1301, USA. */
18
along with this program. If not, see <http://www.gnu.org/licenses/>. */
22
19
23
20
/* As a special exception, you may create a larger work that contains
24
21
part or all of the Bison parser skeleton and distribute that work
29
26
special exception, which will cause the skeleton and the resulting
30
27
Bison output files to be licensed under the GNU General Public
31
28
License without this special exception.
32
29
33
30
This special exception was added by the Free Software Foundation in
34
31
version 2.2 of Bison. */
35
32
47
44
#define YYBISON 1
48
45
49
46
/* Bison version. */
50
#define YYBISON_VERSION "2.3"
47
#define YYBISON_VERSION "2.5"
51
48
52
49
/* Skeleton name. */
53
50
#define YYSKELETON_NAME "yacc.c"
55
52
/* Pure parsers. */
56
53
#define YYPURE 0
57
54
55
/* Push parsers. */
56
#define YYPUSH 0
57
58
/* Pull parsers. */
59
#define YYPULL 1
60
58
61
/* Using locations. */
59
62
#define YYLSP_NEEDED 1
60
63
61
64
/* Substitute the variable and function names. */
62
#define yyparse kjsyyparse
63
#define yylex kjsyylex
64
#define yyerror kjsyyerror
65
#define yylval kjsyylval
66
#define yychar kjsyychar
67
#define yydebug kjsyydebug
68
#define yynerrs kjsyynerrs
65
#define yyparse kjsyyparse
66
#define yylex kjsyylex
67
#define yyerror kjsyyerror
68
#define yylval kjsyylval
69
#define yychar kjsyychar
70
#define yydebug kjsyydebug
71
#define yynerrs kjsyynerrs
72
#define yylloc kjsyylloc
73
74
/* Copy the first part of user declarations. */
75
76
/* Line 268 of yacc.c */
77
#line 1 "grammar.y"
78
79
80
/*
81
* This file is part of the KDE libraries
82
* Copyright (C) 1999-2000 Harri Porten (porten@kde.org)
83
* Copyright (C) 2006, 2007 Apple Inc. All rights reserved.
84
*
85
* This library is free software; you can redistribute it and/or
86
* modify it under the terms of the GNU Lesser General Public
87
* License as published by the Free Software Foundation; either
88
* version 2 of the License, or (at your option) any later version.
89
*
90
* This library is distributed in the hope that it will be useful,
91
* but WITHOUT ANY WARRANTY; without even the implied warranty of
92
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
93
* Lesser General Public License for more details.
94
*
95
* You should have received a copy of the GNU Lesser General Public
96
* License along with this library; if not, write to the Free Software
97
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
98
*
99
*/
100
101
#include "config.h"
102
103
#include <string.h>
104
#include <stdlib.h>
105
#include "value.h"
106
#include "object.h"
107
#include "types.h"
108
#include "interpreter.h"
109
#include "nodes.h"
110
#include "makenodes.h"
111
#include "lexer.h"
112
#include "internal.h"
113
114
// Not sure why, but yacc doesn't add this define along with the others.
69
115
#define yylloc kjsyylloc
70
116
117
/* default values for bison */
118
#define YYDEBUG 0 // Set to 1 to debug a parse error.
119
#define kjsyydebug 0 // Set to 1 to debug a parse error.
120
#if !PLATFORM(DARWIN)
121
// avoid triggering warnings in older bison
122
#define YYERROR_VERBOSE
123
#endif
124
125
extern int kjsyylex();
126
int kjsyyerror(const char *);
127
static bool allowAutomaticSemicolon();
128
129
#define AUTO_SEMICOLON do { if (!allowAutomaticSemicolon()) YYABORT; } while (0)
130
#define DBG(l, s, e) (l)->setLoc((s).first_line, (e).last_line)
131
132
using namespace KJS;
133
134
135
136
/* Line 268 of yacc.c */
137
#line 138 "grammar.tab.c"
138
139
/* Enabling traces. */
140
#ifndef YYDEBUG
141
# define YYDEBUG 0
142
#endif
143
144
/* Enabling verbose error messages. */
145
#ifdef YYERROR_VERBOSE
146
# undef YYERROR_VERBOSE
147
# define YYERROR_VERBOSE 1
148
#else
149
# define YYERROR_VERBOSE 0
150
#endif
151
152
/* Enabling the token table. */
153
#ifndef YYTOKEN_TABLE
154
# define YYTOKEN_TABLE 0
155
#endif
156
157
71
158
/* Tokens. */
72
159
#ifndef YYTOKENTYPE
73
160
# define YYTOKENTYPE
138
225
AUTOMINUSMINUS = 319
139
226
};
140
227
#endif
141
/* Tokens. */
142
#define NULLTOKEN 258
143
#define TRUETOKEN 259
144
#define FALSETOKEN 260
145
#define BREAK 261
146
#define CASE 262
147
#define DEFAULT 263
148
#define FOR 264
149
#define NEW 265
150
#define VAR 266
151
#define CONSTTOKEN 267
152
#define CONTINUE 268
153
#define FUNCTION 269
154
#define RETURN 270
155
#define VOIDTOKEN 271
156
#define DELETETOKEN 272
157
#define IF 273
158
#define THISTOKEN 274
159
#define DO 275
160
#define WHILE 276
161
#define INTOKEN 277
162
#define INSTANCEOF 278
163
#define TYPEOF 279
164
#define SWITCH 280
165
#define WITH 281
166
#define RESERVED 282
167
#define THROW 283
168
#define TRY 284
169
#define CATCH 285
170
#define FINALLY 286
171
#define DEBUGGER 287
172
#define IMPORT 288
173
#define IF_WITHOUT_ELSE 289
174
#define ELSE 290
175
#define EQEQ 291
176
#define NE 292
177
#define STREQ 293
178
#define STRNEQ 294
179
#define LE 295
180
#define GE 296
181
#define OR 297
182
#define AND 298
183
#define PLUSPLUS 299
184
#define MINUSMINUS 300
185
#define LSHIFT 301
186
#define RSHIFT 302
187
#define URSHIFT 303
188
#define PLUSEQUAL 304
189
#define MINUSEQUAL 305
190
#define MULTEQUAL 306
191
#define DIVEQUAL 307
192
#define LSHIFTEQUAL 308
193
#define RSHIFTEQUAL 309
194
#define URSHIFTEQUAL 310
195
#define ANDEQUAL 311
196
#define MODEQUAL 312
197
#define XOREQUAL 313
198
#define OREQUAL 314
199
#define NUMBER 315
200
#define STRING 316
201
#define IDENT 317
202
#define AUTOPLUSPLUS 318
203
#define AUTOMINUSMINUS 319
204
205
206
207
208
/* Copy the first part of user declarations. */
209
#line 1 "grammar.y"
210
211
212
/*
213
* This file is part of the KDE libraries
214
* Copyright (C) 1999-2000 Harri Porten (porten@kde.org)
215
* Copyright (C) 2006, 2007 Apple Inc. All rights reserved.
216
*
217
* This library is free software; you can redistribute it and/or
218
* modify it under the terms of the GNU Lesser General Public
219
* License as published by the Free Software Foundation; either
220
* version 2 of the License, or (at your option) any later version.
221
*
222
* This library is distributed in the hope that it will be useful,
223
* but WITHOUT ANY WARRANTY; without even the implied warranty of
224
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
225
* Lesser General Public License for more details.
226
*
227
* You should have received a copy of the GNU Lesser General Public
228
* License along with this library; if not, write to the Free Software
229
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
230
*
231
*/
232
233
#include "config.h"
234
235
#include <string.h>
236
#include <stdlib.h>
237
#include "value.h"
238
#include "object.h"
239
#include "types.h"
240
#include "interpreter.h"
241
#include "nodes.h"
242
#include "makenodes.h"
243
#include "lexer.h"
244
#include "internal.h"
245
246
// Not sure why, but yacc doesn't add this define along with the others.
247
#define yylloc kjsyylloc
248
249
/* default values for bison */
250
#define YYDEBUG 0 // Set to 1 to debug a parse error.
251
#define kjsyydebug 0 // Set to 1 to debug a parse error.
252
#if !PLATFORM(DARWIN)
253
// avoid triggering warnings in older bison
254
#define YYERROR_VERBOSE
255
#endif
256
257
extern int kjsyylex();
258
int kjsyyerror(const char *);
259
static bool allowAutomaticSemicolon();
260
261
#define AUTO_SEMICOLON do { if (!allowAutomaticSemicolon()) YYABORT; } while (0)
262
#define DBG(l, s, e) (l)->setLoc((s).first_line, (e).last_line)
263
264
using namespace KJS;
265
266
267
268
/* Enabling traces. */
269
#ifndef YYDEBUG
270
# define YYDEBUG 0
271
#endif
272
273
/* Enabling verbose error messages. */
274
#ifdef YYERROR_VERBOSE
275
# undef YYERROR_VERBOSE
276
# define YYERROR_VERBOSE 1
277
#else
278
# define YYERROR_VERBOSE 0
279
#endif
280
281
/* Enabling the token table. */
282
#ifndef YYTOKEN_TABLE
283
# define YYTOKEN_TABLE 0
284
#endif
228
229
285
230
286
231
#if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED
287
232
typedef union YYSTYPE
233
{
234
235
/* Line 293 of yacc.c */
288
236
#line 59 "grammar.y"
289
{
237
290
238
int ival;
291
239
double dval;
292
240
UString *ustr;
313
261
PropertyNode *pnode;
314
262
PropertyNameNode *pname;
315
263
PackageNameNode *pkgn;
316
}
317
/* Line 187 of yacc.c. */
318
#line 319 "grammar.tab.c"
319
YYSTYPE;
264
265
266
267
/* Line 293 of yacc.c */
268
#line 269 "grammar.tab.c"
269
} YYSTYPE;
270
# define YYSTYPE_IS_TRIVIAL 1
320
271
# define yystype YYSTYPE /* obsolescent; will be withdrawn */
321
272
# define YYSTYPE_IS_DECLARED 1
322
# define YYSTYPE_IS_TRIVIAL 1
323
273
#endif
324
274
325
275
#if ! defined YYLTYPE && ! defined YYLTYPE_IS_DECLARED
339
289
/* Copy the second part of user declarations. */
340
290
341
291
342
/* Line 216 of yacc.c. */
343
#line 344 "grammar.tab.c"
292
/* Line 343 of yacc.c */
293
#line 294 "grammar.tab.c"
344
294
345
295
#ifdef short
346
296
# undef short
390
340
#define YYSIZE_MAXIMUM ((YYSIZE_T) -1)
391
341
392
342
#ifndef YY_
393
# if YYENABLE_NLS
343
# if defined YYENABLE_NLS && YYENABLE_NLS
394
344
# if ENABLE_NLS
395
345
# include <libintl.h> /* INFRINGES ON USER NAME SPACE */
396
346
# define YY_(msgid) dgettext ("bison-runtime", msgid)
415
365
#if (defined __STDC__ || defined __C99__FUNC__ \
416
366
|| defined __cplusplus || defined _MSC_VER)
417
367
static int
418
YYID (int i)
368
YYID (int yyi)
419
369
#else
420
370
static int
421
YYID (i)
422
int i;
371
YYID (yyi)
372
int yyi;
423
373
#endif
424
374
{
425
return i;
375
return yyi;
426
376
}
427
377
#endif
428
378
443
393
# define alloca _alloca
444
394
# else
445
395
# define YYSTACK_ALLOC alloca
446
# if ! defined _ALLOCA_H && ! defined _STDLIB_H && (defined __STDC__ || defined __C99__FUNC__ \
396
# if ! defined _ALLOCA_H && ! defined EXIT_SUCCESS && (defined __STDC__ || defined __C99__FUNC__ \
447
397
|| defined __cplusplus || defined _MSC_VER)
448
398
# include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
449
# ifndef _STDLIB_H
450
# define _STDLIB_H 1
399
# ifndef EXIT_SUCCESS
400
# define EXIT_SUCCESS 0
451
401
# endif
452
402
# endif
453
403
# endif
470
420
# ifndef YYSTACK_ALLOC_MAXIMUM
471
421
# define YYSTACK_ALLOC_MAXIMUM YYSIZE_MAXIMUM
472
422
# endif
473
# if (defined __cplusplus && ! defined _STDLIB_H \
423
# if (defined __cplusplus && ! defined EXIT_SUCCESS \
474
424
&& ! ((defined YYMALLOC || defined malloc) \
475
425
&& (defined YYFREE || defined free)))
476
426
# include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
477
# ifndef _STDLIB_H
478
# define _STDLIB_H 1
427
# ifndef EXIT_SUCCESS
428
# define EXIT_SUCCESS 0
479
429
# endif
480
430
# endif
481
431
# ifndef YYMALLOC
482
432
# define YYMALLOC malloc
483
# if ! defined malloc && ! defined _STDLIB_H && (defined __STDC__ || defined __C99__FUNC__ \
433
# if ! defined malloc && ! defined EXIT_SUCCESS && (defined __STDC__ || defined __C99__FUNC__ \
484
434
|| defined __cplusplus || defined _MSC_VER)
485
435
void *malloc (YYSIZE_T); /* INFRINGES ON USER NAME SPACE */
486
436
# endif
487
437
# endif
488
438
# ifndef YYFREE
489
439
# define YYFREE free
490
# if ! defined free && ! defined _STDLIB_H && (defined __STDC__ || defined __C99__FUNC__ \
440
# if ! defined free && ! defined EXIT_SUCCESS && (defined __STDC__ || defined __C99__FUNC__ \
491
441
|| defined __cplusplus || defined _MSC_VER)
492
442
void free (void *); /* INFRINGES ON USER NAME SPACE */
493
443
# endif
504
454
/* A type that is properly aligned for any stack member. */
505
455
union yyalloc
506
456
{
507
yytype_int16 yyss;
508
YYSTYPE yyvs;
509
YYLTYPE yyls;
457
yytype_int16 yyss_alloc;
458
YYSTYPE yyvs_alloc;
459
YYLTYPE yyls_alloc;
510
460
};
511
461
512
462
/* The size of the maximum gap between one aligned stack and the next. */
518
468
((N) * (sizeof (yytype_int16) + sizeof (YYSTYPE) + sizeof (YYLTYPE)) \
519
469
+ 2 * YYSTACK_GAP_MAXIMUM)
520
470
471
# define YYCOPY_NEEDED 1
472
473
/* Relocate STACK from its old location to the new one. The
474
local variables YYSIZE and YYSTACKSIZE give the old and new number of
475
elements in the stack, and YYPTR gives the new location of the
476
stack. Advance YYPTR to a properly aligned location for the next
477
stack. */
478
# define YYSTACK_RELOCATE(Stack_alloc, Stack) \
479
do \
480
{ \
481
YYSIZE_T yynewbytes; \
482
YYCOPY (&yyptr->Stack_alloc, Stack, yysize); \
483
Stack = &yyptr->Stack_alloc; \
484
yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \
485
yyptr += yynewbytes / sizeof (*yyptr); \
486
} \
487
while (YYID (0))
488
489
#endif
490
491
#if defined YYCOPY_NEEDED && YYCOPY_NEEDED
521
492
/* Copy COUNT objects from FROM to TO. The source and destination do
522
493
not overlap. */
523
494
# ifndef YYCOPY
535
506
while (YYID (0))
536
507
# endif
537
508
# endif
538
539
/* Relocate STACK from its old location to the new one. The
540
local variables YYSIZE and YYSTACKSIZE give the old and new number of
541
elements in the stack, and YYPTR gives the new location of the
542
stack. Advance YYPTR to a properly aligned location for the next
543
stack. */
544
# define YYSTACK_RELOCATE(Stack) \
545
do \
546
{ \
547
YYSIZE_T yynewbytes; \
548
YYCOPY (&yyptr->Stack, Stack, yysize); \
549
Stack = &yyptr->Stack; \
550
yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \
551
yyptr += yynewbytes / sizeof (*yyptr); \
552
} \
553
while (YYID (0))
554
555
#endif
509
#endif /* !YYCOPY_NEEDED */
556
510
557
511
/* YYFINAL -- State number of the termination state. */
558
512
#define YYFINAL 212
819
773
"AUTOMINUSMINUS", "'/'", "':'", "'('", "')'", "','", "'{'", "'}'", "'['",
820
774
"']'", "'.'", "'+'", "'-'", "'~'", "'!'", "'*'", "'%'", "'<'", "'>'",
821
775
"'&'", "'^'", "'|'", "'?'", "'='", "';'", "$accept", "Literal",
822
"PropertyName", "Property", "@1", "@2", "PropertyList", "PrimaryExpr",
776
"PropertyName", "Property", "$@1", "$@2", "PropertyList", "PrimaryExpr",
823
777
"PrimaryExprNoBrace", "ArrayLiteral", "ElementList", "ElisionOpt",
824
778
"Elision", "MemberExpr", "MemberExprNoBF", "NewExpr", "NewExprNoBF",
825
779
"CallExpr", "CallExprNoBF", "Arguments", "ArgumentList",
846
800
"CaseBlock", "CaseClausesOpt", "CaseClauses", "CaseClause",
847
801
"DefaultClause", "LabelledStatement", "ThrowStatement", "TryStatement",
848
802
"DebuggerStatement", "PackageName", "ImportStatement",
849
"FunctionDeclaration", "@3", "@4", "FunctionExpr", "@5", "@6", "@7",
850
"@8", "FormalParameterList", "FunctionBody", "Program", "SourceElements",
851
"SourceElement", 0
803
"FunctionDeclaration", "$@3", "$@4", "FunctionExpr", "$@5", "$@6", "$@7",
804
"$@8", "FormalParameterList", "FunctionBody", "Program",
805
"SourceElements", "SourceElement", 0
852
806
};
853
807
#endif
854
808
943
897
1, 3, 2, 3, 0, 1, 1, 2, 1, 1
944
898
};
945
899
946
/* YYDEFACT[STATE-NAME] -- Default rule to reduce with in state
947
STATE-NUM when YYTABLE doesn't specify something else to do. Zero
900
/* YYDEFACT[STATE-NAME] -- Default reduction number in state STATE-NUM.
901
Performed when YYTABLE doesn't specify something else to do. Zero
948
902
means the default is an error. */
949
903
static const yytype_uint16 yydefact[] =
950
904
{
1105
1059
1106
1060
/* YYTABLE[YYPACT[STATE-NUM]]. What to do in state STATE-NUM. If
1107
1061
positive, shift that token. If negative, reduce the rule which
1108
number is the opposite. If zero, do what YYDEFACT says.
1109
If YYTABLE_NINF, syntax error. */
1062
number is the opposite. If YYTABLE_NINF, syntax error. */
1110
1063
#define YYTABLE_NINF -1
1111
1064
static const yytype_uint16 yytable[] =
1112
1065
{
1263
1216
37, 38, 39, 40
1264
1217
};
1265
1218
1219
#define yypact_value_is_default(yystate) \
1220
((yystate) == (-415))
1221
1222
#define yytable_value_is_error(yytable_value) \
1223
YYID (0)
1224
1266
1225
static const yytype_int16 yycheck[] =
1267
1226
{
1268
1227
0, 35, 11, 85, 22, 16, 348, 42, 1, 47,
1492
1451
1493
1452
/* Like YYERROR except do call yyerror. This remains here temporarily
1494
1453
to ease the transition to the new meaning of YYERROR, for GCC.
1495
Once GCC version 2 has supplanted version 1, this can go. */
1454
Once GCC version 2 has supplanted version 1, this can go. However,
1455
YYFAIL appears to be in use. Nevertheless, it is formally deprecated
1456
in Bison 2.4.2's NEWS entry, where a plan to phase it out is
1457
discussed. */
1496
1458
1497
1459
#define YYFAIL goto yyerrlab
1460
#if defined YYFAIL
1461
/* This is here to suppress warnings from the GCC cpp's
1462
-Wunused-macros. Normally we don't worry about that warning, but
1463
some users do, and we want to make it easy for users to remove
1464
YYFAIL uses, which will produce warnings from Bison 2.5. */
1465
#endif
1498
1466
1499
1467
#define YYRECOVERING() (!!yyerrstatus)
1500
1468
1504
1472
{ \
1505
1473
yychar = (Token); \
1506
1474
yylval = (Value); \
1507
yytoken = YYTRANSLATE (yychar); \
1508
1475
YYPOPSTACK (1); \
1509
1476
goto yybackup; \
1510
1477
} \
1551
1518
we won't break user code: when these are the locations we know. */
1552
1519
1553
1520
#ifndef YY_LOCATION_PRINT
1554
# if YYLTYPE_IS_TRIVIAL
1521
# if defined YYLTYPE_IS_TRIVIAL && YYLTYPE_IS_TRIVIAL
1555
1522
# define YY_LOCATION_PRINT(File, Loc) \
1556
1523
fprintf (File, "%d.%d-%d.%d", \
1557
1524
(Loc).first_line, (Loc).first_column, \
1667
1634
#if (defined __STDC__ || defined __C99__FUNC__ \
1668
1635
|| defined __cplusplus || defined _MSC_VER)
1669
1636
static void
1670
yy_stack_print (yytype_int16 *bottom, yytype_int16 *top)
1637
yy_stack_print (yytype_int16 *yybottom, yytype_int16 *yytop)
1671
1638
#else
1672
1639
static void
1673
yy_stack_print (bottom, top)
1674
yytype_int16 *bottom;
1675
yytype_int16 *top;
1640
yy_stack_print (yybottom, yytop)
1641
yytype_int16 *yybottom;
1642
yytype_int16 *yytop;
1676
1643
#endif
1677
1644
{
1678
1645
YYFPRINTF (stderr, "Stack now");
1679
for (; bottom <= top; ++bottom)
1680
YYFPRINTF (stderr, " %d", *bottom);
1646
for (; yybottom <= yytop; yybottom++)
1647
{
1648
int yybot = *yybottom;
1649
YYFPRINTF (stderr, " %d", yybot);
1650
}
1681
1651
YYFPRINTF (stderr, "\n");
1682
1652
}
1683
1653
1712
1682
/* The symbols being reduced. */
1713
1683
for (yyi = 0; yyi < yynrhs; yyi++)
1714
1684
{
1715
fprintf (stderr, " $%d = ", yyi + 1);
1685
YYFPRINTF (stderr, " $%d = ", yyi + 1);
1716
1686
yy_symbol_print (stderr, yyrhs[yyprhs[yyrule] + yyi],
1717
1687
&(yyvsp[(yyi + 1) - (yynrhs)])
1718
1688
, &(yylsp[(yyi + 1) - (yynrhs)]) );
1719
fprintf (stderr, "\n");
1689
YYFPRINTF (stderr, "\n");
1720
1690
}
1721
1691
}
1722
1692
1753
1723
# define YYMAXDEPTH 10000
1754
1724
#endif
1755
1725
1756
1757
1726
1758
1727
#if YYERROR_VERBOSE
1759
1728
1856
1825
}
1857
1826
# endif
1858
1827
1859
/* Copy into YYRESULT an error message about the unexpected token
1860
YYCHAR while in state YYSTATE. Return the number of bytes copied,
1861
including the terminating null byte. If YYRESULT is null, do not
1862
copy anything; just return the number of bytes that would be
1863
copied. As a special case, return 0 if an ordinary "syntax error"
1864
message will do. Return YYSIZE_MAXIMUM if overflow occurs during
1865
size calculation. */
1866
static YYSIZE_T
1867
yysyntax_error (char *yyresult, int yystate, int yychar)
1828
/* Copy into *YYMSG, which is of size *YYMSG_ALLOC, an error message
1829
about the unexpected token YYTOKEN for the state stack whose top is
1830
YYSSP.
1831
1832
Return 0 if *YYMSG was successfully written. Return 1 if *YYMSG is
1833
not large enough to hold the message. In that case, also set
1834
*YYMSG_ALLOC to the required number of bytes. Return 2 if the
1835
required number of bytes is too large to store. */
1836
static int
1837
yysyntax_error (YYSIZE_T *yymsg_alloc, char **yymsg,
1838
yytype_int16 *yyssp, int yytoken)
1868
1839
{
1869
int yyn = yypact[yystate];
1870
1871
if (! (YYPACT_NINF < yyn && yyn <= YYLAST))
1872
return 0;
1873
else
1874
{
1875
int yytype = YYTRANSLATE (yychar);
1876
YYSIZE_T yysize0 = yytnamerr (0, yytname[yytype]);
1877
YYSIZE_T yysize = yysize0;
1878
YYSIZE_T yysize1;
1879
int yysize_overflow = 0;
1880
enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 };
1881
char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM];
1882
int yyx;
1883
1884
# if 0
1885
/* This is so xgettext sees the translatable formats that are
1886
constructed on the fly. */
1887
YY_("syntax error, unexpected %s");
1888
YY_("syntax error, unexpected %s, expecting %s");
1889
YY_("syntax error, unexpected %s, expecting %s or %s");
1890
YY_("syntax error, unexpected %s, expecting %s or %s or %s");
1891
YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s");
1892
# endif
1893
char *yyfmt;
1894
char const *yyf;
1895
static char const yyunexpected[] = "syntax error, unexpected %s";
1896
static char const yyexpecting[] = ", expecting %s";
1897
static char const yyor[] = " or %s";
1898
char yyformat[sizeof yyunexpected
1899
+ sizeof yyexpecting - 1
1900
+ ((YYERROR_VERBOSE_ARGS_MAXIMUM - 2)
1901
* (sizeof yyor - 1))];
1902
char const *yyprefix = yyexpecting;
1903
1904
/* Start YYX at -YYN if negative to avoid negative indexes in
1905
YYCHECK. */
1906
int yyxbegin = yyn < 0 ? -yyn : 0;
1907
1908
/* Stay within bounds of both yycheck and yytname. */
1909
int yychecklim = YYLAST - yyn + 1;
1910
int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS;
1911
int yycount = 1;
1912
1913
yyarg[0] = yytname[yytype];
1914
yyfmt = yystpcpy (yyformat, yyunexpected);
1915
1916
for (yyx = yyxbegin; yyx < yyxend; ++yyx)
1917
if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR)
1918
{
1919
if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM)
1920
{
1921
yycount = 1;
1922
yysize = yysize0;
1923
yyformat[sizeof yyunexpected - 1] = '\0';
1924
break;
1925
}
1926
yyarg[yycount++] = yytname[yyx];
1927
yysize1 = yysize + yytnamerr (0, yytname[yyx]);
1928
yysize_overflow |= (yysize1 < yysize);
1929
yysize = yysize1;
1930
yyfmt = yystpcpy (yyfmt, yyprefix);
1931
yyprefix = yyor;
1932
}
1933
1934
yyf = YY_(yyformat);
1935
yysize1 = yysize + yystrlen (yyf);
1936
yysize_overflow |= (yysize1 < yysize);
1937
yysize = yysize1;
1938
1939
if (yysize_overflow)
1940
return YYSIZE_MAXIMUM;
1941
1942
if (yyresult)
1943
{
1944
/* Avoid sprintf, as that infringes on the user's name space.
1945
Don't have undefined behavior even if the translation
1946
produced a string with the wrong number of "%s"s. */
1947
char *yyp = yyresult;
1948
int yyi = 0;
1949
while ((*yyp = *yyf) != '\0')
1950
{
1951
if (*yyp == '%' && yyf[1] == 's' && yyi < yycount)
1952
{
1953
yyp += yytnamerr (yyp, yyarg[yyi++]);
1954
yyf += 2;
1955
}
1956
else
1957
{
1958
yyp++;
1959
yyf++;
1960
}
1961
}
1962
}
1963
return yysize;
1964
}
1840
YYSIZE_T yysize0 = yytnamerr (0, yytname[yytoken]);
1841
YYSIZE_T yysize = yysize0;
1842
YYSIZE_T yysize1;
1843
enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 };
1844
/* Internationalized format string. */
1845
const char *yyformat = 0;
1846
/* Arguments of yyformat. */
1847
char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM];
1848
/* Number of reported tokens (one for the "unexpected", one per
1849
"expected"). */
1850
int yycount = 0;
1851
1852
/* There are many possibilities here to consider:
1853
- Assume YYFAIL is not used. It's too flawed to consider. See
1854
<http://lists.gnu.org/archive/html/bison-patches/2009-12/msg00024.html>
1855
for details. YYERROR is fine as it does not invoke this
1856
function.
1857
- If this state is a consistent state with a default action, then
1858
the only way this function was invoked is if the default action
1859
is an error action. In that case, don't check for expected
1860
tokens because there are none.
1861
- The only way there can be no lookahead present (in yychar) is if
1862
this state is a consistent state with a default action. Thus,
1863
detecting the absence of a lookahead is sufficient to determine
1864
that there is no unexpected or expected token to report. In that
1865
case, just report a simple "syntax error".
1866
- Don't assume there isn't a lookahead just because this state is a
1867
consistent state with a default action. There might have been a
1868
previous inconsistent state, consistent state with a non-default
1869
action, or user semantic action that manipulated yychar.
1870
- Of course, the expected token list depends on states to have
1871
correct lookahead information, and it depends on the parser not
1872
to perform extra reductions after fetching a lookahead from the
1873
scanner and before detecting a syntax error. Thus, state merging
1874
(from LALR or IELR) and default reductions corrupt the expected
1875
token list. However, the list is correct for canonical LR with
1876
one exception: it will still contain any token that will not be
1877
accepted due to an error action in a later state.
1878
*/
1879
if (yytoken != YYEMPTY)
1880
{
1881
int yyn = yypact[*yyssp];
1882
yyarg[yycount++] = yytname[yytoken];
1883
if (!yypact_value_is_default (yyn))
1884
{
1885
/* Start YYX at -YYN if negative to avoid negative indexes in
1886
YYCHECK. In other words, skip the first -YYN actions for
1887
this state because they are default actions. */
1888
int yyxbegin = yyn < 0 ? -yyn : 0;
1889
/* Stay within bounds of both yycheck and yytname. */
1890
int yychecklim = YYLAST - yyn + 1;
1891
int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS;
1892
int yyx;
1893
1894
for (yyx = yyxbegin; yyx < yyxend; ++yyx)
1895
if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR
1896
&& !yytable_value_is_error (yytable[yyx + yyn]))
1897
{
1898
if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM)
1899
{
1900
yycount = 1;
1901
yysize = yysize0;
1902
break;
1903
}
1904
yyarg[yycount++] = yytname[yyx];
1905
yysize1 = yysize + yytnamerr (0, yytname[yyx]);
1906
if (! (yysize <= yysize1
1907
&& yysize1 <= YYSTACK_ALLOC_MAXIMUM))
1908
return 2;
1909
yysize = yysize1;
1910
}
1911
}
1912
}
1913
1914
switch (yycount)
1915
{
1916
# define YYCASE_(N, S) \
1917
case N: \
1918
yyformat = S; \
1919
break
1920
YYCASE_(0, YY_("syntax error"));
1921
YYCASE_(1, YY_("syntax error, unexpected %s"));
1922
YYCASE_(2, YY_("syntax error, unexpected %s, expecting %s"));
1923
YYCASE_(3, YY_("syntax error, unexpected %s, expecting %s or %s"));
1924
YYCASE_(4, YY_("syntax error, unexpected %s, expecting %s or %s or %s"));
1925
YYCASE_(5, YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s"));
1926
# undef YYCASE_
1927
}
1928
1929
yysize1 = yysize + yystrlen (yyformat);
1930
if (! (yysize <= yysize1 && yysize1 <= YYSTACK_ALLOC_MAXIMUM))
1931
return 2;
1932
yysize = yysize1;
1933
1934
if (*yymsg_alloc < yysize)
1935
{
1936
*yymsg_alloc = 2 * yysize;
1937
if (! (yysize <= *yymsg_alloc
1938
&& *yymsg_alloc <= YYSTACK_ALLOC_MAXIMUM))
1939
*yymsg_alloc = YYSTACK_ALLOC_MAXIMUM;
1940
return 1;
1941
}
1942
1943
/* Avoid sprintf, as that infringes on the user's name space.
1944
Don't have undefined behavior even if the translation
1945
produced a string with the wrong number of "%s"s. */
1946
{
1947
char *yyp = *yymsg;
1948
int yyi = 0;
1949
while ((*yyp = *yyformat) != '\0')
1950
if (*yyp == '%' && yyformat[1] == 's' && yyi < yycount)
1951
{
1952
yyp += yytnamerr (yyp, yyarg[yyi++]);
1953
yyformat += 2;
1954
}
1955
else
1956
{
1957
yyp++;
1958
yyformat++;
1959
}
1960
}
1961
return 0;
1965
1962
}
1966
1963
#endif /* YYERROR_VERBOSE */
1967
1968
1964
1969
1965
/*-----------------------------------------------.
1970
1966
| Release the memory associated to this symbol. |
1998
1994
break;
1999
1995
}
2000
1996
}
2001
1997
2002
1998
2003
1999
/* Prevent warnings from -Wmissing-prototypes. */
2004
2005
2000
#ifdef YYPARSE_PARAM
2006
2001
#if defined __STDC__ || defined __cplusplus
2007
2002
int yyparse (void *YYPARSE_PARAM);
2017
2012
#endif /* ! YYPARSE_PARAM */
2018
2013
2019
2014
2020
2021
/* The look-ahead symbol. */
2015
/* The lookahead symbol. */
2022
2016
int yychar;
2023
2017
2024
/* The semantic value of the look-ahead symbol. */
2018
/* The semantic value of the lookahead symbol. */
2025
2019
YYSTYPE yylval;
2026
2020
2021
/* Location data for the lookahead symbol. */
2022
YYLTYPE yylloc;
2023
2027
2024
/* Number of syntax errors so far. */
2028
2025
int yynerrs;
2029
/* Location data for the look-ahead symbol. */
2030
YYLTYPE yylloc;
2031
2032
2026
2033
2027
2034
2028
/*----------.
2057
2051
#endif
2058
2052
#endif
2059
2053
{
2060
2061
int yystate;
2054
int yystate;
2055
/* Number of tokens to shift before error messages enabled. */
2056
int yyerrstatus;
2057
2058
/* The stacks and their tools:
2059
`yyss': related to states.
2060
`yyvs': related to semantic values.
2061
`yyls': related to locations.
2062
2063
Refer to the stacks thru separate pointers, to allow yyoverflow
2064
to reallocate them elsewhere. */
2065
2066
/* The state stack. */
2067
yytype_int16 yyssa[YYINITDEPTH];
2068
yytype_int16 *yyss;
2069
yytype_int16 *yyssp;
2070
2071
/* The semantic value stack. */
2072
YYSTYPE yyvsa[YYINITDEPTH];
2073
YYSTYPE *yyvs;
2074
YYSTYPE *yyvsp;
2075
2076
/* The location stack. */
2077
YYLTYPE yylsa[YYINITDEPTH];
2078
YYLTYPE *yyls;
2079
YYLTYPE *yylsp;
2080
2081
/* The locations where the error started and ended. */
2082
YYLTYPE yyerror_range[3];
2083
2084
YYSIZE_T yystacksize;
2085
2062
2086
int yyn;
2063
2087
int yyresult;
2064
/* Number of tokens to shift before error messages enabled. */
2065
int yyerrstatus;
2066
/* Look-ahead token as an internal (translated) token number. */
2067
int yytoken = 0;
2088
/* Lookahead token as an internal (translated) token number. */
2089
int yytoken;
2090
/* The variables used to return semantic value and location from the
2091
action routines. */
2092
YYSTYPE yyval;
2093
YYLTYPE yyloc;
2094
2068
2095
#if YYERROR_VERBOSE
2069
2096
/* Buffer for error messages, and its allocated size. */
2070
2097
char yymsgbuf[128];
2072
2099
YYSIZE_T yymsg_alloc = sizeof yymsgbuf;
2073
2100
#endif
2074
2101
2075
/* Three stacks and their tools:
2076
`yyss': related to states,
2077
`yyvs': related to semantic values,
2078
`yyls': related to locations.
2079
2080
Refer to the stacks thru separate pointers, to allow yyoverflow
2081
to reallocate them elsewhere. */
2082
2083
/* The state stack. */
2084
yytype_int16 yyssa[YYINITDEPTH];
2085
yytype_int16 *yyss = yyssa;
2086
yytype_int16 *yyssp;
2087
2088
/* The semantic value stack. */
2089
YYSTYPE yyvsa[YYINITDEPTH];
2090
YYSTYPE *yyvs = yyvsa;
2091
YYSTYPE *yyvsp;
2092
2093
/* The location stack. */
2094
YYLTYPE yylsa[YYINITDEPTH];
2095
YYLTYPE *yyls = yylsa;
2096
YYLTYPE *yylsp;
2097
/* The locations where the error started and ended. */
2098
YYLTYPE yyerror_range[2];
2099
2100
2102
#define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N), yylsp -= (N))
2101
2103
2102
YYSIZE_T yystacksize = YYINITDEPTH;
2103
2104
/* The variables used to return semantic value and location from the
2105
action routines. */
2106
YYSTYPE yyval;
2107
YYLTYPE yyloc;
2108
2109
2104
/* The number of symbols on the RHS of the reduced rule.
2110
2105
Keep to zero when no symbol should be popped. */
2111
2106
int yylen = 0;
2112
2107
2108
yytoken = 0;
2109
yyss = yyssa;
2110
yyvs = yyvsa;
2111
yyls = yylsa;
2112
yystacksize = YYINITDEPTH;
2113
2113
2114
YYDPRINTF ((stderr, "Starting parse\n"));
2114
2115
2115
2116
yystate = 0;
2116
2117
yyerrstatus = 0;
2117
2118
yynerrs = 0;
2118
yychar = YYEMPTY; /* Cause a token to be read. */
2119
yychar = YYEMPTY; /* Cause a token to be read. */
2119
2120
2120
2121
/* Initialize stack pointers.
2121
2122
Waste one element of value and location stack
2122
2123
so that they stay on the same level as the state stack.
2123
2124
The wasted elements are never initialized. */
2124
2125
2125
yyssp = yyss;
2126
2126
yyvsp = yyvs;
2127
2127
yylsp = yyls;
2128
#if YYLTYPE_IS_TRIVIAL
2128
2129
#if defined YYLTYPE_IS_TRIVIAL && YYLTYPE_IS_TRIVIAL
2129
2130
/* Initialize the default location before parsing starts. */
2130
2131
yylloc.first_line = yylloc.last_line = 1;
2131
yylloc.first_column = yylloc.last_column = 0;
2132
yylloc.first_column = yylloc.last_column = 1;
2132
2133
#endif
2133
2134
2134
2135
goto yysetstate;
2167
2168
&yyvs1, yysize * sizeof (*yyvsp),
2168
2169
&yyls1, yysize * sizeof (*yylsp),
2169
2170
&yystacksize);
2171
2170
2172
yyls = yyls1;
2171
2173
yyss = yyss1;
2172
2174
yyvs = yyvs1;
2188
2190
(union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize));
2189
2191
if (! yyptr)
2190
2192
goto yyexhaustedlab;
2191
YYSTACK_RELOCATE (yyss);
2192
YYSTACK_RELOCATE (yyvs);
2193
YYSTACK_RELOCATE (yyls);
2193
YYSTACK_RELOCATE (yyss_alloc, yyss);
2194
YYSTACK_RELOCATE (yyvs_alloc, yyvs);
2195
YYSTACK_RELOCATE (yyls_alloc, yyls);
2194
2196
# undef YYSTACK_RELOCATE
2195
2197
if (yyss1 != yyssa)
2196
2198
YYSTACK_FREE (yyss1);
2211
2213
2212
2214
YYDPRINTF ((stderr, "Entering state %d\n", yystate));
2213
2215
2216
if (yystate == YYFINAL)
2217
YYACCEPT;
2218
2214
2219
goto yybackup;
2215
2220
2216
2221
/*-----------.
2219
2224
yybackup:
2220
2225
2221
2226
/* Do appropriate processing given the current state. Read a
2222
look-ahead token if we need one and don't already have one. */
2227
lookahead token if we need one and don't already have one. */
2223
2228
2224
/* First try to decide what to do without reference to look-ahead token. */
2229
/* First try to decide what to do without reference to lookahead token. */
2225
2230
yyn = yypact[yystate];
2226
if (yyn == YYPACT_NINF)
2231
if (yypact_value_is_default (yyn))
2227
2232
goto yydefault;
2228
2233
2229
/* Not known => get a look-ahead token if don't already have one. */
2234
/* Not known => get a lookahead token if don't already have one. */
2230
2235
2231
/* YYCHAR is either YYEMPTY or YYEOF or a valid look-ahead symbol. */
2236
/* YYCHAR is either YYEMPTY or YYEOF or a valid lookahead symbol. */
2232
2237
if (yychar == YYEMPTY)
2233
2238
{
2234
2239
YYDPRINTF ((stderr, "Reading a token: "));
2254
2259
yyn = yytable[yyn];
2255
2260
if (yyn <= 0)
2256
2261
{
2257
if (yyn == 0 || yyn == YYTABLE_NINF)
2258
goto yyerrlab;
2262
if (yytable_value_is_error (yyn))
2263
goto yyerrlab;
2259
2264
yyn = -yyn;
2260
2265
goto yyreduce;
2261
2266
}
2262
2267
2263
if (yyn == YYFINAL)
2264
YYACCEPT;
2265
2266
2268
/* Count tokens shifted since error; after three, turn off error
2267
2269
status. */
2268
2270
if (yyerrstatus)
2269
2271
yyerrstatus--;
2270
2272
2271
/* Shift the look-ahead token. */
2273
/* Shift the lookahead token. */
2272
2274
YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc);
2273
2275
2274
/* Discard the shifted token unless it is eof. */
2275
if (yychar != YYEOF)
2276
yychar = YYEMPTY;
2276
/* Discard the shifted token. */
2277
yychar = YYEMPTY;
2277
2278
2278
2279
yystate = yyn;
2279
2280
*++yyvsp = yylval;
2314
2315
switch (yyn)
2315
2316
{
2316
2317
case 2:
2318
2319
/* Line 1806 of yacc.c */
2317
2320
#line 185 "grammar.y"
2318
{ (yyval.node) = new NullNode(); ;}
2321
{ (yyval.node) = new NullNode(); }
2319
2322
break;
2320
2323
2321
2324
case 3:
2325
2326
/* Line 1806 of yacc.c */
2322
2327
#line 186 "grammar.y"
2323
{ (yyval.node) = new BooleanNode(true); ;}
2328
{ (yyval.node) = new BooleanNode(true); }
2324
2329
break;
2325
2330
2326
2331
case 4:
2332
2333
/* Line 1806 of yacc.c */
2327
2334
#line 187 "grammar.y"
2328
{ (yyval.node) = new BooleanNode(false); ;}
2335
{ (yyval.node) = new BooleanNode(false); }
2329
2336
break;
2330
2337
2331
2338
case 5:
2339
2340
/* Line 1806 of yacc.c */
2332
2341
#line 188 "grammar.y"
2333
{ (yyval.node) = new NumberNode((yyvsp[(1) - (1)].dval)); ;}
2342
{ (yyval.node) = new NumberNode((yyvsp[(1) - (1)].dval)); }
2334
2343
break;
2335
2344
2336
2345
case 6:
2346
2347
/* Line 1806 of yacc.c */
2337
2348
#line 189 "grammar.y"
2338
{ (yyval.node) = new StringNode((yyvsp[(1) - (1)].ustr)); ;}
2349
{ (yyval.node) = new StringNode((yyvsp[(1) - (1)].ustr)); }
2339
2350
break;
2340
2351
2341
2352
case 7:
2353
2354
/* Line 1806 of yacc.c */
2342
2355
#line 190 "grammar.y"
2343
2356
{
2344
2357
Lexer& l = lexer();
2345
2358
if (!l.scanRegExp())
2346
2359
YYABORT;
2347
2360
(yyval.node) = new RegExpNode(l.pattern(), l.flags());
2348
;}
2361
}
2349
2362
break;
2350
2363
2351
2364
case 8:
2365
2366
/* Line 1806 of yacc.c */
2352
2367
#line 196 "grammar.y"
2353
2368
{
2354
2369
Lexer& l = lexer();
2355
2370
if (!l.scanRegExp())
2356
2371
YYABORT;
2357
2372
(yyval.node) = new RegExpNode("=" + l.pattern(), l.flags());
2358
;}
2373
}
2359
2374
break;
2360
2375
2361
2376
case 9:
2377
2378
/* Line 1806 of yacc.c */
2362
2379
#line 205 "grammar.y"
2363
{ (yyval.pname) = new PropertyNameNode(*(yyvsp[(1) - (1)].ident)); ;}
2380
{ (yyval.pname) = new PropertyNameNode(*(yyvsp[(1) - (1)].ident)); }
2364
2381
break;
2365
2382
2366
2383
case 10:
2384
2385
/* Line 1806 of yacc.c */
2367
2386
#line 206 "grammar.y"
2368
{ (yyval.pname) = new PropertyNameNode(Identifier(*(yyvsp[(1) - (1)].ustr))); ;}
2387
{ (yyval.pname) = new PropertyNameNode(Identifier(*(yyvsp[(1) - (1)].ustr))); }
2369
2388
break;
2370
2389
2371
2390
case 11:
2391
2392
/* Line 1806 of yacc.c */
2372
2393
#line 207 "grammar.y"
2373
{ (yyval.pname) = new PropertyNameNode(Identifier(UString::from((yyvsp[(1) - (1)].dval)))); ;}
2394
{ (yyval.pname) = new PropertyNameNode(Identifier(UString::from((yyvsp[(1) - (1)].dval)))); }
2374
2395
break;
2375
2396
2376
2397
case 12:
2398
2399
/* Line 1806 of yacc.c */
2377
2400
#line 211 "grammar.y"
2378
{ (yyval.pnode) = new PropertyNode((yyvsp[(1) - (3)].pname), (yyvsp[(3) - (3)].node), PropertyNode::Constant); ;}
2401
{ (yyval.pnode) = new PropertyNode((yyvsp[(1) - (3)].pname), (yyvsp[(3) - (3)].node), PropertyNode::Constant); }
2379
2402
break;
2380
2403
2381
2404
case 13:
2405
2406
/* Line 1806 of yacc.c */
2382
2407
#line 212 "grammar.y"
2383
2408
{inFuncExpr();}
2384
2409
break;
2385
2410
2386
2411
case 14:
2412
2413
/* Line 1806 of yacc.c */
2387
2414
#line 212 "grammar.y"
2388
2415
{
2389
2416
if (!makeGetterOrSetterPropertyNode((yyval.pnode), *(yyvsp[(1) - (6)].ident), *(yyvsp[(2) - (6)].ident), 0, (yyvsp[(6) - (6)].body)))
2390
2417
YYABORT;
2391
;}
2418
}
2392
2419
break;
2393
2420
2394
2421
case 15:
2422
2423
/* Line 1806 of yacc.c */
2395
2424
#line 216 "grammar.y"
2396
2425
{inFuncExpr();}
2397
2426
break;
2398
2427
2399
2428
case 16:
2429
2430
/* Line 1806 of yacc.c */
2400
2431
#line 216 "grammar.y"
2401
2432
{
2402
2433
if (!makeGetterOrSetterPropertyNode((yyval.pnode), *(yyvsp[(1) - (7)].ident), *(yyvsp[(2) - (7)].ident), (yyvsp[(4) - (7)].param), (yyvsp[(7) - (7)].body)))
2403
2434
YYABORT;
2404
;}
2435
}
2405
2436
break;
2406
2437
2407
2438
case 17:
2439
2440
/* Line 1806 of yacc.c */
2408
2441
#line 223 "grammar.y"
2409
{ (yyval.plist) = new PropertyListNode((yyvsp[(1) - (1)].pnode)); ;}
2442
{ (yyval.plist) = new PropertyListNode((yyvsp[(1) - (1)].pnode)); }
2410
2443
break;
2411
2444
2412
2445
case 18:
2446
2447
/* Line 1806 of yacc.c */
2413
2448
#line 224 "grammar.y"
2414
{ (yyval.plist) = new PropertyListNode((yyvsp[(3) - (3)].pnode), (yyvsp[(1) - (3)].plist)); ;}
2449
{ (yyval.plist) = new PropertyListNode((yyvsp[(3) - (3)].pnode), (yyvsp[(1) - (3)].plist)); }
2415
2450
break;
2416
2451
2417
2452
case 20:
2453
2454
/* Line 1806 of yacc.c */
2418
2455
#line 229 "grammar.y"
2419
{ (yyval.node) = new ObjectLiteralNode(); ;}
2456
{ (yyval.node) = new ObjectLiteralNode(); }
2420
2457
break;
2421
2458
2422
2459
case 21:
2460
2461
/* Line 1806 of yacc.c */
2423
2462
#line 230 "grammar.y"
2424
{ (yyval.node) = new ObjectLiteralNode((yyvsp[(2) - (3)].plist)); ;}
2463
{ (yyval.node) = new ObjectLiteralNode((yyvsp[(2) - (3)].plist)); }
2425
2464
break;
2426
2465
2427
2466
case 22:
2467
2468
/* Line 1806 of yacc.c */
2428
2469
#line 232 "grammar.y"
2429
{ (yyval.node) = new ObjectLiteralNode((yyvsp[(2) - (4)].plist)); ;}
2470
{ (yyval.node) = new ObjectLiteralNode((yyvsp[(2) - (4)].plist)); }
2430
2471
break;
2431
2472
2432
2473
case 23:
2474
2475
/* Line 1806 of yacc.c */
2433
2476
#line 236 "grammar.y"
2434
{ (yyval.node) = new ThisNode(); ;}
2477
{ (yyval.node) = new ThisNode(); }
2435
2478
break;
2436
2479
2437
2480
case 26:
2481
2482
/* Line 1806 of yacc.c */
2438
2483
#line 239 "grammar.y"
2439
{ (yyval.node) = new VarAccessNode(*(yyvsp[(1) - (1)].ident)); ;}
2484
{ (yyval.node) = new VarAccessNode(*(yyvsp[(1) - (1)].ident)); }
2440
2485
break;
2441
2486
2442
2487
case 27:
2488
2489
/* Line 1806 of yacc.c */
2443
2490
#line 240 "grammar.y"
2444
{ (yyval.node) = makeGroupNode((yyvsp[(2) - (3)].node)); ;}
2491
{ (yyval.node) = makeGroupNode((yyvsp[(2) - (3)].node)); }
2445
2492
break;
2446
2493
2447
2494
case 28:
2495
2496
/* Line 1806 of yacc.c */
2448
2497
#line 245 "grammar.y"
2449
{ (yyval.node) = new ArrayNode((yyvsp[(2) - (3)].ival)); ;}
2498
{ (yyval.node) = new ArrayNode((yyvsp[(2) - (3)].ival)); }
2450
2499
break;
2451
2500
2452
2501
case 29:
2502
2503
/* Line 1806 of yacc.c */
2453
2504
#line 246 "grammar.y"
2454
{ (yyval.node) = new ArrayNode((yyvsp[(2) - (3)].elm)); ;}
2505
{ (yyval.node) = new ArrayNode((yyvsp[(2) - (3)].elm)); }
2455
2506
break;
2456
2507
2457
2508
case 30:
2509
2510
/* Line 1806 of yacc.c */
2458
2511
#line 247 "grammar.y"
2459
{ (yyval.node) = new ArrayNode((yyvsp[(4) - (5)].ival), (yyvsp[(2) - (5)].elm)); ;}
2512
{ (yyval.node) = new ArrayNode((yyvsp[(4) - (5)].ival), (yyvsp[(2) - (5)].elm)); }
2460
2513
break;
2461
2514
2462
2515
case 31:
2516
2517
/* Line 1806 of yacc.c */
2463
2518
#line 251 "grammar.y"
2464
{ (yyval.elm) = new ElementNode((yyvsp[(1) - (2)].ival), (yyvsp[(2) - (2)].node)); ;}
2519
{ (yyval.elm) = new ElementNode((yyvsp[(1) - (2)].ival), (yyvsp[(2) - (2)].node)); }
2465
2520
break;
2466
2521
2467
2522
case 32:
2523
2524
/* Line 1806 of yacc.c */
2468
2525
#line 253 "grammar.y"
2469
{ (yyval.elm) = new ElementNode((yyvsp[(1) - (4)].elm), (yyvsp[(3) - (4)].ival), (yyvsp[(4) - (4)].node)); ;}
2526
{ (yyval.elm) = new ElementNode((yyvsp[(1) - (4)].elm), (yyvsp[(3) - (4)].ival), (yyvsp[(4) - (4)].node)); }
2470
2527
break;
2471
2528
2472
2529
case 33:
2530
2531
/* Line 1806 of yacc.c */
2473
2532
#line 257 "grammar.y"
2474
{ (yyval.ival) = 0; ;}
2533
{ (yyval.ival) = 0; }
2475
2534
break;
2476
2535
2477
2536
case 35:
2537
2538
/* Line 1806 of yacc.c */
2478
2539
#line 262 "grammar.y"
2479
{ (yyval.ival) = 1; ;}
2540
{ (yyval.ival) = 1; }
2480
2541
break;
2481
2542
2482
2543
case 36:
2544
2545
/* Line 1806 of yacc.c */
2483
2546
#line 263 "grammar.y"
2484
{ (yyval.ival) = (yyvsp[(1) - (2)].ival) + 1; ;}
2547
{ (yyval.ival) = (yyvsp[(1) - (2)].ival) + 1; }
2485
2548
break;
2486
2549
2487
2550
case 38:
2551
2552
/* Line 1806 of yacc.c */
2488
2553
#line 268 "grammar.y"
2489
{ (yyval.node) = (yyvsp[(1) - (1)].funcExpr); ;}
2554
{ (yyval.node) = (yyvsp[(1) - (1)].funcExpr); }
2490
2555
break;
2491
2556
2492
2557
case 39:
2558
2559
/* Line 1806 of yacc.c */
2493
2560
#line 269 "grammar.y"
2494
{ (yyval.node) = new BracketAccessorNode((yyvsp[(1) - (4)].node), (yyvsp[(3) - (4)].node)); ;}
2561
{ (yyval.node) = new BracketAccessorNode((yyvsp[(1) - (4)].node), (yyvsp[(3) - (4)].node)); }
2495
2562
break;
2496
2563
2497
2564
case 40:
2565
2566
/* Line 1806 of yacc.c */
2498
2567
#line 270 "grammar.y"
2499
{ (yyval.node) = new DotAccessorNode((yyvsp[(1) - (3)].node), *(yyvsp[(3) - (3)].ident)); ;}
2568
{ (yyval.node) = new DotAccessorNode((yyvsp[(1) - (3)].node), *(yyvsp[(3) - (3)].ident)); }
2500
2569
break;
2501
2570
2502
2571
case 41:
2572
2573
/* Line 1806 of yacc.c */
2503
2574
#line 271 "grammar.y"
2504
{ (yyval.node) = new NewExprNode((yyvsp[(2) - (3)].node), (yyvsp[(3) - (3)].args)); ;}
2575
{ (yyval.node) = new NewExprNode((yyvsp[(2) - (3)].node), (yyvsp[(3) - (3)].args)); }
2505
2576
break;
2506
2577
2507
2578
case 43:
2579
2580
/* Line 1806 of yacc.c */
2508
2581
#line 276 "grammar.y"
2509
{ (yyval.node) = new BracketAccessorNode((yyvsp[(1) - (4)].node), (yyvsp[(3) - (4)].node)); ;}
2582
{ (yyval.node) = new BracketAccessorNode((yyvsp[(1) - (4)].node), (yyvsp[(3) - (4)].node)); }
2510
2583
break;
2511
2584
2512
2585
case 44:
2586
2587
/* Line 1806 of yacc.c */
2513
2588
#line 277 "grammar.y"
2514
{ (yyval.node) = new DotAccessorNode((yyvsp[(1) - (3)].node), *(yyvsp[(3) - (3)].ident)); ;}
2589
{ (yyval.node) = new DotAccessorNode((yyvsp[(1) - (3)].node), *(yyvsp[(3) - (3)].ident)); }
2515
2590
break;
2516
2591
2517
2592
case 45:
2593
2594
/* Line 1806 of yacc.c */
2518
2595
#line 278 "grammar.y"
2519
{ (yyval.node) = new NewExprNode((yyvsp[(2) - (3)].node), (yyvsp[(3) - (3)].args)); ;}
2596
{ (yyval.node) = new NewExprNode((yyvsp[(2) - (3)].node), (yyvsp[(3) - (3)].args)); }
2520
2597
break;
2521
2598
2522
2599
case 47:
2600
2601
/* Line 1806 of yacc.c */
2523
2602
#line 283 "grammar.y"
2524
{ (yyval.node) = new NewExprNode((yyvsp[(2) - (2)].node)); ;}
2603
{ (yyval.node) = new NewExprNode((yyvsp[(2) - (2)].node)); }
2525
2604
break;
2526
2605
2527
2606
case 49:
2607
2608
/* Line 1806 of yacc.c */
2528
2609
#line 288 "grammar.y"
2529
{ (yyval.node) = new NewExprNode((yyvsp[(2) - (2)].node)); ;}
2610
{ (yyval.node) = new NewExprNode((yyvsp[(2) - (2)].node)); }
2530
2611
break;
2531
2612
2532
2613
case 50:
2614
2615
/* Line 1806 of yacc.c */
2533
2616
#line 292 "grammar.y"
2534
{ (yyval.node) = makeFunctionCallNode((yyvsp[(1) - (2)].node), (yyvsp[(2) - (2)].args)); ;}
2617
{ (yyval.node) = makeFunctionCallNode((yyvsp[(1) - (2)].node), (yyvsp[(2) - (2)].args)); }
2535
2618
break;
2536
2619
2537
2620
case 51:
2621
2622
/* Line 1806 of yacc.c */
2538
2623
#line 293 "grammar.y"
2539
{ (yyval.node) = makeFunctionCallNode((yyvsp[(1) - (2)].node), (yyvsp[(2) - (2)].args)); ;}
2624
{ (yyval.node) = makeFunctionCallNode((yyvsp[(1) - (2)].node), (yyvsp[(2) - (2)].args)); }
2540
2625
break;
2541
2626
2542
2627
case 52:
2628
2629
/* Line 1806 of yacc.c */
2543
2630
#line 294 "grammar.y"
2544
{ (yyval.node) = new BracketAccessorNode((yyvsp[(1) - (4)].node), (yyvsp[(3) - (4)].node)); ;}
2631
{ (yyval.node) = new BracketAccessorNode((yyvsp[(1) - (4)].node), (yyvsp[(3) - (4)].node)); }
2545
2632
break;
2546
2633
2547
2634
case 53:
2635
2636
/* Line 1806 of yacc.c */
2548
2637
#line 295 "grammar.y"
2549
{ (yyval.node) = new DotAccessorNode((yyvsp[(1) - (3)].node), *(yyvsp[(3) - (3)].ident)); ;}
2638
{ (yyval.node) = new DotAccessorNode((yyvsp[(1) - (3)].node), *(yyvsp[(3) - (3)].ident)); }
2550
2639
break;
2551
2640
2552
2641
case 54:
2642
2643
/* Line 1806 of yacc.c */
2553
2644
#line 299 "grammar.y"
2554
{ (yyval.node) = makeFunctionCallNode((yyvsp[(1) - (2)].node), (yyvsp[(2) - (2)].args)); ;}
2645
{ (yyval.node) = makeFunctionCallNode((yyvsp[(1) - (2)].node), (yyvsp[(2) - (2)].args)); }
2555
2646
break;
2556
2647
2557
2648
case 55:
2649
2650
/* Line 1806 of yacc.c */
2558
2651
#line 300 "grammar.y"
2559
{ (yyval.node) = makeFunctionCallNode((yyvsp[(1) - (2)].node), (yyvsp[(2) - (2)].args)); ;}
2652
{ (yyval.node) = makeFunctionCallNode((yyvsp[(1) - (2)].node), (yyvsp[(2) - (2)].args)); }
2560
2653
break;
2561
2654
2562
2655
case 56:
2656
2657
/* Line 1806 of yacc.c */
2563
2658
#line 301 "grammar.y"
2564
{ (yyval.node) = new BracketAccessorNode((yyvsp[(1) - (4)].node), (yyvsp[(3) - (4)].node)); ;}
2659
{ (yyval.node) = new BracketAccessorNode((yyvsp[(1) - (4)].node), (yyvsp[(3) - (4)].node)); }
2565
2660
break;
2566
2661
2567
2662
case 57:
2663
2664
/* Line 1806 of yacc.c */
2568
2665
#line 302 "grammar.y"
2569
{ (yyval.node) = new DotAccessorNode((yyvsp[(1) - (3)].node), *(yyvsp[(3) - (3)].ident)); ;}
2666
{ (yyval.node) = new DotAccessorNode((yyvsp[(1) - (3)].node), *(yyvsp[(3) - (3)].ident)); }
2570
2667
break;
2571
2668
2572
2669
case 58:
2670
2671
/* Line 1806 of yacc.c */
2573
2672
#line 306 "grammar.y"
2574
{ (yyval.args) = new ArgumentsNode(); ;}
2673
{ (yyval.args) = new ArgumentsNode(); }
2575
2674
break;
2576
2675
2577
2676
case 59:
2677
2678
/* Line 1806 of yacc.c */
2578
2679
#line 307 "grammar.y"
2579
{ (yyval.args) = new ArgumentsNode((yyvsp[(2) - (3)].alist)); ;}
2680
{ (yyval.args) = new ArgumentsNode((yyvsp[(2) - (3)].alist)); }
2580
2681
break;
2581
2682
2582
2683
case 60:
2684
2685
/* Line 1806 of yacc.c */
2583
2686
#line 311 "grammar.y"
2584
{ (yyval.alist) = new ArgumentListNode((yyvsp[(1) - (1)].node)); ;}
2687
{ (yyval.alist) = new ArgumentListNode((yyvsp[(1) - (1)].node)); }
2585
2688
break;
2586
2689
2587
2690
case 61:
2691
2692
/* Line 1806 of yacc.c */
2588
2693
#line 312 "grammar.y"
2589
{ (yyval.alist) = new ArgumentListNode((yyvsp[(1) - (3)].alist), (yyvsp[(3) - (3)].node)); ;}
2694
{ (yyval.alist) = new ArgumentListNode((yyvsp[(1) - (3)].alist), (yyvsp[(3) - (3)].node)); }
2590
2695
break;
2591
2696
2592
2697
case 67:
2698
2699
/* Line 1806 of yacc.c */
2593
2700
#line 327 "grammar.y"
2594
{ (yyval.node) = makePostfixNode((yyvsp[(1) - (2)].node), OpPlusPlus); ;}
2701
{ (yyval.node) = makePostfixNode((yyvsp[(1) - (2)].node), OpPlusPlus); }
2595
2702
break;
2596
2703
2597
2704
case 68:
2705
2706
/* Line 1806 of yacc.c */
2598
2707
#line 328 "grammar.y"
2599
{ (yyval.node) = makePostfixNode((yyvsp[(1) - (2)].node), OpMinusMinus); ;}
2708
{ (yyval.node) = makePostfixNode((yyvsp[(1) - (2)].node), OpMinusMinus); }
2600
2709
break;
2601
2710
2602
2711
case 70:
2712
2713
/* Line 1806 of yacc.c */
2603
2714
#line 333 "grammar.y"
2604
{ (yyval.node) = makePostfixNode((yyvsp[(1) - (2)].node), OpPlusPlus); ;}
2715
{ (yyval.node) = makePostfixNode((yyvsp[(1) - (2)].node), OpPlusPlus); }
2605
2716
break;
2606
2717
2607
2718
case 71:
2719
2720
/* Line 1806 of yacc.c */
2608
2721
#line 334 "grammar.y"
2609
{ (yyval.node) = makePostfixNode((yyvsp[(1) - (2)].node), OpMinusMinus); ;}
2722
{ (yyval.node) = makePostfixNode((yyvsp[(1) - (2)].node), OpMinusMinus); }
2610
2723
break;
2611
2724
2612
2725
case 72:
2726
2727
/* Line 1806 of yacc.c */
2613
2728
#line 338 "grammar.y"
2614
{ (yyval.node) = makeDeleteNode((yyvsp[(2) - (2)].node)); ;}
2729
{ (yyval.node) = makeDeleteNode((yyvsp[(2) - (2)].node)); }
2615
2730
break;
2616
2731
2617
2732
case 73:
2733
2734
/* Line 1806 of yacc.c */
2618
2735
#line 339 "grammar.y"
2619
{ (yyval.node) = new VoidNode((yyvsp[(2) - (2)].node)); ;}
2736
{ (yyval.node) = new VoidNode((yyvsp[(2) - (2)].node)); }
2620
2737
break;
2621
2738
2622
2739
case 74:
2740
2741
/* Line 1806 of yacc.c */
2623
2742
#line 340 "grammar.y"
2624
{ (yyval.node) = makeTypeOfNode((yyvsp[(2) - (2)].node)); ;}
2743
{ (yyval.node) = makeTypeOfNode((yyvsp[(2) - (2)].node)); }
2625
2744
break;
2626
2745
2627
2746
case 75:
2747
2748
/* Line 1806 of yacc.c */
2628
2749
#line 341 "grammar.y"
2629
{ (yyval.node) = makePrefixNode((yyvsp[(2) - (2)].node), OpPlusPlus); ;}
2750
{ (yyval.node) = makePrefixNode((yyvsp[(2) - (2)].node), OpPlusPlus); }
2630
2751
break;
2631
2752
2632
2753
case 76:
2754
2755
/* Line 1806 of yacc.c */
2633
2756
#line 342 "grammar.y"
2634
{ (yyval.node) = makePrefixNode((yyvsp[(2) - (2)].node), OpPlusPlus); ;}
2757
{ (yyval.node) = makePrefixNode((yyvsp[(2) - (2)].node), OpPlusPlus); }
2635
2758
break;
2636
2759
2637
2760
case 77:
2761
2762
/* Line 1806 of yacc.c */
2638
2763
#line 343 "grammar.y"
2639
{ (yyval.node) = makePrefixNode((yyvsp[(2) - (2)].node), OpMinusMinus); ;}
2764
{ (yyval.node) = makePrefixNode((yyvsp[(2) - (2)].node), OpMinusMinus); }
2640
2765
break;
2641
2766
2642
2767
case 78:
2768
2769
/* Line 1806 of yacc.c */
2643
2770
#line 344 "grammar.y"
2644
{ (yyval.node) = makePrefixNode((yyvsp[(2) - (2)].node), OpMinusMinus); ;}
2771
{ (yyval.node) = makePrefixNode((yyvsp[(2) - (2)].node), OpMinusMinus); }
2645
2772
break;
2646
2773
2647
2774
case 79:
2775
2776
/* Line 1806 of yacc.c */
2648
2777
#line 345 "grammar.y"
2649
{ (yyval.node) = makeUnaryPlusNode((yyvsp[(2) - (2)].node)); ;}
2778
{ (yyval.node) = makeUnaryPlusNode((yyvsp[(2) - (2)].node)); }
2650
2779
break;
2651
2780
2652
2781
case 80:
2782
2783
/* Line 1806 of yacc.c */
2653
2784
#line 346 "grammar.y"
2654
{ (yyval.node) = makeNegateNode((yyvsp[(2) - (2)].node)); ;}
2785
{ (yyval.node) = makeNegateNode((yyvsp[(2) - (2)].node)); }
2655
2786
break;
2656
2787
2657
2788
case 81:
2789
2790
/* Line 1806 of yacc.c */
2658
2791
#line 347 "grammar.y"
2659
{ (yyval.node) = makeBitwiseNotNode((yyvsp[(2) - (2)].node)); ;}
2792
{ (yyval.node) = makeBitwiseNotNode((yyvsp[(2) - (2)].node)); }
2660
2793
break;
2661
2794
2662
2795
case 82:
2796
2797
/* Line 1806 of yacc.c */
2663
2798
#line 348 "grammar.y"
2664
{ (yyval.node) = makeLogicalNotNode((yyvsp[(2) - (2)].node)); ;}
2799
{ (yyval.node) = makeLogicalNotNode((yyvsp[(2) - (2)].node)); }
2665
2800
break;
2666
2801
2667
2802
case 88:
2803
2804
/* Line 1806 of yacc.c */
2668
2805
#line 362 "grammar.y"
2669
{ (yyval.node) = makeMultNode((yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node), OpMult); ;}
2806
{ (yyval.node) = makeMultNode((yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node), OpMult); }
2670
2807
break;
2671
2808
2672
2809
case 89:
2810
2811
/* Line 1806 of yacc.c */
2673
2812
#line 363 "grammar.y"
2674
{ (yyval.node) = makeMultNode((yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node), OpDiv); ;}
2813
{ (yyval.node) = makeMultNode((yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node), OpDiv); }
2675
2814
break;
2676
2815
2677
2816
case 90:
2817
2818
/* Line 1806 of yacc.c */
2678
2819
#line 364 "grammar.y"
2679
{ (yyval.node) = makeMultNode((yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node), OpMod); ;}
2820
{ (yyval.node) = makeMultNode((yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node), OpMod); }
2680
2821
break;
2681
2822
2682
2823
case 92:
2824
2825
/* Line 1806 of yacc.c */
2683
2826
#line 370 "grammar.y"
2684
{ (yyval.node) = makeMultNode((yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node), OpMult); ;}
2827
{ (yyval.node) = makeMultNode((yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node), OpMult); }
2685
2828
break;
2686
2829
2687
2830
case 93:
2831
2832
/* Line 1806 of yacc.c */
2688
2833
#line 372 "grammar.y"
2689
{ (yyval.node) = makeMultNode((yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node), OpDiv); ;}
2834
{ (yyval.node) = makeMultNode((yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node), OpDiv); }
2690
2835
break;
2691
2836
2692
2837
case 94:
2838
2839
/* Line 1806 of yacc.c */
2693
2840
#line 374 "grammar.y"
2694
{ (yyval.node) = makeMultNode((yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node), OpMod); ;}
2841
{ (yyval.node) = makeMultNode((yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node), OpMod); }
2695
2842
break;
2696
2843
2697
2844
case 96:
2845
2846
/* Line 1806 of yacc.c */
2698
2847
#line 379 "grammar.y"
2699
{ (yyval.node) = makeAddNode((yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node), OpPlus); ;}
2848
{ (yyval.node) = makeAddNode((yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node), OpPlus); }
2700
2849
break;
2701
2850
2702
2851
case 97:
2852
2853
/* Line 1806 of yacc.c */
2703
2854
#line 380 "grammar.y"
2704
{ (yyval.node) = makeAddNode((yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node), OpMinus); ;}
2855
{ (yyval.node) = makeAddNode((yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node), OpMinus); }
2705
2856
break;
2706
2857
2707
2858
case 99:
2859
2860
/* Line 1806 of yacc.c */
2708
2861
#line 386 "grammar.y"
2709
{ (yyval.node) = makeAddNode((yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node), OpPlus); ;}
2862
{ (yyval.node) = makeAddNode((yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node), OpPlus); }
2710
2863
break;
2711
2864
2712
2865
case 100:
2866
2867
/* Line 1806 of yacc.c */
2713
2868
#line 388 "grammar.y"
2714
{ (yyval.node) = makeAddNode((yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node), OpMinus); ;}
2869
{ (yyval.node) = makeAddNode((yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node), OpMinus); }
2715
2870
break;
2716
2871
2717
2872
case 102:
2873
2874
/* Line 1806 of yacc.c */
2718
2875
#line 393 "grammar.y"
2719
{ (yyval.node) = makeShiftNode((yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node), OpLShift); ;}
2876
{ (yyval.node) = makeShiftNode((yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node), OpLShift); }
2720
2877
break;
2721
2878
2722
2879
case 103:
2880
2881
/* Line 1806 of yacc.c */
2723
2882
#line 394 "grammar.y"
2724
{ (yyval.node) = makeShiftNode((yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node), OpRShift); ;}
2883
{ (yyval.node) = makeShiftNode((yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node), OpRShift); }
2725
2884
break;
2726
2885
2727
2886
case 104:
2887
2888
/* Line 1806 of yacc.c */
2728
2889
#line 395 "grammar.y"
2729
{ (yyval.node) = makeShiftNode((yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node), OpURShift); ;}
2890
{ (yyval.node) = makeShiftNode((yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node), OpURShift); }
2730
2891
break;
2731
2892
2732
2893
case 106:
2894
2895
/* Line 1806 of yacc.c */
2733
2896
#line 400 "grammar.y"
2734
{ (yyval.node) = makeShiftNode((yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node), OpLShift); ;}
2897
{ (yyval.node) = makeShiftNode((yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node), OpLShift); }
2735
2898
break;
2736
2899
2737
2900
case 107:
2901
2902
/* Line 1806 of yacc.c */
2738
2903
#line 401 "grammar.y"
2739
{ (yyval.node) = makeShiftNode((yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node), OpRShift); ;}
2904
{ (yyval.node) = makeShiftNode((yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node), OpRShift); }
2740
2905
break;
2741
2906
2742
2907
case 108:
2908
2909
/* Line 1806 of yacc.c */
2743
2910
#line 402 "grammar.y"
2744
{ (yyval.node) = makeShiftNode((yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node), OpURShift); ;}
2911
{ (yyval.node) = makeShiftNode((yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node), OpURShift); }
2745
2912
break;
2746
2913
2747
2914
case 110:
2915
2916
/* Line 1806 of yacc.c */
2748
2917
#line 407 "grammar.y"
2749
{ (yyval.node) = makeRelationalNode((yyvsp[(1) - (3)].node), OpLess, (yyvsp[(3) - (3)].node)); ;}
2918
{ (yyval.node) = makeRelationalNode((yyvsp[(1) - (3)].node), OpLess, (yyvsp[(3) - (3)].node)); }
2750
2919
break;
2751
2920
2752
2921
case 111:
2922
2923
/* Line 1806 of yacc.c */
2753
2924
#line 408 "grammar.y"
2754
{ (yyval.node) = makeRelationalNode((yyvsp[(1) - (3)].node), OpGreater, (yyvsp[(3) - (3)].node)); ;}
2925
{ (yyval.node) = makeRelationalNode((yyvsp[(1) - (3)].node), OpGreater, (yyvsp[(3) - (3)].node)); }
2755
2926
break;
2756
2927
2757
2928
case 112:
2929
2930
/* Line 1806 of yacc.c */
2758
2931
#line 409 "grammar.y"
2759
{ (yyval.node) = makeRelationalNode((yyvsp[(1) - (3)].node), OpLessEq, (yyvsp[(3) - (3)].node)); ;}
2932
{ (yyval.node) = makeRelationalNode((yyvsp[(1) - (3)].node), OpLessEq, (yyvsp[(3) - (3)].node)); }
2760
2933
break;
2761
2934
2762
2935
case 113:
2936
2937
/* Line 1806 of yacc.c */
2763
2938
#line 410 "grammar.y"
2764
{ (yyval.node) = makeRelationalNode((yyvsp[(1) - (3)].node), OpGreaterEq, (yyvsp[(3) - (3)].node)); ;}
2939
{ (yyval.node) = makeRelationalNode((yyvsp[(1) - (3)].node), OpGreaterEq, (yyvsp[(3) - (3)].node)); }
2765
2940
break;
2766
2941
2767
2942
case 114:
2943
2944
/* Line 1806 of yacc.c */
2768
2945
#line 411 "grammar.y"
2769
{ (yyval.node) = makeRelationalNode((yyvsp[(1) - (3)].node), OpInstanceOf, (yyvsp[(3) - (3)].node)); ;}
2946
{ (yyval.node) = makeRelationalNode((yyvsp[(1) - (3)].node), OpInstanceOf, (yyvsp[(3) - (3)].node)); }
2770
2947
break;
2771
2948
2772
2949
case 115:
2950
2951
/* Line 1806 of yacc.c */
2773
2952
#line 412 "grammar.y"
2774
{ (yyval.node) = makeRelationalNode((yyvsp[(1) - (3)].node), OpIn, (yyvsp[(3) - (3)].node)); ;}
2953
{ (yyval.node) = makeRelationalNode((yyvsp[(1) - (3)].node), OpIn, (yyvsp[(3) - (3)].node)); }
2775
2954
break;
2776
2955
2777
2956
case 117:
2957
2958
/* Line 1806 of yacc.c */
2778
2959
#line 417 "grammar.y"
2779
{ (yyval.node) = makeRelationalNode((yyvsp[(1) - (3)].node), OpLess, (yyvsp[(3) - (3)].node)); ;}
2960
{ (yyval.node) = makeRelationalNode((yyvsp[(1) - (3)].node), OpLess, (yyvsp[(3) - (3)].node)); }
2780
2961
break;
2781
2962
2782
2963
case 118:
2964
2965
/* Line 1806 of yacc.c */
2783
2966
#line 418 "grammar.y"
2784
{ (yyval.node) = makeRelationalNode((yyvsp[(1) - (3)].node), OpGreater, (yyvsp[(3) - (3)].node)); ;}
2967
{ (yyval.node) = makeRelationalNode((yyvsp[(1) - (3)].node), OpGreater, (yyvsp[(3) - (3)].node)); }
2785
2968
break;
2786
2969
2787
2970
case 119:
2971
2972
/* Line 1806 of yacc.c */
2788
2973
#line 419 "grammar.y"
2789
{ (yyval.node) = makeRelationalNode((yyvsp[(1) - (3)].node), OpLessEq, (yyvsp[(3) - (3)].node)); ;}
2974
{ (yyval.node) = makeRelationalNode((yyvsp[(1) - (3)].node), OpLessEq, (yyvsp[(3) - (3)].node)); }
2790
2975
break;
2791
2976
2792
2977
case 120:
2978
2979
/* Line 1806 of yacc.c */
2793
2980
#line 420 "grammar.y"
2794
{ (yyval.node) = makeRelationalNode((yyvsp[(1) - (3)].node), OpGreaterEq, (yyvsp[(3) - (3)].node)); ;}
2981
{ (yyval.node) = makeRelationalNode((yyvsp[(1) - (3)].node), OpGreaterEq, (yyvsp[(3) - (3)].node)); }
2795
2982
break;
2796
2983
2797
2984
case 121:
2985
2986
/* Line 1806 of yacc.c */
2798
2987
#line 422 "grammar.y"
2799
{ (yyval.node) = makeRelationalNode((yyvsp[(1) - (3)].node), OpInstanceOf, (yyvsp[(3) - (3)].node)); ;}
2988
{ (yyval.node) = makeRelationalNode((yyvsp[(1) - (3)].node), OpInstanceOf, (yyvsp[(3) - (3)].node)); }
2800
2989
break;
2801
2990
2802
2991
case 123:
2992
2993
/* Line 1806 of yacc.c */
2803
2994
#line 427 "grammar.y"
2804
{ (yyval.node) = makeRelationalNode((yyvsp[(1) - (3)].node), OpLess, (yyvsp[(3) - (3)].node)); ;}
2995
{ (yyval.node) = makeRelationalNode((yyvsp[(1) - (3)].node), OpLess, (yyvsp[(3) - (3)].node)); }
2805
2996
break;
2806
2997
2807
2998
case 124:
2999
3000
/* Line 1806 of yacc.c */
2808
3001
#line 428 "grammar.y"
2809
{ (yyval.node) = makeRelationalNode((yyvsp[(1) - (3)].node), OpGreater, (yyvsp[(3) - (3)].node)); ;}
3002
{ (yyval.node) = makeRelationalNode((yyvsp[(1) - (3)].node), OpGreater, (yyvsp[(3) - (3)].node)); }
2810
3003
break;
2811
3004
2812
3005
case 125:
3006
3007
/* Line 1806 of yacc.c */
2813
3008
#line 429 "grammar.y"
2814
{ (yyval.node) = makeRelationalNode((yyvsp[(1) - (3)].node), OpLessEq, (yyvsp[(3) - (3)].node)); ;}
3009
{ (yyval.node) = makeRelationalNode((yyvsp[(1) - (3)].node), OpLessEq, (yyvsp[(3) - (3)].node)); }
2815
3010
break;
2816
3011
2817
3012
case 126:
3013
3014
/* Line 1806 of yacc.c */
2818
3015
#line 430 "grammar.y"
2819
{ (yyval.node) = makeRelationalNode((yyvsp[(1) - (3)].node), OpGreaterEq, (yyvsp[(3) - (3)].node)); ;}
3016
{ (yyval.node) = makeRelationalNode((yyvsp[(1) - (3)].node), OpGreaterEq, (yyvsp[(3) - (3)].node)); }
2820
3017
break;
2821
3018
2822
3019
case 127:
3020
3021
/* Line 1806 of yacc.c */
2823
3022
#line 432 "grammar.y"
2824
{ (yyval.node) = makeRelationalNode((yyvsp[(1) - (3)].node), OpInstanceOf, (yyvsp[(3) - (3)].node)); ;}
3023
{ (yyval.node) = makeRelationalNode((yyvsp[(1) - (3)].node), OpInstanceOf, (yyvsp[(3) - (3)].node)); }
2825
3024
break;
2826
3025
2827
3026
case 128:
3027
3028
/* Line 1806 of yacc.c */
2828
3029
#line 433 "grammar.y"
2829
{ (yyval.node) = makeRelationalNode((yyvsp[(1) - (3)].node), OpIn, (yyvsp[(3) - (3)].node)); ;}
3030
{ (yyval.node) = makeRelationalNode((yyvsp[(1) - (3)].node), OpIn, (yyvsp[(3) - (3)].node)); }
2830
3031
break;
2831
3032
2832
3033
case 130:
3034
3035
/* Line 1806 of yacc.c */
2833
3036
#line 438 "grammar.y"
2834
{ (yyval.node) = makeEqualNode((yyvsp[(1) - (3)].node), OpEqEq, (yyvsp[(3) - (3)].node)); ;}
3037
{ (yyval.node) = makeEqualNode((yyvsp[(1) - (3)].node), OpEqEq, (yyvsp[(3) - (3)].node)); }
2835
3038
break;
2836
3039
2837
3040
case 131:
3041
3042
/* Line 1806 of yacc.c */
2838
3043
#line 439 "grammar.y"
2839
{ (yyval.node) = makeEqualNode((yyvsp[(1) - (3)].node), OpNotEq, (yyvsp[(3) - (3)].node)); ;}
3044
{ (yyval.node) = makeEqualNode((yyvsp[(1) - (3)].node), OpNotEq, (yyvsp[(3) - (3)].node)); }
2840
3045
break;
2841
3046
2842
3047
case 132:
3048
3049
/* Line 1806 of yacc.c */
2843
3050
#line 440 "grammar.y"
2844
{ (yyval.node) = makeEqualNode((yyvsp[(1) - (3)].node), OpStrEq, (yyvsp[(3) - (3)].node)); ;}
3051
{ (yyval.node) = makeEqualNode((yyvsp[(1) - (3)].node), OpStrEq, (yyvsp[(3) - (3)].node)); }
2845
3052
break;
2846
3053
2847
3054
case 133:
3055
3056
/* Line 1806 of yacc.c */
2848
3057
#line 441 "grammar.y"
2849
{ (yyval.node) = makeEqualNode((yyvsp[(1) - (3)].node), OpStrNEq, (yyvsp[(3) - (3)].node));;}
3058
{ (yyval.node) = makeEqualNode((yyvsp[(1) - (3)].node), OpStrNEq, (yyvsp[(3) - (3)].node));}
2850
3059
break;
2851
3060
2852
3061
case 135:
3062
3063
/* Line 1806 of yacc.c */
2853
3064
#line 447 "grammar.y"
2854
{ (yyval.node) = makeEqualNode((yyvsp[(1) - (3)].node), OpEqEq, (yyvsp[(3) - (3)].node)); ;}
3065
{ (yyval.node) = makeEqualNode((yyvsp[(1) - (3)].node), OpEqEq, (yyvsp[(3) - (3)].node)); }
2855
3066
break;
2856
3067
2857
3068
case 136:
3069
3070
/* Line 1806 of yacc.c */
2858
3071
#line 449 "grammar.y"
2859
{ (yyval.node) = makeEqualNode((yyvsp[(1) - (3)].node), OpNotEq, (yyvsp[(3) - (3)].node)); ;}
3072
{ (yyval.node) = makeEqualNode((yyvsp[(1) - (3)].node), OpNotEq, (yyvsp[(3) - (3)].node)); }
2860
3073
break;
2861
3074
2862
3075
case 137:
3076
3077
/* Line 1806 of yacc.c */
2863
3078
#line 451 "grammar.y"
2864
{ (yyval.node) = makeEqualNode((yyvsp[(1) - (3)].node), OpStrEq, (yyvsp[(3) - (3)].node)); ;}
3079
{ (yyval.node) = makeEqualNode((yyvsp[(1) - (3)].node), OpStrEq, (yyvsp[(3) - (3)].node)); }
2865
3080
break;
2866
3081
2867
3082
case 138:
3083
3084
/* Line 1806 of yacc.c */
2868
3085
#line 453 "grammar.y"
2869
{ (yyval.node) = makeEqualNode((yyvsp[(1) - (3)].node), OpStrNEq, (yyvsp[(3) - (3)].node));;}
3086
{ (yyval.node) = makeEqualNode((yyvsp[(1) - (3)].node), OpStrNEq, (yyvsp[(3) - (3)].node));}
2870
3087
break;
2871
3088
2872
3089
case 140:
3090
3091
/* Line 1806 of yacc.c */
2873
3092
#line 459 "grammar.y"
2874
{ (yyval.node) = makeEqualNode((yyvsp[(1) - (3)].node), OpEqEq, (yyvsp[(3) - (3)].node)); ;}
3093
{ (yyval.node) = makeEqualNode((yyvsp[(1) - (3)].node), OpEqEq, (yyvsp[(3) - (3)].node)); }
2875
3094
break;
2876
3095
2877
3096
case 141:
3097
3098
/* Line 1806 of yacc.c */
2878
3099
#line 460 "grammar.y"
2879
{ (yyval.node) = makeEqualNode((yyvsp[(1) - (3)].node), OpNotEq, (yyvsp[(3) - (3)].node)); ;}
3100
{ (yyval.node) = makeEqualNode((yyvsp[(1) - (3)].node), OpNotEq, (yyvsp[(3) - (3)].node)); }
2880
3101
break;
2881
3102
2882
3103
case 142:
3104
3105
/* Line 1806 of yacc.c */
2883
3106
#line 462 "grammar.y"
2884
{ (yyval.node) = makeEqualNode((yyvsp[(1) - (3)].node), OpStrEq, (yyvsp[(3) - (3)].node)); ;}
3107
{ (yyval.node) = makeEqualNode((yyvsp[(1) - (3)].node), OpStrEq, (yyvsp[(3) - (3)].node)); }
2885
3108
break;
2886
3109
2887
3110
case 143:
3111
3112
/* Line 1806 of yacc.c */
2888
3113
#line 464 "grammar.y"
2889
{ (yyval.node) = makeEqualNode((yyvsp[(1) - (3)].node), OpStrNEq, (yyvsp[(3) - (3)].node));;}
3114
{ (yyval.node) = makeEqualNode((yyvsp[(1) - (3)].node), OpStrNEq, (yyvsp[(3) - (3)].node));}
2890
3115
break;
2891
3116
2892
3117
case 145:
3118
3119
/* Line 1806 of yacc.c */
2893
3120
#line 469 "grammar.y"
2894
{ (yyval.node) = makeBitOperNode((yyvsp[(1) - (3)].node), OpBitAnd, (yyvsp[(3) - (3)].node)); ;}
3121
{ (yyval.node) = makeBitOperNode((yyvsp[(1) - (3)].node), OpBitAnd, (yyvsp[(3) - (3)].node)); }
2895
3122
break;
2896
3123
2897
3124
case 147:
3125
3126
/* Line 1806 of yacc.c */
2898
3127
#line 475 "grammar.y"
2899
{ (yyval.node) = makeBitOperNode((yyvsp[(1) - (3)].node), OpBitAnd, (yyvsp[(3) - (3)].node)); ;}
3128
{ (yyval.node) = makeBitOperNode((yyvsp[(1) - (3)].node), OpBitAnd, (yyvsp[(3) - (3)].node)); }
2900
3129
break;
2901
3130
2902
3131
case 149:
3132
3133
/* Line 1806 of yacc.c */
2903
3134
#line 480 "grammar.y"
2904
{ (yyval.node) = makeBitOperNode((yyvsp[(1) - (3)].node), OpBitAnd, (yyvsp[(3) - (3)].node)); ;}
3135
{ (yyval.node) = makeBitOperNode((yyvsp[(1) - (3)].node), OpBitAnd, (yyvsp[(3) - (3)].node)); }
2905
3136
break;
2906
3137
2907
3138
case 151:
3139
3140
/* Line 1806 of yacc.c */
2908
3141
#line 485 "grammar.y"
2909
{ (yyval.node) = makeBitOperNode((yyvsp[(1) - (3)].node), OpBitXOr, (yyvsp[(3) - (3)].node)); ;}
3142
{ (yyval.node) = makeBitOperNode((yyvsp[(1) - (3)].node), OpBitXOr, (yyvsp[(3) - (3)].node)); }
2910
3143
break;
2911
3144
2912
3145
case 153:
3146
3147
/* Line 1806 of yacc.c */
2913
3148
#line 491 "grammar.y"
2914
{ (yyval.node) = makeBitOperNode((yyvsp[(1) - (3)].node), OpBitXOr, (yyvsp[(3) - (3)].node)); ;}
3149
{ (yyval.node) = makeBitOperNode((yyvsp[(1) - (3)].node), OpBitXOr, (yyvsp[(3) - (3)].node)); }
2915
3150
break;
2916
3151
2917
3152
case 155:
3153
3154
/* Line 1806 of yacc.c */
2918
3155
#line 497 "grammar.y"
2919
{ (yyval.node) = makeBitOperNode((yyvsp[(1) - (3)].node), OpBitXOr, (yyvsp[(3) - (3)].node)); ;}
3156
{ (yyval.node) = makeBitOperNode((yyvsp[(1) - (3)].node), OpBitXOr, (yyvsp[(3) - (3)].node)); }
2920
3157
break;
2921
3158
2922
3159
case 157:
3160
3161
/* Line 1806 of yacc.c */
2923
3162
#line 502 "grammar.y"
2924
{ (yyval.node) = makeBitOperNode((yyvsp[(1) - (3)].node), OpBitOr, (yyvsp[(3) - (3)].node)); ;}
3163
{ (yyval.node) = makeBitOperNode((yyvsp[(1) - (3)].node), OpBitOr, (yyvsp[(3) - (3)].node)); }
2925
3164
break;
2926
3165
2927
3166
case 159:
3167
3168
/* Line 1806 of yacc.c */
2928
3169
#line 508 "grammar.y"
2929
{ (yyval.node) = makeBitOperNode((yyvsp[(1) - (3)].node), OpBitOr, (yyvsp[(3) - (3)].node)); ;}
3170
{ (yyval.node) = makeBitOperNode((yyvsp[(1) - (3)].node), OpBitOr, (yyvsp[(3) - (3)].node)); }
2930
3171
break;
2931
3172
2932
3173
case 161:
3174
3175
/* Line 1806 of yacc.c */
2933
3176
#line 514 "grammar.y"
2934
{ (yyval.node) = makeBitOperNode((yyvsp[(1) - (3)].node), OpBitOr, (yyvsp[(3) - (3)].node)); ;}
3177
{ (yyval.node) = makeBitOperNode((yyvsp[(1) - (3)].node), OpBitOr, (yyvsp[(3) - (3)].node)); }
2935
3178
break;
2936
3179
2937
3180
case 163:
3181
3182
/* Line 1806 of yacc.c */
2938
3183
#line 519 "grammar.y"
2939
{ (yyval.node) = makeBinaryLogicalNode((yyvsp[(1) - (3)].node), OpAnd, (yyvsp[(3) - (3)].node)); ;}
3184
{ (yyval.node) = makeBinaryLogicalNode((yyvsp[(1) - (3)].node), OpAnd, (yyvsp[(3) - (3)].node)); }
2940
3185
break;
2941
3186
2942
3187
case 165:
3188
3189
/* Line 1806 of yacc.c */
2943
3190
#line 525 "grammar.y"
2944
{ (yyval.node) = makeBinaryLogicalNode((yyvsp[(1) - (3)].node), OpAnd, (yyvsp[(3) - (3)].node)); ;}
3191
{ (yyval.node) = makeBinaryLogicalNode((yyvsp[(1) - (3)].node), OpAnd, (yyvsp[(3) - (3)].node)); }
2945
3192
break;
2946
3193
2947
3194
case 167:
3195
3196
/* Line 1806 of yacc.c */
2948
3197
#line 531 "grammar.y"
2949
{ (yyval.node) = makeBinaryLogicalNode((yyvsp[(1) - (3)].node), OpAnd, (yyvsp[(3) - (3)].node)); ;}
3198
{ (yyval.node) = makeBinaryLogicalNode((yyvsp[(1) - (3)].node), OpAnd, (yyvsp[(3) - (3)].node)); }
2950
3199
break;
2951
3200
2952
3201
case 169:
3202
3203
/* Line 1806 of yacc.c */
2953
3204
#line 536 "grammar.y"
2954
{ (yyval.node) = makeBinaryLogicalNode((yyvsp[(1) - (3)].node), OpOr, (yyvsp[(3) - (3)].node)); ;}
3205
{ (yyval.node) = makeBinaryLogicalNode((yyvsp[(1) - (3)].node), OpOr, (yyvsp[(3) - (3)].node)); }
2955
3206
break;
2956
3207
2957
3208
case 171:
3209
3210
/* Line 1806 of yacc.c */
2958
3211
#line 542 "grammar.y"
2959
{ (yyval.node) = makeBinaryLogicalNode((yyvsp[(1) - (3)].node), OpOr, (yyvsp[(3) - (3)].node)); ;}
3212
{ (yyval.node) = makeBinaryLogicalNode((yyvsp[(1) - (3)].node), OpOr, (yyvsp[(3) - (3)].node)); }
2960
3213
break;
2961
3214
2962
3215
case 173:
3216
3217
/* Line 1806 of yacc.c */
2963
3218
#line 547 "grammar.y"
2964
{ (yyval.node) = makeBinaryLogicalNode((yyvsp[(1) - (3)].node), OpOr, (yyvsp[(3) - (3)].node)); ;}
3219
{ (yyval.node) = makeBinaryLogicalNode((yyvsp[(1) - (3)].node), OpOr, (yyvsp[(3) - (3)].node)); }
2965
3220
break;
2966
3221
2967
3222
case 175:
3223
3224
/* Line 1806 of yacc.c */
2968
3225
#line 553 "grammar.y"
2969
{ (yyval.node) = makeConditionalNode((yyvsp[(1) - (5)].node), (yyvsp[(3) - (5)].node), (yyvsp[(5) - (5)].node)); ;}
3226
{ (yyval.node) = makeConditionalNode((yyvsp[(1) - (5)].node), (yyvsp[(3) - (5)].node), (yyvsp[(5) - (5)].node)); }
2970
3227
break;
2971
3228
2972
3229
case 177:
3230
3231
/* Line 1806 of yacc.c */
2973
3232
#line 559 "grammar.y"
2974
{ (yyval.node) = makeConditionalNode((yyvsp[(1) - (5)].node), (yyvsp[(3) - (5)].node), (yyvsp[(5) - (5)].node)); ;}
3233
{ (yyval.node) = makeConditionalNode((yyvsp[(1) - (5)].node), (yyvsp[(3) - (5)].node), (yyvsp[(5) - (5)].node)); }
2975
3234
break;
2976
3235
2977
3236
case 179:
3237
3238
/* Line 1806 of yacc.c */
2978
3239
#line 565 "grammar.y"
2979
{ (yyval.node) = makeConditionalNode((yyvsp[(1) - (5)].node), (yyvsp[(3) - (5)].node), (yyvsp[(5) - (5)].node)); ;}
3240
{ (yyval.node) = makeConditionalNode((yyvsp[(1) - (5)].node), (yyvsp[(3) - (5)].node), (yyvsp[(5) - (5)].node)); }
2980
3241
break;
2981
3242
2982
3243
case 181:
3244
3245
/* Line 1806 of yacc.c */
2983
3246
#line 571 "grammar.y"
2984
{ (yyval.node) = makeAssignNode((yyvsp[(1) - (3)].node), (yyvsp[(2) - (3)].op), (yyvsp[(3) - (3)].node)); ;}
3247
{ (yyval.node) = makeAssignNode((yyvsp[(1) - (3)].node), (yyvsp[(2) - (3)].op), (yyvsp[(3) - (3)].node)); }
2985
3248
break;
2986
3249
2987
3250
case 183:
3251
3252
/* Line 1806 of yacc.c */
2988
3253
#line 577 "grammar.y"
2989
{ (yyval.node) = makeAssignNode((yyvsp[(1) - (3)].node), (yyvsp[(2) - (3)].op), (yyvsp[(3) - (3)].node)); ;}
3254
{ (yyval.node) = makeAssignNode((yyvsp[(1) - (3)].node), (yyvsp[(2) - (3)].op), (yyvsp[(3) - (3)].node)); }
2990
3255
break;
2991
3256
2992
3257
case 185:
3258
3259
/* Line 1806 of yacc.c */
2993
3260
#line 583 "grammar.y"
2994
{ (yyval.node) = makeAssignNode((yyvsp[(1) - (3)].node), (yyvsp[(2) - (3)].op), (yyvsp[(3) - (3)].node)); ;}
3261
{ (yyval.node) = makeAssignNode((yyvsp[(1) - (3)].node), (yyvsp[(2) - (3)].op), (yyvsp[(3) - (3)].node)); }
2995
3262
break;
2996
3263
2997
3264
case 186:
3265
3266
/* Line 1806 of yacc.c */
2998
3267
#line 587 "grammar.y"
2999
{ (yyval.op) = OpEqual; ;}
3268
{ (yyval.op) = OpEqual; }
3000
3269
break;
3001
3270
3002
3271
case 187:
3272
3273
/* Line 1806 of yacc.c */
3003
3274
#line 588 "grammar.y"
3004
{ (yyval.op) = OpPlusEq; ;}
3275
{ (yyval.op) = OpPlusEq; }
3005
3276
break;
3006
3277
3007
3278
case 188:
3279
3280
/* Line 1806 of yacc.c */
3008
3281
#line 589 "grammar.y"
3009
{ (yyval.op) = OpMinusEq; ;}
3282
{ (yyval.op) = OpMinusEq; }
3010
3283
break;
3011
3284
3012
3285
case 189:
3286
3287
/* Line 1806 of yacc.c */
3013
3288
#line 590 "grammar.y"
3014
{ (yyval.op) = OpMultEq; ;}
3289
{ (yyval.op) = OpMultEq; }
3015
3290
break;
3016
3291
3017
3292
case 190:
3293
3294
/* Line 1806 of yacc.c */
3018
3295
#line 591 "grammar.y"
3019
{ (yyval.op) = OpDivEq; ;}
3296
{ (yyval.op) = OpDivEq; }
3020
3297
break;
3021
3298
3022
3299
case 191:
3300
3301
/* Line 1806 of yacc.c */
3023
3302
#line 592 "grammar.y"
3024
{ (yyval.op) = OpLShift; ;}
3303
{ (yyval.op) = OpLShift; }
3025
3304
break;
3026
3305
3027
3306
case 192:
3307
3308
/* Line 1806 of yacc.c */
3028
3309
#line 593 "grammar.y"
3029
{ (yyval.op) = OpRShift; ;}
3310
{ (yyval.op) = OpRShift; }
3030
3311
break;
3031
3312
3032
3313
case 193:
3314
3315
/* Line 1806 of yacc.c */
3033
3316
#line 594 "grammar.y"
3034
{ (yyval.op) = OpURShift; ;}
3317
{ (yyval.op) = OpURShift; }
3035
3318
break;
3036
3319
3037
3320
case 194:
3321
3322
/* Line 1806 of yacc.c */
3038
3323
#line 595 "grammar.y"
3039
{ (yyval.op) = OpAndEq; ;}
3324
{ (yyval.op) = OpAndEq; }
3040
3325
break;
3041
3326
3042
3327
case 195:
3328
3329
/* Line 1806 of yacc.c */
3043
3330
#line 596 "grammar.y"
3044
{ (yyval.op) = OpXOrEq; ;}
3331
{ (yyval.op) = OpXOrEq; }
3045
3332
break;
3046
3333
3047
3334
case 196:
3335
3336
/* Line 1806 of yacc.c */
3048
3337
#line 597 "grammar.y"
3049
{ (yyval.op) = OpOrEq; ;}
3338
{ (yyval.op) = OpOrEq; }
3050
3339
break;
3051
3340
3052
3341
case 197:
3342
3343
/* Line 1806 of yacc.c */
3053
3344
#line 598 "grammar.y"
3054
{ (yyval.op) = OpModEq; ;}
3345
{ (yyval.op) = OpModEq; }
3055
3346
break;
3056
3347
3057
3348
case 199:
3349
3350
/* Line 1806 of yacc.c */
3058
3351
#line 603 "grammar.y"
3059
{ (yyval.node) = new CommaNode((yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node)); ;}
3352
{ (yyval.node) = new CommaNode((yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node)); }
3060
3353
break;
3061
3354
3062
3355
case 201:
3356
3357
/* Line 1806 of yacc.c */
3063
3358
#line 608 "grammar.y"
3064
{ (yyval.node) = new CommaNode((yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node)); ;}
3359
{ (yyval.node) = new CommaNode((yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node)); }
3065
3360
break;
3066
3361
3067
3362
case 203:
3363
3364
/* Line 1806 of yacc.c */
3068
3365
#line 613 "grammar.y"
3069
{ (yyval.node) = new CommaNode((yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node)); ;}
3366
{ (yyval.node) = new CommaNode((yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node)); }
3070
3367
break;
3071
3368
3072
3369
case 221:
3370
3371
/* Line 1806 of yacc.c */
3073
3372
#line 637 "grammar.y"
3074
{ (yyval.stat) = new BlockNode(0); DBG((yyval.stat), (yylsp[(2) - (2)]), (yylsp[(2) - (2)])); ;}
3373
{ (yyval.stat) = new BlockNode(0); DBG((yyval.stat), (yylsp[(2) - (2)]), (yylsp[(2) - (2)])); }
3075
3374
break;
3076
3375
3077
3376
case 222:
3377
3378
/* Line 1806 of yacc.c */
3078
3379
#line 638 "grammar.y"
3079
{ (yyval.stat) = new BlockNode((yyvsp[(2) - (3)].srcs)); DBG((yyval.stat), (yylsp[(3) - (3)]), (yylsp[(3) - (3)])); ;}
3380
{ (yyval.stat) = new BlockNode((yyvsp[(2) - (3)].srcs)); DBG((yyval.stat), (yylsp[(3) - (3)]), (yylsp[(3) - (3)])); }
3080
3381
break;
3081
3382
3082
3383
case 223:
3384
3385
/* Line 1806 of yacc.c */
3083
3386
#line 642 "grammar.y"
3084
{ (yyval.stat) = new VarStatementNode((yyvsp[(2) - (3)].vlist)); DBG((yyval.stat), (yylsp[(1) - (3)]), (yylsp[(3) - (3)])); ;}
3387
{ (yyval.stat) = new VarStatementNode((yyvsp[(2) - (3)].vlist)); DBG((yyval.stat), (yylsp[(1) - (3)]), (yylsp[(3) - (3)])); }
3085
3388
break;
3086
3389
3087
3390
case 224:
3391
3392
/* Line 1806 of yacc.c */
3088
3393
#line 643 "grammar.y"
3089
{ (yyval.stat) = new VarStatementNode((yyvsp[(2) - (3)].vlist)); DBG((yyval.stat), (yylsp[(1) - (3)]), (yylsp[(2) - (3)])); AUTO_SEMICOLON; ;}
3394
{ (yyval.stat) = new VarStatementNode((yyvsp[(2) - (3)].vlist)); DBG((yyval.stat), (yylsp[(1) - (3)]), (yylsp[(2) - (3)])); AUTO_SEMICOLON; }
3090
3395
break;
3091
3396
3092
3397
case 225:
3398
3399
/* Line 1806 of yacc.c */
3093
3400
#line 647 "grammar.y"
3094
{ (yyval.vlist) = new VarDeclListNode((yyvsp[(1) - (1)].decl)); ;}
3401
{ (yyval.vlist) = new VarDeclListNode((yyvsp[(1) - (1)].decl)); }
3095
3402
break;
3096
3403
3097
3404
case 226:
3405
3406
/* Line 1806 of yacc.c */
3098
3407
#line 649 "grammar.y"
3099
{ (yyval.vlist) = new VarDeclListNode((yyvsp[(1) - (3)].vlist), (yyvsp[(3) - (3)].decl)); ;}
3408
{ (yyval.vlist) = new VarDeclListNode((yyvsp[(1) - (3)].vlist), (yyvsp[(3) - (3)].decl)); }
3100
3409
break;
3101
3410
3102
3411
case 227:
3412
3413
/* Line 1806 of yacc.c */
3103
3414
#line 653 "grammar.y"
3104
{ (yyval.vlist) = new VarDeclListNode((yyvsp[(1) - (1)].decl)); ;}
3415
{ (yyval.vlist) = new VarDeclListNode((yyvsp[(1) - (1)].decl)); }
3105
3416
break;
3106
3417
3107
3418
case 228:
3419
3420
/* Line 1806 of yacc.c */
3108
3421
#line 655 "grammar.y"
3109
{ (yyval.vlist) = new VarDeclListNode((yyvsp[(1) - (3)].vlist), (yyvsp[(3) - (3)].decl)); ;}
3422
{ (yyval.vlist) = new VarDeclListNode((yyvsp[(1) - (3)].vlist), (yyvsp[(3) - (3)].decl)); }
3110
3423
break;
3111
3424
3112
3425
case 229:
3426
3427
/* Line 1806 of yacc.c */
3113
3428
#line 659 "grammar.y"
3114
{ (yyval.decl) = new VarDeclNode(*(yyvsp[(1) - (1)].ident), 0, VarDeclNode::Variable); ;}
3429
{ (yyval.decl) = new VarDeclNode(*(yyvsp[(1) - (1)].ident), 0, VarDeclNode::Variable); }
3115
3430
break;
3116
3431
3117
3432
case 230:
3433
3434
/* Line 1806 of yacc.c */
3118
3435
#line 660 "grammar.y"
3119
{ (yyval.decl) = new VarDeclNode(*(yyvsp[(1) - (2)].ident), (yyvsp[(2) - (2)].init), VarDeclNode::Variable); ;}
3436
{ (yyval.decl) = new VarDeclNode(*(yyvsp[(1) - (2)].ident), (yyvsp[(2) - (2)].init), VarDeclNode::Variable); }
3120
3437
break;
3121
3438
3122
3439
case 231:
3440
3441
/* Line 1806 of yacc.c */
3123
3442
#line 664 "grammar.y"
3124
{ (yyval.decl) = new VarDeclNode(*(yyvsp[(1) - (1)].ident), 0, VarDeclNode::Variable); ;}
3443
{ (yyval.decl) = new VarDeclNode(*(yyvsp[(1) - (1)].ident), 0, VarDeclNode::Variable); }
3125
3444
break;
3126
3445
3127
3446
case 232:
3447
3448
/* Line 1806 of yacc.c */
3128
3449
#line 665 "grammar.y"
3129
{ (yyval.decl) = new VarDeclNode(*(yyvsp[(1) - (2)].ident), (yyvsp[(2) - (2)].init), VarDeclNode::Variable); ;}
3450
{ (yyval.decl) = new VarDeclNode(*(yyvsp[(1) - (2)].ident), (yyvsp[(2) - (2)].init), VarDeclNode::Variable); }
3130
3451
break;
3131
3452
3132
3453
case 233:
3454
3455
/* Line 1806 of yacc.c */
3133
3456
#line 669 "grammar.y"
3134
{ (yyval.stat) = new VarStatementNode((yyvsp[(2) - (3)].vlist)); DBG((yyval.stat), (yylsp[(1) - (3)]), (yylsp[(3) - (3)])); ;}
3457
{ (yyval.stat) = new VarStatementNode((yyvsp[(2) - (3)].vlist)); DBG((yyval.stat), (yylsp[(1) - (3)]), (yylsp[(3) - (3)])); }
3135
3458
break;
3136
3459
3137
3460
case 234:
3461
3462
/* Line 1806 of yacc.c */
3138
3463
#line 671 "grammar.y"
3139
{ (yyval.stat) = new VarStatementNode((yyvsp[(2) - (3)].vlist)); DBG((yyval.stat), (yylsp[(1) - (3)]), (yylsp[(2) - (3)])); AUTO_SEMICOLON; ;}
3464
{ (yyval.stat) = new VarStatementNode((yyvsp[(2) - (3)].vlist)); DBG((yyval.stat), (yylsp[(1) - (3)]), (yylsp[(2) - (3)])); AUTO_SEMICOLON; }
3140
3465
break;
3141
3466
3142
3467
case 235:
3468
3469
/* Line 1806 of yacc.c */
3143
3470
#line 675 "grammar.y"
3144
{ (yyval.vlist) = new VarDeclListNode((yyvsp[(1) - (1)].decl)); ;}
3471
{ (yyval.vlist) = new VarDeclListNode((yyvsp[(1) - (1)].decl)); }
3145
3472
break;
3146
3473
3147
3474
case 236:
3475
3476
/* Line 1806 of yacc.c */
3148
3477
#line 677 "grammar.y"
3149
{ (yyval.vlist) = new VarDeclListNode((yyvsp[(1) - (3)].vlist), (yyvsp[(3) - (3)].decl)); ;}
3478
{ (yyval.vlist) = new VarDeclListNode((yyvsp[(1) - (3)].vlist), (yyvsp[(3) - (3)].decl)); }
3150
3479
break;
3151
3480
3152
3481
case 237:
3482
3483
/* Line 1806 of yacc.c */
3153
3484
#line 681 "grammar.y"
3154
{ (yyval.decl) = new VarDeclNode(*(yyvsp[(1) - (1)].ident), 0, VarDeclNode::Constant); ;}
3485
{ (yyval.decl) = new VarDeclNode(*(yyvsp[(1) - (1)].ident), 0, VarDeclNode::Constant); }
3155
3486
break;
3156
3487
3157
3488
case 238:
3489
3490
/* Line 1806 of yacc.c */
3158
3491
#line 682 "grammar.y"
3159
{ (yyval.decl) = new VarDeclNode(*(yyvsp[(1) - (2)].ident), (yyvsp[(2) - (2)].init), VarDeclNode::Constant); ;}
3492
{ (yyval.decl) = new VarDeclNode(*(yyvsp[(1) - (2)].ident), (yyvsp[(2) - (2)].init), VarDeclNode::Constant); }
3160
3493
break;
3161
3494
3162
3495
case 239:
3496
3497
/* Line 1806 of yacc.c */
3163
3498
#line 686 "grammar.y"
3164
{ (yyval.init) = new AssignExprNode((yyvsp[(2) - (2)].node)); ;}
3499
{ (yyval.init) = new AssignExprNode((yyvsp[(2) - (2)].node)); }
3165
3500
break;
3166
3501
3167
3502
case 240:
3503
3504
/* Line 1806 of yacc.c */
3168
3505
#line 690 "grammar.y"
3169
{ (yyval.init) = new AssignExprNode((yyvsp[(2) - (2)].node)); ;}
3506
{ (yyval.init) = new AssignExprNode((yyvsp[(2) - (2)].node)); }
3170
3507
break;
3171
3508
3172
3509
case 241:
3510
3511
/* Line 1806 of yacc.c */
3173
3512
#line 694 "grammar.y"
3174
{ (yyval.stat) = new EmptyStatementNode(); ;}
3513
{ (yyval.stat) = new EmptyStatementNode(); }
3175
3514
break;
3176
3515
3177
3516
case 242:
3517
3518
/* Line 1806 of yacc.c */
3178
3519
#line 698 "grammar.y"
3179
{ (yyval.stat) = new ExprStatementNode((yyvsp[(1) - (2)].node)); DBG((yyval.stat), (yylsp[(1) - (2)]), (yylsp[(2) - (2)])); ;}
3520
{ (yyval.stat) = new ExprStatementNode((yyvsp[(1) - (2)].node)); DBG((yyval.stat), (yylsp[(1) - (2)]), (yylsp[(2) - (2)])); }
3180
3521
break;
3181
3522
3182
3523
case 243:
3524
3525
/* Line 1806 of yacc.c */
3183
3526
#line 699 "grammar.y"
3184
{ (yyval.stat) = new ExprStatementNode((yyvsp[(1) - (2)].node)); DBG((yyval.stat), (yylsp[(1) - (2)]), (yylsp[(1) - (2)])); AUTO_SEMICOLON; ;}
3527
{ (yyval.stat) = new ExprStatementNode((yyvsp[(1) - (2)].node)); DBG((yyval.stat), (yylsp[(1) - (2)]), (yylsp[(1) - (2)])); AUTO_SEMICOLON; }
3185
3528
break;
3186
3529
3187
3530
case 244:
3531
3532
/* Line 1806 of yacc.c */
3188
3533
#line 704 "grammar.y"
3189
{ (yyval.stat) = makeIfNode((yyvsp[(3) - (5)].node), (yyvsp[(5) - (5)].stat), 0); DBG((yyval.stat), (yylsp[(1) - (5)]), (yylsp[(4) - (5)])); ;}
3534
{ (yyval.stat) = makeIfNode((yyvsp[(3) - (5)].node), (yyvsp[(5) - (5)].stat), 0); DBG((yyval.stat), (yylsp[(1) - (5)]), (yylsp[(4) - (5)])); }
3190
3535
break;
3191
3536
3192
3537
case 245:
3538
3539
/* Line 1806 of yacc.c */
3193
3540
#line 706 "grammar.y"
3194
{ (yyval.stat) = makeIfNode((yyvsp[(3) - (7)].node), (yyvsp[(5) - (7)].stat), (yyvsp[(7) - (7)].stat)); DBG((yyval.stat), (yylsp[(1) - (7)]), (yylsp[(4) - (7)])); ;}
3541
{ (yyval.stat) = makeIfNode((yyvsp[(3) - (7)].node), (yyvsp[(5) - (7)].stat), (yyvsp[(7) - (7)].stat)); DBG((yyval.stat), (yylsp[(1) - (7)]), (yylsp[(4) - (7)])); }
3195
3542
break;
3196
3543
3197
3544
case 246:
3545
3546
/* Line 1806 of yacc.c */
3198
3547
#line 710 "grammar.y"
3199
{ (yyval.stat) = new DoWhileNode((yyvsp[(2) - (7)].stat), (yyvsp[(5) - (7)].node)); DBG((yyval.stat), (yylsp[(1) - (7)]), (yylsp[(3) - (7)]));;}
3548
{ (yyval.stat) = new DoWhileNode((yyvsp[(2) - (7)].stat), (yyvsp[(5) - (7)].node)); DBG((yyval.stat), (yylsp[(1) - (7)]), (yylsp[(3) - (7)]));}
3200
3549
break;
3201
3550
3202
3551
case 247:
3552
3553
/* Line 1806 of yacc.c */
3203
3554
#line 711 "grammar.y"
3204
{ (yyval.stat) = new DoWhileNode((yyvsp[(2) - (6)].stat), (yyvsp[(5) - (6)].node)); DBG((yyval.stat), (yylsp[(1) - (6)]), (yylsp[(3) - (6)])); ;}
3555
{ (yyval.stat) = new DoWhileNode((yyvsp[(2) - (6)].stat), (yyvsp[(5) - (6)].node)); DBG((yyval.stat), (yylsp[(1) - (6)]), (yylsp[(3) - (6)])); }
3205
3556
break;
3206
3557
3207
3558
case 248:
3559
3560
/* Line 1806 of yacc.c */
3208
3561
#line 712 "grammar.y"
3209
{ (yyval.stat) = new WhileNode((yyvsp[(3) - (5)].node), (yyvsp[(5) - (5)].stat)); DBG((yyval.stat), (yylsp[(1) - (5)]), (yylsp[(4) - (5)])); ;}
3562
{ (yyval.stat) = new WhileNode((yyvsp[(3) - (5)].node), (yyvsp[(5) - (5)].stat)); DBG((yyval.stat), (yylsp[(1) - (5)]), (yylsp[(4) - (5)])); }
3210
3563
break;
3211
3564
3212
3565
case 249:
3566
3567
/* Line 1806 of yacc.c */
3213
3568
#line 714 "grammar.y"
3214
{ (yyval.stat) = new ForNode((yyvsp[(3) - (9)].node), (yyvsp[(5) - (9)].node), (yyvsp[(7) - (9)].node), (yyvsp[(9) - (9)].stat)); DBG((yyval.stat), (yylsp[(1) - (9)]), (yylsp[(8) - (9)])); ;}
3569
{ (yyval.stat) = new ForNode((yyvsp[(3) - (9)].node), (yyvsp[(5) - (9)].node), (yyvsp[(7) - (9)].node), (yyvsp[(9) - (9)].stat)); DBG((yyval.stat), (yylsp[(1) - (9)]), (yylsp[(8) - (9)])); }
3215
3570
break;
3216
3571
3217
3572
case 250:
3573
3574
/* Line 1806 of yacc.c */
3218
3575
#line 716 "grammar.y"
3219
{ (yyval.stat) = new ForNode((yyvsp[(4) - (10)].vlist), (yyvsp[(6) - (10)].node), (yyvsp[(8) - (10)].node), (yyvsp[(10) - (10)].stat)); DBG((yyval.stat), (yylsp[(1) - (10)]), (yylsp[(9) - (10)])); ;}
3576
{ (yyval.stat) = new ForNode((yyvsp[(4) - (10)].vlist), (yyvsp[(6) - (10)].node), (yyvsp[(8) - (10)].node), (yyvsp[(10) - (10)].stat)); DBG((yyval.stat), (yylsp[(1) - (10)]), (yylsp[(9) - (10)])); }
3220
3577
break;
3221
3578
3222
3579
case 251:
3580
3581
/* Line 1806 of yacc.c */
3223
3582
#line 718 "grammar.y"
3224
3583
{
3225
3584
Node *n = (yyvsp[(3) - (7)].node)->nodeInsideAllParens();
3227
3586
YYABORT;
3228
3587
(yyval.stat) = new ForInNode(n, (yyvsp[(5) - (7)].node), (yyvsp[(7) - (7)].stat));
3229
3588
DBG((yyval.stat), (yylsp[(1) - (7)]), (yylsp[(6) - (7)]));
3230
;}
3589
}
3231
3590
break;
3232
3591
3233
3592
case 252:
3593
3594
/* Line 1806 of yacc.c */
3234
3595
#line 726 "grammar.y"
3235
{ (yyval.stat) = new ForInNode(*(yyvsp[(4) - (8)].ident), 0, (yyvsp[(6) - (8)].node), (yyvsp[(8) - (8)].stat)); DBG((yyval.stat), (yylsp[(1) - (8)]), (yylsp[(7) - (8)])); ;}
3596
{ (yyval.stat) = new ForInNode(*(yyvsp[(4) - (8)].ident), 0, (yyvsp[(6) - (8)].node), (yyvsp[(8) - (8)].stat)); DBG((yyval.stat), (yylsp[(1) - (8)]), (yylsp[(7) - (8)])); }
3236
3597
break;
3237
3598
3238
3599
case 253:
3600
3601
/* Line 1806 of yacc.c */
3239
3602
#line 728 "grammar.y"
3240
{ (yyval.stat) = new ForInNode(*(yyvsp[(4) - (9)].ident), (yyvsp[(5) - (9)].init), (yyvsp[(7) - (9)].node), (yyvsp[(9) - (9)].stat)); DBG((yyval.stat), (yylsp[(1) - (9)]), (yylsp[(8) - (9)])); ;}
3603
{ (yyval.stat) = new ForInNode(*(yyvsp[(4) - (9)].ident), (yyvsp[(5) - (9)].init), (yyvsp[(7) - (9)].node), (yyvsp[(9) - (9)].stat)); DBG((yyval.stat), (yylsp[(1) - (9)]), (yylsp[(8) - (9)])); }
3241
3604
break;
3242
3605
3243
3606
case 254:
3607
3608
/* Line 1806 of yacc.c */
3244
3609
#line 732 "grammar.y"
3245
{ (yyval.node) = 0; ;}
3610
{ (yyval.node) = 0; }
3246
3611
break;
3247
3612
3248
3613
case 256:
3614
3615
/* Line 1806 of yacc.c */
3249
3616
#line 737 "grammar.y"
3250
{ (yyval.node) = 0; ;}
3617
{ (yyval.node) = 0; }
3251
3618
break;
3252
3619
3253
3620
case 258:
3621
3622
/* Line 1806 of yacc.c */
3254
3623
#line 742 "grammar.y"
3255
{ (yyval.stat) = new ContinueNode(); DBG((yyval.stat), (yylsp[(1) - (2)]), (yylsp[(2) - (2)])); ;}
3624
{ (yyval.stat) = new ContinueNode(); DBG((yyval.stat), (yylsp[(1) - (2)]), (yylsp[(2) - (2)])); }
3256
3625
break;
3257
3626
3258
3627
case 259:
3628
3629
/* Line 1806 of yacc.c */
3259
3630
#line 743 "grammar.y"
3260
{ (yyval.stat) = new ContinueNode(); DBG((yyval.stat), (yylsp[(1) - (2)]), (yylsp[(1) - (2)])); AUTO_SEMICOLON; ;}
3631
{ (yyval.stat) = new ContinueNode(); DBG((yyval.stat), (yylsp[(1) - (2)]), (yylsp[(1) - (2)])); AUTO_SEMICOLON; }
3261
3632
break;
3262
3633
3263
3634
case 260:
3635
3636
/* Line 1806 of yacc.c */
3264
3637
#line 744 "grammar.y"
3265
{ (yyval.stat) = new ContinueNode(*(yyvsp[(2) - (3)].ident)); DBG((yyval.stat), (yylsp[(1) - (3)]), (yylsp[(3) - (3)])); ;}
3638
{ (yyval.stat) = new ContinueNode(*(yyvsp[(2) - (3)].ident)); DBG((yyval.stat), (yylsp[(1) - (3)]), (yylsp[(3) - (3)])); }
3266
3639
break;
3267
3640
3268
3641
case 261:
3642
3643
/* Line 1806 of yacc.c */
3269
3644
#line 745 "grammar.y"
3270
{ (yyval.stat) = new ContinueNode(*(yyvsp[(2) - (3)].ident)); DBG((yyval.stat), (yylsp[(1) - (3)]), (yylsp[(2) - (3)])); AUTO_SEMICOLON; ;}
3645
{ (yyval.stat) = new ContinueNode(*(yyvsp[(2) - (3)].ident)); DBG((yyval.stat), (yylsp[(1) - (3)]), (yylsp[(2) - (3)])); AUTO_SEMICOLON; }
3271
3646
break;
3272
3647
3273
3648
case 262:
3649
3650
/* Line 1806 of yacc.c */
3274
3651
#line 749 "grammar.y"
3275
{ (yyval.stat) = new BreakNode(); DBG((yyval.stat), (yylsp[(1) - (2)]), (yylsp[(2) - (2)])); ;}
3652
{ (yyval.stat) = new BreakNode(); DBG((yyval.stat), (yylsp[(1) - (2)]), (yylsp[(2) - (2)])); }
3276
3653
break;
3277
3654
3278
3655
case 263:
3656
3657
/* Line 1806 of yacc.c */
3279
3658
#line 750 "grammar.y"
3280
{ (yyval.stat) = new BreakNode(); DBG((yyval.stat), (yylsp[(1) - (2)]), (yylsp[(1) - (2)])); AUTO_SEMICOLON; ;}
3659
{ (yyval.stat) = new BreakNode(); DBG((yyval.stat), (yylsp[(1) - (2)]), (yylsp[(1) - (2)])); AUTO_SEMICOLON; }
3281
3660
break;
3282
3661
3283
3662
case 264:
3663
3664
/* Line 1806 of yacc.c */
3284
3665
#line 751 "grammar.y"
3285
{ (yyval.stat) = new BreakNode(*(yyvsp[(2) - (3)].ident)); DBG((yyval.stat), (yylsp[(1) - (3)]), (yylsp[(3) - (3)])); ;}
3666
{ (yyval.stat) = new BreakNode(*(yyvsp[(2) - (3)].ident)); DBG((yyval.stat), (yylsp[(1) - (3)]), (yylsp[(3) - (3)])); }
3286
3667
break;
3287
3668
3288
3669
case 265:
3670
3671
/* Line 1806 of yacc.c */
3289
3672
#line 752 "grammar.y"
3290
{ (yyval.stat) = new BreakNode(*(yyvsp[(2) - (3)].ident)); DBG((yyval.stat), (yylsp[(1) - (3)]), (yylsp[(2) - (3)])); AUTO_SEMICOLON; ;}
3673
{ (yyval.stat) = new BreakNode(*(yyvsp[(2) - (3)].ident)); DBG((yyval.stat), (yylsp[(1) - (3)]), (yylsp[(2) - (3)])); AUTO_SEMICOLON; }
3291
3674
break;
3292
3675
3293
3676
case 266:
3677
3678
/* Line 1806 of yacc.c */
3294
3679
#line 756 "grammar.y"
3295
{ (yyval.stat) = new ReturnNode(0); DBG((yyval.stat), (yylsp[(1) - (2)]), (yylsp[(2) - (2)])); ;}
3680
{ (yyval.stat) = new ReturnNode(0); DBG((yyval.stat), (yylsp[(1) - (2)]), (yylsp[(2) - (2)])); }
3296
3681
break;
3297
3682
3298
3683
case 267:
3684
3685
/* Line 1806 of yacc.c */
3299
3686
#line 757 "grammar.y"
3300
{ (yyval.stat) = new ReturnNode(0); DBG((yyval.stat), (yylsp[(1) - (2)]), (yylsp[(1) - (2)])); AUTO_SEMICOLON; ;}
3687
{ (yyval.stat) = new ReturnNode(0); DBG((yyval.stat), (yylsp[(1) - (2)]), (yylsp[(1) - (2)])); AUTO_SEMICOLON; }
3301
3688
break;
3302
3689
3303
3690
case 268:
3691
3692
/* Line 1806 of yacc.c */
3304
3693
#line 758 "grammar.y"
3305
{ (yyval.stat) = new ReturnNode((yyvsp[(2) - (3)].node)); DBG((yyval.stat), (yylsp[(1) - (3)]), (yylsp[(3) - (3)])); ;}
3694
{ (yyval.stat) = new ReturnNode((yyvsp[(2) - (3)].node)); DBG((yyval.stat), (yylsp[(1) - (3)]), (yylsp[(3) - (3)])); }
3306
3695
break;
3307
3696
3308
3697
case 269:
3698
3699
/* Line 1806 of yacc.c */
3309
3700
#line 759 "grammar.y"
3310
{ (yyval.stat) = new ReturnNode((yyvsp[(2) - (3)].node)); DBG((yyval.stat), (yylsp[(1) - (3)]), (yylsp[(2) - (3)])); AUTO_SEMICOLON; ;}
3701
{ (yyval.stat) = new ReturnNode((yyvsp[(2) - (3)].node)); DBG((yyval.stat), (yylsp[(1) - (3)]), (yylsp[(2) - (3)])); AUTO_SEMICOLON; }
3311
3702
break;
3312
3703
3313
3704
case 270:
3705
3706
/* Line 1806 of yacc.c */
3314
3707
#line 763 "grammar.y"
3315
{ (yyval.stat) = new WithNode((yyvsp[(3) - (5)].node), (yyvsp[(5) - (5)].stat)); DBG((yyval.stat), (yylsp[(1) - (5)]), (yylsp[(4) - (5)])); ;}
3708
{ (yyval.stat) = new WithNode((yyvsp[(3) - (5)].node), (yyvsp[(5) - (5)].stat)); DBG((yyval.stat), (yylsp[(1) - (5)]), (yylsp[(4) - (5)])); }
3316
3709
break;
3317
3710
3318
3711
case 271:
3712
3713
/* Line 1806 of yacc.c */
3319
3714
#line 767 "grammar.y"
3320
{ (yyval.stat) = new SwitchNode((yyvsp[(3) - (5)].node), (yyvsp[(5) - (5)].cblk)); DBG((yyval.stat), (yylsp[(1) - (5)]), (yylsp[(4) - (5)])); ;}
3715
{ (yyval.stat) = new SwitchNode((yyvsp[(3) - (5)].node), (yyvsp[(5) - (5)].cblk)); DBG((yyval.stat), (yylsp[(1) - (5)]), (yylsp[(4) - (5)])); }
3321
3716
break;
3322
3717
3323
3718
case 272:
3719
3720
/* Line 1806 of yacc.c */
3324
3721
#line 771 "grammar.y"
3325
{ (yyval.cblk) = new CaseBlockNode((yyvsp[(2) - (3)].clist), 0, 0); ;}
3722
{ (yyval.cblk) = new CaseBlockNode((yyvsp[(2) - (3)].clist), 0, 0); }
3326
3723
break;
3327
3724
3328
3725
case 273:
3726
3727
/* Line 1806 of yacc.c */
3329
3728
#line 773 "grammar.y"
3330
{ (yyval.cblk) = new CaseBlockNode((yyvsp[(2) - (5)].clist), (yyvsp[(3) - (5)].ccl), (yyvsp[(4) - (5)].clist)); ;}
3729
{ (yyval.cblk) = new CaseBlockNode((yyvsp[(2) - (5)].clist), (yyvsp[(3) - (5)].ccl), (yyvsp[(4) - (5)].clist)); }
3331
3730
break;
3332
3731
3333
3732
case 274:
3733
3734
/* Line 1806 of yacc.c */
3334
3735
#line 777 "grammar.y"
3335
{ (yyval.clist) = 0; ;}
3736
{ (yyval.clist) = 0; }
3336
3737
break;
3337
3738
3338
3739
case 276:
3740
3741
/* Line 1806 of yacc.c */
3339
3742
#line 782 "grammar.y"
3340
{ (yyval.clist) = new ClauseListNode((yyvsp[(1) - (1)].ccl)); ;}
3743
{ (yyval.clist) = new ClauseListNode((yyvsp[(1) - (1)].ccl)); }
3341
3744
break;
3342
3745
3343
3746
case 277:
3747
3748
/* Line 1806 of yacc.c */
3344
3749
#line 783 "grammar.y"
3345
{ (yyval.clist) = new ClauseListNode((yyvsp[(1) - (2)].clist), (yyvsp[(2) - (2)].ccl)); ;}
3750
{ (yyval.clist) = new ClauseListNode((yyvsp[(1) - (2)].clist), (yyvsp[(2) - (2)].ccl)); }
3346
3751
break;
3347
3752
3348
3753
case 278:
3754
3755
/* Line 1806 of yacc.c */
3349
3756
#line 787 "grammar.y"
3350
{ (yyval.ccl) = new CaseClauseNode((yyvsp[(2) - (3)].node)); ;}
3757
{ (yyval.ccl) = new CaseClauseNode((yyvsp[(2) - (3)].node)); }
3351
3758
break;
3352
3759
3353
3760
case 279:
3761
3762
/* Line 1806 of yacc.c */
3354
3763
#line 788 "grammar.y"
3355
{ (yyval.ccl) = new CaseClauseNode((yyvsp[(2) - (4)].node), (yyvsp[(4) - (4)].srcs)); ;}
3764
{ (yyval.ccl) = new CaseClauseNode((yyvsp[(2) - (4)].node), (yyvsp[(4) - (4)].srcs)); }
3356
3765
break;
3357
3766
3358
3767
case 280:
3768
3769
/* Line 1806 of yacc.c */
3359
3770
#line 792 "grammar.y"
3360
{ (yyval.ccl) = new CaseClauseNode(0); ;}
3771
{ (yyval.ccl) = new CaseClauseNode(0); }
3361
3772
break;
3362
3773
3363
3774
case 281:
3775
3776
/* Line 1806 of yacc.c */
3364
3777
#line 793 "grammar.y"
3365
{ (yyval.ccl) = new CaseClauseNode(0, (yyvsp[(3) - (3)].srcs)); ;}
3778
{ (yyval.ccl) = new CaseClauseNode(0, (yyvsp[(3) - (3)].srcs)); }
3366
3779
break;
3367
3780
3368
3781
case 282:
3782
3783
/* Line 1806 of yacc.c */
3369
3784
#line 797 "grammar.y"
3370
{ (yyval.stat) = makeLabelNode(*(yyvsp[(1) - (3)].ident), (yyvsp[(3) - (3)].stat)); ;}
3785
{ (yyval.stat) = makeLabelNode(*(yyvsp[(1) - (3)].ident), (yyvsp[(3) - (3)].stat)); }
3371
3786
break;
3372
3787
3373
3788
case 283:
3789
3790
/* Line 1806 of yacc.c */
3374
3791
#line 801 "grammar.y"
3375
{ (yyval.stat) = new ThrowNode((yyvsp[(2) - (3)].node)); DBG((yyval.stat), (yylsp[(1) - (3)]), (yylsp[(3) - (3)])); ;}
3792
{ (yyval.stat) = new ThrowNode((yyvsp[(2) - (3)].node)); DBG((yyval.stat), (yylsp[(1) - (3)]), (yylsp[(3) - (3)])); }
3376
3793
break;
3377
3794
3378
3795
case 284:
3796
3797
/* Line 1806 of yacc.c */
3379
3798
#line 802 "grammar.y"
3380
{ (yyval.stat) = new ThrowNode((yyvsp[(2) - (3)].node)); DBG((yyval.stat), (yylsp[(1) - (3)]), (yylsp[(2) - (3)])); AUTO_SEMICOLON; ;}
3799
{ (yyval.stat) = new ThrowNode((yyvsp[(2) - (3)].node)); DBG((yyval.stat), (yylsp[(1) - (3)]), (yylsp[(2) - (3)])); AUTO_SEMICOLON; }
3381
3800
break;
3382
3801
3383
3802
case 285:
3803
3804
/* Line 1806 of yacc.c */
3384
3805
#line 806 "grammar.y"
3385
{ (yyval.stat) = new TryNode((yyvsp[(2) - (4)].stat), CommonIdentifiers::shared()->nullIdentifier, 0, (yyvsp[(4) - (4)].stat)); DBG((yyval.stat), (yylsp[(1) - (4)]), (yylsp[(2) - (4)])); ;}
3806
{ (yyval.stat) = new TryNode((yyvsp[(2) - (4)].stat), CommonIdentifiers::shared()->nullIdentifier, 0, (yyvsp[(4) - (4)].stat)); DBG((yyval.stat), (yylsp[(1) - (4)]), (yylsp[(2) - (4)])); }
3386
3807
break;
3387
3808
3388
3809
case 286:
3810
3811
/* Line 1806 of yacc.c */
3389
3812
#line 807 "grammar.y"
3390
{ (yyval.stat) = new TryNode((yyvsp[(2) - (7)].stat), *(yyvsp[(5) - (7)].ident), (yyvsp[(7) - (7)].stat), 0); DBG((yyval.stat), (yylsp[(1) - (7)]), (yylsp[(2) - (7)])); ;}
3813
{ (yyval.stat) = new TryNode((yyvsp[(2) - (7)].stat), *(yyvsp[(5) - (7)].ident), (yyvsp[(7) - (7)].stat), 0); DBG((yyval.stat), (yylsp[(1) - (7)]), (yylsp[(2) - (7)])); }
3391
3814
break;
3392
3815
3393
3816
case 287:
3817
3818
/* Line 1806 of yacc.c */
3394
3819
#line 809 "grammar.y"
3395
{ (yyval.stat) = new TryNode((yyvsp[(2) - (9)].stat), *(yyvsp[(5) - (9)].ident), (yyvsp[(7) - (9)].stat), (yyvsp[(9) - (9)].stat)); DBG((yyval.stat), (yylsp[(1) - (9)]), (yylsp[(2) - (9)])); ;}
3820
{ (yyval.stat) = new TryNode((yyvsp[(2) - (9)].stat), *(yyvsp[(5) - (9)].ident), (yyvsp[(7) - (9)].stat), (yyvsp[(9) - (9)].stat)); DBG((yyval.stat), (yylsp[(1) - (9)]), (yylsp[(2) - (9)])); }
3396
3821
break;
3397
3822
3398
3823
case 288:
3824
3825
/* Line 1806 of yacc.c */
3399
3826
#line 813 "grammar.y"
3400
{ (yyval.stat) = new EmptyStatementNode(); DBG((yyval.stat), (yylsp[(1) - (2)]), (yylsp[(2) - (2)])); ;}
3827
{ (yyval.stat) = new EmptyStatementNode(); DBG((yyval.stat), (yylsp[(1) - (2)]), (yylsp[(2) - (2)])); }
3401
3828
break;
3402
3829
3403
3830
case 289:
3831
3832
/* Line 1806 of yacc.c */
3404
3833
#line 814 "grammar.y"
3405
{ (yyval.stat) = new EmptyStatementNode(); DBG((yyval.stat), (yylsp[(1) - (2)]), (yylsp[(1) - (2)])); AUTO_SEMICOLON; ;}
3834
{ (yyval.stat) = new EmptyStatementNode(); DBG((yyval.stat), (yylsp[(1) - (2)]), (yylsp[(1) - (2)])); AUTO_SEMICOLON; }
3406
3835
break;
3407
3836
3408
3837
case 290:
3838
3839
/* Line 1806 of yacc.c */
3409
3840
#line 818 "grammar.y"
3410
{ (yyval.pkgn) = new PackageNameNode(*(yyvsp[(1) - (1)].ident)); ;}
3841
{ (yyval.pkgn) = new PackageNameNode(*(yyvsp[(1) - (1)].ident)); }
3411
3842
break;
3412
3843
3413
3844
case 291:
3845
3846
/* Line 1806 of yacc.c */
3414
3847
#line 819 "grammar.y"
3415
{ (yyval.pkgn) = new PackageNameNode((yyvsp[(1) - (3)].pkgn), *(yyvsp[(3) - (3)].ident)); ;}
3848
{ (yyval.pkgn) = new PackageNameNode((yyvsp[(1) - (3)].pkgn), *(yyvsp[(3) - (3)].ident)); }
3416
3849
break;
3417
3850
3418
3851
case 292:
3852
3853
/* Line 1806 of yacc.c */
3419
3854
#line 823 "grammar.y"
3420
3855
{ (yyval.stat) = makeImportNode((yyvsp[(2) - (5)].pkgn), true, 0);
3421
DBG((yyval.stat), (yylsp[(1) - (5)]), (yylsp[(5) - (5)])); ;}
3856
DBG((yyval.stat), (yylsp[(1) - (5)]), (yylsp[(5) - (5)])); }
3422
3857
break;
3423
3858
3424
3859
case 293:
3860
3861
/* Line 1806 of yacc.c */
3425
3862
#line 825 "grammar.y"
3426
3863
{ (yyval.stat) = makeImportNode((yyvsp[(2) - (5)].pkgn), true, 0);
3427
DBG((yyval.stat), (yylsp[(1) - (5)]), (yylsp[(5) - (5)])); AUTO_SEMICOLON; ;}
3864
DBG((yyval.stat), (yylsp[(1) - (5)]), (yylsp[(5) - (5)])); AUTO_SEMICOLON; }
3428
3865
break;
3429
3866
3430
3867
case 294:
3868
3869
/* Line 1806 of yacc.c */
3431
3870
#line 827 "grammar.y"
3432
3871
{ (yyval.stat) = makeImportNode((yyvsp[(2) - (3)].pkgn), false, 0);
3433
DBG((yyval.stat), (yylsp[(1) - (3)]), (yylsp[(3) - (3)])); ;}
3872
DBG((yyval.stat), (yylsp[(1) - (3)]), (yylsp[(3) - (3)])); }
3434
3873
break;
3435
3874
3436
3875
case 295:
3876
3877
/* Line 1806 of yacc.c */
3437
3878
#line 829 "grammar.y"
3438
3879
{ (yyval.stat) = makeImportNode((yyvsp[(2) - (3)].pkgn), false, 0);
3439
DBG((yyval.stat), (yylsp[(1) - (3)]), (yylsp[(3) - (3)])); AUTO_SEMICOLON; ;}
3880
DBG((yyval.stat), (yylsp[(1) - (3)]), (yylsp[(3) - (3)])); AUTO_SEMICOLON; }
3440
3881
break;
3441
3882
3442
3883
case 296:
3884
3885
/* Line 1806 of yacc.c */
3443
3886
#line 831 "grammar.y"
3444
3887
{ (yyval.stat) = makeImportNode((yyvsp[(4) - (5)].pkgn), false, *(yyvsp[(2) - (5)].ident));
3445
DBG((yyval.stat), (yylsp[(1) - (5)]), (yylsp[(5) - (5)])); ;}
3888
DBG((yyval.stat), (yylsp[(1) - (5)]), (yylsp[(5) - (5)])); }
3446
3889
break;
3447
3890
3448
3891
case 297:
3892
3893
/* Line 1806 of yacc.c */
3449
3894
#line 833 "grammar.y"
3450
3895
{ (yyval.stat) = makeImportNode((yyvsp[(4) - (5)].pkgn), false, *(yyvsp[(2) - (5)].ident));
3451
DBG((yyval.stat), (yylsp[(1) - (5)]), (yylsp[(5) - (5)])); AUTO_SEMICOLON; ;}
3896
DBG((yyval.stat), (yylsp[(1) - (5)]), (yylsp[(5) - (5)])); AUTO_SEMICOLON; }
3452
3897
break;
3453
3898
3454
3899
case 298:
3900
3901
/* Line 1806 of yacc.c */
3455
3902
#line 838 "grammar.y"
3456
3903
{inFuncDecl();}
3457
3904
break;
3458
3905
3459
3906
case 299:
3907
3908
/* Line 1806 of yacc.c */
3460
3909
#line 838 "grammar.y"
3461
{ (yyval.func) = new FuncDeclNode(*(yyvsp[(2) - (6)].ident), (yyvsp[(6) - (6)].body)); ;}
3910
{ (yyval.func) = new FuncDeclNode(*(yyvsp[(2) - (6)].ident), (yyvsp[(6) - (6)].body)); }
3462
3911
break;
3463
3912
3464
3913
case 300:
3914
3915
/* Line 1806 of yacc.c */
3465
3916
#line 839 "grammar.y"
3466
3917
{inFuncDecl();}
3467
3918
break;
3468
3919
3469
3920
case 301:
3921
3922
/* Line 1806 of yacc.c */
3470
3923
#line 840 "grammar.y"
3471
{ (yyval.func) = new FuncDeclNode(*(yyvsp[(2) - (7)].ident), (yyvsp[(4) - (7)].param), (yyvsp[(7) - (7)].body)); ;}
3924
{ (yyval.func) = new FuncDeclNode(*(yyvsp[(2) - (7)].ident), (yyvsp[(4) - (7)].param), (yyvsp[(7) - (7)].body)); }
3472
3925
break;
3473
3926
3474
3927
case 302:
3928
3929
/* Line 1806 of yacc.c */
3475
3930
#line 844 "grammar.y"
3476
3931
{inFuncExpr();}
3477
3932
break;
3478
3933
3479
3934
case 303:
3935
3936
/* Line 1806 of yacc.c */
3480
3937
#line 844 "grammar.y"
3481
3938
{
3482
3939
(yyval.funcExpr) = new FuncExprNode(CommonIdentifiers::shared()->nullIdentifier, (yyvsp[(5) - (5)].body));
3483
;}
3940
}
3484
3941
break;
3485
3942
3486
3943
case 304:
3944
3945
/* Line 1806 of yacc.c */
3487
3946
#line 847 "grammar.y"
3488
3947
{inFuncExpr();}
3489
3948
break;
3490
3949
3491
3950
case 305:
3951
3952
/* Line 1806 of yacc.c */
3492
3953
#line 847 "grammar.y"
3493
3954
{
3494
3955
(yyval.funcExpr) = new FuncExprNode(CommonIdentifiers::shared()->nullIdentifier, (yyvsp[(6) - (6)].body), (yyvsp[(3) - (6)].param));
3495
;}
3956
}
3496
3957
break;
3497
3958
3498
3959
case 306:
3960
3961
/* Line 1806 of yacc.c */
3499
3962
#line 850 "grammar.y"
3500
3963
{inFuncExpr();}
3501
3964
break;
3502
3965
3503
3966
case 307:
3967
3968
/* Line 1806 of yacc.c */
3504
3969
#line 850 "grammar.y"
3505
{ (yyval.funcExpr) = new FuncExprNode(*(yyvsp[(2) - (6)].ident), (yyvsp[(6) - (6)].body)); ;}
3970
{ (yyval.funcExpr) = new FuncExprNode(*(yyvsp[(2) - (6)].ident), (yyvsp[(6) - (6)].body)); }
3506
3971
break;
3507
3972
3508
3973
case 308:
3974
3975
/* Line 1806 of yacc.c */
3509
3976
#line 851 "grammar.y"
3510
3977
{inFuncExpr();}
3511
3978
break;
3512
3979
3513
3980
case 309:
3981
3982
/* Line 1806 of yacc.c */
3514
3983
#line 851 "grammar.y"
3515
3984
{
3516
3985
(yyval.funcExpr) = new FuncExprNode(*(yyvsp[(2) - (7)].ident), (yyvsp[(7) - (7)].body), (yyvsp[(4) - (7)].param));
3517
;}
3986
}
3518
3987
break;
3519
3988
3520
3989
case 310:
3990
3991
/* Line 1806 of yacc.c */
3521
3992
#line 857 "grammar.y"
3522
{ (yyval.param) = new ParameterNode(*(yyvsp[(1) - (1)].ident)); ;}
3993
{ (yyval.param) = new ParameterNode(*(yyvsp[(1) - (1)].ident)); }
3523
3994
break;
3524
3995
3525
3996
case 311:
3997
3998
/* Line 1806 of yacc.c */
3526
3999
#line 858 "grammar.y"
3527
{ (yyval.param) = new ParameterNode((yyvsp[(1) - (3)].param), *(yyvsp[(3) - (3)].ident)); ;}
4000
{ (yyval.param) = new ParameterNode((yyvsp[(1) - (3)].param), *(yyvsp[(3) - (3)].ident)); }
3528
4001
break;
3529
4002
3530
4003
case 312:
4004
4005
/* Line 1806 of yacc.c */
3531
4006
#line 862 "grammar.y"
3532
{ (yyval.body) = new FunctionBodyNode(0); DBG((yyval.body), (yylsp[(1) - (2)]), (yylsp[(2) - (2)])); ;}
4007
{ (yyval.body) = new FunctionBodyNode(0); DBG((yyval.body), (yylsp[(1) - (2)]), (yylsp[(2) - (2)])); }
3533
4008
break;
3534
4009
3535
4010
case 313:
4011
4012
/* Line 1806 of yacc.c */
3536
4013
#line 863 "grammar.y"
3537
{ (yyval.body) = new FunctionBodyNode((yyvsp[(2) - (3)].srcs)); DBG((yyval.body), (yylsp[(1) - (3)]), (yylsp[(3) - (3)])); ;}
4014
{ (yyval.body) = new FunctionBodyNode((yyvsp[(2) - (3)].srcs)); DBG((yyval.body), (yylsp[(1) - (3)]), (yylsp[(3) - (3)])); }
3538
4015
break;
3539
4016
3540
4017
case 314:
4018
4019
/* Line 1806 of yacc.c */
3541
4020
#line 867 "grammar.y"
3542
{ parser().didFinishParsing(new ProgramNode(0)); ;}
4021
{ parser().didFinishParsing(new ProgramNode(0)); }
3543
4022
break;
3544
4023
3545
4024
case 315:
4025
4026
/* Line 1806 of yacc.c */
3546
4027
#line 868 "grammar.y"
3547
{ parser().didFinishParsing(new ProgramNode((yyvsp[(1) - (1)].srcs))); ;}
4028
{ parser().didFinishParsing(new ProgramNode((yyvsp[(1) - (1)].srcs))); }
3548
4029
break;
3549
4030
3550
4031
case 316:
4032
4033
/* Line 1806 of yacc.c */
3551
4034
#line 872 "grammar.y"
3552
{ (yyval.srcs) = new SourceElementsNode((yyvsp[(1) - (1)].stat)); ;}
4035
{ (yyval.srcs) = new SourceElementsNode((yyvsp[(1) - (1)].stat)); }
3553
4036
break;
3554
4037
3555
4038
case 317:
4039
4040
/* Line 1806 of yacc.c */
3556
4041
#line 873 "grammar.y"
3557
{ (yyval.srcs) = new SourceElementsNode((yyvsp[(1) - (2)].srcs), (yyvsp[(2) - (2)].stat)); ;}
4042
{ (yyval.srcs) = new SourceElementsNode((yyvsp[(1) - (2)].srcs), (yyvsp[(2) - (2)].stat)); }
3558
4043
break;
3559
4044
3560
4045
case 318:
4046
4047
/* Line 1806 of yacc.c */
3561
4048
#line 877 "grammar.y"
3562
{ (yyval.stat) = (yyvsp[(1) - (1)].func); ;}
4049
{ (yyval.stat) = (yyvsp[(1) - (1)].func); }
3563
4050
break;
3564
4051
3565
4052
case 319:
4053
4054
/* Line 1806 of yacc.c */
3566
4055
#line 878 "grammar.y"
3567
{ (yyval.stat) = (yyvsp[(1) - (1)].stat); ;}
4056
{ (yyval.stat) = (yyvsp[(1) - (1)].stat); }
3568
4057
break;
3569
4058
3570
4059
3571
/* Line 1267 of yacc.c. */
3572
#line 3573 "grammar.tab.c"
4060
4061
/* Line 1806 of yacc.c */
4062
#line 4063 "grammar.tab.c"
3573
4063
default: break;
3574
4064
}
4065
/* User semantic actions sometimes alter yychar, and that requires
4066
that yytoken be updated with the new translation. We take the
4067
approach of translating immediately before every use of yytoken.
4068
One alternative is translating here after every semantic action,
4069
but that translation would be missed if the semantic action invokes
4070
YYABORT, YYACCEPT, or YYERROR immediately after altering yychar or
4071
if it invokes YYBACKUP. In the case of YYABORT or YYACCEPT, an
4072
incorrect destructor might then be invoked immediately. In the
4073
case of YYERROR or YYBACKUP, subsequent parser actions might lead
4074
to an incorrect destructor call or verbose syntax error message
4075
before the lookahead is translated. */
3575
4076
YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyn], &yyval, &yyloc);
3576
4077
3577
4078
YYPOPSTACK (yylen);
3600
4101
| yyerrlab -- here on detecting error |
3601
4102
`------------------------------------*/
3602
4103
yyerrlab:
4104
/* Make sure we have latest lookahead translation. See comments at
4105
user semantic actions for why this is necessary. */
4106
yytoken = yychar == YYEMPTY ? YYEMPTY : YYTRANSLATE (yychar);
4107
3603
4108
/* If not already recovering from an error, report this error. */
3604
4109
if (!yyerrstatus)
3605
4110
{
3607
4112
#if ! YYERROR_VERBOSE
3608
4113
yyerror (YY_("syntax error"));
3609
4114
#else
4115
# define YYSYNTAX_ERROR yysyntax_error (&yymsg_alloc, &yymsg, \
4116
yyssp, yytoken)
3610
4117
{
3611
YYSIZE_T yysize = yysyntax_error (0, yystate, yychar);
3612
if (yymsg_alloc < yysize && yymsg_alloc < YYSTACK_ALLOC_MAXIMUM)
3613
{
3614
YYSIZE_T yyalloc = 2 * yysize;
3615
if (! (yysize <= yyalloc && yyalloc <= YYSTACK_ALLOC_MAXIMUM))
3616
yyalloc = YYSTACK_ALLOC_MAXIMUM;
3617
if (yymsg != yymsgbuf)
3618
YYSTACK_FREE (yymsg);
3619
yymsg = (char *) YYSTACK_ALLOC (yyalloc);
3620
if (yymsg)
3621
yymsg_alloc = yyalloc;
3622
else
3623
{
3624
yymsg = yymsgbuf;
3625
yymsg_alloc = sizeof yymsgbuf;
3626
}
3627
}
3628
3629
if (0 < yysize && yysize <= yymsg_alloc)
3630
{
3631
(void) yysyntax_error (yymsg, yystate, yychar);
3632
yyerror (yymsg);
3633
}
3634
else
3635
{
3636
yyerror (YY_("syntax error"));
3637
if (yysize != 0)
3638
goto yyexhaustedlab;
3639
}
4118
char const *yymsgp = YY_("syntax error");
4119
int yysyntax_error_status;
4120
yysyntax_error_status = YYSYNTAX_ERROR;
4121
if (yysyntax_error_status == 0)
4122
yymsgp = yymsg;
4123
else if (yysyntax_error_status == 1)
4124
{
4125
if (yymsg != yymsgbuf)
4126
YYSTACK_FREE (yymsg);
4127
yymsg = (char *) YYSTACK_ALLOC (yymsg_alloc);
4128
if (!yymsg)
4129
{
4130
yymsg = yymsgbuf;
4131
yymsg_alloc = sizeof yymsgbuf;
4132
yysyntax_error_status = 2;
4133
}
4134
else
4135
{
4136
yysyntax_error_status = YYSYNTAX_ERROR;
4137
yymsgp = yymsg;
4138
}
4139
}
4140
yyerror (yymsgp);
4141
if (yysyntax_error_status == 2)
4142
goto yyexhaustedlab;
3640
4143
}
4144
# undef YYSYNTAX_ERROR
3641
4145
#endif
3642
4146
}
3643
4147
3644
yyerror_range[0] = yylloc;
4148
yyerror_range[1] = yylloc;
3645
4149
3646
4150
if (yyerrstatus == 3)
3647
4151
{
3648
/* If just tried and failed to reuse look-ahead token after an
4152
/* If just tried and failed to reuse lookahead token after an
3649
4153
error, discard it. */
3650
4154
3651
4155
if (yychar <= YYEOF)
3662
4166
}
3663
4167
}
3664
4168
3665
/* Else will try to reuse look-ahead token after shifting the error
4169
/* Else will try to reuse lookahead token after shifting the error
3666
4170
token. */
3667
4171
goto yyerrlab1;
3668
4172
3678
4182
if (/*CONSTCOND*/ 0)
3679
4183
goto yyerrorlab;
3680
4184
3681
yyerror_range[0] = yylsp[1-yylen];
4185
yyerror_range[1] = yylsp[1-yylen];
3682
4186
/* Do not reclaim the symbols of the rule which action triggered
3683
4187
this YYERROR. */
3684
4188
YYPOPSTACK (yylen);
3697
4201
for (;;)
3698
4202
{
3699
4203
yyn = yypact[yystate];
3700
if (yyn != YYPACT_NINF)
4204
if (!yypact_value_is_default (yyn))
3701
4205
{
3702
4206
yyn += YYTERROR;
3703
4207
if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR)
3712
4216
if (yyssp == yyss)
3713
4217
YYABORT;
3714
4218
3715
yyerror_range[0] = *yylsp;
4219
yyerror_range[1] = *yylsp;
3716
4220
yydestruct ("Error: popping",
3717
4221
yystos[yystate], yyvsp, yylsp);
3718
4222
YYPOPSTACK (1);
3720
4224
YY_STACK_PRINT (yyss, yyssp);
3721
4225
}
3722
4226
3723
if (yyn == YYFINAL)
3724
YYACCEPT;
3725
3726
4227
*++yyvsp = yylval;
3727
4228
3728
yyerror_range[1] = yylloc;
4229
yyerror_range[2] = yylloc;
3729
4230
/* Using YYLLOC is tempting, but would change the location of
3730
the look-ahead. YYLOC is available though. */
3731
YYLLOC_DEFAULT (yyloc, (yyerror_range - 1), 2);
4231
the lookahead. YYLOC is available though. */
4232
YYLLOC_DEFAULT (yyloc, yyerror_range, 2);
3732
4233
*++yylsp = yyloc;
3733
4234
3734
4235
/* Shift the error token. */
3752
4253
yyresult = 1;
3753
4254
goto yyreturn;
3754
4255
3755
#ifndef yyoverflow
4256
#if !defined(yyoverflow) || YYERROR_VERBOSE
3756
4257
/*-------------------------------------------------.
3757
4258
| yyexhaustedlab -- memory exhaustion comes here. |
3758
4259
`-------------------------------------------------*/
3763
4264
#endif
3764
4265
3765
4266
yyreturn:
3766
if (yychar != YYEOF && yychar != YYEMPTY)
3767
yydestruct ("Cleanup: discarding lookahead",
3768
yytoken, &yylval, &yylloc);
4267
if (yychar != YYEMPTY)
4268
{
4269
/* Make sure we have latest lookahead translation. See comments at
4270
user semantic actions for why this is necessary. */
4271
yytoken = YYTRANSLATE (yychar);
4272
yydestruct ("Cleanup: discarding lookahead",
4273
yytoken, &yylval, &yylloc);
4274
}
3769
4275
/* Do not reclaim the symbols of the rule which action triggered
3770
4276
this YYABORT or YYACCEPT. */
3771
4277
YYPOPSTACK (yylen);
3789
4295
}
3790
4296
3791
4297
4298
4299
/* Line 2067 of yacc.c */
3792
4300
#line 881 "grammar.y"
3793
4301
3794
4302
Loggerhead is a web-based interface for Breezy
Version: 2.0.1