« back to all changes in this revision
Viewing changes to parser/generated/phpparser.cpp
- browse files at revision 1
- compare with another revision
- download diff
- download tarball
- view history from revision 1
- Committer: Bazaar Package Importer
- Author(s): Fathi Boudra
- Date: 2010-01-17 17:10:22 UTC
- Revision ID: james.westby@ubuntu.com-20100117171022-q2xlgd9ekewo2ijx
Tags: upstream-1.0.0~beta2
Import upstream version 1.0.0~beta2
- files added:
- app_templates
- app_templates/simple_phpapp
- cmake
- completion
- completion/tests
- duchain
- duchain/navigation
- duchain/tests
- parser
- parser/generated
- parser/generated/kdevelop-pg-qt
- parser/test
added
removed
parser/generated/phpparser.cpp
1
// THIS FILE IS GENERATED
2
// WARNING! All changes made in this file will be lost!
3
4
#include "phpparser.h"
5
6
7
8
#include <QtCore/QDebug>
9
#include <KTextEditor/Range>
10
11
namespace Php
12
{
13
14
void Parser::tokenize(const QString& contents, int initialState)
15
{
16
m_contents = contents;
17
Lexer lexer(tokenStream, contents, initialState);
18
int kind = Parser::Token_EOF;
19
int lastDocCommentBegin;
20
int lastDocCommentEnd;
21
22
do
23
{
24
lastDocCommentBegin = 0;
25
lastDocCommentEnd = 0;
26
kind = lexer.nextTokenKind();
27
while (kind == Parser::Token_WHITESPACE || kind == Parser::Token_COMMENT || kind == Parser::Token_DOC_COMMENT)
28
{
29
if (kind == Parser::Token_DOC_COMMENT)
30
{
31
lastDocCommentBegin = lexer.tokenBegin();
32
lastDocCommentEnd = lexer.tokenEnd();
33
}
34
kind = lexer.nextTokenKind();
35
}
36
if ( !kind ) // when the lexer returns 0, the end of file is reached
37
{
38
kind = Parser::Token_EOF;
39
}
40
Parser::Token &t = tokenStream->next();
41
t.begin = lexer.tokenBegin();
42
t.end = lexer.tokenEnd();
43
t.kind = kind;
44
t.docCommentBegin = lastDocCommentBegin;
45
t.docCommentEnd = lastDocCommentEnd;
46
//if ( m_debug ) qDebug() << kind << tokenText(t.begin,t.end) << t.begin << t.end;
47
}
48
while ( kind != Parser::Token_EOF );
49
50
yylex(); // produce the look ahead token
51
}
52
53
54
QString Parser::tokenText(qint64 begin, qint64 end)
55
{
56
return m_contents.mid(begin,end-begin+1);
57
}
58
59
60
void Parser::reportProblem( Parser::ProblemType type, const QString& message )
61
{
62
if (type == Error)
63
qDebug() << "** ERROR:" << message;
64
else if (type == Warning)
65
qDebug() << "** WARNING:" << message;
66
else if (type == Info)
67
qDebug() << "** Info:" << message;
68
69
qint64 sLine;
70
qint64 sCol;
71
qint64 index = tokenStream->index()-1;
72
tokenStream->startPosition(index, &sLine, &sCol);
73
qint64 eLine;
74
qint64 eCol;
75
tokenStream->endPosition(index, &eLine, &eCol);
76
KDevelop::Problem *p = new KDevelop::Problem();
77
p->setSource(KDevelop::ProblemData::Parser);
78
switch ( type )
79
{
80
case Error:
81
p->setSeverity(KDevelop::ProblemData::Error);
82
break;
83
case Warning:
84
p->setSeverity(KDevelop::ProblemData::Warning);
85
break;
86
case Info:
87
p->setSeverity(KDevelop::ProblemData::Hint);
88
break;
89
}
90
p->setDescription(message);
91
p->setFinalLocation(KDevelop::DocumentRange(m_currentDocument, KTextEditor::Range(sLine, sCol, eLine, eCol+1)));
92
m_problems << KDevelop::ProblemPointer(p);
93
}
94
95
96
// custom error recovery
97
void Parser::expectedToken(int /*expected*/, qint64 /*where*/, const QString& name)
98
{
99
reportProblem( Parser::Error, QString("Expected token \"%1\"").arg(name));
100
}
101
102
void Parser::expectedSymbol(int /*expectedSymbol*/, const QString& name)
103
{
104
qint64 line;
105
qint64 col;
106
qint64 index = tokenStream->index()-1;
107
Token &token = tokenStream->token(index);
108
kDebug() << "token starts at:" << token.begin;
109
kDebug() << "index is:" << index;
110
tokenStream->startPosition(index, &line, &col);
111
QString tokenValue = tokenText(token.begin, token.end);
112
qint64 eLine;
113
qint64 eCol;
114
tokenStream->endPosition(index, &eLine, &eCol);
115
reportProblem( Parser::Error,
116
QString("Expected symbol \"%1\" (current token: \"%2\" [%3] at %4:%5 - %6:%7)")
117
.arg(name)
118
.arg(token.kind != 0 ? tokenValue : "EOF")
119
.arg(token.kind)
120
.arg(line)
121
.arg(col)
122
.arg(eLine)
123
.arg(eCol));
124
}
125
126
void Parser::setDebug( bool debug )
127
{
128
m_debug = debug;
129
}
130
131
void Parser::setCurrentDocument(QString url)
132
{
133
m_currentDocument = url;
134
}
135
136
137
Parser::ParserState *Parser::copyCurrentState()
138
{
139
ParserState *state = new ParserState();
140
state->varExpressionState = m_state.varExpressionState;
141
state->varExpressionIsVariable = m_state.varExpressionIsVariable;
142
return state;
143
}
144
145
void Parser::restoreState( Parser::ParserState* state)
146
{
147
m_state.varExpressionState = state->varExpressionState;
148
m_state.varExpressionIsVariable = state->varExpressionIsVariable;
149
}
150
151
} // end of namespace Php
152
153
154
namespace Php
155
{
156
157
bool Parser::parseAdditiveExpression(AdditiveExpressionAst **yynode)
158
{
159
*yynode = create<AdditiveExpressionAst>();
160
161
(*yynode)->startToken = tokenStream->index() - 1;
162
163
if (yytoken == Token_ARRAY
164
|| yytoken == Token_ARRAY_CAST
165
|| yytoken == Token_AT
166
|| yytoken == Token_BACKTICK
167
|| yytoken == Token_BANG
168
|| yytoken == Token_BOOL_CAST
169
|| yytoken == Token_CLASS_C
170
|| yytoken == Token_CLONE
171
|| yytoken == Token_CONSTANT_ENCAPSED_STRING
172
|| yytoken == Token_DEC
173
|| yytoken == Token_DNUMBER
174
|| yytoken == Token_DOLLAR
175
|| yytoken == Token_DOUBLE_CAST
176
|| yytoken == Token_DOUBLE_QUOTE
177
|| yytoken == Token_EMPTY
178
|| yytoken == Token_EVAL
179
|| yytoken == Token_EXIT
180
|| yytoken == Token_FILE
181
|| yytoken == Token_FUNC_C
182
|| yytoken == Token_INC
183
|| yytoken == Token_INCLUDE
184
|| yytoken == Token_INCLUDE_ONCE
185
|| yytoken == Token_INT_CAST
186
|| yytoken == Token_ISSET
187
|| yytoken == Token_LINE
188
|| yytoken == Token_LIST
189
|| yytoken == Token_LNUMBER
190
|| yytoken == Token_LPAREN
191
|| yytoken == Token_METHOD_C
192
|| yytoken == Token_MINUS
193
|| yytoken == Token_NEW
194
|| yytoken == Token_OBJECT_CAST
195
|| yytoken == Token_PLUS
196
|| yytoken == Token_REQUIRE
197
|| yytoken == Token_REQUIRE_ONCE
198
|| yytoken == Token_START_HEREDOC
199
|| yytoken == Token_STRING
200
|| yytoken == Token_STRING_CAST
201
|| yytoken == Token_STRING_VARNAME
202
|| yytoken == Token_TILDE
203
|| yytoken == Token_UNSET_CAST
204
|| yytoken == Token_VARIABLE)
205
{
206
MultiplicativeExpressionAst *__node_0 = 0;
207
if (!parseMultiplicativeExpression(&__node_0))
208
{
209
if (!mBlockErrors)
210
{
211
expectedSymbol(AstNode::MultiplicativeExpressionKind, "multiplicativeExpression");
212
}
213
return false;
214
}
215
(*yynode)->expression = __node_0;
216
217
while (yytoken == Token_CONCAT
218
|| yytoken == Token_MINUS
219
|| yytoken == Token_PLUS)
220
{
221
AdditiveExpressionRestAst *__node_1 = 0;
222
if (!parseAdditiveExpressionRest(&__node_1))
223
{
224
if (!mBlockErrors)
225
{
226
expectedSymbol(AstNode::AdditiveExpressionRestKind, "additiveExpressionRest");
227
}
228
return false;
229
}
230
(*yynode)->additionalExpressionSequence = snoc((*yynode)->additionalExpressionSequence, __node_1, memoryPool);
231
232
}
233
}
234
else
235
{
236
return false;
237
}
238
239
(*yynode)->endToken = tokenStream->index() - 2;
240
241
return true;
242
}
243
244
bool Parser::parseAdditiveExpressionRest(AdditiveExpressionRestAst **yynode)
245
{
246
*yynode = create<AdditiveExpressionRestAst>();
247
248
(*yynode)->startToken = tokenStream->index() - 1;
249
250
if (yytoken == Token_CONCAT
251
|| yytoken == Token_MINUS
252
|| yytoken == Token_PLUS)
253
{
254
if (yytoken == Token_PLUS)
255
{
256
if (yytoken != Token_PLUS)
257
{
258
if (!mBlockErrors)
259
{
260
expectedToken(yytoken, Token_PLUS, "+");
261
}
262
return false;
263
}
264
yylex();
265
266
(*yynode)->operation = OperationPlus;
267
}
268
else if (yytoken == Token_MINUS)
269
{
270
if (yytoken != Token_MINUS)
271
{
272
if (!mBlockErrors)
273
{
274
expectedToken(yytoken, Token_MINUS, "-");
275
}
276
return false;
277
}
278
yylex();
279
280
(*yynode)->operation = OperationMinus;
281
}
282
else if (yytoken == Token_CONCAT)
283
{
284
if (yytoken != Token_CONCAT)
285
{
286
if (!mBlockErrors)
287
{
288
expectedToken(yytoken, Token_CONCAT, ".");
289
}
290
return false;
291
}
292
yylex();
293
294
(*yynode)->operation = OperationConcat;
295
}
296
else
297
{
298
return false;
299
}
300
MultiplicativeExpressionAst *__node_2 = 0;
301
if (!parseMultiplicativeExpression(&__node_2))
302
{
303
if (!mBlockErrors)
304
{
305
expectedSymbol(AstNode::MultiplicativeExpressionKind, "multiplicativeExpression");
306
}
307
return false;
308
}
309
(*yynode)->expression = __node_2;
310
311
}
312
else
313
{
314
return false;
315
}
316
317
(*yynode)->endToken = tokenStream->index() - 2;
318
319
return true;
320
}
321
322
bool Parser::parseArrayPairValue(ArrayPairValueAst **yynode)
323
{
324
*yynode = create<ArrayPairValueAst>();
325
326
(*yynode)->startToken = tokenStream->index() - 1;
327
328
if (yytoken == Token_ARRAY
329
|| yytoken == Token_ARRAY_CAST
330
|| yytoken == Token_AT
331
|| yytoken == Token_BACKTICK
332
|| yytoken == Token_BANG
333
|| yytoken == Token_BIT_AND
334
|| yytoken == Token_BOOL_CAST
335
|| yytoken == Token_CLASS_C
336
|| yytoken == Token_CLONE
337
|| yytoken == Token_CONSTANT_ENCAPSED_STRING
338
|| yytoken == Token_DEC
339
|| yytoken == Token_DNUMBER
340
|| yytoken == Token_DOLLAR
341
|| yytoken == Token_DOUBLE_CAST
342
|| yytoken == Token_DOUBLE_QUOTE
343
|| yytoken == Token_EMPTY
344
|| yytoken == Token_EVAL
345
|| yytoken == Token_EXIT
346
|| yytoken == Token_FILE
347
|| yytoken == Token_FUNC_C
348
|| yytoken == Token_INC
349
|| yytoken == Token_INCLUDE
350
|| yytoken == Token_INCLUDE_ONCE
351
|| yytoken == Token_INT_CAST
352
|| yytoken == Token_ISSET
353
|| yytoken == Token_LINE
354
|| yytoken == Token_LIST
355
|| yytoken == Token_LNUMBER
356
|| yytoken == Token_LPAREN
357
|| yytoken == Token_METHOD_C
358
|| yytoken == Token_MINUS
359
|| yytoken == Token_NEW
360
|| yytoken == Token_OBJECT_CAST
361
|| yytoken == Token_PLUS
362
|| yytoken == Token_PRINT
363
|| yytoken == Token_REQUIRE
364
|| yytoken == Token_REQUIRE_ONCE
365
|| yytoken == Token_START_HEREDOC
366
|| yytoken == Token_STRING
367
|| yytoken == Token_STRING_CAST
368
|| yytoken == Token_STRING_VARNAME
369
|| yytoken == Token_TILDE
370
|| yytoken == Token_UNSET_CAST
371
|| yytoken == Token_VARIABLE)
372
{
373
if (yytoken == Token_ARRAY
374
|| yytoken == Token_ARRAY_CAST
375
|| yytoken == Token_AT
376
|| yytoken == Token_BACKTICK
377
|| yytoken == Token_BANG
378
|| yytoken == Token_BOOL_CAST
379
|| yytoken == Token_CLASS_C
380
|| yytoken == Token_CLONE
381
|| yytoken == Token_CONSTANT_ENCAPSED_STRING
382
|| yytoken == Token_DEC
383
|| yytoken == Token_DNUMBER
384
|| yytoken == Token_DOLLAR
385
|| yytoken == Token_DOUBLE_CAST
386
|| yytoken == Token_DOUBLE_QUOTE
387
|| yytoken == Token_EMPTY
388
|| yytoken == Token_EVAL
389
|| yytoken == Token_EXIT
390
|| yytoken == Token_FILE
391
|| yytoken == Token_FUNC_C
392
|| yytoken == Token_INC
393
|| yytoken == Token_INCLUDE
394
|| yytoken == Token_INCLUDE_ONCE
395
|| yytoken == Token_INT_CAST
396
|| yytoken == Token_ISSET
397
|| yytoken == Token_LINE
398
|| yytoken == Token_LIST
399
|| yytoken == Token_LNUMBER
400
|| yytoken == Token_LPAREN
401
|| yytoken == Token_METHOD_C
402
|| yytoken == Token_MINUS
403
|| yytoken == Token_NEW
404
|| yytoken == Token_OBJECT_CAST
405
|| yytoken == Token_PLUS
406
|| yytoken == Token_PRINT
407
|| yytoken == Token_REQUIRE
408
|| yytoken == Token_REQUIRE_ONCE
409
|| yytoken == Token_START_HEREDOC
410
|| yytoken == Token_STRING
411
|| yytoken == Token_STRING_CAST
412
|| yytoken == Token_STRING_VARNAME
413
|| yytoken == Token_TILDE
414
|| yytoken == Token_UNSET_CAST
415
|| yytoken == Token_VARIABLE)
416
{
417
ExprAst *__node_3 = 0;
418
if (!parseExpr(&__node_3))
419
{
420
if (!mBlockErrors)
421
{
422
expectedSymbol(AstNode::ExprKind, "expr");
423
}
424
return false;
425
}
426
(*yynode)->expr = __node_3;
427
428
if (yytoken == Token_DOUBLE_ARROW)
429
{
430
if (yytoken != Token_DOUBLE_ARROW)
431
{
432
if (!mBlockErrors)
433
{
434
expectedToken(yytoken, Token_DOUBLE_ARROW, "=>");
435
}
436
return false;
437
}
438
yylex();
439
440
if (yytoken == Token_ARRAY
441
|| yytoken == Token_ARRAY_CAST
442
|| yytoken == Token_AT
443
|| yytoken == Token_BACKTICK
444
|| yytoken == Token_BANG
445
|| yytoken == Token_BOOL_CAST
446
|| yytoken == Token_CLASS_C
447
|| yytoken == Token_CLONE
448
|| yytoken == Token_CONSTANT_ENCAPSED_STRING
449
|| yytoken == Token_DEC
450
|| yytoken == Token_DNUMBER
451
|| yytoken == Token_DOLLAR
452
|| yytoken == Token_DOUBLE_CAST
453
|| yytoken == Token_DOUBLE_QUOTE
454
|| yytoken == Token_EMPTY
455
|| yytoken == Token_EVAL
456
|| yytoken == Token_EXIT
457
|| yytoken == Token_FILE
458
|| yytoken == Token_FUNC_C
459
|| yytoken == Token_INC
460
|| yytoken == Token_INCLUDE
461
|| yytoken == Token_INCLUDE_ONCE
462
|| yytoken == Token_INT_CAST
463
|| yytoken == Token_ISSET
464
|| yytoken == Token_LINE
465
|| yytoken == Token_LIST
466
|| yytoken == Token_LNUMBER
467
|| yytoken == Token_LPAREN
468
|| yytoken == Token_METHOD_C
469
|| yytoken == Token_MINUS
470
|| yytoken == Token_NEW
471
|| yytoken == Token_OBJECT_CAST
472
|| yytoken == Token_PLUS
473
|| yytoken == Token_PRINT
474
|| yytoken == Token_REQUIRE
475
|| yytoken == Token_REQUIRE_ONCE
476
|| yytoken == Token_START_HEREDOC
477
|| yytoken == Token_STRING
478
|| yytoken == Token_STRING_CAST
479
|| yytoken == Token_STRING_VARNAME
480
|| yytoken == Token_TILDE
481
|| yytoken == Token_UNSET_CAST
482
|| yytoken == Token_VARIABLE)
483
{
484
ExprAst *__node_4 = 0;
485
if (!parseExpr(&__node_4))
486
{
487
if (!mBlockErrors)
488
{
489
expectedSymbol(AstNode::ExprKind, "expr");
490
}
491
return false;
492
}
493
(*yynode)->exprValue = __node_4;
494
495
}
496
else if (yytoken == Token_BIT_AND)
497
{
498
if (yytoken != Token_BIT_AND)
499
{
500
if (!mBlockErrors)
501
{
502
expectedToken(yytoken, Token_BIT_AND, "&");
503
}
504
return false;
505
}
506
yylex();
507
508
VariableAst *__node_5 = 0;
509
if (!parseVariable(&__node_5))
510
{
511
if (!mBlockErrors)
512
{
513
expectedSymbol(AstNode::VariableKind, "variable");
514
}
515
return false;
516
}
517
(*yynode)->varValue = __node_5;
518
519
}
520
else
521
{
522
return false;
523
}
524
}
525
else if (true /*epsilon*/)
526
{
527
}
528
else
529
{
530
return false;
531
}
532
}
533
else if (yytoken == Token_BIT_AND)
534
{
535
if (yytoken != Token_BIT_AND)
536
{
537
if (!mBlockErrors)
538
{
539
expectedToken(yytoken, Token_BIT_AND, "&");
540
}
541
return false;
542
}
543
yylex();
544
545
VariableAst *__node_6 = 0;
546
if (!parseVariable(&__node_6))
547
{
548
if (!mBlockErrors)
549
{
550
expectedSymbol(AstNode::VariableKind, "variable");
551
}
552
return false;
553
}
554
(*yynode)->variable = __node_6;
555
556
}
557
else
558
{
559
return false;
560
}
561
}
562
else
563
{
564
return false;
565
}
566
567
(*yynode)->endToken = tokenStream->index() - 2;
568
569
return true;
570
}
571
572
bool Parser::parseAssignmentExpression(AssignmentExpressionAst **yynode)
573
{
574
*yynode = create<AssignmentExpressionAst>();
575
576
(*yynode)->startToken = tokenStream->index() - 1;
577
578
if (yytoken == Token_ARRAY
579
|| yytoken == Token_ARRAY_CAST
580
|| yytoken == Token_AT
581
|| yytoken == Token_BACKTICK
582
|| yytoken == Token_BANG
583
|| yytoken == Token_BOOL_CAST
584
|| yytoken == Token_CLASS_C
585
|| yytoken == Token_CLONE
586
|| yytoken == Token_CONSTANT_ENCAPSED_STRING
587
|| yytoken == Token_DEC
588
|| yytoken == Token_DNUMBER
589
|| yytoken == Token_DOLLAR
590
|| yytoken == Token_DOUBLE_CAST
591
|| yytoken == Token_DOUBLE_QUOTE
592
|| yytoken == Token_EMPTY
593
|| yytoken == Token_EVAL
594
|| yytoken == Token_EXIT
595
|| yytoken == Token_FILE
596
|| yytoken == Token_FUNC_C
597
|| yytoken == Token_INC
598
|| yytoken == Token_INCLUDE
599
|| yytoken == Token_INCLUDE_ONCE
600
|| yytoken == Token_INT_CAST
601
|| yytoken == Token_ISSET
602
|| yytoken == Token_LINE
603
|| yytoken == Token_LIST
604
|| yytoken == Token_LNUMBER
605
|| yytoken == Token_LPAREN
606
|| yytoken == Token_METHOD_C
607
|| yytoken == Token_MINUS
608
|| yytoken == Token_NEW
609
|| yytoken == Token_OBJECT_CAST
610
|| yytoken == Token_PLUS
611
|| yytoken == Token_REQUIRE
612
|| yytoken == Token_REQUIRE_ONCE
613
|| yytoken == Token_START_HEREDOC
614
|| yytoken == Token_STRING
615
|| yytoken == Token_STRING_CAST
616
|| yytoken == Token_STRING_VARNAME
617
|| yytoken == Token_TILDE
618
|| yytoken == Token_UNSET_CAST
619
|| yytoken == Token_VARIABLE)
620
{
621
m_state.varExpressionIsVariable = false;
622
ConditionalExpressionAst *__node_7 = 0;
623
if (!parseConditionalExpression(&__node_7))
624
{
625
if (!mBlockErrors)
626
{
627
expectedSymbol(AstNode::ConditionalExpressionKind, "conditionalExpression");
628
}
629
return false;
630
}
631
(*yynode)->expression = __node_7;
632
633
if (yytoken == Token_ASSIGN)
634
{
635
AssignmentExpressionEqualAst *__node_8 = 0;
636
if (!parseAssignmentExpressionEqual(&__node_8))
637
{
638
if (!mBlockErrors)
639
{
640
expectedSymbol(AstNode::AssignmentExpressionEqualKind, "assignmentExpressionEqual");
641
}
642
return false;
643
}
644
(*yynode)->assignmentExpressionEqual = __node_8;
645
646
}
647
else if (yytoken == Token_AND_ASSIGN
648
|| yytoken == Token_CONCAT_ASSIGN
649
|| yytoken == Token_DIV_ASSIGN
650
|| yytoken == Token_MINUS_ASSIGN
651
|| yytoken == Token_MOD_ASSIGN
652
|| yytoken == Token_MUL_ASSIGN
653
|| yytoken == Token_OR_ASSIGN
654
|| yytoken == Token_PLUS_ASSIGN
655
|| yytoken == Token_SL_ASSIGN
656
|| yytoken == Token_SR_ASSIGN
657
|| yytoken == Token_XOR_ASSIGN)
658
{
659
if (yytoken == Token_PLUS_ASSIGN)
660
{
661
if (yytoken != Token_PLUS_ASSIGN)
662
{
663
if (!mBlockErrors)
664
{
665
expectedToken(yytoken, Token_PLUS_ASSIGN, "+=");
666
}
667
return false;
668
}
669
yylex();
670
671
(*yynode)->operation = OperationPlus;
672
}
673
else if (yytoken == Token_MINUS_ASSIGN)
674
{
675
if (yytoken != Token_MINUS_ASSIGN)
676
{
677
if (!mBlockErrors)
678
{
679
expectedToken(yytoken, Token_MINUS_ASSIGN, "-=");
680
}
681
return false;
682
}
683
yylex();
684
685
(*yynode)->operation = OperationMinus;
686
}
687
else if (yytoken == Token_MUL_ASSIGN)
688
{
689
if (yytoken != Token_MUL_ASSIGN)
690
{
691
if (!mBlockErrors)
692
{
693
expectedToken(yytoken, Token_MUL_ASSIGN, "*=");
694
}
695
return false;
696
}
697
yylex();
698
699
(*yynode)->operation = OperationMul;
700
}
701
else if (yytoken == Token_DIV_ASSIGN)
702
{
703
if (yytoken != Token_DIV_ASSIGN)
704
{
705
if (!mBlockErrors)
706
{
707
expectedToken(yytoken, Token_DIV_ASSIGN, "/=");
708
}
709
return false;
710
}
711
yylex();
712
713
(*yynode)->operation = OperationDiv;
714
}
715
else if (yytoken == Token_CONCAT_ASSIGN)
716
{
717
if (yytoken != Token_CONCAT_ASSIGN)
718
{
719
if (!mBlockErrors)
720
{
721
expectedToken(yytoken, Token_CONCAT_ASSIGN, ".=");
722
}
723
return false;
724
}
725
yylex();
726
727
(*yynode)->operation = OperationConcat;
728
}
729
else if (yytoken == Token_MOD_ASSIGN)
730
{
731
if (yytoken != Token_MOD_ASSIGN)
732
{
733
if (!mBlockErrors)
734
{
735
expectedToken(yytoken, Token_MOD_ASSIGN, "%=");
736
}
737
return false;
738
}
739
yylex();
740
741
(*yynode)->operation = OperationMod;
742
}
743
else if (yytoken == Token_AND_ASSIGN)
744
{
745
if (yytoken != Token_AND_ASSIGN)
746
{
747
if (!mBlockErrors)
748
{
749
expectedToken(yytoken, Token_AND_ASSIGN, "&=");
750
}
751
return false;
752
}
753
yylex();
754
755
(*yynode)->operation = OperationAnd;
756
}
757
else if (yytoken == Token_OR_ASSIGN)
758
{
759
if (yytoken != Token_OR_ASSIGN)
760
{
761
if (!mBlockErrors)
762
{
763
expectedToken(yytoken, Token_OR_ASSIGN, "|=");
764
}
765
return false;
766
}
767
yylex();
768
769
(*yynode)->operation = OperationOr;
770
}
771
else if (yytoken == Token_XOR_ASSIGN)
772
{
773
if (yytoken != Token_XOR_ASSIGN)
774
{
775
if (!mBlockErrors)
776
{
777
expectedToken(yytoken, Token_XOR_ASSIGN, "^=");
778
}
779
return false;
780
}
781
yylex();
782
783
(*yynode)->operation = OperationXor;
784
}
785
else if (yytoken == Token_SL_ASSIGN)
786
{
787
if (yytoken != Token_SL_ASSIGN)
788
{
789
if (!mBlockErrors)
790
{
791
expectedToken(yytoken, Token_SL_ASSIGN, "<<=");
792
}
793
return false;
794
}
795
yylex();
796
797
(*yynode)->operation = OperationSl;
798
}
799
else if (yytoken == Token_SR_ASSIGN)
800
{
801
if (yytoken != Token_SR_ASSIGN)
802
{
803
if (!mBlockErrors)
804
{
805
expectedToken(yytoken, Token_SR_ASSIGN, ">>=");
806
}
807
return false;
808
}
809
yylex();
810
811
(*yynode)->operation = OperationSr;
812
}
813
else
814
{
815
return false;
816
}
817
AssignmentExpressionCheckIfVariableAst *__node_9 = 0;
818
if (!parseAssignmentExpressionCheckIfVariable(&__node_9))
819
{
820
if (!mBlockErrors)
821
{
822
expectedSymbol(AstNode::AssignmentExpressionCheckIfVariableKind, "assignmentExpressionCheckIfVariable");
823
}
824
return false;
825
}
826
AssignmentExpressionAst *__node_10 = 0;
827
if (!parseAssignmentExpression(&__node_10))
828
{
829
if (!mBlockErrors)
830
{
831
expectedSymbol(AstNode::AssignmentExpressionKind, "assignmentExpression");
832
}
833
return false;
834
}
835
(*yynode)->assignmentExpression = __node_10;
836
837
}
838
else if (true /*epsilon*/)
839
{
840
}
841
else
842
{
843
return false;
844
}
845
}
846
else
847
{
848
return false;
849
}
850
851
(*yynode)->endToken = tokenStream->index() - 2;
852
853
return true;
854
}
855
856
bool Parser::parseAssignmentExpressionCheckIfVariable(AssignmentExpressionCheckIfVariableAst **yynode)
857
{
858
*yynode = create<AssignmentExpressionCheckIfVariableAst>();
859
860
(*yynode)->startToken = tokenStream->index() - 1;
861
862
if (true /*epsilon*/ || yytoken == Token_ARRAY
863
|| yytoken == Token_ARRAY_CAST
864
|| yytoken == Token_AT
865
|| yytoken == Token_BACKTICK
866
|| yytoken == Token_BANG
867
|| yytoken == Token_BIT_AND
868
|| yytoken == Token_BOOL_CAST
869
|| yytoken == Token_CLASS_C
870
|| yytoken == Token_CLONE
871
|| yytoken == Token_CONSTANT_ENCAPSED_STRING
872
|| yytoken == Token_DEC
873
|| yytoken == Token_DNUMBER
874
|| yytoken == Token_DOLLAR
875
|| yytoken == Token_DOUBLE_CAST
876
|| yytoken == Token_DOUBLE_QUOTE
877
|| yytoken == Token_EMPTY
878
|| yytoken == Token_EOF
879
|| yytoken == Token_EVAL
880
|| yytoken == Token_EXIT
881
|| yytoken == Token_FILE
882
|| yytoken == Token_FUNC_C
883
|| yytoken == Token_INC
884
|| yytoken == Token_INCLUDE
885
|| yytoken == Token_INCLUDE_ONCE
886
|| yytoken == Token_INT_CAST
887
|| yytoken == Token_ISSET
888
|| yytoken == Token_LINE
889
|| yytoken == Token_LIST
890
|| yytoken == Token_LNUMBER
891
|| yytoken == Token_LPAREN
892
|| yytoken == Token_METHOD_C
893
|| yytoken == Token_MINUS
894
|| yytoken == Token_NEW
895
|| yytoken == Token_OBJECT_CAST
896
|| yytoken == Token_PLUS
897
|| yytoken == Token_REQUIRE
898
|| yytoken == Token_REQUIRE_ONCE
899
|| yytoken == Token_START_HEREDOC
900
|| yytoken == Token_STRING
901
|| yytoken == Token_STRING_CAST
902
|| yytoken == Token_STRING_VARNAME
903
|| yytoken == Token_TILDE
904
|| yytoken == Token_UNSET_CAST
905
|| yytoken == Token_VARIABLE)
906
{
907
908
if (!m_state.varExpressionIsVariable)
909
{
910
reportProblem(Error, "Left side is not a variable");
911
return false;
912
}
913
}
914
else
915
{
916
return false;
917
}
918
919
(*yynode)->endToken = tokenStream->index() - 2;
920
921
return true;
922
}
923
924
bool Parser::parseAssignmentExpressionEqual(AssignmentExpressionEqualAst **yynode)
925
{
926
*yynode = create<AssignmentExpressionEqualAst>();
927
928
(*yynode)->startToken = tokenStream->index() - 1;
929
930
if (yytoken == Token_ASSIGN)
931
{
932
if (yytoken != Token_ASSIGN)
933
{
934
if (!mBlockErrors)
935
{
936
expectedToken(yytoken, Token_ASSIGN, "=");
937
}
938
return false;
939
}
940
yylex();
941
942
AssignmentExpressionCheckIfVariableAst *__node_11 = 0;
943
if (!parseAssignmentExpressionCheckIfVariable(&__node_11))
944
{
945
if (!mBlockErrors)
946
{
947
expectedSymbol(AstNode::AssignmentExpressionCheckIfVariableKind, "assignmentExpressionCheckIfVariable");
948
}
949
return false;
950
}
951
if (yytoken == Token_BIT_AND)
952
{
953
if (yytoken != Token_BIT_AND)
954
{
955
if (!mBlockErrors)
956
{
957
expectedToken(yytoken, Token_BIT_AND, "&");
958
}
959
return false;
960
}
961
yylex();
962
963
if (yytoken == Token_NEW)
964
{
965
reportProblem(Warning, "=& new foo() is deprecated");
966
m_state.varExpressionState = OnlyNewObject;
967
}
968
else
969
{
970
m_state.varExpressionState = OnlyVariable;
971
}
972
}
973
else if (true /*epsilon*/)
974
{
975
}
976
else
977
{
978
return false;
979
}
980
AssignmentExpressionAst *__node_12 = 0;
981
if (!parseAssignmentExpression(&__node_12))
982
{
983
if (!mBlockErrors)
984
{
985
expectedSymbol(AstNode::AssignmentExpressionKind, "assignmentExpression");
986
}
987
return false;
988
}
989
(*yynode)->assignmentExpression = __node_12;
990
991
m_state.varExpressionState = Normal;
992
}
993
else
994
{
995
return false;
996
}
997
998
(*yynode)->endToken = tokenStream->index() - 2;
999
1000
return true;
1001
}
1002
1003
bool Parser::parseAssignmentList(AssignmentListAst **yynode)
1004
{
1005
*yynode = create<AssignmentListAst>();
1006
1007
(*yynode)->startToken = tokenStream->index() - 1;
1008
1009
if (yytoken == Token_COMMA
1010
|| yytoken == Token_DOLLAR
1011
|| yytoken == Token_LIST
1012
|| yytoken == Token_STRING
1013
|| yytoken == Token_VARIABLE || yytoken == Token_EOF
1014
|| yytoken == Token_RPAREN)
1015
{
1016
AssignmentListElementAst *__node_13 = 0;
1017
if (!parseAssignmentListElement(&__node_13))
1018
{
1019
if (!mBlockErrors)
1020
{
1021
expectedSymbol(AstNode::AssignmentListElementKind, "assignmentListElement");
1022
}
1023
return false;
1024
}
1025
(*yynode)->elementSequence = snoc((*yynode)->elementSequence, __node_13, memoryPool);
1026
1027
while (yytoken == Token_COMMA)
1028
{
1029
if (yytoken != Token_COMMA)
1030
{
1031
if (!mBlockErrors)
1032
{
1033
expectedToken(yytoken, Token_COMMA, ",");
1034
}
1035
return false;
1036
}
1037
yylex();
1038
1039
AssignmentListElementAst *__node_14 = 0;
1040
if (!parseAssignmentListElement(&__node_14))
1041
{
1042
if (!mBlockErrors)
1043
{
1044
expectedSymbol(AstNode::AssignmentListElementKind, "assignmentListElement");
1045
}
1046
return false;
1047
}
1048
(*yynode)->elementSequence = snoc((*yynode)->elementSequence, __node_14, memoryPool);
1049
1050
}
1051
}
1052
else
1053
{
1054
return false;
1055
}
1056
1057
(*yynode)->endToken = tokenStream->index() - 2;
1058
1059
return true;
1060
}
1061
1062
bool Parser::parseAssignmentListElement(AssignmentListElementAst **yynode)
1063
{
1064
*yynode = create<AssignmentListElementAst>();
1065
1066
(*yynode)->startToken = tokenStream->index() - 1;
1067
1068
if (yytoken == Token_DOLLAR
1069
|| yytoken == Token_LIST
1070
|| yytoken == Token_STRING
1071
|| yytoken == Token_VARIABLE || yytoken == Token_COMMA
1072
|| yytoken == Token_EOF
1073
|| yytoken == Token_RPAREN)
1074
{
1075
if (yytoken == Token_DOLLAR
1076
|| yytoken == Token_STRING
1077
|| yytoken == Token_VARIABLE)
1078
{
1079
VariableAst *__node_15 = 0;
1080
if (!parseVariable(&__node_15))
1081
{
1082
if (!mBlockErrors)
1083
{
1084
expectedSymbol(AstNode::VariableKind, "variable");
1085
}
1086
return false;
1087
}
1088
(*yynode)->variable = __node_15;
1089
1090
}
1091
else if (yytoken == Token_LIST)
1092
{
1093
if (yytoken != Token_LIST)
1094
{
1095
if (!mBlockErrors)
1096
{
1097
expectedToken(yytoken, Token_LIST, "list");
1098
}
1099
return false;
1100
}
1101
yylex();
1102
1103
if (yytoken != Token_LPAREN)
1104
{
1105
if (!mBlockErrors)
1106
{
1107
expectedToken(yytoken, Token_LPAREN, "(");
1108
}
1109
return false;
1110
}
1111
yylex();
1112
1113
AssignmentListAst *__node_16 = 0;
1114
if (!parseAssignmentList(&__node_16))
1115
{
1116
if (!mBlockErrors)
1117
{
1118
expectedSymbol(AstNode::AssignmentListKind, "assignmentList");
1119
}
1120
return false;
1121
}
1122
(*yynode)->assignmentList = __node_16;
1123
1124
if (yytoken != Token_RPAREN)
1125
{
1126
if (!mBlockErrors)
1127
{
1128
expectedToken(yytoken, Token_RPAREN, ")");
1129
}
1130
return false;
1131
}
1132
yylex();
1133
1134
}
1135
else if (true /*epsilon*/)
1136
{
1137
}
1138
else
1139
{
1140
return false;
1141
}
1142
}
1143
else
1144
{
1145
return false;
1146
}
1147
1148
(*yynode)->endToken = tokenStream->index() - 2;
1149
1150
return true;
1151
}
1152
1153
bool Parser::parseBaseVariable(BaseVariableAst **yynode)
1154
{
1155
*yynode = create<BaseVariableAst>();
1156
1157
(*yynode)->startToken = tokenStream->index() - 1;
1158
1159
if (yytoken == Token_DOLLAR
1160
|| yytoken == Token_STRING
1161
|| yytoken == Token_VARIABLE)
1162
{
1163
if (yytoken == Token_DOLLAR
1164
|| yytoken == Token_VARIABLE)
1165
{
1166
CompoundVariableWithSimpleIndirectReferenceAst *__node_17 = 0;
1167
if (!parseCompoundVariableWithSimpleIndirectReference(&__node_17))
1168
{
1169
if (!mBlockErrors)
1170
{
1171
expectedSymbol(AstNode::CompoundVariableWithSimpleIndirectReferenceKind, "compoundVariableWithSimpleIndirectReference");
1172
}
1173
return false;
1174
}
1175
(*yynode)->var = __node_17;
1176
1177
while (yytoken == Token_LBRACE
1178
|| yytoken == Token_LBRACKET)
1179
{
1180
DimListItemAst *__node_18 = 0;
1181
if (!parseDimListItem(&__node_18))
1182
{
1183
if (!mBlockErrors)
1184
{
1185
expectedSymbol(AstNode::DimListItemKind, "dimListItem");
1186
}
1187
return false;
1188
}
1189
(*yynode)->offsetItemsSequence = snoc((*yynode)->offsetItemsSequence, __node_18, memoryPool);
1190
1191
}
1192
}
1193
else if (yytoken == Token_STRING)
1194
{
1195
StaticMemberAst *__node_19 = 0;
1196
if (!parseStaticMember(&__node_19))
1197
{
1198
if (!mBlockErrors)
1199
{
1200
expectedSymbol(AstNode::StaticMemberKind, "staticMember");
1201
}
1202
return false;
1203
}
1204
(*yynode)->staticMember = __node_19;
1205
1206
}
1207
else
1208
{
1209
return false;
1210
}
1211
}
1212
else
1213
{
1214
return false;
1215
}
1216
1217
(*yynode)->endToken = tokenStream->index() - 2;
1218
1219
return true;
1220
}
1221
1222
bool Parser::parseBaseVariableWithFunctionCalls(BaseVariableWithFunctionCallsAst **yynode)
1223
{
1224
*yynode = create<BaseVariableWithFunctionCallsAst>();
1225
1226
(*yynode)->startToken = tokenStream->index() - 1;
1227
1228
if (yytoken == Token_DOLLAR
1229
|| yytoken == Token_STRING
1230
|| yytoken == Token_VARIABLE)
1231
{
1232
bool blockErrors_1 = blockErrors(true);
1233
qint64 try_startToken_1 = tokenStream->index() - 1;
1234
ParserState *try_startState_1 = copyCurrentState();
1235
{
1236
FunctionCallAst *__node_20 = 0;
1237
if (!parseFunctionCall(&__node_20))
1238
{
1239
goto __catch_1;
1240
}
1241
(*yynode)->functionCall = __node_20;
1242
1243
}
1244
blockErrors(blockErrors_1);
1245
if (try_startState_1)
1246
delete try_startState_1;
1247
1248
if (false) // the only way to enter here is using goto
1249
{
1250
__catch_1:
1251
if (try_startState_1)
1252
{
1253
restoreState(try_startState_1);
1254
delete try_startState_1;
1255
}
1256
blockErrors(blockErrors_1);
1257
rewind(try_startToken_1);
1258
1259
BaseVariableAst *__node_21 = 0;
1260
if (!parseBaseVariable(&__node_21))
1261
{
1262
if (!mBlockErrors)
1263
{
1264
expectedSymbol(AstNode::BaseVariableKind, "baseVariable");
1265
}
1266
return false;
1267
}
1268
(*yynode)->baseVariable = __node_21;
1269
1270
}
1271
1272
}
1273
else
1274
{
1275
return false;
1276
}
1277
1278
(*yynode)->endToken = tokenStream->index() - 2;
1279
1280
return true;
1281
}
1282
1283
bool Parser::parseBitAndExpression(BitAndExpressionAst **yynode)
1284
{
1285
*yynode = create<BitAndExpressionAst>();
1286
1287
(*yynode)->startToken = tokenStream->index() - 1;
1288
1289
if (yytoken == Token_ARRAY
1290
|| yytoken == Token_ARRAY_CAST
1291
|| yytoken == Token_AT
1292
|| yytoken == Token_BACKTICK
1293
|| yytoken == Token_BANG
1294
|| yytoken == Token_BOOL_CAST
1295
|| yytoken == Token_CLASS_C
1296
|| yytoken == Token_CLONE
1297
|| yytoken == Token_CONSTANT_ENCAPSED_STRING
1298
|| yytoken == Token_DEC
1299
|| yytoken == Token_DNUMBER
1300
|| yytoken == Token_DOLLAR
1301
|| yytoken == Token_DOUBLE_CAST
1302
|| yytoken == Token_DOUBLE_QUOTE
1303
|| yytoken == Token_EMPTY
1304
|| yytoken == Token_EVAL
1305
|| yytoken == Token_EXIT
1306
|| yytoken == Token_FILE
1307
|| yytoken == Token_FUNC_C
1308
|| yytoken == Token_INC
1309
|| yytoken == Token_INCLUDE
1310
|| yytoken == Token_INCLUDE_ONCE
1311
|| yytoken == Token_INT_CAST
1312
|| yytoken == Token_ISSET
1313
|| yytoken == Token_LINE
1314
|| yytoken == Token_LIST
1315
|| yytoken == Token_LNUMBER
1316
|| yytoken == Token_LPAREN
1317
|| yytoken == Token_METHOD_C
1318
|| yytoken == Token_MINUS
1319
|| yytoken == Token_NEW
1320
|| yytoken == Token_OBJECT_CAST
1321
|| yytoken == Token_PLUS
1322
|| yytoken == Token_REQUIRE
1323
|| yytoken == Token_REQUIRE_ONCE
1324
|| yytoken == Token_START_HEREDOC
1325
|| yytoken == Token_STRING
1326
|| yytoken == Token_STRING_CAST
1327
|| yytoken == Token_STRING_VARNAME
1328
|| yytoken == Token_TILDE
1329
|| yytoken == Token_UNSET_CAST
1330
|| yytoken == Token_VARIABLE)
1331
{
1332
EqualityExpressionAst *__node_22 = 0;
1333
if (!parseEqualityExpression(&__node_22))
1334
{
1335
if (!mBlockErrors)
1336
{
1337
expectedSymbol(AstNode::EqualityExpressionKind, "equalityExpression");
1338
}
1339
return false;
1340
}
1341
(*yynode)->expressionSequence = snoc((*yynode)->expressionSequence, __node_22, memoryPool);
1342
1343
while (yytoken == Token_BIT_AND)
1344
{
1345
if (yytoken != Token_BIT_AND)
1346
{
1347
if (!mBlockErrors)
1348
{
1349
expectedToken(yytoken, Token_BIT_AND, "&");
1350
}
1351
return false;
1352
}
1353
yylex();
1354
1355
EqualityExpressionAst *__node_23 = 0;
1356
if (!parseEqualityExpression(&__node_23))
1357
{
1358
if (!mBlockErrors)
1359
{
1360
expectedSymbol(AstNode::EqualityExpressionKind, "equalityExpression");
1361
}
1362
return false;
1363
}
1364
(*yynode)->expressionSequence = snoc((*yynode)->expressionSequence, __node_23, memoryPool);
1365
1366
}
1367
}
1368
else
1369
{
1370
return false;
1371
}
1372
1373
(*yynode)->endToken = tokenStream->index() - 2;
1374
1375
return true;
1376
}
1377
1378
bool Parser::parseBitOrExpression(BitOrExpressionAst **yynode)
1379
{
1380
*yynode = create<BitOrExpressionAst>();
1381
1382
(*yynode)->startToken = tokenStream->index() - 1;
1383
1384
if (yytoken == Token_ARRAY
1385
|| yytoken == Token_ARRAY_CAST
1386
|| yytoken == Token_AT
1387
|| yytoken == Token_BACKTICK
1388
|| yytoken == Token_BANG
1389
|| yytoken == Token_BOOL_CAST
1390
|| yytoken == Token_CLASS_C
1391
|| yytoken == Token_CLONE
1392
|| yytoken == Token_CONSTANT_ENCAPSED_STRING
1393
|| yytoken == Token_DEC
1394
|| yytoken == Token_DNUMBER
1395
|| yytoken == Token_DOLLAR
1396
|| yytoken == Token_DOUBLE_CAST
1397
|| yytoken == Token_DOUBLE_QUOTE
1398
|| yytoken == Token_EMPTY
1399
|| yytoken == Token_EVAL
1400
|| yytoken == Token_EXIT
1401
|| yytoken == Token_FILE
1402
|| yytoken == Token_FUNC_C
1403
|| yytoken == Token_INC
1404
|| yytoken == Token_INCLUDE
1405
|| yytoken == Token_INCLUDE_ONCE
1406
|| yytoken == Token_INT_CAST
1407
|| yytoken == Token_ISSET
1408
|| yytoken == Token_LINE
1409
|| yytoken == Token_LIST
1410
|| yytoken == Token_LNUMBER
1411
|| yytoken == Token_LPAREN
1412
|| yytoken == Token_METHOD_C
1413
|| yytoken == Token_MINUS
1414
|| yytoken == Token_NEW
1415
|| yytoken == Token_OBJECT_CAST
1416
|| yytoken == Token_PLUS
1417
|| yytoken == Token_REQUIRE
1418
|| yytoken == Token_REQUIRE_ONCE
1419
|| yytoken == Token_START_HEREDOC
1420
|| yytoken == Token_STRING
1421
|| yytoken == Token_STRING_CAST
1422
|| yytoken == Token_STRING_VARNAME
1423
|| yytoken == Token_TILDE
1424
|| yytoken == Token_UNSET_CAST
1425
|| yytoken == Token_VARIABLE)
1426
{
1427
BitXorExpressionAst *__node_24 = 0;
1428
if (!parseBitXorExpression(&__node_24))
1429
{
1430
if (!mBlockErrors)
1431
{
1432
expectedSymbol(AstNode::BitXorExpressionKind, "bitXorExpression");
1433
}
1434
return false;
1435
}
1436
(*yynode)->expressionSequence = snoc((*yynode)->expressionSequence, __node_24, memoryPool);
1437
1438
while (yytoken == Token_BIT_OR)
1439
{
1440
if (yytoken != Token_BIT_OR)
1441
{
1442
if (!mBlockErrors)
1443
{
1444
expectedToken(yytoken, Token_BIT_OR, "|");
1445
}
1446
return false;
1447
}
1448
yylex();
1449
1450
BitXorExpressionAst *__node_25 = 0;
1451
if (!parseBitXorExpression(&__node_25))
1452
{
1453
if (!mBlockErrors)
1454
{
1455
expectedSymbol(AstNode::BitXorExpressionKind, "bitXorExpression");
1456
}
1457
return false;
1458
}
1459
(*yynode)->expressionSequence = snoc((*yynode)->expressionSequence, __node_25, memoryPool);
1460
1461
}
1462
}
1463
else
1464
{
1465
return false;
1466
}
1467
1468
(*yynode)->endToken = tokenStream->index() - 2;
1469
1470
return true;
1471
}
1472
1473
bool Parser::parseBitXorExpression(BitXorExpressionAst **yynode)
1474
{
1475
*yynode = create<BitXorExpressionAst>();
1476
1477
(*yynode)->startToken = tokenStream->index() - 1;
1478
1479
if (yytoken == Token_ARRAY
1480
|| yytoken == Token_ARRAY_CAST
1481
|| yytoken == Token_AT
1482
|| yytoken == Token_BACKTICK
1483
|| yytoken == Token_BANG
1484
|| yytoken == Token_BOOL_CAST
1485
|| yytoken == Token_CLASS_C
1486
|| yytoken == Token_CLONE
1487
|| yytoken == Token_CONSTANT_ENCAPSED_STRING
1488
|| yytoken == Token_DEC
1489
|| yytoken == Token_DNUMBER
1490
|| yytoken == Token_DOLLAR
1491
|| yytoken == Token_DOUBLE_CAST
1492
|| yytoken == Token_DOUBLE_QUOTE
1493
|| yytoken == Token_EMPTY
1494
|| yytoken == Token_EVAL
1495
|| yytoken == Token_EXIT
1496
|| yytoken == Token_FILE
1497
|| yytoken == Token_FUNC_C
1498
|| yytoken == Token_INC
1499
|| yytoken == Token_INCLUDE
1500
|| yytoken == Token_INCLUDE_ONCE
1501
|| yytoken == Token_INT_CAST
1502
|| yytoken == Token_ISSET
1503
|| yytoken == Token_LINE
1504
|| yytoken == Token_LIST
1505
|| yytoken == Token_LNUMBER
1506
|| yytoken == Token_LPAREN
1507
|| yytoken == Token_METHOD_C
1508
|| yytoken == Token_MINUS
1509
|| yytoken == Token_NEW
1510
|| yytoken == Token_OBJECT_CAST
1511
|| yytoken == Token_PLUS
1512
|| yytoken == Token_REQUIRE
1513
|| yytoken == Token_REQUIRE_ONCE
1514
|| yytoken == Token_START_HEREDOC
1515
|| yytoken == Token_STRING
1516
|| yytoken == Token_STRING_CAST
1517
|| yytoken == Token_STRING_VARNAME
1518
|| yytoken == Token_TILDE
1519
|| yytoken == Token_UNSET_CAST
1520
|| yytoken == Token_VARIABLE)
1521
{
1522
BitAndExpressionAst *__node_26 = 0;
1523
if (!parseBitAndExpression(&__node_26))
1524
{
1525
if (!mBlockErrors)
1526
{
1527
expectedSymbol(AstNode::BitAndExpressionKind, "bitAndExpression");
1528
}
1529
return false;
1530
}
1531
(*yynode)->expressionSequence = snoc((*yynode)->expressionSequence, __node_26, memoryPool);
1532
1533
while (yytoken == Token_BIT_XOR)
1534
{
1535
if (yytoken != Token_BIT_XOR)
1536
{
1537
if (!mBlockErrors)
1538
{
1539
expectedToken(yytoken, Token_BIT_XOR, "^");
1540
}
1541
return false;
1542
}
1543
yylex();
1544
1545
BitAndExpressionAst *__node_27 = 0;
1546
if (!parseBitAndExpression(&__node_27))
1547
{
1548
if (!mBlockErrors)
1549
{
1550
expectedSymbol(AstNode::BitAndExpressionKind, "bitAndExpression");
1551
}
1552
return false;
1553
}
1554
(*yynode)->expressionSequence = snoc((*yynode)->expressionSequence, __node_27, memoryPool);
1555
1556
}
1557
}
1558
else
1559
{
1560
return false;
1561
}
1562
1563
(*yynode)->endToken = tokenStream->index() - 2;
1564
1565
return true;
1566
}
1567
1568
bool Parser::parseBooleanAndExpression(BooleanAndExpressionAst **yynode)
1569
{
1570
*yynode = create<BooleanAndExpressionAst>();
1571
1572
(*yynode)->startToken = tokenStream->index() - 1;
1573
1574
if (yytoken == Token_ARRAY
1575
|| yytoken == Token_ARRAY_CAST
1576
|| yytoken == Token_AT
1577
|| yytoken == Token_BACKTICK
1578
|| yytoken == Token_BANG
1579
|| yytoken == Token_BOOL_CAST
1580
|| yytoken == Token_CLASS_C
1581
|| yytoken == Token_CLONE
1582
|| yytoken == Token_CONSTANT_ENCAPSED_STRING
1583
|| yytoken == Token_DEC
1584
|| yytoken == Token_DNUMBER
1585
|| yytoken == Token_DOLLAR
1586
|| yytoken == Token_DOUBLE_CAST
1587
|| yytoken == Token_DOUBLE_QUOTE
1588
|| yytoken == Token_EMPTY
1589
|| yytoken == Token_EVAL
1590
|| yytoken == Token_EXIT
1591
|| yytoken == Token_FILE
1592
|| yytoken == Token_FUNC_C
1593
|| yytoken == Token_INC
1594
|| yytoken == Token_INCLUDE
1595
|| yytoken == Token_INCLUDE_ONCE
1596
|| yytoken == Token_INT_CAST
1597
|| yytoken == Token_ISSET
1598
|| yytoken == Token_LINE
1599
|| yytoken == Token_LIST
1600
|| yytoken == Token_LNUMBER
1601
|| yytoken == Token_LPAREN
1602
|| yytoken == Token_METHOD_C
1603
|| yytoken == Token_MINUS
1604
|| yytoken == Token_NEW
1605
|| yytoken == Token_OBJECT_CAST
1606
|| yytoken == Token_PLUS
1607
|| yytoken == Token_REQUIRE
1608
|| yytoken == Token_REQUIRE_ONCE
1609
|| yytoken == Token_START_HEREDOC
1610
|| yytoken == Token_STRING
1611
|| yytoken == Token_STRING_CAST
1612
|| yytoken == Token_STRING_VARNAME
1613
|| yytoken == Token_TILDE
1614
|| yytoken == Token_UNSET_CAST
1615
|| yytoken == Token_VARIABLE)
1616
{
1617
BitOrExpressionAst *__node_28 = 0;
1618
if (!parseBitOrExpression(&__node_28))
1619
{
1620
if (!mBlockErrors)
1621
{
1622
expectedSymbol(AstNode::BitOrExpressionKind, "bitOrExpression");
1623
}
1624
return false;
1625
}
1626
(*yynode)->expressionSequence = snoc((*yynode)->expressionSequence, __node_28, memoryPool);
1627
1628
while (yytoken == Token_BOOLEAN_AND)
1629
{
1630
if (yytoken != Token_BOOLEAN_AND)
1631
{
1632
if (!mBlockErrors)
1633
{
1634
expectedToken(yytoken, Token_BOOLEAN_AND, "&&");
1635
}
1636
return false;
1637
}
1638
yylex();
1639
1640
BitOrExpressionAst *__node_29 = 0;
1641
if (!parseBitOrExpression(&__node_29))
1642
{
1643
if (!mBlockErrors)
1644
{
1645
expectedSymbol(AstNode::BitOrExpressionKind, "bitOrExpression");
1646
}
1647
return false;
1648
}
1649
(*yynode)->expressionSequence = snoc((*yynode)->expressionSequence, __node_29, memoryPool);
1650
1651
}
1652
}
1653
else
1654
{
1655
return false;
1656
}
1657
1658
(*yynode)->endToken = tokenStream->index() - 2;
1659
1660
return true;
1661
}
1662
1663
bool Parser::parseBooleanOrExpression(BooleanOrExpressionAst **yynode)
1664
{
1665
*yynode = create<BooleanOrExpressionAst>();
1666
1667
(*yynode)->startToken = tokenStream->index() - 1;
1668
1669
if (yytoken == Token_ARRAY
1670
|| yytoken == Token_ARRAY_CAST
1671
|| yytoken == Token_AT
1672
|| yytoken == Token_BACKTICK
1673
|| yytoken == Token_BANG
1674
|| yytoken == Token_BOOL_CAST
1675
|| yytoken == Token_CLASS_C
1676
|| yytoken == Token_CLONE
1677
|| yytoken == Token_CONSTANT_ENCAPSED_STRING
1678
|| yytoken == Token_DEC
1679
|| yytoken == Token_DNUMBER
1680
|| yytoken == Token_DOLLAR
1681
|| yytoken == Token_DOUBLE_CAST
1682
|| yytoken == Token_DOUBLE_QUOTE
1683
|| yytoken == Token_EMPTY
1684
|| yytoken == Token_EVAL
1685
|| yytoken == Token_EXIT
1686
|| yytoken == Token_FILE
1687
|| yytoken == Token_FUNC_C
1688
|| yytoken == Token_INC
1689
|| yytoken == Token_INCLUDE
1690
|| yytoken == Token_INCLUDE_ONCE
1691
|| yytoken == Token_INT_CAST
1692
|| yytoken == Token_ISSET
1693
|| yytoken == Token_LINE
1694
|| yytoken == Token_LIST
1695
|| yytoken == Token_LNUMBER
1696
|| yytoken == Token_LPAREN
1697
|| yytoken == Token_METHOD_C
1698
|| yytoken == Token_MINUS
1699
|| yytoken == Token_NEW
1700
|| yytoken == Token_OBJECT_CAST
1701
|| yytoken == Token_PLUS
1702
|| yytoken == Token_REQUIRE
1703
|| yytoken == Token_REQUIRE_ONCE
1704
|| yytoken == Token_START_HEREDOC
1705
|| yytoken == Token_STRING
1706
|| yytoken == Token_STRING_CAST
1707
|| yytoken == Token_STRING_VARNAME
1708
|| yytoken == Token_TILDE
1709
|| yytoken == Token_UNSET_CAST
1710
|| yytoken == Token_VARIABLE)
1711
{
1712
BooleanAndExpressionAst *__node_30 = 0;
1713
if (!parseBooleanAndExpression(&__node_30))
1714
{
1715
if (!mBlockErrors)
1716
{
1717
expectedSymbol(AstNode::BooleanAndExpressionKind, "booleanAndExpression");
1718
}
1719
return false;
1720
}
1721
(*yynode)->expressionSequence = snoc((*yynode)->expressionSequence, __node_30, memoryPool);
1722
1723
while (yytoken == Token_BOOLEAN_OR)
1724
{
1725
if (yytoken != Token_BOOLEAN_OR)
1726
{
1727
if (!mBlockErrors)
1728
{
1729
expectedToken(yytoken, Token_BOOLEAN_OR, "||");
1730
}
1731
return false;
1732
}
1733
yylex();
1734
1735
BooleanAndExpressionAst *__node_31 = 0;
1736
if (!parseBooleanAndExpression(&__node_31))
1737
{
1738
if (!mBlockErrors)
1739
{
1740
expectedSymbol(AstNode::BooleanAndExpressionKind, "booleanAndExpression");
1741
}
1742
return false;
1743
}
1744
(*yynode)->expressionSequence = snoc((*yynode)->expressionSequence, __node_31, memoryPool);
1745
1746
}
1747
}
1748
else
1749
{
1750
return false;
1751
}
1752
1753
(*yynode)->endToken = tokenStream->index() - 2;
1754
1755
return true;
1756
}
1757
1758
bool Parser::parseCaseList(CaseListAst **yynode)
1759
{
1760
*yynode = create<CaseListAst>();
1761
1762
(*yynode)->startToken = tokenStream->index() - 1;
1763
1764
if (yytoken == Token_CASE
1765
|| yytoken == Token_DEFAULT || yytoken == Token_ENDSWITCH
1766
|| yytoken == Token_EOF
1767
|| yytoken == Token_RBRACE)
1768
{
1769
while (yytoken == Token_CASE
1770
|| yytoken == Token_DEFAULT)
1771
{
1772
Case_itemAst *__node_32 = 0;
1773
if (!parseCase_item(&__node_32))
1774
{
1775
if (!mBlockErrors)
1776
{
1777
expectedSymbol(AstNode::Case_itemKind, "case_item");
1778
}
1779
return false;
1780
}
1781
(*yynode)->caseItemsSequence = snoc((*yynode)->caseItemsSequence, __node_32, memoryPool);
1782
1783
}
1784
}
1785
else
1786
{
1787
return false;
1788
}
1789
1790
(*yynode)->endToken = tokenStream->index() - 2;
1791
1792
return true;
1793
}
1794
1795
bool Parser::parseCase_item(Case_itemAst **yynode)
1796
{
1797
*yynode = create<Case_itemAst>();
1798
1799
(*yynode)->startToken = tokenStream->index() - 1;
1800
(*yynode)->def = -1;
1801
1802
if (yytoken == Token_CASE
1803
|| yytoken == Token_DEFAULT)
1804
{
1805
if (yytoken == Token_CASE)
1806
{
1807
if (yytoken != Token_CASE)
1808
{
1809
if (!mBlockErrors)
1810
{
1811
expectedToken(yytoken, Token_CASE, "case");
1812
}
1813
return false;
1814
}
1815
yylex();
1816
1817
ExprAst *__node_33 = 0;
1818
if (!parseExpr(&__node_33))
1819
{
1820
if (!mBlockErrors)
1821
{
1822
expectedSymbol(AstNode::ExprKind, "expr");
1823
}
1824
return false;
1825
}
1826
(*yynode)->expr = __node_33;
1827
1828
if (yytoken == Token_COLON)
1829
{
1830
if (yytoken != Token_COLON)
1831
{
1832
if (!mBlockErrors)
1833
{
1834
expectedToken(yytoken, Token_COLON, ":");
1835
}
1836
return false;
1837
}
1838
yylex();
1839
1840
}
1841
else if (yytoken == Token_SEMICOLON)
1842
{
1843
if (yytoken != Token_SEMICOLON)
1844
{
1845
if (!mBlockErrors)
1846
{
1847
expectedToken(yytoken, Token_SEMICOLON, ";");
1848
}
1849
return false;
1850
}
1851
yylex();
1852
1853
}
1854
else
1855
{
1856
return false;
1857
}
1858
InnerStatementListAst *__node_34 = 0;
1859
if (!parseInnerStatementList(&__node_34))
1860
{
1861
if (!mBlockErrors)
1862
{
1863
expectedSymbol(AstNode::InnerStatementListKind, "innerStatementList");
1864
}
1865
return false;
1866
}
1867
(*yynode)->statements = __node_34;
1868
1869
}
1870
else if (yytoken == Token_DEFAULT)
1871
{
1872
if (yytoken != Token_DEFAULT)
1873
{
1874
if (!mBlockErrors)
1875
{
1876
expectedToken(yytoken, Token_DEFAULT, "default");
1877
}
1878
return false;
1879
}
1880
(*yynode)->def = tokenStream->index() - 1;
1881
yylex();
1882
1883
if (yytoken == Token_COLON)
1884
{
1885
if (yytoken != Token_COLON)
1886
{
1887
if (!mBlockErrors)
1888
{
1889
expectedToken(yytoken, Token_COLON, ":");
1890
}
1891
return false;
1892
}
1893
yylex();
1894
1895
}
1896
else if (yytoken == Token_SEMICOLON)
1897
{
1898
if (yytoken != Token_SEMICOLON)
1899
{
1900
if (!mBlockErrors)
1901
{
1902
expectedToken(yytoken, Token_SEMICOLON, ";");
1903
}
1904
return false;
1905
}
1906
yylex();
1907
1908
}
1909
else
1910
{
1911
return false;
1912
}
1913
InnerStatementListAst *__node_35 = 0;
1914
if (!parseInnerStatementList(&__node_35))
1915
{
1916
if (!mBlockErrors)
1917
{
1918
expectedSymbol(AstNode::InnerStatementListKind, "innerStatementList");
1919
}
1920
return false;
1921
}
1922
(*yynode)->statements = __node_35;
1923
1924
}
1925
else
1926
{
1927
return false;
1928
}
1929
}
1930
else
1931
{
1932
return false;
1933
}
1934
1935
(*yynode)->endToken = tokenStream->index() - 2;
1936
1937
return true;
1938
}
1939
1940
bool Parser::parseCatchItem(CatchItemAst **yynode)
1941
{
1942
*yynode = create<CatchItemAst>();
1943
1944
(*yynode)->startToken = tokenStream->index() - 1;
1945
1946
if (yytoken == Token_CATCH)
1947
{
1948
if (yytoken != Token_CATCH)
1949
{
1950
if (!mBlockErrors)
1951
{
1952
expectedToken(yytoken, Token_CATCH, "catch");
1953
}
1954
return false;
1955
}
1956
yylex();
1957
1958
if (yytoken != Token_LPAREN)
1959
{
1960
if (!mBlockErrors)
1961
{
1962
expectedToken(yytoken, Token_LPAREN, "(");
1963
}
1964
return false;
1965
}
1966
yylex();
1967
1968
IdentifierAst *__node_36 = 0;
1969
if (!parseIdentifier(&__node_36))
1970
{
1971
if (!mBlockErrors)
1972
{
1973
expectedSymbol(AstNode::IdentifierKind, "identifier");
1974
}
1975
return false;
1976
}
1977
(*yynode)->catchClass = __node_36;
1978
1979
VariableIdentifierAst *__node_37 = 0;
1980
if (!parseVariableIdentifier(&__node_37))
1981
{
1982
if (!mBlockErrors)
1983
{
1984
expectedSymbol(AstNode::VariableIdentifierKind, "variableIdentifier");
1985
}
1986
return false;
1987
}
1988
(*yynode)->var = __node_37;
1989
1990
if (yytoken != Token_RPAREN)
1991
{
1992
if (!mBlockErrors)
1993
{
1994
expectedToken(yytoken, Token_RPAREN, ")");
1995
}
1996
return false;
1997
}
1998
yylex();
1999
2000
if (yytoken != Token_LBRACE)
2001
{
2002
if (!mBlockErrors)
2003
{
2004
expectedToken(yytoken, Token_LBRACE, "{");
2005
}
2006
return false;
2007
}
2008
yylex();
2009
2010
InnerStatementListAst *__node_38 = 0;
2011
if (!parseInnerStatementList(&__node_38))
2012
{
2013
if (!mBlockErrors)
2014
{
2015
expectedSymbol(AstNode::InnerStatementListKind, "innerStatementList");
2016
}
2017
return false;
2018
}
2019
(*yynode)->statements = __node_38;
2020
2021
if (yytoken != Token_RBRACE)
2022
{
2023
if (!mBlockErrors)
2024
{
2025
expectedToken(yytoken, Token_RBRACE, "}");
2026
}
2027
return false;
2028
}
2029
yylex();
2030
2031
}
2032
else
2033
{
2034
return false;
2035
}
2036
2037
(*yynode)->endToken = tokenStream->index() - 2;
2038
2039
return true;
2040
}
2041
2042
bool Parser::parseClassBody(ClassBodyAst **yynode)
2043
{
2044
*yynode = create<ClassBodyAst>();
2045
2046
(*yynode)->startToken = tokenStream->index() - 1;
2047
2048
if (yytoken == Token_ABSTRACT
2049
|| yytoken == Token_CONST
2050
|| yytoken == Token_FINAL
2051
|| yytoken == Token_FUNCTION
2052
|| yytoken == Token_PRIVATE
2053
|| yytoken == Token_PROTECTED
2054
|| yytoken == Token_PUBLIC
2055
|| yytoken == Token_STATIC
2056
|| yytoken == Token_VAR
2057
|| yytoken == Token_VARIABLE || yytoken == Token_EOF
2058
|| yytoken == Token_RBRACE)
2059
{
2060
while (yytoken == Token_ABSTRACT
2061
|| yytoken == Token_CONST
2062
|| yytoken == Token_FINAL
2063
|| yytoken == Token_FUNCTION
2064
|| yytoken == Token_PRIVATE
2065
|| yytoken == Token_PROTECTED
2066
|| yytoken == Token_PUBLIC
2067
|| yytoken == Token_STATIC
2068
|| yytoken == Token_VAR
2069
|| yytoken == Token_VARIABLE)
2070
{
2071
ClassStatementAst *__node_39 = 0;
2072
if (!parseClassStatement(&__node_39))
2073
{
2074
if (!mBlockErrors)
2075
{
2076
expectedSymbol(AstNode::ClassStatementKind, "classStatement");
2077
}
2078
return false;
2079
}
2080
(*yynode)->classStatementsSequence = snoc((*yynode)->classStatementsSequence, __node_39, memoryPool);
2081
2082
}
2083
}
2084
else
2085
{
2086
return false;
2087
}
2088
2089
(*yynode)->endToken = tokenStream->index() - 2;
2090
2091
return true;
2092
}
2093
2094
bool Parser::parseClassConstantDeclaration(ClassConstantDeclarationAst **yynode)
2095
{
2096
*yynode = create<ClassConstantDeclarationAst>();
2097
2098
(*yynode)->startToken = tokenStream->index() - 1;
2099
2100
if (yytoken == Token_STRING)
2101
{
2102
IdentifierAst *__node_40 = 0;
2103
if (!parseIdentifier(&__node_40))
2104
{
2105
if (!mBlockErrors)
2106
{
2107
expectedSymbol(AstNode::IdentifierKind, "identifier");
2108
}
2109
return false;
2110
}
2111
(*yynode)->identifier = __node_40;
2112
2113
if (yytoken != Token_ASSIGN)
2114
{
2115
if (!mBlockErrors)
2116
{
2117
expectedToken(yytoken, Token_ASSIGN, "=");
2118
}
2119
return false;
2120
}
2121
yylex();
2122
2123
StaticScalarAst *__node_41 = 0;
2124
if (!parseStaticScalar(&__node_41))
2125
{
2126
if (!mBlockErrors)
2127
{
2128
expectedSymbol(AstNode::StaticScalarKind, "staticScalar");
2129
}
2130
return false;
2131
}
2132
(*yynode)->scalar = __node_41;
2133
2134
}
2135
else
2136
{
2137
return false;
2138
}
2139
2140
(*yynode)->endToken = tokenStream->index() - 2;
2141
2142
return true;
2143
}
2144
2145
bool Parser::parseClassDeclarationStatement(ClassDeclarationStatementAst **yynode)
2146
{
2147
*yynode = create<ClassDeclarationStatementAst>();
2148
2149
(*yynode)->startToken = tokenStream->index() - 1;
2150
2151
if (yytoken == Token_ABSTRACT
2152
|| yytoken == Token_CLASS
2153
|| yytoken == Token_FINAL)
2154
{
2155
OptionalClassModifierAst *__node_42 = 0;
2156
if (!parseOptionalClassModifier(&__node_42))
2157
{
2158
if (!mBlockErrors)
2159
{
2160
expectedSymbol(AstNode::OptionalClassModifierKind, "optionalClassModifier");
2161
}
2162
return false;
2163
}
2164
(*yynode)->modifier = __node_42;
2165
2166
if (yytoken != Token_CLASS)
2167
{
2168
if (!mBlockErrors)
2169
{
2170
expectedToken(yytoken, Token_CLASS, "class");
2171
}
2172
return false;
2173
}
2174
yylex();
2175
2176
IdentifierAst *__node_43 = 0;
2177
if (!parseIdentifier(&__node_43))
2178
{
2179
if (!mBlockErrors)
2180
{
2181
expectedSymbol(AstNode::IdentifierKind, "identifier");
2182
}
2183
return false;
2184
}
2185
(*yynode)->className = __node_43;
2186
2187
if (yytoken == Token_EXTENDS)
2188
{
2189
if (yytoken != Token_EXTENDS)
2190
{
2191
if (!mBlockErrors)
2192
{
2193
expectedToken(yytoken, Token_EXTENDS, "extends");
2194
}
2195
return false;
2196
}
2197
yylex();
2198
2199
ClassExtendsAst *__node_44 = 0;
2200
if (!parseClassExtends(&__node_44))
2201
{
2202
if (!mBlockErrors)
2203
{
2204
expectedSymbol(AstNode::ClassExtendsKind, "classExtends");
2205
}
2206
return false;
2207
}
2208
(*yynode)->extends = __node_44;
2209
2210
}
2211
else if (true /*epsilon*/)
2212
{
2213
}
2214
else
2215
{
2216
return false;
2217
}
2218
if (yytoken == Token_IMPLEMENTS)
2219
{
2220
if (yytoken != Token_IMPLEMENTS)
2221
{
2222
if (!mBlockErrors)
2223
{
2224
expectedToken(yytoken, Token_IMPLEMENTS, "implements");
2225
}
2226
return false;
2227
}
2228
yylex();
2229
2230
ClassImplementsAst *__node_45 = 0;
2231
if (!parseClassImplements(&__node_45))
2232
{
2233
if (!mBlockErrors)
2234
{
2235
expectedSymbol(AstNode::ClassImplementsKind, "classImplements");
2236
}
2237
return false;
2238
}
2239
(*yynode)->implements = __node_45;
2240
2241
}
2242
else if (true /*epsilon*/)
2243
{
2244
}
2245
else
2246
{
2247
return false;
2248
}
2249
if (yytoken != Token_LBRACE)
2250
{
2251
if (!mBlockErrors)
2252
{
2253
expectedToken(yytoken, Token_LBRACE, "{");
2254
}
2255
return false;
2256
}
2257
yylex();
2258
2259
ClassBodyAst *__node_46 = 0;
2260
if (!parseClassBody(&__node_46))
2261
{
2262
if (!mBlockErrors)
2263
{
2264
expectedSymbol(AstNode::ClassBodyKind, "classBody");
2265
}
2266
return false;
2267
}
2268
(*yynode)->body = __node_46;
2269
2270
if (yytoken != Token_RBRACE)
2271
{
2272
if (!mBlockErrors)
2273
{
2274
expectedToken(yytoken, Token_RBRACE, "}");
2275
}
2276
return false;
2277
}
2278
yylex();
2279
2280
}
2281
else
2282
{
2283
return false;
2284
}
2285
2286
(*yynode)->endToken = tokenStream->index() - 2;
2287
2288
return true;
2289
}
2290
2291
bool Parser::parseClassExtends(ClassExtendsAst **yynode)
2292
{
2293
*yynode = create<ClassExtendsAst>();
2294
2295
(*yynode)->startToken = tokenStream->index() - 1;
2296
2297
if (yytoken == Token_STRING)
2298
{
2299
IdentifierAst *__node_47 = 0;
2300
if (!parseIdentifier(&__node_47))
2301
{
2302
if (!mBlockErrors)
2303
{
2304
expectedSymbol(AstNode::IdentifierKind, "identifier");
2305
}
2306
return false;
2307
}
2308
(*yynode)->identifier = __node_47;
2309
2310
}
2311
else
2312
{
2313
return false;
2314
}
2315
2316
(*yynode)->endToken = tokenStream->index() - 2;
2317
2318
return true;
2319
}
2320
2321
bool Parser::parseClassImplements(ClassImplementsAst **yynode)
2322
{
2323
*yynode = create<ClassImplementsAst>();
2324
2325
(*yynode)->startToken = tokenStream->index() - 1;
2326
2327
if (yytoken == Token_STRING)
2328
{
2329
IdentifierAst *__node_48 = 0;
2330
if (!parseIdentifier(&__node_48))
2331
{
2332
if (!mBlockErrors)
2333
{
2334
expectedSymbol(AstNode::IdentifierKind, "identifier");
2335
}
2336
return false;
2337
}
2338
(*yynode)->implementsSequence = snoc((*yynode)->implementsSequence, __node_48, memoryPool);
2339
2340
while (yytoken == Token_COMMA)
2341
{
2342
if (yytoken != Token_COMMA)
2343
{
2344
if (!mBlockErrors)
2345
{
2346
expectedToken(yytoken, Token_COMMA, ",");
2347
}
2348
return false;
2349
}
2350
yylex();
2351
2352
IdentifierAst *__node_49 = 0;
2353
if (!parseIdentifier(&__node_49))
2354
{
2355
if (!mBlockErrors)
2356
{
2357
expectedSymbol(AstNode::IdentifierKind, "identifier");
2358
}
2359
return false;
2360
}
2361
(*yynode)->implementsSequence = snoc((*yynode)->implementsSequence, __node_49, memoryPool);
2362
2363
}
2364
}
2365
else
2366
{
2367
return false;
2368
}
2369
2370
(*yynode)->endToken = tokenStream->index() - 2;
2371
2372
return true;
2373
}
2374
2375
bool Parser::parseClassNameReference(ClassNameReferenceAst **yynode)
2376
{
2377
*yynode = create<ClassNameReferenceAst>();
2378
2379
(*yynode)->startToken = tokenStream->index() - 1;
2380
2381
if (yytoken == Token_DOLLAR
2382
|| yytoken == Token_STRING
2383
|| yytoken == Token_VARIABLE)
2384
{
2385
if ((yytoken == Token_STRING) && ( LA(2).kind != Token_PAAMAYIM_NEKUDOTAYIM ))
2386
{
2387
IdentifierAst *__node_50 = 0;
2388
if (!parseIdentifier(&__node_50))
2389
{
2390
if (!mBlockErrors)
2391
{
2392
expectedSymbol(AstNode::IdentifierKind, "identifier");
2393
}
2394
return false;
2395
}
2396
(*yynode)->identifier = __node_50;
2397
2398
}
2399
else if (yytoken == Token_DOLLAR
2400
|| yytoken == Token_STRING
2401
|| yytoken == Token_VARIABLE)
2402
{
2403
DynamicClassNameReferenceAst *__node_51 = 0;
2404
if (!parseDynamicClassNameReference(&__node_51))
2405
{
2406
if (!mBlockErrors)
2407
{
2408
expectedSymbol(AstNode::DynamicClassNameReferenceKind, "dynamicClassNameReference");
2409
}
2410
return false;
2411
}
2412
(*yynode)->dynamicClassNameReference = __node_51;
2413
2414
}
2415
else
2416
{
2417
return false;
2418
}
2419
}
2420
else
2421
{
2422
return false;
2423
}
2424
2425
(*yynode)->endToken = tokenStream->index() - 2;
2426
2427
return true;
2428
}
2429
2430
bool Parser::parseClassStatement(ClassStatementAst **yynode)
2431
{
2432
*yynode = create<ClassStatementAst>();
2433
2434
(*yynode)->startToken = tokenStream->index() - 1;
2435
2436
if (yytoken == Token_ABSTRACT
2437
|| yytoken == Token_CONST
2438
|| yytoken == Token_FINAL
2439
|| yytoken == Token_FUNCTION
2440
|| yytoken == Token_PRIVATE
2441
|| yytoken == Token_PROTECTED
2442
|| yytoken == Token_PUBLIC
2443
|| yytoken == Token_STATIC
2444
|| yytoken == Token_VAR
2445
|| yytoken == Token_VARIABLE)
2446
{
2447
if (yytoken == Token_CONST)
2448
{
2449
if (yytoken != Token_CONST)
2450
{
2451
if (!mBlockErrors)
2452
{
2453
expectedToken(yytoken, Token_CONST, "const");
2454
}
2455
return false;
2456
}
2457
yylex();
2458
2459
ClassConstantDeclarationAst *__node_52 = 0;
2460
if (!parseClassConstantDeclaration(&__node_52))
2461
{
2462
if (!mBlockErrors)
2463
{
2464
expectedSymbol(AstNode::ClassConstantDeclarationKind, "classConstantDeclaration");
2465
}
2466
return false;
2467
}
2468
(*yynode)->consts = __node_52;
2469
2470
while (yytoken == Token_COMMA)
2471
{
2472
if (yytoken != Token_COMMA)
2473
{
2474
if (!mBlockErrors)
2475
{
2476
expectedToken(yytoken, Token_COMMA, ",");
2477
}
2478
return false;
2479
}
2480
yylex();
2481
2482
ClassConstantDeclarationAst *__node_53 = 0;
2483
if (!parseClassConstantDeclaration(&__node_53))
2484
{
2485
if (!mBlockErrors)
2486
{
2487
expectedSymbol(AstNode::ClassConstantDeclarationKind, "classConstantDeclaration");
2488
}
2489
return false;
2490
}
2491
(*yynode)->consts = __node_53;
2492
2493
}
2494
if (yytoken != Token_SEMICOLON)
2495
{
2496
if (!mBlockErrors)
2497
{
2498
expectedToken(yytoken, Token_SEMICOLON, ";");
2499
}
2500
return false;
2501
}
2502
yylex();
2503
2504
}
2505
else if (yytoken == Token_VAR)
2506
{
2507
if (yytoken != Token_VAR)
2508
{
2509
if (!mBlockErrors)
2510
{
2511
expectedToken(yytoken, Token_VAR, "var ");
2512
}
2513
return false;
2514
}
2515
yylex();
2516
2517
ClassVariableDeclarationAst *__node_54 = 0;
2518
if (!parseClassVariableDeclaration(&__node_54))
2519
{
2520
if (!mBlockErrors)
2521
{
2522
expectedSymbol(AstNode::ClassVariableDeclarationKind, "classVariableDeclaration");
2523
}
2524
return false;
2525
}
2526
(*yynode)->variable = __node_54;
2527
2528
if (yytoken != Token_SEMICOLON)
2529
{
2530
if (!mBlockErrors)
2531
{
2532
expectedToken(yytoken, Token_SEMICOLON, ";");
2533
}
2534
return false;
2535
}
2536
yylex();
2537
2538
}
2539
else if (yytoken == Token_ABSTRACT
2540
|| yytoken == Token_FINAL
2541
|| yytoken == Token_FUNCTION
2542
|| yytoken == Token_PRIVATE
2543
|| yytoken == Token_PROTECTED
2544
|| yytoken == Token_PUBLIC
2545
|| yytoken == Token_STATIC
2546
|| yytoken == Token_VARIABLE)
2547
{
2548
OptionalModifiersAst *__node_55 = 0;
2549
if (!parseOptionalModifiers(&__node_55))
2550
{
2551
if (!mBlockErrors)
2552
{
2553
expectedSymbol(AstNode::OptionalModifiersKind, "optionalModifiers");
2554
}
2555
return false;
2556
}
2557
(*yynode)->modifiers = __node_55;
2558
2559
if (yytoken == Token_VARIABLE)
2560
{
2561
ClassVariableDeclarationAst *__node_56 = 0;
2562
if (!parseClassVariableDeclaration(&__node_56))
2563
{
2564
if (!mBlockErrors)
2565
{
2566
expectedSymbol(AstNode::ClassVariableDeclarationKind, "classVariableDeclaration");
2567
}
2568
return false;
2569
}
2570
(*yynode)->variable = __node_56;
2571
2572
if (yytoken != Token_SEMICOLON)
2573
{
2574
if (!mBlockErrors)
2575
{
2576
expectedToken(yytoken, Token_SEMICOLON, ";");
2577
}
2578
return false;
2579
}
2580
yylex();
2581
2582
}
2583
else if (yytoken == Token_FUNCTION)
2584
{
2585
if (yytoken != Token_FUNCTION)
2586
{
2587
if (!mBlockErrors)
2588
{
2589
expectedToken(yytoken, Token_FUNCTION, "function");
2590
}
2591
return false;
2592
}
2593
yylex();
2594
2595
if (yytoken == Token_BIT_AND)
2596
{
2597
if (yytoken != Token_BIT_AND)
2598
{
2599
if (!mBlockErrors)
2600
{
2601
expectedToken(yytoken, Token_BIT_AND, "&");
2602
}
2603
return false;
2604
}
2605
yylex();
2606
2607
}
2608
else if (true /*epsilon*/)
2609
{
2610
}
2611
else
2612
{
2613
return false;
2614
}
2615
IdentifierAst *__node_57 = 0;
2616
if (!parseIdentifier(&__node_57))
2617
{
2618
if (!mBlockErrors)
2619
{
2620
expectedSymbol(AstNode::IdentifierKind, "identifier");
2621
}
2622
return false;
2623
}
2624
(*yynode)->methodName = __node_57;
2625
2626
if (yytoken != Token_LPAREN)
2627
{
2628
if (!mBlockErrors)
2629
{
2630
expectedToken(yytoken, Token_LPAREN, "(");
2631
}
2632
return false;
2633
}
2634
yylex();
2635
2636
ParameterListAst *__node_58 = 0;
2637
if (!parseParameterList(&__node_58))
2638
{
2639
if (!mBlockErrors)
2640
{
2641
expectedSymbol(AstNode::ParameterListKind, "parameterList");
2642
}
2643
return false;
2644
}
2645
(*yynode)->parameters = __node_58;
2646
2647
if (yytoken != Token_RPAREN)
2648
{
2649
if (!mBlockErrors)
2650
{
2651
expectedToken(yytoken, Token_RPAREN, ")");
2652
}
2653
return false;
2654
}
2655
yylex();
2656
2657
MethodBodyAst *__node_59 = 0;
2658
if (!parseMethodBody(&__node_59))
2659
{
2660
if (!mBlockErrors)
2661
{
2662
expectedSymbol(AstNode::MethodBodyKind, "methodBody");
2663
}
2664
return false;
2665
}
2666
(*yynode)->methodBody = __node_59;
2667
2668
}
2669
else
2670
{
2671
return false;
2672
}
2673
}
2674
else
2675
{
2676
return false;
2677
}
2678
}
2679
else
2680
{
2681
return false;
2682
}
2683
2684
(*yynode)->endToken = tokenStream->index() - 2;
2685
2686
return true;
2687
}
2688
2689
bool Parser::parseClassVariable(ClassVariableAst **yynode)
2690
{
2691
*yynode = create<ClassVariableAst>();
2692
2693
(*yynode)->startToken = tokenStream->index() - 1;
2694
2695
if (yytoken == Token_VARIABLE)
2696
{
2697
VariableIdentifierAst *__node_60 = 0;
2698
if (!parseVariableIdentifier(&__node_60))
2699
{
2700
if (!mBlockErrors)
2701
{
2702
expectedSymbol(AstNode::VariableIdentifierKind, "variableIdentifier");
2703
}
2704
return false;
2705
}
2706
(*yynode)->variable = __node_60;
2707
2708
if (yytoken == Token_ASSIGN)
2709
{
2710
if (yytoken != Token_ASSIGN)
2711
{
2712
if (!mBlockErrors)
2713
{
2714
expectedToken(yytoken, Token_ASSIGN, "=");
2715
}
2716
return false;
2717
}
2718
yylex();
2719
2720
StaticScalarAst *__node_61 = 0;
2721
if (!parseStaticScalar(&__node_61))
2722
{
2723
if (!mBlockErrors)
2724
{
2725
expectedSymbol(AstNode::StaticScalarKind, "staticScalar");
2726
}
2727
return false;
2728
}
2729
(*yynode)->value = __node_61;
2730
2731
}
2732
else if (true /*epsilon*/)
2733
{
2734
}
2735
else
2736
{
2737
return false;
2738
}
2739
}
2740
else
2741
{
2742
return false;
2743
}
2744
2745
(*yynode)->endToken = tokenStream->index() - 2;
2746
2747
return true;
2748
}
2749
2750
bool Parser::parseClassVariableDeclaration(ClassVariableDeclarationAst **yynode)
2751
{
2752
*yynode = create<ClassVariableDeclarationAst>();
2753
2754
(*yynode)->startToken = tokenStream->index() - 1;
2755
2756
if (yytoken == Token_VARIABLE)
2757
{
2758
ClassVariableAst *__node_62 = 0;
2759
if (!parseClassVariable(&__node_62))
2760
{
2761
if (!mBlockErrors)
2762
{
2763
expectedSymbol(AstNode::ClassVariableKind, "classVariable");
2764
}
2765
return false;
2766
}
2767
(*yynode)->varsSequence = snoc((*yynode)->varsSequence, __node_62, memoryPool);
2768
2769
while (yytoken == Token_COMMA)
2770
{
2771
if (yytoken != Token_COMMA)
2772
{
2773
if (!mBlockErrors)
2774
{
2775
expectedToken(yytoken, Token_COMMA, ",");
2776
}
2777
return false;
2778
}
2779
yylex();
2780
2781
ClassVariableAst *__node_63 = 0;
2782
if (!parseClassVariable(&__node_63))
2783
{
2784
if (!mBlockErrors)
2785
{
2786
expectedSymbol(AstNode::ClassVariableKind, "classVariable");
2787
}
2788
return false;
2789
}
2790
(*yynode)->varsSequence = snoc((*yynode)->varsSequence, __node_63, memoryPool);
2791
2792
}
2793
}
2794
else
2795
{
2796
return false;
2797
}
2798
2799
(*yynode)->endToken = tokenStream->index() - 2;
2800
2801
return true;
2802
}
2803
2804
bool Parser::parseCommonScalar(CommonScalarAst **yynode)
2805
{
2806
*yynode = create<CommonScalarAst>();
2807
2808
(*yynode)->startToken = tokenStream->index() - 1;
2809
(*yynode)->string = -1;
2810
2811
if (yytoken == Token_CLASS_C
2812
|| yytoken == Token_CONSTANT_ENCAPSED_STRING
2813
|| yytoken == Token_DNUMBER
2814
|| yytoken == Token_FILE
2815
|| yytoken == Token_FUNC_C
2816
|| yytoken == Token_LINE
2817
|| yytoken == Token_LNUMBER
2818
|| yytoken == Token_METHOD_C)
2819
{
2820
if (yytoken == Token_LNUMBER)
2821
{
2822
if (yytoken != Token_LNUMBER)
2823
{
2824
if (!mBlockErrors)
2825
{
2826
expectedToken(yytoken, Token_LNUMBER, "long number");
2827
}
2828
return false;
2829
}
2830
yylex();
2831
2832
(*yynode)->scalarType = ScalarTypeInt;
2833
}
2834
else if (yytoken == Token_DNUMBER)
2835
{
2836
if (yytoken != Token_DNUMBER)
2837
{
2838
if (!mBlockErrors)
2839
{
2840
expectedToken(yytoken, Token_DNUMBER, "double number");
2841
}
2842
return false;
2843
}
2844
yylex();
2845
2846
(*yynode)->scalarType = ScalarTypeFloat;
2847
}
2848
else if (yytoken == Token_CONSTANT_ENCAPSED_STRING)
2849
{
2850
if (yytoken != Token_CONSTANT_ENCAPSED_STRING)
2851
{
2852
if (!mBlockErrors)
2853
{
2854
expectedToken(yytoken, Token_CONSTANT_ENCAPSED_STRING, "constant encapsed string");
2855
}
2856
return false;
2857
}
2858
(*yynode)->string = tokenStream->index() - 1;
2859
yylex();
2860
2861
(*yynode)->scalarType = ScalarTypeString;
2862
}
2863
else if (yytoken == Token_LINE)
2864
{
2865
if (yytoken != Token_LINE)
2866
{
2867
if (!mBlockErrors)
2868
{
2869
expectedToken(yytoken, Token_LINE, "__LINE__");
2870
}
2871
return false;
2872
}
2873
yylex();
2874
2875
(*yynode)->scalarType = ScalarTypeInt;
2876
}
2877
else if (yytoken == Token_FILE)
2878
{
2879
if (yytoken != Token_FILE)
2880
{
2881
if (!mBlockErrors)
2882
{
2883
expectedToken(yytoken, Token_FILE, "__FILE__");
2884
}
2885
return false;
2886
}
2887
yylex();
2888
2889
(*yynode)->scalarType = ScalarTypeString;
2890
}
2891
else if (yytoken == Token_CLASS_C)
2892
{
2893
if (yytoken != Token_CLASS_C)
2894
{
2895
if (!mBlockErrors)
2896
{
2897
expectedToken(yytoken, Token_CLASS_C, "__CLASS__");
2898
}
2899
return false;
2900
}
2901
yylex();
2902
2903
(*yynode)->scalarType = ScalarTypeString;
2904
}
2905
else if (yytoken == Token_METHOD_C)
2906
{
2907
if (yytoken != Token_METHOD_C)
2908
{
2909
if (!mBlockErrors)
2910
{
2911
expectedToken(yytoken, Token_METHOD_C, "__METHOD__");
2912
}
2913
return false;
2914
}
2915
yylex();
2916
2917
(*yynode)->scalarType = ScalarTypeString;
2918
}
2919
else if (yytoken == Token_FUNC_C)
2920
{
2921
if (yytoken != Token_FUNC_C)
2922
{
2923
if (!mBlockErrors)
2924
{
2925
expectedToken(yytoken, Token_FUNC_C, "__FUNCTION__");
2926
}
2927
return false;
2928
}
2929
yylex();
2930
2931
(*yynode)->scalarType = ScalarTypeString;
2932
}
2933
else
2934
{
2935
return false;
2936
}
2937
}
2938
else
2939
{
2940
return false;
2941
}
2942
2943
(*yynode)->endToken = tokenStream->index() - 2;
2944
2945
return true;
2946
}
2947
2948
bool Parser::parseCompoundVariable(CompoundVariableAst **yynode)
2949
{
2950
*yynode = create<CompoundVariableAst>();
2951
2952
(*yynode)->startToken = tokenStream->index() - 1;
2953
2954
if (yytoken == Token_DOLLAR
2955
|| yytoken == Token_VARIABLE)
2956
{
2957
if (yytoken == Token_VARIABLE)
2958
{
2959
VariableIdentifierAst *__node_64 = 0;
2960
if (!parseVariableIdentifier(&__node_64))
2961
{
2962
if (!mBlockErrors)
2963
{
2964
expectedSymbol(AstNode::VariableIdentifierKind, "variableIdentifier");
2965
}
2966
return false;
2967
}
2968
(*yynode)->variable = __node_64;
2969
2970
}
2971
else if (yytoken == Token_DOLLAR)
2972
{
2973
if (yytoken != Token_DOLLAR)
2974
{
2975
if (!mBlockErrors)
2976
{
2977
expectedToken(yytoken, Token_DOLLAR, "$");
2978
}
2979
return false;
2980
}
2981
yylex();
2982
2983
if (yytoken != Token_LBRACE)
2984
{
2985
if (!mBlockErrors)
2986
{
2987
expectedToken(yytoken, Token_LBRACE, "{");
2988
}
2989
return false;
2990
}
2991
yylex();
2992
2993
ExprAst *__node_65 = 0;
2994
if (!parseExpr(&__node_65))
2995
{
2996
if (!mBlockErrors)
2997
{
2998
expectedSymbol(AstNode::ExprKind, "expr");
2999
}
3000
return false;
3001
}
3002
(*yynode)->expr = __node_65;
3003
3004
if (yytoken != Token_RBRACE)
3005
{
3006
if (!mBlockErrors)
3007
{
3008
expectedToken(yytoken, Token_RBRACE, "}");
3009
}
3010
return false;
3011
}
3012
yylex();
3013
3014
}
3015
else
3016
{
3017
return false;
3018
}
3019
}
3020
else
3021
{
3022
return false;
3023
}
3024
3025
(*yynode)->endToken = tokenStream->index() - 2;
3026
3027
return true;
3028
}
3029
3030
bool Parser::parseCompoundVariableWithSimpleIndirectReference(CompoundVariableWithSimpleIndirectReferenceAst **yynode)
3031
{
3032
*yynode = create<CompoundVariableWithSimpleIndirectReferenceAst>();
3033
3034
(*yynode)->startToken = tokenStream->index() - 1;
3035
3036
if (yytoken == Token_DOLLAR
3037
|| yytoken == Token_VARIABLE)
3038
{
3039
if (yytoken == Token_DOLLAR)
3040
{
3041
if (yytoken != Token_DOLLAR)
3042
{
3043
if (!mBlockErrors)
3044
{
3045
expectedToken(yytoken, Token_DOLLAR, "$");
3046
}
3047
return false;
3048
}
3049
yylex();
3050
3051
if (yytoken == Token_DOLLAR)
3052
{
3053
do
3054
{
3055
if (yytoken != Token_DOLLAR)
3056
{
3057
if (!mBlockErrors)
3058
{
3059
expectedToken(yytoken, Token_DOLLAR, "$");
3060
}
3061
return false;
3062
}
3063
yylex();
3064
3065
}
3066
while (yytoken == Token_DOLLAR);
3067
}
3068
else if (true /*epsilon*/)
3069
{
3070
}
3071
else
3072
{
3073
return false;
3074
}
3075
if (yytoken == Token_VARIABLE)
3076
{
3077
VariableIdentifierAst *__node_66 = 0;
3078
if (!parseVariableIdentifier(&__node_66))
3079
{
3080
if (!mBlockErrors)
3081
{
3082
expectedSymbol(AstNode::VariableIdentifierKind, "variableIdentifier");
3083
}
3084
return false;
3085
}
3086
(*yynode)->indirectVariable = __node_66;
3087
3088
}
3089
else if (yytoken == Token_LBRACE)
3090
{
3091
if (yytoken != Token_LBRACE)
3092
{
3093
if (!mBlockErrors)
3094
{
3095
expectedToken(yytoken, Token_LBRACE, "{");
3096
}
3097
return false;
3098
}
3099
yylex();
3100
3101
ExprAst *__node_67 = 0;
3102
if (!parseExpr(&__node_67))
3103
{
3104
if (!mBlockErrors)
3105
{
3106
expectedSymbol(AstNode::ExprKind, "expr");
3107
}
3108
return false;
3109
}
3110
(*yynode)->expr = __node_67;
3111
3112
if (yytoken != Token_RBRACE)
3113
{
3114
if (!mBlockErrors)
3115
{
3116
expectedToken(yytoken, Token_RBRACE, "}");
3117
}
3118
return false;
3119
}
3120
yylex();
3121
3122
}
3123
else
3124
{
3125
return false;
3126
}
3127
}
3128
else if (yytoken == Token_VARIABLE)
3129
{
3130
VariableIdentifierAst *__node_68 = 0;
3131
if (!parseVariableIdentifier(&__node_68))
3132
{
3133
if (!mBlockErrors)
3134
{
3135
expectedSymbol(AstNode::VariableIdentifierKind, "variableIdentifier");
3136
}
3137
return false;
3138
}
3139
(*yynode)->variable = __node_68;
3140
3141
}
3142
else
3143
{
3144
return false;
3145
}
3146
}
3147
else
3148
{
3149
return false;
3150
}
3151
3152
(*yynode)->endToken = tokenStream->index() - 2;
3153
3154
return true;
3155
}
3156
3157
bool Parser::parseConditionalExpression(ConditionalExpressionAst **yynode)
3158
{
3159
*yynode = create<ConditionalExpressionAst>();
3160
3161
(*yynode)->startToken = tokenStream->index() - 1;
3162
3163
if (yytoken == Token_ARRAY
3164
|| yytoken == Token_ARRAY_CAST
3165
|| yytoken == Token_AT
3166
|| yytoken == Token_BACKTICK
3167
|| yytoken == Token_BANG
3168
|| yytoken == Token_BOOL_CAST
3169
|| yytoken == Token_CLASS_C
3170
|| yytoken == Token_CLONE
3171
|| yytoken == Token_CONSTANT_ENCAPSED_STRING
3172
|| yytoken == Token_DEC
3173
|| yytoken == Token_DNUMBER
3174
|| yytoken == Token_DOLLAR
3175
|| yytoken == Token_DOUBLE_CAST
3176
|| yytoken == Token_DOUBLE_QUOTE
3177
|| yytoken == Token_EMPTY
3178
|| yytoken == Token_EVAL
3179
|| yytoken == Token_EXIT
3180
|| yytoken == Token_FILE
3181
|| yytoken == Token_FUNC_C
3182
|| yytoken == Token_INC
3183
|| yytoken == Token_INCLUDE
3184
|| yytoken == Token_INCLUDE_ONCE
3185
|| yytoken == Token_INT_CAST
3186
|| yytoken == Token_ISSET
3187
|| yytoken == Token_LINE
3188
|| yytoken == Token_LIST
3189
|| yytoken == Token_LNUMBER
3190
|| yytoken == Token_LPAREN
3191
|| yytoken == Token_METHOD_C
3192
|| yytoken == Token_MINUS
3193
|| yytoken == Token_NEW
3194
|| yytoken == Token_OBJECT_CAST
3195
|| yytoken == Token_PLUS
3196
|| yytoken == Token_REQUIRE
3197
|| yytoken == Token_REQUIRE_ONCE
3198
|| yytoken == Token_START_HEREDOC
3199
|| yytoken == Token_STRING
3200
|| yytoken == Token_STRING_CAST
3201
|| yytoken == Token_STRING_VARNAME
3202
|| yytoken == Token_TILDE
3203
|| yytoken == Token_UNSET_CAST
3204
|| yytoken == Token_VARIABLE)
3205
{
3206
BooleanOrExpressionAst *__node_69 = 0;
3207
if (!parseBooleanOrExpression(&__node_69))
3208
{
3209
if (!mBlockErrors)
3210
{
3211
expectedSymbol(AstNode::BooleanOrExpressionKind, "booleanOrExpression");
3212
}
3213
return false;
3214
}
3215
(*yynode)->expression = __node_69;
3216
3217
if (yytoken == Token_QUESTION)
3218
{
3219
if (yytoken != Token_QUESTION)
3220
{
3221
if (!mBlockErrors)
3222
{
3223
expectedToken(yytoken, Token_QUESTION, "?");
3224
}
3225
return false;
3226
}
3227
yylex();
3228
3229
ExprAst *__node_70 = 0;
3230
if (!parseExpr(&__node_70))
3231
{
3232
if (!mBlockErrors)
3233
{
3234
expectedSymbol(AstNode::ExprKind, "expr");
3235
}
3236
return false;
3237
}
3238
(*yynode)->ifExpression = __node_70;
3239
3240
if (yytoken != Token_COLON)
3241
{
3242
if (!mBlockErrors)
3243
{
3244
expectedToken(yytoken, Token_COLON, ":");
3245
}
3246
return false;
3247
}
3248
yylex();
3249
3250
ConditionalExpressionAst *__node_71 = 0;
3251
if (!parseConditionalExpression(&__node_71))
3252
{
3253
if (!mBlockErrors)
3254
{
3255
expectedSymbol(AstNode::ConditionalExpressionKind, "conditionalExpression");
3256
}
3257
return false;
3258
}
3259
(*yynode)->elseExpression = __node_71;
3260
3261
}
3262
else if (true /*epsilon*/)
3263
{
3264
}
3265
else
3266
{
3267
return false;
3268
}
3269
}
3270
else
3271
{
3272
return false;
3273
}
3274
3275
(*yynode)->endToken = tokenStream->index() - 2;
3276
3277
return true;
3278
}
3279
3280
bool Parser::parseConstantOrClassConst(ConstantOrClassConstAst **yynode)
3281
{
3282
*yynode = create<ConstantOrClassConstAst>();
3283
3284
(*yynode)->startToken = tokenStream->index() - 1;
3285
3286
if (yytoken == Token_STRING)
3287
{
3288
if ((yytoken == Token_STRING) && ( LA(2).kind == Token_PAAMAYIM_NEKUDOTAYIM ))
3289
{
3290
IdentifierAst *__node_72 = 0;
3291
if (!parseIdentifier(&__node_72))
3292
{
3293
if (!mBlockErrors)
3294
{
3295
expectedSymbol(AstNode::IdentifierKind, "identifier");
3296
}
3297
return false;
3298
}
3299
(*yynode)->className = __node_72;
3300
3301
if (yytoken != Token_PAAMAYIM_NEKUDOTAYIM)
3302
{
3303
if (!mBlockErrors)
3304
{
3305
expectedToken(yytoken, Token_PAAMAYIM_NEKUDOTAYIM, "::");
3306
}
3307
return false;
3308
}
3309
yylex();
3310
3311
IdentifierAst *__node_73 = 0;
3312
if (!parseIdentifier(&__node_73))
3313
{
3314
if (!mBlockErrors)
3315
{
3316
expectedSymbol(AstNode::IdentifierKind, "identifier");
3317
}
3318
return false;
3319
}
3320
(*yynode)->constant = __node_73;
3321
3322
}
3323
else if (yytoken == Token_STRING)
3324
{
3325
IdentifierAst *__node_74 = 0;
3326
if (!parseIdentifier(&__node_74))
3327
{
3328
if (!mBlockErrors)
3329
{
3330
expectedSymbol(AstNode::IdentifierKind, "identifier");
3331
}
3332
return false;
3333
}
3334
(*yynode)->constant = __node_74;
3335
3336
}
3337
else
3338
{
3339
return false;
3340
}
3341
}
3342
else
3343
{
3344
return false;
3345
}
3346
3347
(*yynode)->endToken = tokenStream->index() - 2;
3348
3349
return true;
3350
}
3351
3352
bool Parser::parseCtorArguments(CtorArgumentsAst **yynode)
3353
{
3354
*yynode = create<CtorArgumentsAst>();
3355
3356
(*yynode)->startToken = tokenStream->index() - 1;
3357
3358
if (yytoken == Token_LPAREN || yytoken == Token_AND_ASSIGN
3359
|| yytoken == Token_AS
3360
|| yytoken == Token_ASSIGN
3361
|| yytoken == Token_BIT_AND
3362
|| yytoken == Token_BIT_OR
3363
|| yytoken == Token_BIT_XOR
3364
|| yytoken == Token_BOOLEAN_AND
3365
|| yytoken == Token_BOOLEAN_OR
3366
|| yytoken == Token_CLOSE_TAG
3367
|| yytoken == Token_COLON
3368
|| yytoken == Token_COMMA
3369
|| yytoken == Token_CONCAT
3370
|| yytoken == Token_CONCAT_ASSIGN
3371
|| yytoken == Token_DEC
3372
|| yytoken == Token_DIV
3373
|| yytoken == Token_DIV_ASSIGN
3374
|| yytoken == Token_DOUBLE_ARROW
3375
|| yytoken == Token_EOF
3376
|| yytoken == Token_INC
3377
|| yytoken == Token_INSTANCEOF
3378
|| yytoken == Token_IS_EQUAL
3379
|| yytoken == Token_IS_GREATER
3380
|| yytoken == Token_IS_GREATER_OR_EQUAL
3381
|| yytoken == Token_IS_IDENTICAL
3382
|| yytoken == Token_IS_NOT_EQUAL
3383
|| yytoken == Token_IS_NOT_IDENTICAL
3384
|| yytoken == Token_IS_SMALLER
3385
|| yytoken == Token_IS_SMALLER_OR_EQUAL
3386
|| yytoken == Token_LOGICAL_AND
3387
|| yytoken == Token_LOGICAL_OR
3388
|| yytoken == Token_LOGICAL_XOR
3389
|| yytoken == Token_MINUS
3390
|| yytoken == Token_MINUS_ASSIGN
3391
|| yytoken == Token_MOD
3392
|| yytoken == Token_MOD_ASSIGN
3393
|| yytoken == Token_MUL
3394
|| yytoken == Token_MUL_ASSIGN
3395
|| yytoken == Token_OR_ASSIGN
3396
|| yytoken == Token_PLUS
3397
|| yytoken == Token_PLUS_ASSIGN
3398
|| yytoken == Token_QUESTION
3399
|| yytoken == Token_RBRACE
3400
|| yytoken == Token_RBRACKET
3401
|| yytoken == Token_RPAREN
3402
|| yytoken == Token_SEMICOLON
3403
|| yytoken == Token_SL
3404
|| yytoken == Token_SL_ASSIGN
3405
|| yytoken == Token_SR
3406
|| yytoken == Token_SR_ASSIGN
3407
|| yytoken == Token_XOR_ASSIGN)
3408
{
3409
if (yytoken == Token_LPAREN)
3410
{
3411
if (yytoken != Token_LPAREN)
3412
{
3413
if (!mBlockErrors)
3414
{
3415
expectedToken(yytoken, Token_LPAREN, "(");
3416
}
3417
return false;
3418
}
3419
yylex();
3420
3421
FunctionCallParameterListAst *__node_75 = 0;
3422
if (!parseFunctionCallParameterList(&__node_75))
3423
{
3424
if (!mBlockErrors)
3425
{
3426
expectedSymbol(AstNode::FunctionCallParameterListKind, "functionCallParameterList");
3427
}
3428
return false;
3429
}
3430
(*yynode)->parameterList = __node_75;
3431
3432
if (yytoken != Token_RPAREN)
3433
{
3434
if (!mBlockErrors)
3435
{
3436
expectedToken(yytoken, Token_RPAREN, ")");
3437
}
3438
return false;
3439
}
3440
yylex();
3441
3442
}
3443
else if (true /*epsilon*/)
3444
{
3445
}
3446
else
3447
{
3448
return false;
3449
}
3450
}
3451
else
3452
{
3453
return false;
3454
}
3455
3456
(*yynode)->endToken = tokenStream->index() - 2;
3457
3458
return true;
3459
}
3460
3461
bool Parser::parseDeclareItem(DeclareItemAst **yynode)
3462
{
3463
*yynode = create<DeclareItemAst>();
3464
3465
(*yynode)->startToken = tokenStream->index() - 1;
3466
3467
if (yytoken == Token_STRING)
3468
{
3469
if (yytoken != Token_STRING)
3470
{
3471
if (!mBlockErrors)
3472
{
3473
expectedToken(yytoken, Token_STRING, "string");
3474
}
3475
return false;
3476
}
3477
yylex();
3478
3479
if (yytoken != Token_ASSIGN)
3480
{
3481
if (!mBlockErrors)
3482
{
3483
expectedToken(yytoken, Token_ASSIGN, "=");
3484
}
3485
return false;
3486
}
3487
yylex();
3488
3489
StaticScalarAst *__node_76 = 0;
3490
if (!parseStaticScalar(&__node_76))
3491
{
3492
if (!mBlockErrors)
3493
{
3494
expectedSymbol(AstNode::StaticScalarKind, "staticScalar");
3495
}
3496
return false;
3497
}
3498
(*yynode)->scalar = __node_76;
3499
3500
}
3501
else
3502
{
3503
return false;
3504
}
3505
3506
(*yynode)->endToken = tokenStream->index() - 2;
3507
3508
return true;
3509
}
3510
3511
bool Parser::parseDeclareStatement(DeclareStatementAst **yynode)
3512
{
3513
*yynode = create<DeclareStatementAst>();
3514
3515
(*yynode)->startToken = tokenStream->index() - 1;
3516
3517
if (yytoken == Token_ARRAY
3518
|| yytoken == Token_ARRAY_CAST
3519
|| yytoken == Token_AT
3520
|| yytoken == Token_BACKTICK
3521
|| yytoken == Token_BANG
3522
|| yytoken == Token_BOOL_CAST
3523
|| yytoken == Token_BREAK
3524
|| yytoken == Token_CLASS_C
3525
|| yytoken == Token_CLONE
3526
|| yytoken == Token_CLOSE_TAG
3527
|| yytoken == Token_COLON
3528
|| yytoken == Token_CONSTANT_ENCAPSED_STRING
3529
|| yytoken == Token_CONTINUE
3530
|| yytoken == Token_DEC
3531
|| yytoken == Token_DECLARE
3532
|| yytoken == Token_DNUMBER
3533
|| yytoken == Token_DO
3534
|| yytoken == Token_DOLLAR
3535
|| yytoken == Token_DOUBLE_CAST
3536
|| yytoken == Token_DOUBLE_QUOTE
3537
|| yytoken == Token_ECHO
3538
|| yytoken == Token_EMPTY
3539
|| yytoken == Token_EVAL
3540
|| yytoken == Token_EXIT
3541
|| yytoken == Token_FILE
3542
|| yytoken == Token_FOR
3543
|| yytoken == Token_FOREACH
3544
|| yytoken == Token_FUNC_C
3545
|| yytoken == Token_GLOBAL
3546
|| yytoken == Token_IF
3547
|| yytoken == Token_INC
3548
|| yytoken == Token_INCLUDE
3549
|| yytoken == Token_INCLUDE_ONCE
3550
|| yytoken == Token_INLINE_HTML
3551
|| yytoken == Token_INT_CAST
3552
|| yytoken == Token_ISSET
3553
|| yytoken == Token_LBRACE
3554
|| yytoken == Token_LINE
3555
|| yytoken == Token_LIST
3556
|| yytoken == Token_LNUMBER
3557
|| yytoken == Token_LPAREN
3558
|| yytoken == Token_METHOD_C
3559
|| yytoken == Token_MINUS
3560
|| yytoken == Token_NEW
3561
|| yytoken == Token_OBJECT_CAST
3562
|| yytoken == Token_OPEN_TAG
3563
|| yytoken == Token_OPEN_TAG_WITH_ECHO
3564
|| yytoken == Token_PLUS
3565
|| yytoken == Token_PRINT
3566
|| yytoken == Token_REQUIRE
3567
|| yytoken == Token_REQUIRE_ONCE
3568
|| yytoken == Token_RETURN
3569
|| yytoken == Token_SEMICOLON
3570
|| yytoken == Token_START_HEREDOC
3571
|| yytoken == Token_STATIC
3572
|| yytoken == Token_STRING
3573
|| yytoken == Token_STRING_CAST
3574
|| yytoken == Token_STRING_VARNAME
3575
|| yytoken == Token_SWITCH
3576
|| yytoken == Token_THROW
3577
|| yytoken == Token_TILDE
3578
|| yytoken == Token_TRY
3579
|| yytoken == Token_UNSET
3580
|| yytoken == Token_UNSET_CAST
3581
|| yytoken == Token_VARIABLE
3582
|| yytoken == Token_WHILE)
3583
{
3584
if (yytoken == Token_ARRAY
3585
|| yytoken == Token_ARRAY_CAST
3586
|| yytoken == Token_AT
3587
|| yytoken == Token_BACKTICK
3588
|| yytoken == Token_BANG
3589
|| yytoken == Token_BOOL_CAST
3590
|| yytoken == Token_BREAK
3591
|| yytoken == Token_CLASS_C
3592
|| yytoken == Token_CLONE
3593
|| yytoken == Token_CLOSE_TAG
3594
|| yytoken == Token_CONSTANT_ENCAPSED_STRING
3595
|| yytoken == Token_CONTINUE
3596
|| yytoken == Token_DEC
3597
|| yytoken == Token_DECLARE
3598
|| yytoken == Token_DNUMBER
3599
|| yytoken == Token_DO
3600
|| yytoken == Token_DOLLAR
3601
|| yytoken == Token_DOUBLE_CAST
3602
|| yytoken == Token_DOUBLE_QUOTE
3603
|| yytoken == Token_ECHO
3604
|| yytoken == Token_EMPTY
3605
|| yytoken == Token_EVAL
3606
|| yytoken == Token_EXIT
3607
|| yytoken == Token_FILE
3608
|| yytoken == Token_FOR
3609
|| yytoken == Token_FOREACH
3610
|| yytoken == Token_FUNC_C
3611
|| yytoken == Token_GLOBAL
3612
|| yytoken == Token_IF
3613
|| yytoken == Token_INC
3614
|| yytoken == Token_INCLUDE
3615
|| yytoken == Token_INCLUDE_ONCE
3616
|| yytoken == Token_INLINE_HTML
3617
|| yytoken == Token_INT_CAST
3618
|| yytoken == Token_ISSET
3619
|| yytoken == Token_LBRACE
3620
|| yytoken == Token_LINE
3621
|| yytoken == Token_LIST
3622
|| yytoken == Token_LNUMBER
3623
|| yytoken == Token_LPAREN
3624
|| yytoken == Token_METHOD_C
3625
|| yytoken == Token_MINUS
3626
|| yytoken == Token_NEW
3627
|| yytoken == Token_OBJECT_CAST
3628
|| yytoken == Token_OPEN_TAG
3629
|| yytoken == Token_OPEN_TAG_WITH_ECHO
3630
|| yytoken == Token_PLUS
3631
|| yytoken == Token_PRINT
3632
|| yytoken == Token_REQUIRE
3633
|| yytoken == Token_REQUIRE_ONCE
3634
|| yytoken == Token_RETURN
3635
|| yytoken == Token_SEMICOLON
3636
|| yytoken == Token_START_HEREDOC
3637
|| yytoken == Token_STATIC
3638
|| yytoken == Token_STRING
3639
|| yytoken == Token_STRING_CAST
3640
|| yytoken == Token_STRING_VARNAME
3641
|| yytoken == Token_SWITCH
3642
|| yytoken == Token_THROW
3643
|| yytoken == Token_TILDE
3644
|| yytoken == Token_TRY
3645
|| yytoken == Token_UNSET
3646
|| yytoken == Token_UNSET_CAST
3647
|| yytoken == Token_VARIABLE
3648
|| yytoken == Token_WHILE)
3649
{
3650
StatementAst *__node_77 = 0;
3651
if (!parseStatement(&__node_77))
3652
{
3653
if (!mBlockErrors)
3654
{
3655
expectedSymbol(AstNode::StatementKind, "statement");
3656
}
3657
return false;
3658
}
3659
(*yynode)->statement = __node_77;
3660
3661
}
3662
else if (yytoken == Token_COLON)
3663
{
3664
if (yytoken != Token_COLON)
3665
{
3666
if (!mBlockErrors)
3667
{
3668
expectedToken(yytoken, Token_COLON, ":");
3669
}
3670
return false;
3671
}
3672
yylex();
3673
3674
InnerStatementListAst *__node_78 = 0;
3675
if (!parseInnerStatementList(&__node_78))
3676
{
3677
if (!mBlockErrors)
3678
{
3679
expectedSymbol(AstNode::InnerStatementListKind, "innerStatementList");
3680
}
3681
return false;
3682
}
3683
(*yynode)->statements = __node_78;
3684
3685
if (yytoken != Token_ENDDECLARE)
3686
{
3687
if (!mBlockErrors)
3688
{
3689
expectedToken(yytoken, Token_ENDDECLARE, "enddeclare");
3690
}
3691
return false;
3692
}
3693
yylex();
3694
3695
SemicolonOrCloseTagAst *__node_79 = 0;
3696
if (!parseSemicolonOrCloseTag(&__node_79))
3697
{
3698
if (!mBlockErrors)
3699
{
3700
expectedSymbol(AstNode::SemicolonOrCloseTagKind, "semicolonOrCloseTag");
3701
}
3702
return false;
3703
}
3704
}
3705
else
3706
{
3707
return false;
3708
}
3709
}
3710
else
3711
{
3712
return false;
3713
}
3714
3715
(*yynode)->endToken = tokenStream->index() - 2;
3716
3717
return true;
3718
}
3719
3720
bool Parser::parseDimListItem(DimListItemAst **yynode)
3721
{
3722
*yynode = create<DimListItemAst>();
3723
3724
(*yynode)->startToken = tokenStream->index() - 1;
3725
3726
if (yytoken == Token_LBRACE
3727
|| yytoken == Token_LBRACKET)
3728
{
3729
if (yytoken == Token_LBRACKET)
3730
{
3731
if (yytoken != Token_LBRACKET)
3732
{
3733
if (!mBlockErrors)
3734
{
3735
expectedToken(yytoken, Token_LBRACKET, "[");
3736
}
3737
return false;
3738
}
3739
yylex();
3740
3741
DimOffsetAst *__node_80 = 0;
3742
if (!parseDimOffset(&__node_80))
3743
{
3744
if (!mBlockErrors)
3745
{
3746
expectedSymbol(AstNode::DimOffsetKind, "dimOffset");
3747
}
3748
return false;
3749
}
3750
(*yynode)->dimOffset = __node_80;
3751
3752
if (yytoken != Token_RBRACKET)
3753
{
3754
if (!mBlockErrors)
3755
{
3756
expectedToken(yytoken, Token_RBRACKET, "]");
3757
}
3758
return false;
3759
}
3760
yylex();
3761
3762
}
3763
else if (yytoken == Token_LBRACE)
3764
{
3765
if (yytoken != Token_LBRACE)
3766
{
3767
if (!mBlockErrors)
3768
{
3769
expectedToken(yytoken, Token_LBRACE, "{");
3770
}
3771
return false;
3772
}
3773
yylex();
3774
3775
ExprAst *__node_81 = 0;
3776
if (!parseExpr(&__node_81))
3777
{
3778
if (!mBlockErrors)
3779
{
3780
expectedSymbol(AstNode::ExprKind, "expr");
3781
}
3782
return false;
3783
}
3784
(*yynode)->expr = __node_81;
3785
3786
if (yytoken != Token_RBRACE)
3787
{
3788
if (!mBlockErrors)
3789
{
3790
expectedToken(yytoken, Token_RBRACE, "}");
3791
}
3792
return false;
3793
}
3794
yylex();
3795
3796
}
3797
else
3798
{
3799
return false;
3800
}
3801
}
3802
else
3803
{
3804
return false;
3805
}
3806
3807
(*yynode)->endToken = tokenStream->index() - 2;
3808
3809
return true;
3810
}
3811
3812
bool Parser::parseDimOffset(DimOffsetAst **yynode)
3813
{
3814
*yynode = create<DimOffsetAst>();
3815
3816
(*yynode)->startToken = tokenStream->index() - 1;
3817
3818
if (yytoken == Token_ARRAY
3819
|| yytoken == Token_ARRAY_CAST
3820
|| yytoken == Token_AT
3821
|| yytoken == Token_BACKTICK
3822
|| yytoken == Token_BANG
3823
|| yytoken == Token_BOOL_CAST
3824
|| yytoken == Token_CLASS_C
3825
|| yytoken == Token_CLONE
3826
|| yytoken == Token_CONSTANT_ENCAPSED_STRING
3827
|| yytoken == Token_DEC
3828
|| yytoken == Token_DNUMBER
3829
|| yytoken == Token_DOLLAR
3830
|| yytoken == Token_DOUBLE_CAST
3831
|| yytoken == Token_DOUBLE_QUOTE
3832
|| yytoken == Token_EMPTY
3833
|| yytoken == Token_EVAL
3834
|| yytoken == Token_EXIT
3835
|| yytoken == Token_FILE
3836
|| yytoken == Token_FUNC_C
3837
|| yytoken == Token_INC
3838
|| yytoken == Token_INCLUDE
3839
|| yytoken == Token_INCLUDE_ONCE
3840
|| yytoken == Token_INT_CAST
3841
|| yytoken == Token_ISSET
3842
|| yytoken == Token_LINE
3843
|| yytoken == Token_LIST
3844
|| yytoken == Token_LNUMBER
3845
|| yytoken == Token_LPAREN
3846
|| yytoken == Token_METHOD_C
3847
|| yytoken == Token_MINUS
3848
|| yytoken == Token_NEW
3849
|| yytoken == Token_OBJECT_CAST
3850
|| yytoken == Token_PLUS
3851
|| yytoken == Token_PRINT
3852
|| yytoken == Token_REQUIRE
3853
|| yytoken == Token_REQUIRE_ONCE
3854
|| yytoken == Token_START_HEREDOC
3855
|| yytoken == Token_STRING
3856
|| yytoken == Token_STRING_CAST
3857
|| yytoken == Token_STRING_VARNAME
3858
|| yytoken == Token_TILDE
3859
|| yytoken == Token_UNSET_CAST
3860
|| yytoken == Token_VARIABLE || yytoken == Token_EOF
3861
|| yytoken == Token_RBRACKET)
3862
{
3863
if (yytoken == Token_ARRAY
3864
|| yytoken == Token_ARRAY_CAST
3865
|| yytoken == Token_AT
3866
|| yytoken == Token_BACKTICK
3867
|| yytoken == Token_BANG
3868
|| yytoken == Token_BOOL_CAST
3869
|| yytoken == Token_CLASS_C
3870
|| yytoken == Token_CLONE
3871
|| yytoken == Token_CONSTANT_ENCAPSED_STRING
3872
|| yytoken == Token_DEC
3873
|| yytoken == Token_DNUMBER
3874
|| yytoken == Token_DOLLAR
3875
|| yytoken == Token_DOUBLE_CAST
3876
|| yytoken == Token_DOUBLE_QUOTE
3877
|| yytoken == Token_EMPTY
3878
|| yytoken == Token_EVAL
3879
|| yytoken == Token_EXIT
3880
|| yytoken == Token_FILE
3881
|| yytoken == Token_FUNC_C
3882
|| yytoken == Token_INC
3883
|| yytoken == Token_INCLUDE
3884
|| yytoken == Token_INCLUDE_ONCE
3885
|| yytoken == Token_INT_CAST
3886
|| yytoken == Token_ISSET
3887
|| yytoken == Token_LINE
3888
|| yytoken == Token_LIST
3889
|| yytoken == Token_LNUMBER
3890
|| yytoken == Token_LPAREN
3891
|| yytoken == Token_METHOD_C
3892
|| yytoken == Token_MINUS
3893
|| yytoken == Token_NEW
3894
|| yytoken == Token_OBJECT_CAST
3895
|| yytoken == Token_PLUS
3896
|| yytoken == Token_PRINT
3897
|| yytoken == Token_REQUIRE
3898
|| yytoken == Token_REQUIRE_ONCE
3899
|| yytoken == Token_START_HEREDOC
3900
|| yytoken == Token_STRING
3901
|| yytoken == Token_STRING_CAST
3902
|| yytoken == Token_STRING_VARNAME
3903
|| yytoken == Token_TILDE
3904
|| yytoken == Token_UNSET_CAST
3905
|| yytoken == Token_VARIABLE)
3906
{
3907
ExprAst *__node_82 = 0;
3908
if (!parseExpr(&__node_82))
3909
{
3910
if (!mBlockErrors)
3911
{
3912
expectedSymbol(AstNode::ExprKind, "expr");
3913
}
3914
return false;
3915
}
3916
(*yynode)->expr = __node_82;
3917
3918
}
3919
else if (true /*epsilon*/)
3920
{
3921
}
3922
else
3923
{
3924
return false;
3925
}
3926
}
3927
else
3928
{
3929
return false;
3930
}
3931
3932
(*yynode)->endToken = tokenStream->index() - 2;
3933
3934
return true;
3935
}
3936
3937
bool Parser::parseDynamicClassNameReference(DynamicClassNameReferenceAst **yynode)
3938
{
3939
*yynode = create<DynamicClassNameReferenceAst>();
3940
3941
(*yynode)->startToken = tokenStream->index() - 1;
3942
3943
if (yytoken == Token_DOLLAR
3944
|| yytoken == Token_STRING
3945
|| yytoken == Token_VARIABLE)
3946
{
3947
BaseVariableAst *__node_83 = 0;
3948
if (!parseBaseVariable(&__node_83))
3949
{
3950
if (!mBlockErrors)
3951
{
3952
expectedSymbol(AstNode::BaseVariableKind, "baseVariable");
3953
}
3954
return false;
3955
}
3956
(*yynode)->baseVariable = __node_83;
3957
3958
if (yytoken == Token_OBJECT_OPERATOR)
3959
{
3960
if (yytoken != Token_OBJECT_OPERATOR)
3961
{
3962
if (!mBlockErrors)
3963
{
3964
expectedToken(yytoken, Token_OBJECT_OPERATOR, "->");
3965
}
3966
return false;
3967
}
3968
yylex();
3969
3970
ObjectPropertyAst *__node_84 = 0;
3971
if (!parseObjectProperty(&__node_84))
3972
{
3973
if (!mBlockErrors)
3974
{
3975
expectedSymbol(AstNode::ObjectPropertyKind, "objectProperty");
3976
}
3977
return false;
3978
}
3979
(*yynode)->objectProperty = __node_84;
3980
3981
DynamicClassNameVariablePropertiesAst *__node_85 = 0;
3982
if (!parseDynamicClassNameVariableProperties(&__node_85))
3983
{
3984
if (!mBlockErrors)
3985
{
3986
expectedSymbol(AstNode::DynamicClassNameVariablePropertiesKind, "dynamicClassNameVariableProperties");
3987
}
3988
return false;
3989
}
3990
(*yynode)->properties = __node_85;
3991
3992
}
3993
else if (true /*epsilon*/)
3994
{
3995
}
3996
else
3997
{
3998
return false;
3999
}
4000
}
4001
else
4002
{
4003
return false;
4004
}
4005
4006
(*yynode)->endToken = tokenStream->index() - 2;
4007
4008
return true;
4009
}
4010
4011
bool Parser::parseDynamicClassNameVariableProperties(DynamicClassNameVariablePropertiesAst **yynode)
4012
{
4013
*yynode = create<DynamicClassNameVariablePropertiesAst>();
4014
4015
(*yynode)->startToken = tokenStream->index() - 1;
4016
4017
if (yytoken == Token_OBJECT_OPERATOR || yytoken == Token_AND_ASSIGN
4018
|| yytoken == Token_AS
4019
|| yytoken == Token_ASSIGN
4020
|| yytoken == Token_BIT_AND
4021
|| yytoken == Token_BIT_OR
4022
|| yytoken == Token_BIT_XOR
4023
|| yytoken == Token_BOOLEAN_AND
4024
|| yytoken == Token_BOOLEAN_OR
4025
|| yytoken == Token_CLOSE_TAG
4026
|| yytoken == Token_COLON
4027
|| yytoken == Token_COMMA
4028
|| yytoken == Token_CONCAT
4029
|| yytoken == Token_CONCAT_ASSIGN
4030
|| yytoken == Token_DEC
4031
|| yytoken == Token_DIV
4032
|| yytoken == Token_DIV_ASSIGN
4033
|| yytoken == Token_DOUBLE_ARROW
4034
|| yytoken == Token_EOF
4035
|| yytoken == Token_INC
4036
|| yytoken == Token_INSTANCEOF
4037
|| yytoken == Token_IS_EQUAL
4038
|| yytoken == Token_IS_GREATER
4039
|| yytoken == Token_IS_GREATER_OR_EQUAL
4040
|| yytoken == Token_IS_IDENTICAL
4041
|| yytoken == Token_IS_NOT_EQUAL
4042
|| yytoken == Token_IS_NOT_IDENTICAL
4043
|| yytoken == Token_IS_SMALLER
4044
|| yytoken == Token_IS_SMALLER_OR_EQUAL
4045
|| yytoken == Token_LOGICAL_AND
4046
|| yytoken == Token_LOGICAL_OR
4047
|| yytoken == Token_LOGICAL_XOR
4048
|| yytoken == Token_LPAREN
4049
|| yytoken == Token_MINUS
4050
|| yytoken == Token_MINUS_ASSIGN
4051
|| yytoken == Token_MOD
4052
|| yytoken == Token_MOD_ASSIGN
4053
|| yytoken == Token_MUL
4054
|| yytoken == Token_MUL_ASSIGN
4055
|| yytoken == Token_OR_ASSIGN
4056
|| yytoken == Token_PLUS
4057
|| yytoken == Token_PLUS_ASSIGN
4058
|| yytoken == Token_QUESTION
4059
|| yytoken == Token_RBRACE
4060
|| yytoken == Token_RBRACKET
4061
|| yytoken == Token_RPAREN
4062
|| yytoken == Token_SEMICOLON
4063
|| yytoken == Token_SL
4064
|| yytoken == Token_SL_ASSIGN
4065
|| yytoken == Token_SR
4066
|| yytoken == Token_SR_ASSIGN
4067
|| yytoken == Token_XOR_ASSIGN)
4068
{
4069
while (yytoken == Token_OBJECT_OPERATOR)
4070
{
4071
DynamicClassNameVariablePropertyAst *__node_86 = 0;
4072
if (!parseDynamicClassNameVariableProperty(&__node_86))
4073
{
4074
if (!mBlockErrors)
4075
{
4076
expectedSymbol(AstNode::DynamicClassNameVariablePropertyKind, "dynamicClassNameVariableProperty");
4077
}
4078
return false;
4079
}
4080
(*yynode)->propertiesSequence = snoc((*yynode)->propertiesSequence, __node_86, memoryPool);
4081
4082
}
4083
}
4084
else
4085
{
4086
return false;
4087
}
4088
4089
(*yynode)->endToken = tokenStream->index() - 2;
4090
4091
return true;
4092
}
4093
4094
bool Parser::parseDynamicClassNameVariableProperty(DynamicClassNameVariablePropertyAst **yynode)
4095
{
4096
*yynode = create<DynamicClassNameVariablePropertyAst>();
4097
4098
(*yynode)->startToken = tokenStream->index() - 1;
4099
4100
if (yytoken == Token_OBJECT_OPERATOR)
4101
{
4102
if (yytoken != Token_OBJECT_OPERATOR)
4103
{
4104
if (!mBlockErrors)
4105
{
4106
expectedToken(yytoken, Token_OBJECT_OPERATOR, "->");
4107
}
4108
return false;
4109
}
4110
yylex();
4111
4112
ObjectPropertyAst *__node_87 = 0;
4113
if (!parseObjectProperty(&__node_87))
4114
{
4115
if (!mBlockErrors)
4116
{
4117
expectedSymbol(AstNode::ObjectPropertyKind, "objectProperty");
4118
}
4119
return false;
4120
}
4121
(*yynode)->property = __node_87;
4122
4123
}
4124
else
4125
{
4126
return false;
4127
}
4128
4129
(*yynode)->endToken = tokenStream->index() - 2;
4130
4131
return true;
4132
}
4133
4134
bool Parser::parseElseSingle(ElseSingleAst **yynode)
4135
{
4136
*yynode = create<ElseSingleAst>();
4137
4138
(*yynode)->startToken = tokenStream->index() - 1;
4139
4140
if (yytoken == Token_ELSE || yytoken == Token_ABSTRACT
4141
|| yytoken == Token_ARRAY
4142
|| yytoken == Token_ARRAY_CAST
4143
|| yytoken == Token_AT
4144
|| yytoken == Token_BACKTICK
4145
|| yytoken == Token_BANG
4146
|| yytoken == Token_BOOL_CAST
4147
|| yytoken == Token_BREAK
4148
|| yytoken == Token_CASE
4149
|| yytoken == Token_CLASS
4150
|| yytoken == Token_CLASS_C
4151
|| yytoken == Token_CLONE
4152
|| yytoken == Token_CLOSE_TAG
4153
|| yytoken == Token_CONSTANT_ENCAPSED_STRING
4154
|| yytoken == Token_CONTINUE
4155
|| yytoken == Token_DEC
4156
|| yytoken == Token_DECLARE
4157
|| yytoken == Token_DEFAULT
4158
|| yytoken == Token_DNUMBER
4159
|| yytoken == Token_DO
4160
|| yytoken == Token_DOLLAR
4161
|| yytoken == Token_DOUBLE_CAST
4162
|| yytoken == Token_DOUBLE_QUOTE
4163
|| yytoken == Token_ECHO
4164
|| yytoken == Token_ELSE
4165
|| yytoken == Token_ELSEIF
4166
|| yytoken == Token_EMPTY
4167
|| yytoken == Token_ENDDECLARE
4168
|| yytoken == Token_ENDFOR
4169
|| yytoken == Token_ENDFOREACH
4170
|| yytoken == Token_ENDIF
4171
|| yytoken == Token_ENDSWITCH
4172
|| yytoken == Token_ENDWHILE
4173
|| yytoken == Token_EOF
4174
|| yytoken == Token_EVAL
4175
|| yytoken == Token_EXIT
4176
|| yytoken == Token_FILE
4177
|| yytoken == Token_FINAL
4178
|| yytoken == Token_FOR
4179
|| yytoken == Token_FOREACH
4180
|| yytoken == Token_FUNCTION
4181
|| yytoken == Token_FUNC_C
4182
|| yytoken == Token_GLOBAL
4183
|| yytoken == Token_HALT_COMPILER
4184
|| yytoken == Token_IF
4185
|| yytoken == Token_INC
4186
|| yytoken == Token_INCLUDE
4187
|| yytoken == Token_INCLUDE_ONCE
4188
|| yytoken == Token_INLINE_HTML
4189
|| yytoken == Token_INTERFACE
4190
|| yytoken == Token_INT_CAST
4191
|| yytoken == Token_ISSET
4192
|| yytoken == Token_LBRACE
4193
|| yytoken == Token_LINE
4194
|| yytoken == Token_LIST
4195
|| yytoken == Token_LNUMBER
4196
|| yytoken == Token_LPAREN
4197
|| yytoken == Token_METHOD_C
4198
|| yytoken == Token_MINUS
4199
|| yytoken == Token_NEW
4200
|| yytoken == Token_OBJECT_CAST
4201
|| yytoken == Token_OPEN_TAG
4202
|| yytoken == Token_OPEN_TAG_WITH_ECHO
4203
|| yytoken == Token_PLUS
4204
|| yytoken == Token_PRINT
4205
|| yytoken == Token_RBRACE
4206
|| yytoken == Token_REQUIRE
4207
|| yytoken == Token_REQUIRE_ONCE
4208
|| yytoken == Token_RETURN
4209
|| yytoken == Token_SEMICOLON
4210
|| yytoken == Token_START_HEREDOC
4211
|| yytoken == Token_STATIC
4212
|| yytoken == Token_STRING
4213
|| yytoken == Token_STRING_CAST
4214
|| yytoken == Token_STRING_VARNAME
4215
|| yytoken == Token_SWITCH
4216
|| yytoken == Token_THROW
4217
|| yytoken == Token_TILDE
4218
|| yytoken == Token_TRY
4219
|| yytoken == Token_UNSET
4220
|| yytoken == Token_UNSET_CAST
4221
|| yytoken == Token_VARIABLE
4222
|| yytoken == Token_WHILE)
4223
{
4224
if (yytoken == Token_ELSE)
4225
{
4226
if (yytoken != Token_ELSE)
4227
{
4228
if (!mBlockErrors)
4229
{
4230
expectedToken(yytoken, Token_ELSE, "else");
4231
}
4232
return false;
4233
}
4234
yylex();
4235
4236
StatementAst *__node_88 = 0;
4237
if (!parseStatement(&__node_88))
4238
{
4239
if (!mBlockErrors)
4240
{
4241
expectedSymbol(AstNode::StatementKind, "statement");
4242
}
4243
return false;
4244
}
4245
(*yynode)->statement = __node_88;
4246
4247
}
4248
else if (true /*epsilon*/)
4249
{
4250
}
4251
else
4252
{
4253
return false;
4254
}
4255
}
4256
else
4257
{
4258
return false;
4259
}
4260
4261
(*yynode)->endToken = tokenStream->index() - 2;
4262
4263
return true;
4264
}
4265
4266
bool Parser::parseElseifList(ElseifListAst **yynode)
4267
{
4268
*yynode = create<ElseifListAst>();
4269
4270
(*yynode)->startToken = tokenStream->index() - 1;
4271
4272
if (yytoken == Token_ELSEIF || yytoken == Token_ABSTRACT
4273
|| yytoken == Token_ARRAY
4274
|| yytoken == Token_ARRAY_CAST
4275
|| yytoken == Token_AT
4276
|| yytoken == Token_BACKTICK
4277
|| yytoken == Token_BANG
4278
|| yytoken == Token_BOOL_CAST
4279
|| yytoken == Token_BREAK
4280
|| yytoken == Token_CASE
4281
|| yytoken == Token_CLASS
4282
|| yytoken == Token_CLASS_C
4283
|| yytoken == Token_CLONE
4284
|| yytoken == Token_CLOSE_TAG
4285
|| yytoken == Token_CONSTANT_ENCAPSED_STRING
4286
|| yytoken == Token_CONTINUE
4287
|| yytoken == Token_DEC
4288
|| yytoken == Token_DECLARE
4289
|| yytoken == Token_DEFAULT
4290
|| yytoken == Token_DNUMBER
4291
|| yytoken == Token_DO
4292
|| yytoken == Token_DOLLAR
4293
|| yytoken == Token_DOUBLE_CAST
4294
|| yytoken == Token_DOUBLE_QUOTE
4295
|| yytoken == Token_ECHO
4296
|| yytoken == Token_ELSE
4297
|| yytoken == Token_ELSEIF
4298
|| yytoken == Token_EMPTY
4299
|| yytoken == Token_ENDDECLARE
4300
|| yytoken == Token_ENDFOR
4301
|| yytoken == Token_ENDFOREACH
4302
|| yytoken == Token_ENDIF
4303
|| yytoken == Token_ENDSWITCH
4304
|| yytoken == Token_ENDWHILE
4305
|| yytoken == Token_EOF
4306
|| yytoken == Token_EVAL
4307
|| yytoken == Token_EXIT
4308
|| yytoken == Token_FILE
4309
|| yytoken == Token_FINAL
4310
|| yytoken == Token_FOR
4311
|| yytoken == Token_FOREACH
4312
|| yytoken == Token_FUNCTION
4313
|| yytoken == Token_FUNC_C
4314
|| yytoken == Token_GLOBAL
4315
|| yytoken == Token_HALT_COMPILER
4316
|| yytoken == Token_IF
4317
|| yytoken == Token_INC
4318
|| yytoken == Token_INCLUDE
4319
|| yytoken == Token_INCLUDE_ONCE
4320
|| yytoken == Token_INLINE_HTML
4321
|| yytoken == Token_INTERFACE
4322
|| yytoken == Token_INT_CAST
4323
|| yytoken == Token_ISSET
4324
|| yytoken == Token_LBRACE
4325
|| yytoken == Token_LINE
4326
|| yytoken == Token_LIST
4327
|| yytoken == Token_LNUMBER
4328
|| yytoken == Token_LPAREN
4329
|| yytoken == Token_METHOD_C
4330
|| yytoken == Token_MINUS
4331
|| yytoken == Token_NEW
4332
|| yytoken == Token_OBJECT_CAST
4333
|| yytoken == Token_OPEN_TAG
4334
|| yytoken == Token_OPEN_TAG_WITH_ECHO
4335
|| yytoken == Token_PLUS
4336
|| yytoken == Token_PRINT
4337
|| yytoken == Token_RBRACE
4338
|| yytoken == Token_REQUIRE
4339
|| yytoken == Token_REQUIRE_ONCE
4340
|| yytoken == Token_RETURN
4341
|| yytoken == Token_SEMICOLON
4342
|| yytoken == Token_START_HEREDOC
4343
|| yytoken == Token_STATIC
4344
|| yytoken == Token_STRING
4345
|| yytoken == Token_STRING_CAST
4346
|| yytoken == Token_STRING_VARNAME
4347
|| yytoken == Token_SWITCH
4348
|| yytoken == Token_THROW
4349
|| yytoken == Token_TILDE
4350
|| yytoken == Token_TRY
4351
|| yytoken == Token_UNSET
4352
|| yytoken == Token_UNSET_CAST
4353
|| yytoken == Token_VARIABLE
4354
|| yytoken == Token_WHILE)
4355
{
4356
while (yytoken == Token_ELSEIF)
4357
{
4358
ElseifListItemAst *__node_89 = 0;
4359
if (!parseElseifListItem(&__node_89))
4360
{
4361
if (!mBlockErrors)
4362
{
4363
expectedSymbol(AstNode::ElseifListItemKind, "elseifListItem");
4364
}
4365
return false;
4366
}
4367
(*yynode)->elseifListItemSequence = snoc((*yynode)->elseifListItemSequence, __node_89, memoryPool);
4368
4369
}
4370
}
4371
else
4372
{
4373
return false;
4374
}
4375
4376
(*yynode)->endToken = tokenStream->index() - 2;
4377
4378
return true;
4379
}
4380
4381
bool Parser::parseElseifListItem(ElseifListItemAst **yynode)
4382
{
4383
*yynode = create<ElseifListItemAst>();
4384
4385
(*yynode)->startToken = tokenStream->index() - 1;
4386
4387
if (yytoken == Token_ELSEIF)
4388
{
4389
if (yytoken != Token_ELSEIF)
4390
{
4391
if (!mBlockErrors)
4392
{
4393
expectedToken(yytoken, Token_ELSEIF, "elseif");
4394
}
4395
return false;
4396
}
4397
yylex();
4398
4399
if (yytoken != Token_LPAREN)
4400
{
4401
if (!mBlockErrors)
4402
{
4403
expectedToken(yytoken, Token_LPAREN, "(");
4404
}
4405
return false;
4406
}
4407
yylex();
4408
4409
ExprAst *__node_90 = 0;
4410
if (!parseExpr(&__node_90))
4411
{
4412
if (!mBlockErrors)
4413
{
4414
expectedSymbol(AstNode::ExprKind, "expr");
4415
}
4416
return false;
4417
}
4418
(*yynode)->expr = __node_90;
4419
4420
if (yytoken != Token_RPAREN)
4421
{
4422
if (!mBlockErrors)
4423
{
4424
expectedToken(yytoken, Token_RPAREN, ")");
4425
}
4426
return false;
4427
}
4428
yylex();
4429
4430
StatementAst *__node_91 = 0;
4431
if (!parseStatement(&__node_91))
4432
{
4433
if (!mBlockErrors)
4434
{
4435
expectedSymbol(AstNode::StatementKind, "statement");
4436
}
4437
return false;
4438
}
4439
(*yynode)->statement = __node_91;
4440
4441
}
4442
else
4443
{
4444
return false;
4445
}
4446
4447
(*yynode)->endToken = tokenStream->index() - 2;
4448
4449
return true;
4450
}
4451
4452
bool Parser::parseEncaps(EncapsAst **yynode)
4453
{
4454
*yynode = create<EncapsAst>();
4455
4456
(*yynode)->startToken = tokenStream->index() - 1;
4457
(*yynode)->value = -1;
4458
4459
if (yytoken == Token_CURLY_OPEN
4460
|| yytoken == Token_DOLLAR_OPEN_CURLY_BRACES
4461
|| yytoken == Token_ENCAPSED_AND_WHITESPACE
4462
|| yytoken == Token_VARIABLE)
4463
{
4464
if (yytoken == Token_CURLY_OPEN
4465
|| yytoken == Token_DOLLAR_OPEN_CURLY_BRACES
4466
|| yytoken == Token_VARIABLE)
4467
{
4468
EncapsVarAst *__node_92 = 0;
4469
if (!parseEncapsVar(&__node_92))
4470
{
4471
if (!mBlockErrors)
4472
{
4473
expectedSymbol(AstNode::EncapsVarKind, "encapsVar");
4474
}
4475
return false;
4476
}
4477
(*yynode)->var = __node_92;
4478
4479
}
4480
else if (yytoken == Token_ENCAPSED_AND_WHITESPACE)
4481
{
4482
if (yytoken != Token_ENCAPSED_AND_WHITESPACE)
4483
{
4484
if (!mBlockErrors)
4485
{
4486
expectedToken(yytoken, Token_ENCAPSED_AND_WHITESPACE, "encapsed and whitespace");
4487
}
4488
return false;
4489
}
4490
(*yynode)->value = tokenStream->index() - 1;
4491
yylex();
4492
4493
}
4494
else
4495
{
4496
return false;
4497
}
4498
}
4499
else
4500
{
4501
return false;
4502
}
4503
4504
(*yynode)->endToken = tokenStream->index() - 2;
4505
4506
return true;
4507
}
4508
4509
bool Parser::parseEncapsList(EncapsListAst **yynode)
4510
{
4511
*yynode = create<EncapsListAst>();
4512
4513
(*yynode)->startToken = tokenStream->index() - 1;
4514
4515
if (yytoken == Token_CURLY_OPEN
4516
|| yytoken == Token_DOLLAR_OPEN_CURLY_BRACES
4517
|| yytoken == Token_ENCAPSED_AND_WHITESPACE
4518
|| yytoken == Token_VARIABLE || yytoken == Token_BACKTICK
4519
|| yytoken == Token_DOUBLE_QUOTE
4520
|| yytoken == Token_END_HEREDOC
4521
|| yytoken == Token_EOF)
4522
{
4523
while (yytoken == Token_CURLY_OPEN
4524
|| yytoken == Token_DOLLAR_OPEN_CURLY_BRACES
4525
|| yytoken == Token_ENCAPSED_AND_WHITESPACE
4526
|| yytoken == Token_VARIABLE)
4527
{
4528
EncapsAst *__node_93 = 0;
4529
if (!parseEncaps(&__node_93))
4530
{
4531
if (!mBlockErrors)
4532
{
4533
expectedSymbol(AstNode::EncapsKind, "encaps");
4534
}
4535
return false;
4536
}
4537
(*yynode)->encapsSequence = snoc((*yynode)->encapsSequence, __node_93, memoryPool);
4538
4539
}
4540
}
4541
else
4542
{
4543
return false;
4544
}
4545
4546
(*yynode)->endToken = tokenStream->index() - 2;
4547
4548
return true;
4549
}
4550
4551
bool Parser::parseEncapsVar(EncapsVarAst **yynode)
4552
{
4553
*yynode = create<EncapsVarAst>();
4554
4555
(*yynode)->startToken = tokenStream->index() - 1;
4556
4557
if (yytoken == Token_CURLY_OPEN
4558
|| yytoken == Token_DOLLAR_OPEN_CURLY_BRACES
4559
|| yytoken == Token_VARIABLE)
4560
{
4561
if (yytoken == Token_DOLLAR_OPEN_CURLY_BRACES)
4562
{
4563
if (yytoken != Token_DOLLAR_OPEN_CURLY_BRACES)
4564
{
4565
if (!mBlockErrors)
4566
{
4567
expectedToken(yytoken, Token_DOLLAR_OPEN_CURLY_BRACES, "${");
4568
}
4569
return false;
4570
}
4571
yylex();
4572
4573
if ((yytoken == Token_STRING_VARNAME) && ( LA(2).kind == Token_LBRACKET))
4574
{
4575
if (yytoken != Token_STRING_VARNAME)
4576
{
4577
if (!mBlockErrors)
4578
{
4579
expectedToken(yytoken, Token_STRING_VARNAME, "string varname");
4580
}
4581
return false;
4582
}
4583
yylex();
4584
4585
if (yytoken != Token_LBRACKET)
4586
{
4587
if (!mBlockErrors)
4588
{
4589
expectedToken(yytoken, Token_LBRACKET, "[");
4590
}
4591
return false;
4592
}
4593
yylex();
4594
4595
ExprAst *__node_94 = 0;
4596
if (!parseExpr(&__node_94))
4597
{
4598
if (!mBlockErrors)
4599
{
4600
expectedSymbol(AstNode::ExprKind, "expr");
4601
}
4602
return false;
4603
}
4604
(*yynode)->expr = __node_94;
4605
4606
if (yytoken != Token_RBRACKET)
4607
{
4608
if (!mBlockErrors)
4609
{
4610
expectedToken(yytoken, Token_RBRACKET, "]");
4611
}
4612
return false;
4613
}
4614
yylex();
4615
4616
if (yytoken != Token_RBRACE)
4617
{
4618
if (!mBlockErrors)
4619
{
4620
expectedToken(yytoken, Token_RBRACE, "}");
4621
}
4622
return false;
4623
}
4624
yylex();
4625
4626
}
4627
else if (yytoken == Token_ARRAY
4628
|| yytoken == Token_ARRAY_CAST
4629
|| yytoken == Token_AT
4630
|| yytoken == Token_BACKTICK
4631
|| yytoken == Token_BANG
4632
|| yytoken == Token_BOOL_CAST
4633
|| yytoken == Token_CLASS_C
4634
|| yytoken == Token_CLONE
4635
|| yytoken == Token_CONSTANT_ENCAPSED_STRING
4636
|| yytoken == Token_DEC
4637
|| yytoken == Token_DNUMBER
4638
|| yytoken == Token_DOLLAR
4639
|| yytoken == Token_DOUBLE_CAST
4640
|| yytoken == Token_DOUBLE_QUOTE
4641
|| yytoken == Token_EMPTY
4642
|| yytoken == Token_EVAL
4643
|| yytoken == Token_EXIT
4644
|| yytoken == Token_FILE
4645
|| yytoken == Token_FUNC_C
4646
|| yytoken == Token_INC
4647
|| yytoken == Token_INCLUDE
4648
|| yytoken == Token_INCLUDE_ONCE
4649
|| yytoken == Token_INT_CAST
4650
|| yytoken == Token_ISSET
4651
|| yytoken == Token_LINE
4652
|| yytoken == Token_LIST
4653
|| yytoken == Token_LNUMBER
4654
|| yytoken == Token_LPAREN
4655
|| yytoken == Token_METHOD_C
4656
|| yytoken == Token_MINUS
4657
|| yytoken == Token_NEW
4658
|| yytoken == Token_OBJECT_CAST
4659
|| yytoken == Token_PLUS
4660
|| yytoken == Token_PRINT
4661
|| yytoken == Token_REQUIRE
4662
|| yytoken == Token_REQUIRE_ONCE
4663
|| yytoken == Token_START_HEREDOC
4664
|| yytoken == Token_STRING
4665
|| yytoken == Token_STRING_CAST
4666
|| yytoken == Token_STRING_VARNAME
4667
|| yytoken == Token_TILDE
4668
|| yytoken == Token_UNSET_CAST
4669
|| yytoken == Token_VARIABLE)
4670
{
4671
ExprAst *__node_95 = 0;
4672
if (!parseExpr(&__node_95))
4673
{
4674
if (!mBlockErrors)
4675
{
4676
expectedSymbol(AstNode::ExprKind, "expr");
4677
}
4678
return false;
4679
}
4680
(*yynode)->expr = __node_95;
4681
4682
if (yytoken != Token_RBRACE)
4683
{
4684
if (!mBlockErrors)
4685
{
4686
expectedToken(yytoken, Token_RBRACE, "}");
4687
}
4688
return false;
4689
}
4690
yylex();
4691
4692
}
4693
else
4694
{
4695
return false;
4696
}
4697
}
4698
else if (yytoken == Token_VARIABLE)
4699
{
4700
VariableIdentifierAst *__node_96 = 0;
4701
if (!parseVariableIdentifier(&__node_96))
4702
{
4703
if (!mBlockErrors)
4704
{
4705
expectedSymbol(AstNode::VariableIdentifierKind, "variableIdentifier");
4706
}
4707
return false;
4708
}
4709
(*yynode)->variable = __node_96;
4710
4711
if (yytoken == Token_OBJECT_OPERATOR)
4712
{
4713
if (yytoken != Token_OBJECT_OPERATOR)
4714
{
4715
if (!mBlockErrors)
4716
{
4717
expectedToken(yytoken, Token_OBJECT_OPERATOR, "->");
4718
}
4719
return false;
4720
}
4721
yylex();
4722
4723
IdentifierAst *__node_97 = 0;
4724
if (!parseIdentifier(&__node_97))
4725
{
4726
if (!mBlockErrors)
4727
{
4728
expectedSymbol(AstNode::IdentifierKind, "identifier");
4729
}
4730
return false;
4731
}
4732
(*yynode)->propertyIdentifier = __node_97;
4733
4734
}
4735
else if (yytoken == Token_LBRACKET)
4736
{
4737
if (yytoken != Token_LBRACKET)
4738
{
4739
if (!mBlockErrors)
4740
{
4741
expectedToken(yytoken, Token_LBRACKET, "[");
4742
}
4743
return false;
4744
}
4745
yylex();
4746
4747
EncapsVarOffsetAst *__node_98 = 0;
4748
if (!parseEncapsVarOffset(&__node_98))
4749
{
4750
if (!mBlockErrors)
4751
{
4752
expectedSymbol(AstNode::EncapsVarOffsetKind, "encapsVarOffset");
4753
}
4754
return false;
4755
}
4756
(*yynode)->offset = __node_98;
4757
4758
if (yytoken != Token_RBRACKET)
4759
{
4760
if (!mBlockErrors)
4761
{
4762
expectedToken(yytoken, Token_RBRACKET, "]");
4763
}
4764
return false;
4765
}
4766
yylex();
4767
4768
}
4769
else if (true /*epsilon*/)
4770
{
4771
}
4772
else
4773
{
4774
return false;
4775
}
4776
}
4777
else if (yytoken == Token_CURLY_OPEN)
4778
{
4779
if (yytoken != Token_CURLY_OPEN)
4780
{
4781
if (!mBlockErrors)
4782
{
4783
expectedToken(yytoken, Token_CURLY_OPEN, "curly open");
4784
}
4785
return false;
4786
}
4787
yylex();
4788
4789
ExprAst *__node_99 = 0;
4790
if (!parseExpr(&__node_99))
4791
{
4792
if (!mBlockErrors)
4793
{
4794
expectedSymbol(AstNode::ExprKind, "expr");
4795
}
4796
return false;
4797
}
4798
(*yynode)->expr = __node_99;
4799
4800
if (yytoken != Token_RBRACE)
4801
{
4802
if (!mBlockErrors)
4803
{
4804
expectedToken(yytoken, Token_RBRACE, "}");
4805
}
4806
return false;
4807
}
4808
yylex();
4809
4810
}
4811
else
4812
{
4813
return false;
4814
}
4815
}
4816
else
4817
{
4818
return false;
4819
}
4820
4821
(*yynode)->endToken = tokenStream->index() - 2;
4822
4823
return true;
4824
}
4825
4826
bool Parser::parseEncapsVarOffset(EncapsVarOffsetAst **yynode)
4827
{
4828
*yynode = create<EncapsVarOffsetAst>();
4829
4830
(*yynode)->startToken = tokenStream->index() - 1;
4831
4832
if (yytoken == Token_NUM_STRING
4833
|| yytoken == Token_STRING
4834
|| yytoken == Token_VARIABLE)
4835
{
4836
if (yytoken == Token_STRING)
4837
{
4838
if (yytoken != Token_STRING)
4839
{
4840
if (!mBlockErrors)
4841
{
4842
expectedToken(yytoken, Token_STRING, "string");
4843
}
4844
return false;
4845
}
4846
yylex();
4847
4848
}
4849
else if (yytoken == Token_NUM_STRING)
4850
{
4851
if (yytoken != Token_NUM_STRING)
4852
{
4853
if (!mBlockErrors)
4854
{
4855
expectedToken(yytoken, Token_NUM_STRING, "num string");
4856
}
4857
return false;
4858
}
4859
yylex();
4860
4861
}
4862
else if (yytoken == Token_VARIABLE)
4863
{
4864
VariableIdentifierAst *__node_100 = 0;
4865
if (!parseVariableIdentifier(&__node_100))
4866
{
4867
if (!mBlockErrors)
4868
{
4869
expectedSymbol(AstNode::VariableIdentifierKind, "variableIdentifier");
4870
}
4871
return false;
4872
}
4873
}
4874
else
4875
{
4876
return false;
4877
}
4878
}
4879
else
4880
{
4881
return false;
4882
}
4883
4884
(*yynode)->endToken = tokenStream->index() - 2;
4885
4886
return true;
4887
}
4888
4889
bool Parser::parseEqualityExpression(EqualityExpressionAst **yynode)
4890
{
4891
*yynode = create<EqualityExpressionAst>();
4892
4893
(*yynode)->startToken = tokenStream->index() - 1;
4894
4895
if (yytoken == Token_ARRAY
4896
|| yytoken == Token_ARRAY_CAST
4897
|| yytoken == Token_AT
4898
|| yytoken == Token_BACKTICK
4899
|| yytoken == Token_BANG
4900
|| yytoken == Token_BOOL_CAST
4901
|| yytoken == Token_CLASS_C
4902
|| yytoken == Token_CLONE
4903
|| yytoken == Token_CONSTANT_ENCAPSED_STRING
4904
|| yytoken == Token_DEC
4905
|| yytoken == Token_DNUMBER
4906
|| yytoken == Token_DOLLAR
4907
|| yytoken == Token_DOUBLE_CAST
4908
|| yytoken == Token_DOUBLE_QUOTE
4909
|| yytoken == Token_EMPTY
4910
|| yytoken == Token_EVAL
4911
|| yytoken == Token_EXIT
4912
|| yytoken == Token_FILE
4913
|| yytoken == Token_FUNC_C
4914
|| yytoken == Token_INC
4915
|| yytoken == Token_INCLUDE
4916
|| yytoken == Token_INCLUDE_ONCE
4917
|| yytoken == Token_INT_CAST
4918
|| yytoken == Token_ISSET
4919
|| yytoken == Token_LINE
4920
|| yytoken == Token_LIST
4921
|| yytoken == Token_LNUMBER
4922
|| yytoken == Token_LPAREN
4923
|| yytoken == Token_METHOD_C
4924
|| yytoken == Token_MINUS
4925
|| yytoken == Token_NEW
4926
|| yytoken == Token_OBJECT_CAST
4927
|| yytoken == Token_PLUS
4928
|| yytoken == Token_REQUIRE
4929
|| yytoken == Token_REQUIRE_ONCE
4930
|| yytoken == Token_START_HEREDOC
4931
|| yytoken == Token_STRING
4932
|| yytoken == Token_STRING_CAST
4933
|| yytoken == Token_STRING_VARNAME
4934
|| yytoken == Token_TILDE
4935
|| yytoken == Token_UNSET_CAST
4936
|| yytoken == Token_VARIABLE)
4937
{
4938
RelationalExpressionAst *__node_101 = 0;
4939
if (!parseRelationalExpression(&__node_101))
4940
{
4941
if (!mBlockErrors)
4942
{
4943
expectedSymbol(AstNode::RelationalExpressionKind, "relationalExpression");
4944
}
4945
return false;
4946
}
4947
(*yynode)->expression = __node_101;
4948
4949
while (yytoken == Token_IS_EQUAL
4950
|| yytoken == Token_IS_IDENTICAL
4951
|| yytoken == Token_IS_NOT_EQUAL
4952
|| yytoken == Token_IS_NOT_IDENTICAL)
4953
{
4954
EqualityExpressionRestAst *__node_102 = 0;
4955
if (!parseEqualityExpressionRest(&__node_102))
4956
{
4957
if (!mBlockErrors)
4958
{
4959
expectedSymbol(AstNode::EqualityExpressionRestKind, "equalityExpressionRest");
4960
}
4961
return false;
4962
}
4963
(*yynode)->additionalExpressionSequence = snoc((*yynode)->additionalExpressionSequence, __node_102, memoryPool);
4964
4965
}
4966
}
4967
else
4968
{
4969
return false;
4970
}
4971
4972
(*yynode)->endToken = tokenStream->index() - 2;
4973
4974
return true;
4975
}
4976
4977
bool Parser::parseEqualityExpressionRest(EqualityExpressionRestAst **yynode)
4978
{
4979
*yynode = create<EqualityExpressionRestAst>();
4980
4981
(*yynode)->startToken = tokenStream->index() - 1;
4982
4983
if (yytoken == Token_IS_EQUAL
4984
|| yytoken == Token_IS_IDENTICAL
4985
|| yytoken == Token_IS_NOT_EQUAL
4986
|| yytoken == Token_IS_NOT_IDENTICAL)
4987
{
4988
if (yytoken == Token_IS_EQUAL)
4989
{
4990
if (yytoken != Token_IS_EQUAL)
4991
{
4992
if (!mBlockErrors)
4993
{
4994
expectedToken(yytoken, Token_IS_EQUAL, "==");
4995
}
4996
return false;
4997
}
4998
yylex();
4999
5000
}
5001
else if (yytoken == Token_IS_NOT_EQUAL)
5002
{
5003
if (yytoken != Token_IS_NOT_EQUAL)
5004
{
5005
if (!mBlockErrors)
5006
{
5007
expectedToken(yytoken, Token_IS_NOT_EQUAL, "!=");
5008
}
5009
return false;
5010
}
5011
yylex();
5012
5013
}
5014
else if (yytoken == Token_IS_IDENTICAL)
5015
{
5016
if (yytoken != Token_IS_IDENTICAL)
5017
{
5018
if (!mBlockErrors)
5019
{
5020
expectedToken(yytoken, Token_IS_IDENTICAL, "===");
5021
}
5022
return false;
5023
}
5024
yylex();
5025
5026
}
5027
else if (yytoken == Token_IS_NOT_IDENTICAL)
5028
{
5029
if (yytoken != Token_IS_NOT_IDENTICAL)
5030
{
5031
if (!mBlockErrors)
5032
{
5033
expectedToken(yytoken, Token_IS_NOT_IDENTICAL, "!==");
5034
}
5035
return false;
5036
}
5037
yylex();
5038
5039
}
5040
else
5041
{
5042
return false;
5043
}
5044
RelationalExpressionAst *__node_103 = 0;
5045
if (!parseRelationalExpression(&__node_103))
5046
{
5047
if (!mBlockErrors)
5048
{
5049
expectedSymbol(AstNode::RelationalExpressionKind, "relationalExpression");
5050
}
5051
return false;
5052
}
5053
(*yynode)->expression = __node_103;
5054
5055
}
5056
else
5057
{
5058
return false;
5059
}
5060
5061
(*yynode)->endToken = tokenStream->index() - 2;
5062
5063
return true;
5064
}
5065
5066
bool Parser::parseExpr(ExprAst **yynode)
5067
{
5068
*yynode = create<ExprAst>();
5069
5070
(*yynode)->startToken = tokenStream->index() - 1;
5071
5072
if (yytoken == Token_ARRAY
5073
|| yytoken == Token_ARRAY_CAST
5074
|| yytoken == Token_AT
5075
|| yytoken == Token_BACKTICK
5076
|| yytoken == Token_BANG
5077
|| yytoken == Token_BOOL_CAST
5078
|| yytoken == Token_CLASS_C
5079
|| yytoken == Token_CLONE
5080
|| yytoken == Token_CONSTANT_ENCAPSED_STRING
5081
|| yytoken == Token_DEC
5082
|| yytoken == Token_DNUMBER
5083
|| yytoken == Token_DOLLAR
5084
|| yytoken == Token_DOUBLE_CAST
5085
|| yytoken == Token_DOUBLE_QUOTE
5086
|| yytoken == Token_EMPTY
5087
|| yytoken == Token_EVAL
5088
|| yytoken == Token_EXIT
5089
|| yytoken == Token_FILE
5090
|| yytoken == Token_FUNC_C
5091
|| yytoken == Token_INC
5092
|| yytoken == Token_INCLUDE
5093
|| yytoken == Token_INCLUDE_ONCE
5094
|| yytoken == Token_INT_CAST
5095
|| yytoken == Token_ISSET
5096
|| yytoken == Token_LINE
5097
|| yytoken == Token_LIST
5098
|| yytoken == Token_LNUMBER
5099
|| yytoken == Token_LPAREN
5100
|| yytoken == Token_METHOD_C
5101
|| yytoken == Token_MINUS
5102
|| yytoken == Token_NEW
5103
|| yytoken == Token_OBJECT_CAST
5104
|| yytoken == Token_PLUS
5105
|| yytoken == Token_PRINT
5106
|| yytoken == Token_REQUIRE
5107
|| yytoken == Token_REQUIRE_ONCE
5108
|| yytoken == Token_START_HEREDOC
5109
|| yytoken == Token_STRING
5110
|| yytoken == Token_STRING_CAST
5111
|| yytoken == Token_STRING_VARNAME
5112
|| yytoken == Token_TILDE
5113
|| yytoken == Token_UNSET_CAST
5114
|| yytoken == Token_VARIABLE)
5115
{
5116
LogicalOrExpressionAst *__node_104 = 0;
5117
if (!parseLogicalOrExpression(&__node_104))
5118
{
5119
if (!mBlockErrors)
5120
{
5121
expectedSymbol(AstNode::LogicalOrExpressionKind, "logicalOrExpression");
5122
}
5123
return false;
5124
}
5125
(*yynode)->expression = __node_104;
5126
5127
}
5128
else
5129
{
5130
return false;
5131
}
5132
5133
(*yynode)->endToken = tokenStream->index() - 2;
5134
5135
return true;
5136
}
5137
5138
bool Parser::parseForExpr(ForExprAst **yynode)
5139
{
5140
*yynode = create<ForExprAst>();
5141
5142
(*yynode)->startToken = tokenStream->index() - 1;
5143
5144
if (yytoken == Token_ARRAY
5145
|| yytoken == Token_ARRAY_CAST
5146
|| yytoken == Token_AT
5147
|| yytoken == Token_BACKTICK
5148
|| yytoken == Token_BANG
5149
|| yytoken == Token_BOOL_CAST
5150
|| yytoken == Token_CLASS_C
5151
|| yytoken == Token_CLONE
5152
|| yytoken == Token_CONSTANT_ENCAPSED_STRING
5153
|| yytoken == Token_DEC
5154
|| yytoken == Token_DNUMBER
5155
|| yytoken == Token_DOLLAR
5156
|| yytoken == Token_DOUBLE_CAST
5157
|| yytoken == Token_DOUBLE_QUOTE
5158
|| yytoken == Token_EMPTY
5159
|| yytoken == Token_EVAL
5160
|| yytoken == Token_EXIT
5161
|| yytoken == Token_FILE
5162
|| yytoken == Token_FUNC_C
5163
|| yytoken == Token_INC
5164
|| yytoken == Token_INCLUDE
5165
|| yytoken == Token_INCLUDE_ONCE
5166
|| yytoken == Token_INT_CAST
5167
|| yytoken == Token_ISSET
5168
|| yytoken == Token_LINE
5169
|| yytoken == Token_LIST
5170
|| yytoken == Token_LNUMBER
5171
|| yytoken == Token_LPAREN
5172
|| yytoken == Token_METHOD_C
5173
|| yytoken == Token_MINUS
5174
|| yytoken == Token_NEW
5175
|| yytoken == Token_OBJECT_CAST
5176
|| yytoken == Token_PLUS
5177
|| yytoken == Token_PRINT
5178
|| yytoken == Token_REQUIRE
5179
|| yytoken == Token_REQUIRE_ONCE
5180
|| yytoken == Token_START_HEREDOC
5181
|| yytoken == Token_STRING
5182
|| yytoken == Token_STRING_CAST
5183
|| yytoken == Token_STRING_VARNAME
5184
|| yytoken == Token_TILDE
5185
|| yytoken == Token_UNSET_CAST
5186
|| yytoken == Token_VARIABLE || yytoken == Token_EOF
5187
|| yytoken == Token_RPAREN
5188
|| yytoken == Token_SEMICOLON)
5189
{
5190
if (yytoken == Token_ARRAY
5191
|| yytoken == Token_ARRAY_CAST
5192
|| yytoken == Token_AT
5193
|| yytoken == Token_BACKTICK
5194
|| yytoken == Token_BANG
5195
|| yytoken == Token_BOOL_CAST
5196
|| yytoken == Token_CLASS_C
5197
|| yytoken == Token_CLONE
5198
|| yytoken == Token_CONSTANT_ENCAPSED_STRING
5199
|| yytoken == Token_DEC
5200
|| yytoken == Token_DNUMBER
5201
|| yytoken == Token_DOLLAR
5202
|| yytoken == Token_DOUBLE_CAST
5203
|| yytoken == Token_DOUBLE_QUOTE
5204
|| yytoken == Token_EMPTY
5205
|| yytoken == Token_EVAL
5206
|| yytoken == Token_EXIT
5207
|| yytoken == Token_FILE
5208
|| yytoken == Token_FUNC_C
5209
|| yytoken == Token_INC
5210
|| yytoken == Token_INCLUDE
5211
|| yytoken == Token_INCLUDE_ONCE
5212
|| yytoken == Token_INT_CAST
5213
|| yytoken == Token_ISSET
5214
|| yytoken == Token_LINE
5215
|| yytoken == Token_LIST
5216
|| yytoken == Token_LNUMBER
5217
|| yytoken == Token_LPAREN
5218
|| yytoken == Token_METHOD_C
5219
|| yytoken == Token_MINUS
5220
|| yytoken == Token_NEW
5221
|| yytoken == Token_OBJECT_CAST
5222
|| yytoken == Token_PLUS
5223
|| yytoken == Token_PRINT
5224
|| yytoken == Token_REQUIRE
5225
|| yytoken == Token_REQUIRE_ONCE
5226
|| yytoken == Token_START_HEREDOC
5227
|| yytoken == Token_STRING
5228
|| yytoken == Token_STRING_CAST
5229
|| yytoken == Token_STRING_VARNAME
5230
|| yytoken == Token_TILDE
5231
|| yytoken == Token_UNSET_CAST
5232
|| yytoken == Token_VARIABLE)
5233
{
5234
ExprAst *__node_105 = 0;
5235
if (!parseExpr(&__node_105))
5236
{
5237
if (!mBlockErrors)
5238
{
5239
expectedSymbol(AstNode::ExprKind, "expr");
5240
}
5241
return false;
5242
}
5243
(*yynode)->exprsSequence = snoc((*yynode)->exprsSequence, __node_105, memoryPool);
5244
5245
while (yytoken == Token_COMMA)
5246
{
5247
if (yytoken != Token_COMMA)
5248
{
5249
if (!mBlockErrors)
5250
{
5251
expectedToken(yytoken, Token_COMMA, ",");
5252
}
5253
return false;
5254
}
5255
yylex();
5256
5257
ExprAst *__node_106 = 0;
5258
if (!parseExpr(&__node_106))
5259
{
5260
if (!mBlockErrors)
5261
{
5262
expectedSymbol(AstNode::ExprKind, "expr");
5263
}
5264
return false;
5265
}
5266
(*yynode)->exprsSequence = snoc((*yynode)->exprsSequence, __node_106, memoryPool);
5267
5268
}
5269
}
5270
else if (true /*epsilon*/)
5271
{
5272
}
5273
else
5274
{
5275
return false;
5276
}
5277
}
5278
else
5279
{
5280
return false;
5281
}
5282
5283
(*yynode)->endToken = tokenStream->index() - 2;
5284
5285
return true;
5286
}
5287
5288
bool Parser::parseForStatement(ForStatementAst **yynode)
5289
{
5290
*yynode = create<ForStatementAst>();
5291
5292
(*yynode)->startToken = tokenStream->index() - 1;
5293
5294
if (yytoken == Token_ARRAY
5295
|| yytoken == Token_ARRAY_CAST
5296
|| yytoken == Token_AT
5297
|| yytoken == Token_BACKTICK
5298
|| yytoken == Token_BANG
5299
|| yytoken == Token_BOOL_CAST
5300
|| yytoken == Token_BREAK
5301
|| yytoken == Token_CLASS_C
5302
|| yytoken == Token_CLONE
5303
|| yytoken == Token_CLOSE_TAG
5304
|| yytoken == Token_COLON
5305
|| yytoken == Token_CONSTANT_ENCAPSED_STRING
5306
|| yytoken == Token_CONTINUE
5307
|| yytoken == Token_DEC
5308
|| yytoken == Token_DECLARE
5309
|| yytoken == Token_DNUMBER
5310
|| yytoken == Token_DO
5311
|| yytoken == Token_DOLLAR
5312
|| yytoken == Token_DOUBLE_CAST
5313
|| yytoken == Token_DOUBLE_QUOTE
5314
|| yytoken == Token_ECHO
5315
|| yytoken == Token_EMPTY
5316
|| yytoken == Token_EVAL
5317
|| yytoken == Token_EXIT
5318
|| yytoken == Token_FILE
5319
|| yytoken == Token_FOR
5320
|| yytoken == Token_FOREACH
5321
|| yytoken == Token_FUNC_C
5322
|| yytoken == Token_GLOBAL
5323
|| yytoken == Token_IF
5324
|| yytoken == Token_INC
5325
|| yytoken == Token_INCLUDE
5326
|| yytoken == Token_INCLUDE_ONCE
5327
|| yytoken == Token_INLINE_HTML
5328
|| yytoken == Token_INT_CAST
5329
|| yytoken == Token_ISSET
5330
|| yytoken == Token_LBRACE
5331
|| yytoken == Token_LINE
5332
|| yytoken == Token_LIST
5333
|| yytoken == Token_LNUMBER
5334
|| yytoken == Token_LPAREN
5335
|| yytoken == Token_METHOD_C
5336
|| yytoken == Token_MINUS
5337
|| yytoken == Token_NEW
5338
|| yytoken == Token_OBJECT_CAST
5339
|| yytoken == Token_OPEN_TAG
5340
|| yytoken == Token_OPEN_TAG_WITH_ECHO
5341
|| yytoken == Token_PLUS
5342
|| yytoken == Token_PRINT
5343
|| yytoken == Token_REQUIRE
5344
|| yytoken == Token_REQUIRE_ONCE
5345
|| yytoken == Token_RETURN
5346
|| yytoken == Token_SEMICOLON
5347
|| yytoken == Token_START_HEREDOC
5348
|| yytoken == Token_STATIC
5349
|| yytoken == Token_STRING
5350
|| yytoken == Token_STRING_CAST
5351
|| yytoken == Token_STRING_VARNAME
5352
|| yytoken == Token_SWITCH
5353
|| yytoken == Token_THROW
5354
|| yytoken == Token_TILDE
5355
|| yytoken == Token_TRY
5356
|| yytoken == Token_UNSET
5357
|| yytoken == Token_UNSET_CAST
5358
|| yytoken == Token_VARIABLE
5359
|| yytoken == Token_WHILE)
5360
{
5361
if (yytoken == Token_ARRAY
5362
|| yytoken == Token_ARRAY_CAST
5363
|| yytoken == Token_AT
5364
|| yytoken == Token_BACKTICK
5365
|| yytoken == Token_BANG
5366
|| yytoken == Token_BOOL_CAST
5367
|| yytoken == Token_BREAK
5368
|| yytoken == Token_CLASS_C
5369
|| yytoken == Token_CLONE
5370
|| yytoken == Token_CLOSE_TAG
5371
|| yytoken == Token_CONSTANT_ENCAPSED_STRING
5372
|| yytoken == Token_CONTINUE
5373
|| yytoken == Token_DEC
5374
|| yytoken == Token_DECLARE
5375
|| yytoken == Token_DNUMBER
5376
|| yytoken == Token_DO
5377
|| yytoken == Token_DOLLAR
5378
|| yytoken == Token_DOUBLE_CAST
5379
|| yytoken == Token_DOUBLE_QUOTE
5380
|| yytoken == Token_ECHO
5381
|| yytoken == Token_EMPTY
5382
|| yytoken == Token_EVAL
5383
|| yytoken == Token_EXIT
5384
|| yytoken == Token_FILE
5385
|| yytoken == Token_FOR
5386
|| yytoken == Token_FOREACH
5387
|| yytoken == Token_FUNC_C
5388
|| yytoken == Token_GLOBAL
5389
|| yytoken == Token_IF
5390
|| yytoken == Token_INC
5391
|| yytoken == Token_INCLUDE
5392
|| yytoken == Token_INCLUDE_ONCE
5393
|| yytoken == Token_INLINE_HTML
5394
|| yytoken == Token_INT_CAST
5395
|| yytoken == Token_ISSET
5396
|| yytoken == Token_LBRACE
5397
|| yytoken == Token_LINE
5398
|| yytoken == Token_LIST
5399
|| yytoken == Token_LNUMBER
5400
|| yytoken == Token_LPAREN
5401
|| yytoken == Token_METHOD_C
5402
|| yytoken == Token_MINUS
5403
|| yytoken == Token_NEW
5404
|| yytoken == Token_OBJECT_CAST
5405
|| yytoken == Token_OPEN_TAG
5406
|| yytoken == Token_OPEN_TAG_WITH_ECHO
5407
|| yytoken == Token_PLUS
5408
|| yytoken == Token_PRINT
5409
|| yytoken == Token_REQUIRE
5410
|| yytoken == Token_REQUIRE_ONCE
5411
|| yytoken == Token_RETURN
5412
|| yytoken == Token_SEMICOLON
5413
|| yytoken == Token_START_HEREDOC
5414
|| yytoken == Token_STATIC
5415
|| yytoken == Token_STRING
5416
|| yytoken == Token_STRING_CAST
5417
|| yytoken == Token_STRING_VARNAME
5418
|| yytoken == Token_SWITCH
5419
|| yytoken == Token_THROW
5420
|| yytoken == Token_TILDE
5421
|| yytoken == Token_TRY
5422
|| yytoken == Token_UNSET
5423
|| yytoken == Token_UNSET_CAST
5424
|| yytoken == Token_VARIABLE
5425
|| yytoken == Token_WHILE)
5426
{
5427
StatementAst *__node_107 = 0;
5428
if (!parseStatement(&__node_107))
5429
{
5430
if (!mBlockErrors)
5431
{
5432
expectedSymbol(AstNode::StatementKind, "statement");
5433
}
5434
return false;
5435
}
5436
(*yynode)->statement = __node_107;
5437
5438
}
5439
else if (yytoken == Token_COLON)
5440
{
5441
if (yytoken != Token_COLON)
5442
{
5443
if (!mBlockErrors)
5444
{
5445
expectedToken(yytoken, Token_COLON, ":");
5446
}
5447
return false;
5448
}
5449
yylex();
5450
5451
InnerStatementListAst *__node_108 = 0;
5452
if (!parseInnerStatementList(&__node_108))
5453
{
5454
if (!mBlockErrors)
5455
{
5456
expectedSymbol(AstNode::InnerStatementListKind, "innerStatementList");
5457
}
5458
return false;
5459
}
5460
(*yynode)->statements = __node_108;
5461
5462
if (yytoken != Token_ENDFOR)
5463
{
5464
if (!mBlockErrors)
5465
{
5466
expectedToken(yytoken, Token_ENDFOR, "endfor");
5467
}
5468
return false;
5469
}
5470
yylex();
5471
5472
SemicolonOrCloseTagAst *__node_109 = 0;
5473
if (!parseSemicolonOrCloseTag(&__node_109))
5474
{
5475
if (!mBlockErrors)
5476
{
5477
expectedSymbol(AstNode::SemicolonOrCloseTagKind, "semicolonOrCloseTag");
5478
}
5479
return false;
5480
}
5481
}
5482
else
5483
{
5484
return false;
5485
}
5486
}
5487
else
5488
{
5489
return false;
5490
}
5491
5492
(*yynode)->endToken = tokenStream->index() - 2;
5493
5494
return true;
5495
}
5496
5497
bool Parser::parseForeachStatement(ForeachStatementAst **yynode)
5498
{
5499
*yynode = create<ForeachStatementAst>();
5500
5501
(*yynode)->startToken = tokenStream->index() - 1;
5502
5503
if (yytoken == Token_ARRAY
5504
|| yytoken == Token_ARRAY_CAST
5505
|| yytoken == Token_AT
5506
|| yytoken == Token_BACKTICK
5507
|| yytoken == Token_BANG
5508
|| yytoken == Token_BOOL_CAST
5509
|| yytoken == Token_BREAK
5510
|| yytoken == Token_CLASS_C
5511
|| yytoken == Token_CLONE
5512
|| yytoken == Token_CLOSE_TAG
5513
|| yytoken == Token_COLON
5514
|| yytoken == Token_CONSTANT_ENCAPSED_STRING
5515
|| yytoken == Token_CONTINUE
5516
|| yytoken == Token_DEC
5517
|| yytoken == Token_DECLARE
5518
|| yytoken == Token_DNUMBER
5519
|| yytoken == Token_DO
5520
|| yytoken == Token_DOLLAR
5521
|| yytoken == Token_DOUBLE_CAST
5522
|| yytoken == Token_DOUBLE_QUOTE
5523
|| yytoken == Token_ECHO
5524
|| yytoken == Token_EMPTY
5525
|| yytoken == Token_EVAL
5526
|| yytoken == Token_EXIT
5527
|| yytoken == Token_FILE
5528
|| yytoken == Token_FOR
5529
|| yytoken == Token_FOREACH
5530
|| yytoken == Token_FUNC_C
5531
|| yytoken == Token_GLOBAL
5532
|| yytoken == Token_IF
5533
|| yytoken == Token_INC
5534
|| yytoken == Token_INCLUDE
5535
|| yytoken == Token_INCLUDE_ONCE
5536
|| yytoken == Token_INLINE_HTML
5537
|| yytoken == Token_INT_CAST
5538
|| yytoken == Token_ISSET
5539
|| yytoken == Token_LBRACE
5540
|| yytoken == Token_LINE
5541
|| yytoken == Token_LIST
5542
|| yytoken == Token_LNUMBER
5543
|| yytoken == Token_LPAREN
5544
|| yytoken == Token_METHOD_C
5545
|| yytoken == Token_MINUS
5546
|| yytoken == Token_NEW
5547
|| yytoken == Token_OBJECT_CAST
5548
|| yytoken == Token_OPEN_TAG
5549
|| yytoken == Token_OPEN_TAG_WITH_ECHO
5550
|| yytoken == Token_PLUS
5551
|| yytoken == Token_PRINT
5552
|| yytoken == Token_REQUIRE
5553
|| yytoken == Token_REQUIRE_ONCE
5554
|| yytoken == Token_RETURN
5555
|| yytoken == Token_SEMICOLON
5556
|| yytoken == Token_START_HEREDOC
5557
|| yytoken == Token_STATIC
5558
|| yytoken == Token_STRING
5559
|| yytoken == Token_STRING_CAST
5560
|| yytoken == Token_STRING_VARNAME
5561
|| yytoken == Token_SWITCH
5562
|| yytoken == Token_THROW
5563
|| yytoken == Token_TILDE
5564
|| yytoken == Token_TRY
5565
|| yytoken == Token_UNSET
5566
|| yytoken == Token_UNSET_CAST
5567
|| yytoken == Token_VARIABLE
5568
|| yytoken == Token_WHILE)
5569
{
5570
if (yytoken == Token_ARRAY
5571
|| yytoken == Token_ARRAY_CAST
5572
|| yytoken == Token_AT
5573
|| yytoken == Token_BACKTICK
5574
|| yytoken == Token_BANG
5575
|| yytoken == Token_BOOL_CAST
5576
|| yytoken == Token_BREAK
5577
|| yytoken == Token_CLASS_C
5578
|| yytoken == Token_CLONE
5579
|| yytoken == Token_CLOSE_TAG
5580
|| yytoken == Token_CONSTANT_ENCAPSED_STRING
5581
|| yytoken == Token_CONTINUE
5582
|| yytoken == Token_DEC
5583
|| yytoken == Token_DECLARE
5584
|| yytoken == Token_DNUMBER
5585
|| yytoken == Token_DO
5586
|| yytoken == Token_DOLLAR
5587
|| yytoken == Token_DOUBLE_CAST
5588
|| yytoken == Token_DOUBLE_QUOTE
5589
|| yytoken == Token_ECHO
5590
|| yytoken == Token_EMPTY
5591
|| yytoken == Token_EVAL
5592
|| yytoken == Token_EXIT
5593
|| yytoken == Token_FILE
5594
|| yytoken == Token_FOR
5595
|| yytoken == Token_FOREACH
5596
|| yytoken == Token_FUNC_C
5597
|| yytoken == Token_GLOBAL
5598
|| yytoken == Token_IF
5599
|| yytoken == Token_INC
5600
|| yytoken == Token_INCLUDE
5601
|| yytoken == Token_INCLUDE_ONCE
5602
|| yytoken == Token_INLINE_HTML
5603
|| yytoken == Token_INT_CAST
5604
|| yytoken == Token_ISSET
5605
|| yytoken == Token_LBRACE
5606
|| yytoken == Token_LINE
5607
|| yytoken == Token_LIST
5608
|| yytoken == Token_LNUMBER
5609
|| yytoken == Token_LPAREN
5610
|| yytoken == Token_METHOD_C
5611
|| yytoken == Token_MINUS
5612
|| yytoken == Token_NEW
5613
|| yytoken == Token_OBJECT_CAST
5614
|| yytoken == Token_OPEN_TAG
5615
|| yytoken == Token_OPEN_TAG_WITH_ECHO
5616
|| yytoken == Token_PLUS
5617
|| yytoken == Token_PRINT
5618
|| yytoken == Token_REQUIRE
5619
|| yytoken == Token_REQUIRE_ONCE
5620
|| yytoken == Token_RETURN
5621
|| yytoken == Token_SEMICOLON
5622
|| yytoken == Token_START_HEREDOC
5623
|| yytoken == Token_STATIC
5624
|| yytoken == Token_STRING
5625
|| yytoken == Token_STRING_CAST
5626
|| yytoken == Token_STRING_VARNAME
5627
|| yytoken == Token_SWITCH
5628
|| yytoken == Token_THROW
5629
|| yytoken == Token_TILDE
5630
|| yytoken == Token_TRY
5631
|| yytoken == Token_UNSET
5632
|| yytoken == Token_UNSET_CAST
5633
|| yytoken == Token_VARIABLE
5634
|| yytoken == Token_WHILE)
5635
{
5636
StatementAst *__node_110 = 0;
5637
if (!parseStatement(&__node_110))
5638
{
5639
if (!mBlockErrors)
5640
{
5641
expectedSymbol(AstNode::StatementKind, "statement");
5642
}
5643
return false;
5644
}
5645
(*yynode)->statement = __node_110;
5646
5647
}
5648
else if (yytoken == Token_COLON)
5649
{
5650
if (yytoken != Token_COLON)
5651
{
5652
if (!mBlockErrors)
5653
{
5654
expectedToken(yytoken, Token_COLON, ":");
5655
}
5656
return false;
5657
}
5658
yylex();
5659
5660
InnerStatementListAst *__node_111 = 0;
5661
if (!parseInnerStatementList(&__node_111))
5662
{
5663
if (!mBlockErrors)
5664
{
5665
expectedSymbol(AstNode::InnerStatementListKind, "innerStatementList");
5666
}
5667
return false;
5668
}
5669
(*yynode)->statements = __node_111;
5670
5671
if (yytoken != Token_ENDFOREACH)
5672
{
5673
if (!mBlockErrors)
5674
{
5675
expectedToken(yytoken, Token_ENDFOREACH, "endforeach");
5676
}
5677
return false;
5678
}
5679
yylex();
5680
5681
SemicolonOrCloseTagAst *__node_112 = 0;
5682
if (!parseSemicolonOrCloseTag(&__node_112))
5683
{
5684
if (!mBlockErrors)
5685
{
5686
expectedSymbol(AstNode::SemicolonOrCloseTagKind, "semicolonOrCloseTag");
5687
}
5688
return false;
5689
}
5690
}
5691
else
5692
{
5693
return false;
5694
}
5695
}
5696
else
5697
{
5698
return false;
5699
}
5700
5701
(*yynode)->endToken = tokenStream->index() - 2;
5702
5703
return true;
5704
}
5705
5706
bool Parser::parseForeachVariable(ForeachVariableAst **yynode)
5707
{
5708
*yynode = create<ForeachVariableAst>();
5709
5710
(*yynode)->startToken = tokenStream->index() - 1;
5711
5712
if (yytoken == Token_BIT_AND
5713
|| yytoken == Token_VARIABLE)
5714
{
5715
if (yytoken == Token_BIT_AND)
5716
{
5717
if (yytoken != Token_BIT_AND)
5718
{
5719
if (!mBlockErrors)
5720
{
5721
expectedToken(yytoken, Token_BIT_AND, "&");
5722
}
5723
return false;
5724
}
5725
yylex();
5726
5727
}
5728
else if (true /*epsilon*/)
5729
{
5730
}
5731
else
5732
{
5733
return false;
5734
}
5735
VariableIdentifierAst *__node_113 = 0;
5736
if (!parseVariableIdentifier(&__node_113))
5737
{
5738
if (!mBlockErrors)
5739
{
5740
expectedSymbol(AstNode::VariableIdentifierKind, "variableIdentifier");
5741
}
5742
return false;
5743
}
5744
(*yynode)->variable = __node_113;
5745
5746
}
5747
else
5748
{
5749
return false;
5750
}
5751
5752
(*yynode)->endToken = tokenStream->index() - 2;
5753
5754
return true;
5755
}
5756
5757
bool Parser::parseFunctionCall(FunctionCallAst **yynode)
5758
{
5759
*yynode = create<FunctionCallAst>();
5760
5761
(*yynode)->startToken = tokenStream->index() - 1;
5762
5763
if (yytoken == Token_DOLLAR
5764
|| yytoken == Token_STRING
5765
|| yytoken == Token_VARIABLE)
5766
{
5767
if (yytoken == Token_STRING)
5768
{
5769
IdentifierAst *__node_114 = 0;
5770
if (!parseIdentifier(&__node_114))
5771
{
5772
if (!mBlockErrors)
5773
{
5774
expectedSymbol(AstNode::IdentifierKind, "identifier");
5775
}
5776
return false;
5777
}
5778
(*yynode)->stringFunctionNameOrClass = __node_114;
5779
5780
if (yytoken == Token_LPAREN)
5781
{
5782
if (yytoken != Token_LPAREN)
5783
{
5784
if (!mBlockErrors)
5785
{
5786
expectedToken(yytoken, Token_LPAREN, "(");
5787
}
5788
return false;
5789
}
5790
yylex();
5791
5792
FunctionCallParameterListAst *__node_115 = 0;
5793
if (!parseFunctionCallParameterList(&__node_115))
5794
{
5795
if (!mBlockErrors)
5796
{
5797
expectedSymbol(AstNode::FunctionCallParameterListKind, "functionCallParameterList");
5798
}
5799
return false;
5800
}
5801
(*yynode)->stringParameterList = __node_115;
5802
5803
if (yytoken != Token_RPAREN)
5804
{
5805
if (!mBlockErrors)
5806
{
5807
expectedToken(yytoken, Token_RPAREN, ")");
5808
}
5809
return false;
5810
}
5811
yylex();
5812
5813
}
5814
else if (yytoken == Token_PAAMAYIM_NEKUDOTAYIM)
5815
{
5816
if (yytoken != Token_PAAMAYIM_NEKUDOTAYIM)
5817
{
5818
if (!mBlockErrors)
5819
{
5820
expectedToken(yytoken, Token_PAAMAYIM_NEKUDOTAYIM, "::");
5821
}
5822
return false;
5823
}
5824
yylex();
5825
5826
if (yytoken == Token_STRING)
5827
{
5828
IdentifierAst *__node_116 = 0;
5829
if (!parseIdentifier(&__node_116))
5830
{
5831
if (!mBlockErrors)
5832
{
5833
expectedSymbol(AstNode::IdentifierKind, "identifier");
5834
}
5835
return false;
5836
}
5837
(*yynode)->stringFunctionName = __node_116;
5838
5839
if (yytoken != Token_LPAREN)
5840
{
5841
if (!mBlockErrors)
5842
{
5843
expectedToken(yytoken, Token_LPAREN, "(");
5844
}
5845
return false;
5846
}
5847
yylex();
5848
5849
FunctionCallParameterListAst *__node_117 = 0;
5850
if (!parseFunctionCallParameterList(&__node_117))
5851
{
5852
if (!mBlockErrors)
5853
{
5854
expectedSymbol(AstNode::FunctionCallParameterListKind, "functionCallParameterList");
5855
}
5856
return false;
5857
}
5858
(*yynode)->stringParameterList = __node_117;
5859
5860
if (yytoken != Token_RPAREN)
5861
{
5862
if (!mBlockErrors)
5863
{
5864
expectedToken(yytoken, Token_RPAREN, ")");
5865
}
5866
return false;
5867
}
5868
yylex();
5869
5870
}
5871
else if (yytoken == Token_DOLLAR
5872
|| yytoken == Token_VARIABLE)
5873
{
5874
VariableWithoutObjectsAst *__node_118 = 0;
5875
if (!parseVariableWithoutObjects(&__node_118))
5876
{
5877
if (!mBlockErrors)
5878
{
5879
expectedSymbol(AstNode::VariableWithoutObjectsKind, "variableWithoutObjects");
5880
}
5881
return false;
5882
}
5883
(*yynode)->varFunctionName = __node_118;
5884
5885
if (yytoken != Token_LPAREN)
5886
{
5887
if (!mBlockErrors)
5888
{
5889
expectedToken(yytoken, Token_LPAREN, "(");
5890
}
5891
return false;
5892
}
5893
yylex();
5894
5895
FunctionCallParameterListAst *__node_119 = 0;
5896
if (!parseFunctionCallParameterList(&__node_119))
5897
{
5898
if (!mBlockErrors)
5899
{
5900
expectedSymbol(AstNode::FunctionCallParameterListKind, "functionCallParameterList");
5901
}
5902
return false;
5903
}
5904
(*yynode)->stringParameterList = __node_119;
5905
5906
if (yytoken != Token_RPAREN)
5907
{
5908
if (!mBlockErrors)
5909
{
5910
expectedToken(yytoken, Token_RPAREN, ")");
5911
}
5912
return false;
5913
}
5914
yylex();
5915
5916
}
5917
else
5918
{
5919
return false;
5920
}
5921
}
5922
else
5923
{
5924
return false;
5925
}
5926
}
5927
else if (yytoken == Token_DOLLAR
5928
|| yytoken == Token_VARIABLE)
5929
{
5930
VariableWithoutObjectsAst *__node_120 = 0;
5931
if (!parseVariableWithoutObjects(&__node_120))
5932
{
5933
if (!mBlockErrors)
5934
{
5935
expectedSymbol(AstNode::VariableWithoutObjectsKind, "variableWithoutObjects");
5936
}
5937
return false;
5938
}
5939
(*yynode)->varFunctionName = __node_120;
5940
5941
if (yytoken != Token_LPAREN)
5942
{
5943
if (!mBlockErrors)
5944
{
5945
expectedToken(yytoken, Token_LPAREN, "(");
5946
}
5947
return false;
5948
}
5949
yylex();
5950
5951
FunctionCallParameterListAst *__node_121 = 0;
5952
if (!parseFunctionCallParameterList(&__node_121))
5953
{
5954
if (!mBlockErrors)
5955
{
5956
expectedSymbol(AstNode::FunctionCallParameterListKind, "functionCallParameterList");
5957
}
5958
return false;
5959
}
5960
(*yynode)->varParameterList = __node_121;
5961
5962
if (yytoken != Token_RPAREN)
5963
{
5964
if (!mBlockErrors)
5965
{
5966
expectedToken(yytoken, Token_RPAREN, ")");
5967
}
5968
return false;
5969
}
5970
yylex();
5971
5972
}
5973
else
5974
{
5975
return false;
5976
}
5977
}
5978
else
5979
{
5980
return false;
5981
}
5982
5983
(*yynode)->endToken = tokenStream->index() - 2;
5984
5985
return true;
5986
}
5987
5988
bool Parser::parseFunctionCallParameterList(FunctionCallParameterListAst **yynode)
5989
{
5990
*yynode = create<FunctionCallParameterListAst>();
5991
5992
(*yynode)->startToken = tokenStream->index() - 1;
5993
5994
if (yytoken == Token_ARRAY
5995
|| yytoken == Token_ARRAY_CAST
5996
|| yytoken == Token_AT
5997
|| yytoken == Token_BACKTICK
5998
|| yytoken == Token_BANG
5999
|| yytoken == Token_BIT_AND
6000
|| yytoken == Token_BOOL_CAST
6001
|| yytoken == Token_CLASS_C
6002
|| yytoken == Token_CLONE
6003
|| yytoken == Token_CONSTANT_ENCAPSED_STRING
6004
|| yytoken == Token_DEC
6005
|| yytoken == Token_DNUMBER
6006
|| yytoken == Token_DOLLAR
6007
|| yytoken == Token_DOUBLE_CAST
6008
|| yytoken == Token_DOUBLE_QUOTE
6009
|| yytoken == Token_EMPTY
6010
|| yytoken == Token_EVAL
6011
|| yytoken == Token_EXIT
6012
|| yytoken == Token_FILE
6013
|| yytoken == Token_FUNC_C
6014
|| yytoken == Token_INC
6015
|| yytoken == Token_INCLUDE
6016
|| yytoken == Token_INCLUDE_ONCE
6017
|| yytoken == Token_INT_CAST
6018
|| yytoken == Token_ISSET
6019
|| yytoken == Token_LINE
6020
|| yytoken == Token_LIST
6021
|| yytoken == Token_LNUMBER
6022
|| yytoken == Token_LPAREN
6023
|| yytoken == Token_METHOD_C
6024
|| yytoken == Token_MINUS
6025
|| yytoken == Token_NEW
6026
|| yytoken == Token_OBJECT_CAST
6027
|| yytoken == Token_PLUS
6028
|| yytoken == Token_PRINT
6029
|| yytoken == Token_REQUIRE
6030
|| yytoken == Token_REQUIRE_ONCE
6031
|| yytoken == Token_START_HEREDOC
6032
|| yytoken == Token_STRING
6033
|| yytoken == Token_STRING_CAST
6034
|| yytoken == Token_STRING_VARNAME
6035
|| yytoken == Token_TILDE
6036
|| yytoken == Token_UNSET_CAST
6037
|| yytoken == Token_VARIABLE || yytoken == Token_EOF
6038
|| yytoken == Token_RPAREN)
6039
{
6040
if (yytoken == Token_ARRAY
6041
|| yytoken == Token_ARRAY_CAST
6042
|| yytoken == Token_AT
6043
|| yytoken == Token_BACKTICK
6044
|| yytoken == Token_BANG
6045
|| yytoken == Token_BIT_AND
6046
|| yytoken == Token_BOOL_CAST
6047
|| yytoken == Token_CLASS_C
6048
|| yytoken == Token_CLONE
6049
|| yytoken == Token_CONSTANT_ENCAPSED_STRING
6050
|| yytoken == Token_DEC
6051
|| yytoken == Token_DNUMBER
6052
|| yytoken == Token_DOLLAR
6053
|| yytoken == Token_DOUBLE_CAST
6054
|| yytoken == Token_DOUBLE_QUOTE
6055
|| yytoken == Token_EMPTY
6056
|| yytoken == Token_EVAL
6057
|| yytoken == Token_EXIT
6058
|| yytoken == Token_FILE
6059
|| yytoken == Token_FUNC_C
6060
|| yytoken == Token_INC
6061
|| yytoken == Token_INCLUDE
6062
|| yytoken == Token_INCLUDE_ONCE
6063
|| yytoken == Token_INT_CAST
6064
|| yytoken == Token_ISSET
6065
|| yytoken == Token_LINE
6066
|| yytoken == Token_LIST
6067
|| yytoken == Token_LNUMBER
6068
|| yytoken == Token_LPAREN
6069
|| yytoken == Token_METHOD_C
6070
|| yytoken == Token_MINUS
6071
|| yytoken == Token_NEW
6072
|| yytoken == Token_OBJECT_CAST
6073
|| yytoken == Token_PLUS
6074
|| yytoken == Token_PRINT
6075
|| yytoken == Token_REQUIRE
6076
|| yytoken == Token_REQUIRE_ONCE
6077
|| yytoken == Token_START_HEREDOC
6078
|| yytoken == Token_STRING
6079
|| yytoken == Token_STRING_CAST
6080
|| yytoken == Token_STRING_VARNAME
6081
|| yytoken == Token_TILDE
6082
|| yytoken == Token_UNSET_CAST
6083
|| yytoken == Token_VARIABLE)
6084
{
6085
FunctionCallParameterListElementAst *__node_122 = 0;
6086
if (!parseFunctionCallParameterListElement(&__node_122))
6087
{
6088
if (!mBlockErrors)
6089
{
6090
expectedSymbol(AstNode::FunctionCallParameterListElementKind, "functionCallParameterListElement");
6091
}
6092
return false;
6093
}
6094
(*yynode)->parametersSequence = snoc((*yynode)->parametersSequence, __node_122, memoryPool);
6095
6096
while (yytoken == Token_COMMA)
6097
{
6098
if (yytoken != Token_COMMA)
6099
{
6100
if (!mBlockErrors)
6101
{
6102
expectedToken(yytoken, Token_COMMA, ",");
6103
}
6104
return false;
6105
}
6106
yylex();
6107
6108
FunctionCallParameterListElementAst *__node_123 = 0;
6109
if (!parseFunctionCallParameterListElement(&__node_123))
6110
{
6111
if (!mBlockErrors)
6112
{
6113
expectedSymbol(AstNode::FunctionCallParameterListElementKind, "functionCallParameterListElement");
6114
}
6115
return false;
6116
}
6117
(*yynode)->parametersSequence = snoc((*yynode)->parametersSequence, __node_123, memoryPool);
6118
6119
}
6120
}
6121
else if (true /*epsilon*/)
6122
{
6123
}
6124
else
6125
{
6126
return false;
6127
}
6128
}
6129
else
6130
{
6131
return false;
6132
}
6133
6134
(*yynode)->endToken = tokenStream->index() - 2;
6135
6136
return true;
6137
}
6138
6139
bool Parser::parseFunctionCallParameterListElement(FunctionCallParameterListElementAst **yynode)
6140
{
6141
*yynode = create<FunctionCallParameterListElementAst>();
6142
6143
(*yynode)->startToken = tokenStream->index() - 1;
6144
6145
if (yytoken == Token_ARRAY
6146
|| yytoken == Token_ARRAY_CAST
6147
|| yytoken == Token_AT
6148
|| yytoken == Token_BACKTICK
6149
|| yytoken == Token_BANG
6150
|| yytoken == Token_BIT_AND
6151
|| yytoken == Token_BOOL_CAST
6152
|| yytoken == Token_CLASS_C
6153
|| yytoken == Token_CLONE
6154
|| yytoken == Token_CONSTANT_ENCAPSED_STRING
6155
|| yytoken == Token_DEC
6156
|| yytoken == Token_DNUMBER
6157
|| yytoken == Token_DOLLAR
6158
|| yytoken == Token_DOUBLE_CAST
6159
|| yytoken == Token_DOUBLE_QUOTE
6160
|| yytoken == Token_EMPTY
6161
|| yytoken == Token_EVAL
6162
|| yytoken == Token_EXIT
6163
|| yytoken == Token_FILE
6164
|| yytoken == Token_FUNC_C
6165
|| yytoken == Token_INC
6166
|| yytoken == Token_INCLUDE
6167
|| yytoken == Token_INCLUDE_ONCE
6168
|| yytoken == Token_INT_CAST
6169
|| yytoken == Token_ISSET
6170
|| yytoken == Token_LINE
6171
|| yytoken == Token_LIST
6172
|| yytoken == Token_LNUMBER
6173
|| yytoken == Token_LPAREN
6174
|| yytoken == Token_METHOD_C
6175
|| yytoken == Token_MINUS
6176
|| yytoken == Token_NEW
6177
|| yytoken == Token_OBJECT_CAST
6178
|| yytoken == Token_PLUS
6179
|| yytoken == Token_PRINT
6180
|| yytoken == Token_REQUIRE
6181
|| yytoken == Token_REQUIRE_ONCE
6182
|| yytoken == Token_START_HEREDOC
6183
|| yytoken == Token_STRING
6184
|| yytoken == Token_STRING_CAST
6185
|| yytoken == Token_STRING_VARNAME
6186
|| yytoken == Token_TILDE
6187
|| yytoken == Token_UNSET_CAST
6188
|| yytoken == Token_VARIABLE)
6189
{
6190
if (yytoken == Token_BIT_AND)
6191
{
6192
if (yytoken != Token_BIT_AND)
6193
{
6194
if (!mBlockErrors)
6195
{
6196
expectedToken(yytoken, Token_BIT_AND, "&");
6197
}
6198
return false;
6199
}
6200
yylex();
6201
6202
VariableAst *__node_124 = 0;
6203
if (!parseVariable(&__node_124))
6204
{
6205
if (!mBlockErrors)
6206
{
6207
expectedSymbol(AstNode::VariableKind, "variable");
6208
}
6209
return false;
6210
}
6211
(*yynode)->variable = __node_124;
6212
6213
}
6214
else if (yytoken == Token_ARRAY
6215
|| yytoken == Token_ARRAY_CAST
6216
|| yytoken == Token_AT
6217
|| yytoken == Token_BACKTICK
6218
|| yytoken == Token_BANG
6219
|| yytoken == Token_BOOL_CAST
6220
|| yytoken == Token_CLASS_C
6221
|| yytoken == Token_CLONE
6222
|| yytoken == Token_CONSTANT_ENCAPSED_STRING
6223
|| yytoken == Token_DEC
6224
|| yytoken == Token_DNUMBER
6225
|| yytoken == Token_DOLLAR
6226
|| yytoken == Token_DOUBLE_CAST
6227
|| yytoken == Token_DOUBLE_QUOTE
6228
|| yytoken == Token_EMPTY
6229
|| yytoken == Token_EVAL
6230
|| yytoken == Token_EXIT
6231
|| yytoken == Token_FILE
6232
|| yytoken == Token_FUNC_C
6233
|| yytoken == Token_INC
6234
|| yytoken == Token_INCLUDE
6235
|| yytoken == Token_INCLUDE_ONCE
6236
|| yytoken == Token_INT_CAST
6237
|| yytoken == Token_ISSET
6238
|| yytoken == Token_LINE
6239
|| yytoken == Token_LIST
6240
|| yytoken == Token_LNUMBER
6241
|| yytoken == Token_LPAREN
6242
|| yytoken == Token_METHOD_C
6243
|| yytoken == Token_MINUS
6244
|| yytoken == Token_NEW
6245
|| yytoken == Token_OBJECT_CAST
6246
|| yytoken == Token_PLUS
6247
|| yytoken == Token_PRINT
6248
|| yytoken == Token_REQUIRE
6249
|| yytoken == Token_REQUIRE_ONCE
6250
|| yytoken == Token_START_HEREDOC
6251
|| yytoken == Token_STRING
6252
|| yytoken == Token_STRING_CAST
6253
|| yytoken == Token_STRING_VARNAME
6254
|| yytoken == Token_TILDE
6255
|| yytoken == Token_UNSET_CAST
6256
|| yytoken == Token_VARIABLE)
6257
{
6258
ExprAst *__node_125 = 0;
6259
if (!parseExpr(&__node_125))
6260
{
6261
if (!mBlockErrors)
6262
{
6263
expectedSymbol(AstNode::ExprKind, "expr");
6264
}
6265
return false;
6266
}
6267
(*yynode)->expr = __node_125;
6268
6269
}
6270
else
6271
{
6272
return false;
6273
}
6274
}
6275
else
6276
{
6277
return false;
6278
}
6279
6280
(*yynode)->endToken = tokenStream->index() - 2;
6281
6282
return true;
6283
}
6284
6285
bool Parser::parseFunctionDeclarationStatement(FunctionDeclarationStatementAst **yynode)
6286
{
6287
*yynode = create<FunctionDeclarationStatementAst>();
6288
6289
(*yynode)->startToken = tokenStream->index() - 1;
6290
6291
if (yytoken == Token_FUNCTION)
6292
{
6293
if (yytoken != Token_FUNCTION)
6294
{
6295
if (!mBlockErrors)
6296
{
6297
expectedToken(yytoken, Token_FUNCTION, "function");
6298
}
6299
return false;
6300
}
6301
yylex();
6302
6303
if (yytoken == Token_BIT_AND)
6304
{
6305
if (yytoken != Token_BIT_AND)
6306
{
6307
if (!mBlockErrors)
6308
{
6309
expectedToken(yytoken, Token_BIT_AND, "&");
6310
}
6311
return false;
6312
}
6313
yylex();
6314
6315
}
6316
else if (true /*epsilon*/)
6317
{
6318
}
6319
else
6320
{
6321
return false;
6322
}
6323
IdentifierAst *__node_126 = 0;
6324
if (!parseIdentifier(&__node_126))
6325
{
6326
if (!mBlockErrors)
6327
{
6328
expectedSymbol(AstNode::IdentifierKind, "identifier");
6329
}
6330
return false;
6331
}
6332
(*yynode)->functionName = __node_126;
6333
6334
if (yytoken != Token_LPAREN)
6335
{
6336
if (!mBlockErrors)
6337
{
6338
expectedToken(yytoken, Token_LPAREN, "(");
6339
}
6340
return false;
6341
}
6342
yylex();
6343
6344
ParameterListAst *__node_127 = 0;
6345
if (!parseParameterList(&__node_127))
6346
{
6347
if (!mBlockErrors)
6348
{
6349
expectedSymbol(AstNode::ParameterListKind, "parameterList");
6350
}
6351
return false;
6352
}
6353
(*yynode)->parameters = __node_127;
6354
6355
if (yytoken != Token_RPAREN)
6356
{
6357
if (!mBlockErrors)
6358
{
6359
expectedToken(yytoken, Token_RPAREN, ")");
6360
}
6361
return false;
6362
}
6363
yylex();
6364
6365
if (yytoken != Token_LBRACE)
6366
{
6367
if (!mBlockErrors)
6368
{
6369
expectedToken(yytoken, Token_LBRACE, "{");
6370
}
6371
return false;
6372
}
6373
yylex();
6374
6375
InnerStatementListAst *__node_128 = 0;
6376
if (!parseInnerStatementList(&__node_128))
6377
{
6378
if (!mBlockErrors)
6379
{
6380
expectedSymbol(AstNode::InnerStatementListKind, "innerStatementList");
6381
}
6382
return false;
6383
}
6384
(*yynode)->functionBody = __node_128;
6385
6386
if (yytoken != Token_RBRACE)
6387
{
6388
if (!mBlockErrors)
6389
{
6390
expectedToken(yytoken, Token_RBRACE, "}");
6391
}
6392
return false;
6393
}
6394
yylex();
6395
6396
}
6397
else
6398
{
6399
return false;
6400
}
6401
6402
(*yynode)->endToken = tokenStream->index() - 2;
6403
6404
return true;
6405
}
6406
6407
bool Parser::parseGlobalVar(GlobalVarAst **yynode)
6408
{
6409
*yynode = create<GlobalVarAst>();
6410
6411
(*yynode)->startToken = tokenStream->index() - 1;
6412
6413
if (yytoken == Token_DOLLAR
6414
|| yytoken == Token_VARIABLE)
6415
{
6416
if (yytoken == Token_VARIABLE)
6417
{
6418
VariableIdentifierAst *__node_129 = 0;
6419
if (!parseVariableIdentifier(&__node_129))
6420
{
6421
if (!mBlockErrors)
6422
{
6423
expectedSymbol(AstNode::VariableIdentifierKind, "variableIdentifier");
6424
}
6425
return false;
6426
}
6427
(*yynode)->var = __node_129;
6428
6429
}
6430
else if (yytoken == Token_DOLLAR)
6431
{
6432
if (yytoken != Token_DOLLAR)
6433
{
6434
if (!mBlockErrors)
6435
{
6436
expectedToken(yytoken, Token_DOLLAR, "$");
6437
}
6438
return false;
6439
}
6440
yylex();
6441
6442
if (yytoken == Token_DOLLAR
6443
|| yytoken == Token_STRING
6444
|| yytoken == Token_VARIABLE)
6445
{
6446
VariableAst *__node_130 = 0;
6447
if (!parseVariable(&__node_130))
6448
{
6449
if (!mBlockErrors)
6450
{
6451
expectedSymbol(AstNode::VariableKind, "variable");
6452
}
6453
return false;
6454
}
6455
(*yynode)->dollarVar = __node_130;
6456
6457
}
6458
else if (yytoken == Token_LBRACE)
6459
{
6460
if (yytoken != Token_LBRACE)
6461
{
6462
if (!mBlockErrors)
6463
{
6464
expectedToken(yytoken, Token_LBRACE, "{");
6465
}
6466
return false;
6467
}
6468
yylex();
6469
6470
ExprAst *__node_131 = 0;
6471
if (!parseExpr(&__node_131))
6472
{
6473
if (!mBlockErrors)
6474
{
6475
expectedSymbol(AstNode::ExprKind, "expr");
6476
}
6477
return false;
6478
}
6479
(*yynode)->expr = __node_131;
6480
6481
if (yytoken != Token_RBRACE)
6482
{
6483
if (!mBlockErrors)
6484
{
6485
expectedToken(yytoken, Token_RBRACE, "}");
6486
}
6487
return false;
6488
}
6489
yylex();
6490
6491
}
6492
else
6493
{
6494
return false;
6495
}
6496
}
6497
else
6498
{
6499
return false;
6500
}
6501
}
6502
else
6503
{
6504
return false;
6505
}
6506
6507
(*yynode)->endToken = tokenStream->index() - 2;
6508
6509
return true;
6510
}
6511
6512
bool Parser::parseIdentifier(IdentifierAst **yynode)
6513
{
6514
*yynode = create<IdentifierAst>();
6515
6516
(*yynode)->startToken = tokenStream->index() - 1;
6517
(*yynode)->string = -1;
6518
6519
if (yytoken == Token_STRING)
6520
{
6521
if (yytoken != Token_STRING)
6522
{
6523
if (!mBlockErrors)
6524
{
6525
expectedToken(yytoken, Token_STRING, "string");
6526
}
6527
return false;
6528
}
6529
(*yynode)->string = tokenStream->index() - 1;
6530
yylex();
6531
6532
}
6533
else
6534
{
6535
return false;
6536
}
6537
6538
(*yynode)->endToken = tokenStream->index() - 2;
6539
6540
return true;
6541
}
6542
6543
bool Parser::parseInnerStatementList(InnerStatementListAst **yynode)
6544
{
6545
*yynode = create<InnerStatementListAst>();
6546
6547
(*yynode)->startToken = tokenStream->index() - 1;
6548
6549
if (yytoken == Token_ABSTRACT
6550
|| yytoken == Token_ARRAY
6551
|| yytoken == Token_ARRAY_CAST
6552
|| yytoken == Token_AT
6553
|| yytoken == Token_BACKTICK
6554
|| yytoken == Token_BANG
6555
|| yytoken == Token_BOOL_CAST
6556
|| yytoken == Token_BREAK
6557
|| yytoken == Token_CLASS
6558
|| yytoken == Token_CLASS_C
6559
|| yytoken == Token_CLONE
6560
|| yytoken == Token_CLOSE_TAG
6561
|| yytoken == Token_CONSTANT_ENCAPSED_STRING
6562
|| yytoken == Token_CONTINUE
6563
|| yytoken == Token_DEC
6564
|| yytoken == Token_DECLARE
6565
|| yytoken == Token_DNUMBER
6566
|| yytoken == Token_DO
6567
|| yytoken == Token_DOLLAR
6568
|| yytoken == Token_DOUBLE_CAST
6569
|| yytoken == Token_DOUBLE_QUOTE
6570
|| yytoken == Token_ECHO
6571
|| yytoken == Token_EMPTY
6572
|| yytoken == Token_EVAL
6573
|| yytoken == Token_EXIT
6574
|| yytoken == Token_FILE
6575
|| yytoken == Token_FINAL
6576
|| yytoken == Token_FOR
6577
|| yytoken == Token_FOREACH
6578
|| yytoken == Token_FUNCTION
6579
|| yytoken == Token_FUNC_C
6580
|| yytoken == Token_GLOBAL
6581
|| yytoken == Token_HALT_COMPILER
6582
|| yytoken == Token_IF
6583
|| yytoken == Token_INC
6584
|| yytoken == Token_INCLUDE
6585
|| yytoken == Token_INCLUDE_ONCE
6586
|| yytoken == Token_INLINE_HTML
6587
|| yytoken == Token_INTERFACE
6588
|| yytoken == Token_INT_CAST
6589
|| yytoken == Token_ISSET
6590
|| yytoken == Token_LBRACE
6591
|| yytoken == Token_LINE
6592
|| yytoken == Token_LIST
6593
|| yytoken == Token_LNUMBER
6594
|| yytoken == Token_LPAREN
6595
|| yytoken == Token_METHOD_C
6596
|| yytoken == Token_MINUS
6597
|| yytoken == Token_NEW
6598
|| yytoken == Token_OBJECT_CAST
6599
|| yytoken == Token_OPEN_TAG
6600
|| yytoken == Token_OPEN_TAG_WITH_ECHO
6601
|| yytoken == Token_PLUS
6602
|| yytoken == Token_PRINT
6603
|| yytoken == Token_REQUIRE
6604
|| yytoken == Token_REQUIRE_ONCE
6605
|| yytoken == Token_RETURN
6606
|| yytoken == Token_SEMICOLON
6607
|| yytoken == Token_START_HEREDOC
6608
|| yytoken == Token_STATIC
6609
|| yytoken == Token_STRING
6610
|| yytoken == Token_STRING_CAST
6611
|| yytoken == Token_STRING_VARNAME
6612
|| yytoken == Token_SWITCH
6613
|| yytoken == Token_THROW
6614
|| yytoken == Token_TILDE
6615
|| yytoken == Token_TRY
6616
|| yytoken == Token_UNSET
6617
|| yytoken == Token_UNSET_CAST
6618
|| yytoken == Token_VARIABLE
6619
|| yytoken == Token_WHILE || yytoken == Token_CASE
6620
|| yytoken == Token_DEFAULT
6621
|| yytoken == Token_ELSE
6622
|| yytoken == Token_ELSEIF
6623
|| yytoken == Token_ENDDECLARE
6624
|| yytoken == Token_ENDFOR
6625
|| yytoken == Token_ENDFOREACH
6626
|| yytoken == Token_ENDIF
6627
|| yytoken == Token_ENDSWITCH
6628
|| yytoken == Token_ENDWHILE
6629
|| yytoken == Token_EOF
6630
|| yytoken == Token_RBRACE)
6631
{
6632
while (yytoken == Token_ABSTRACT
6633
|| yytoken == Token_ARRAY
6634
|| yytoken == Token_ARRAY_CAST
6635
|| yytoken == Token_AT
6636
|| yytoken == Token_BACKTICK
6637
|| yytoken == Token_BANG
6638
|| yytoken == Token_BOOL_CAST
6639
|| yytoken == Token_BREAK
6640
|| yytoken == Token_CLASS
6641
|| yytoken == Token_CLASS_C
6642
|| yytoken == Token_CLONE
6643
|| yytoken == Token_CLOSE_TAG
6644
|| yytoken == Token_CONSTANT_ENCAPSED_STRING
6645
|| yytoken == Token_CONTINUE
6646
|| yytoken == Token_DEC
6647
|| yytoken == Token_DECLARE
6648
|| yytoken == Token_DNUMBER
6649
|| yytoken == Token_DO
6650
|| yytoken == Token_DOLLAR
6651
|| yytoken == Token_DOUBLE_CAST
6652
|| yytoken == Token_DOUBLE_QUOTE
6653
|| yytoken == Token_ECHO
6654
|| yytoken == Token_EMPTY
6655
|| yytoken == Token_EVAL
6656
|| yytoken == Token_EXIT
6657
|| yytoken == Token_FILE
6658
|| yytoken == Token_FINAL
6659
|| yytoken == Token_FOR
6660
|| yytoken == Token_FOREACH
6661
|| yytoken == Token_FUNCTION
6662
|| yytoken == Token_FUNC_C
6663
|| yytoken == Token_GLOBAL
6664
|| yytoken == Token_HALT_COMPILER
6665
|| yytoken == Token_IF
6666
|| yytoken == Token_INC
6667
|| yytoken == Token_INCLUDE
6668
|| yytoken == Token_INCLUDE_ONCE
6669
|| yytoken == Token_INLINE_HTML
6670
|| yytoken == Token_INTERFACE
6671
|| yytoken == Token_INT_CAST
6672
|| yytoken == Token_ISSET
6673
|| yytoken == Token_LBRACE
6674
|| yytoken == Token_LINE
6675
|| yytoken == Token_LIST
6676
|| yytoken == Token_LNUMBER
6677
|| yytoken == Token_LPAREN
6678
|| yytoken == Token_METHOD_C
6679
|| yytoken == Token_MINUS
6680
|| yytoken == Token_NEW
6681
|| yytoken == Token_OBJECT_CAST
6682
|| yytoken == Token_OPEN_TAG
6683
|| yytoken == Token_OPEN_TAG_WITH_ECHO
6684
|| yytoken == Token_PLUS
6685
|| yytoken == Token_PRINT
6686
|| yytoken == Token_REQUIRE
6687
|| yytoken == Token_REQUIRE_ONCE
6688
|| yytoken == Token_RETURN
6689
|| yytoken == Token_SEMICOLON
6690
|| yytoken == Token_START_HEREDOC
6691
|| yytoken == Token_STATIC
6692
|| yytoken == Token_STRING
6693
|| yytoken == Token_STRING_CAST
6694
|| yytoken == Token_STRING_VARNAME
6695
|| yytoken == Token_SWITCH
6696
|| yytoken == Token_THROW
6697
|| yytoken == Token_TILDE
6698
|| yytoken == Token_TRY
6699
|| yytoken == Token_UNSET
6700
|| yytoken == Token_UNSET_CAST
6701
|| yytoken == Token_VARIABLE
6702
|| yytoken == Token_WHILE)
6703
{
6704
TopStatementAst *__node_132 = 0;
6705
if (!parseTopStatement(&__node_132))
6706
{
6707
if (!mBlockErrors)
6708
{
6709
expectedSymbol(AstNode::TopStatementKind, "topStatement");
6710
}
6711
return false;
6712
}
6713
(*yynode)->statementsSequence = snoc((*yynode)->statementsSequence, __node_132, memoryPool);
6714
6715
}
6716
}
6717
else
6718
{
6719
return false;
6720
}
6721
6722
(*yynode)->endToken = tokenStream->index() - 2;
6723
6724
return true;
6725
}
6726
6727
bool Parser::parseInterfaceDeclarationStatement(InterfaceDeclarationStatementAst **yynode)
6728
{
6729
*yynode = create<InterfaceDeclarationStatementAst>();
6730
6731
(*yynode)->startToken = tokenStream->index() - 1;
6732
6733
if (yytoken == Token_INTERFACE)
6734
{
6735
if (yytoken != Token_INTERFACE)
6736
{
6737
if (!mBlockErrors)
6738
{
6739
expectedToken(yytoken, Token_INTERFACE, "interface");
6740
}
6741
return false;
6742
}
6743
yylex();
6744
6745
IdentifierAst *__node_133 = 0;
6746
if (!parseIdentifier(&__node_133))
6747
{
6748
if (!mBlockErrors)
6749
{
6750
expectedSymbol(AstNode::IdentifierKind, "identifier");
6751
}
6752
return false;
6753
}
6754
(*yynode)->interfaceName = __node_133;
6755
6756
if (yytoken == Token_EXTENDS)
6757
{
6758
if (yytoken != Token_EXTENDS)
6759
{
6760
if (!mBlockErrors)
6761
{
6762
expectedToken(yytoken, Token_EXTENDS, "extends");
6763
}
6764
return false;
6765
}
6766
yylex();
6767
6768
ClassImplementsAst *__node_134 = 0;
6769
if (!parseClassImplements(&__node_134))
6770
{
6771
if (!mBlockErrors)
6772
{
6773
expectedSymbol(AstNode::ClassImplementsKind, "classImplements");
6774
}
6775
return false;
6776
}
6777
(*yynode)->extends = __node_134;
6778
6779
}
6780
else if (true /*epsilon*/)
6781
{
6782
}
6783
else
6784
{
6785
return false;
6786
}
6787
if (yytoken != Token_LBRACE)
6788
{
6789
if (!mBlockErrors)
6790
{
6791
expectedToken(yytoken, Token_LBRACE, "{");
6792
}
6793
return false;
6794
}
6795
yylex();
6796
6797
ClassBodyAst *__node_135 = 0;
6798
if (!parseClassBody(&__node_135))
6799
{
6800
if (!mBlockErrors)
6801
{
6802
expectedSymbol(AstNode::ClassBodyKind, "classBody");
6803
}
6804
return false;
6805
}
6806
(*yynode)->body = __node_135;
6807
6808
if (yytoken != Token_RBRACE)
6809
{
6810
if (!mBlockErrors)
6811
{
6812
expectedToken(yytoken, Token_RBRACE, "}");
6813
}
6814
return false;
6815
}
6816
yylex();
6817
6818
}
6819
else
6820
{
6821
return false;
6822
}
6823
6824
(*yynode)->endToken = tokenStream->index() - 2;
6825
6826
return true;
6827
}
6828
6829
bool Parser::parseLogicalAndExpression(LogicalAndExpressionAst **yynode)
6830
{
6831
*yynode = create<LogicalAndExpressionAst>();
6832
6833
(*yynode)->startToken = tokenStream->index() - 1;
6834
6835
if (yytoken == Token_ARRAY
6836
|| yytoken == Token_ARRAY_CAST
6837
|| yytoken == Token_AT
6838
|| yytoken == Token_BACKTICK
6839
|| yytoken == Token_BANG
6840
|| yytoken == Token_BOOL_CAST
6841
|| yytoken == Token_CLASS_C
6842
|| yytoken == Token_CLONE
6843
|| yytoken == Token_CONSTANT_ENCAPSED_STRING
6844
|| yytoken == Token_DEC
6845
|| yytoken == Token_DNUMBER
6846
|| yytoken == Token_DOLLAR
6847
|| yytoken == Token_DOUBLE_CAST
6848
|| yytoken == Token_DOUBLE_QUOTE
6849
|| yytoken == Token_EMPTY
6850
|| yytoken == Token_EVAL
6851
|| yytoken == Token_EXIT
6852
|| yytoken == Token_FILE
6853
|| yytoken == Token_FUNC_C
6854
|| yytoken == Token_INC
6855
|| yytoken == Token_INCLUDE
6856
|| yytoken == Token_INCLUDE_ONCE
6857
|| yytoken == Token_INT_CAST
6858
|| yytoken == Token_ISSET
6859
|| yytoken == Token_LINE
6860
|| yytoken == Token_LIST
6861
|| yytoken == Token_LNUMBER
6862
|| yytoken == Token_LPAREN
6863
|| yytoken == Token_METHOD_C
6864
|| yytoken == Token_MINUS
6865
|| yytoken == Token_NEW
6866
|| yytoken == Token_OBJECT_CAST
6867
|| yytoken == Token_PLUS
6868
|| yytoken == Token_PRINT
6869
|| yytoken == Token_REQUIRE
6870
|| yytoken == Token_REQUIRE_ONCE
6871
|| yytoken == Token_START_HEREDOC
6872
|| yytoken == Token_STRING
6873
|| yytoken == Token_STRING_CAST
6874
|| yytoken == Token_STRING_VARNAME
6875
|| yytoken == Token_TILDE
6876
|| yytoken == Token_UNSET_CAST
6877
|| yytoken == Token_VARIABLE)
6878
{
6879
PrintExpressionAst *__node_136 = 0;
6880
if (!parsePrintExpression(&__node_136))
6881
{
6882
if (!mBlockErrors)
6883
{
6884
expectedSymbol(AstNode::PrintExpressionKind, "printExpression");
6885
}
6886
return false;
6887
}
6888
(*yynode)->expressionSequence = snoc((*yynode)->expressionSequence, __node_136, memoryPool);
6889
6890
while (yytoken == Token_LOGICAL_AND)
6891
{
6892
if (yytoken != Token_LOGICAL_AND)
6893
{
6894
if (!mBlockErrors)
6895
{
6896
expectedToken(yytoken, Token_LOGICAL_AND, "logical and");
6897
}
6898
return false;
6899
}
6900
yylex();
6901
6902
PrintExpressionAst *__node_137 = 0;
6903
if (!parsePrintExpression(&__node_137))
6904
{
6905
if (!mBlockErrors)
6906
{
6907
expectedSymbol(AstNode::PrintExpressionKind, "printExpression");
6908
}
6909
return false;
6910
}
6911
(*yynode)->expressionSequence = snoc((*yynode)->expressionSequence, __node_137, memoryPool);
6912
6913
}
6914
}
6915
else
6916
{
6917
return false;
6918
}
6919
6920
(*yynode)->endToken = tokenStream->index() - 2;
6921
6922
return true;
6923
}
6924
6925
bool Parser::parseLogicalOrExpression(LogicalOrExpressionAst **yynode)
6926
{
6927
*yynode = create<LogicalOrExpressionAst>();
6928
6929
(*yynode)->startToken = tokenStream->index() - 1;
6930
6931
if (yytoken == Token_ARRAY
6932
|| yytoken == Token_ARRAY_CAST
6933
|| yytoken == Token_AT
6934
|| yytoken == Token_BACKTICK
6935
|| yytoken == Token_BANG
6936
|| yytoken == Token_BOOL_CAST
6937
|| yytoken == Token_CLASS_C
6938
|| yytoken == Token_CLONE
6939
|| yytoken == Token_CONSTANT_ENCAPSED_STRING
6940
|| yytoken == Token_DEC
6941
|| yytoken == Token_DNUMBER
6942
|| yytoken == Token_DOLLAR
6943
|| yytoken == Token_DOUBLE_CAST
6944
|| yytoken == Token_DOUBLE_QUOTE
6945
|| yytoken == Token_EMPTY
6946
|| yytoken == Token_EVAL
6947
|| yytoken == Token_EXIT
6948
|| yytoken == Token_FILE
6949
|| yytoken == Token_FUNC_C
6950
|| yytoken == Token_INC
6951
|| yytoken == Token_INCLUDE
6952
|| yytoken == Token_INCLUDE_ONCE
6953
|| yytoken == Token_INT_CAST
6954
|| yytoken == Token_ISSET
6955
|| yytoken == Token_LINE
6956
|| yytoken == Token_LIST
6957
|| yytoken == Token_LNUMBER
6958
|| yytoken == Token_LPAREN
6959
|| yytoken == Token_METHOD_C
6960
|| yytoken == Token_MINUS
6961
|| yytoken == Token_NEW
6962
|| yytoken == Token_OBJECT_CAST
6963
|| yytoken == Token_PLUS
6964
|| yytoken == Token_PRINT
6965
|| yytoken == Token_REQUIRE
6966
|| yytoken == Token_REQUIRE_ONCE
6967
|| yytoken == Token_START_HEREDOC
6968
|| yytoken == Token_STRING
6969
|| yytoken == Token_STRING_CAST
6970
|| yytoken == Token_STRING_VARNAME
6971
|| yytoken == Token_TILDE
6972
|| yytoken == Token_UNSET_CAST
6973
|| yytoken == Token_VARIABLE)
6974
{
6975
LogicalXorExpressionAst *__node_138 = 0;
6976
if (!parseLogicalXorExpression(&__node_138))
6977
{
6978
if (!mBlockErrors)
6979
{
6980
expectedSymbol(AstNode::LogicalXorExpressionKind, "logicalXorExpression");
6981
}
6982
return false;
6983
}
6984
(*yynode)->expressionSequence = snoc((*yynode)->expressionSequence, __node_138, memoryPool);
6985
6986
while (yytoken == Token_LOGICAL_OR)
6987
{
6988
if (yytoken != Token_LOGICAL_OR)
6989
{
6990
if (!mBlockErrors)
6991
{
6992
expectedToken(yytoken, Token_LOGICAL_OR, "logical or");
6993
}
6994
return false;
6995
}
6996
yylex();
6997
6998
LogicalXorExpressionAst *__node_139 = 0;
6999
if (!parseLogicalXorExpression(&__node_139))
7000
{
7001
if (!mBlockErrors)
7002
{
7003
expectedSymbol(AstNode::LogicalXorExpressionKind, "logicalXorExpression");
7004
}
7005
return false;
7006
}
7007
(*yynode)->expressionSequence = snoc((*yynode)->expressionSequence, __node_139, memoryPool);
7008
7009
}
7010
}
7011
else
7012
{
7013
return false;
7014
}
7015
7016
(*yynode)->endToken = tokenStream->index() - 2;
7017
7018
return true;
7019
}
7020
7021
bool Parser::parseLogicalXorExpression(LogicalXorExpressionAst **yynode)
7022
{
7023
*yynode = create<LogicalXorExpressionAst>();
7024
7025
(*yynode)->startToken = tokenStream->index() - 1;
7026
7027
if (yytoken == Token_ARRAY
7028
|| yytoken == Token_ARRAY_CAST
7029
|| yytoken == Token_AT
7030
|| yytoken == Token_BACKTICK
7031
|| yytoken == Token_BANG
7032
|| yytoken == Token_BOOL_CAST
7033
|| yytoken == Token_CLASS_C
7034
|| yytoken == Token_CLONE
7035
|| yytoken == Token_CONSTANT_ENCAPSED_STRING
7036
|| yytoken == Token_DEC
7037
|| yytoken == Token_DNUMBER
7038
|| yytoken == Token_DOLLAR
7039
|| yytoken == Token_DOUBLE_CAST
7040
|| yytoken == Token_DOUBLE_QUOTE
7041
|| yytoken == Token_EMPTY
7042
|| yytoken == Token_EVAL
7043
|| yytoken == Token_EXIT
7044
|| yytoken == Token_FILE
7045
|| yytoken == Token_FUNC_C
7046
|| yytoken == Token_INC
7047
|| yytoken == Token_INCLUDE
7048
|| yytoken == Token_INCLUDE_ONCE
7049
|| yytoken == Token_INT_CAST
7050
|| yytoken == Token_ISSET
7051
|| yytoken == Token_LINE
7052
|| yytoken == Token_LIST
7053
|| yytoken == Token_LNUMBER
7054
|| yytoken == Token_LPAREN
7055
|| yytoken == Token_METHOD_C
7056
|| yytoken == Token_MINUS
7057
|| yytoken == Token_NEW
7058
|| yytoken == Token_OBJECT_CAST
7059
|| yytoken == Token_PLUS
7060
|| yytoken == Token_PRINT
7061
|| yytoken == Token_REQUIRE
7062
|| yytoken == Token_REQUIRE_ONCE
7063
|| yytoken == Token_START_HEREDOC
7064
|| yytoken == Token_STRING
7065
|| yytoken == Token_STRING_CAST
7066
|| yytoken == Token_STRING_VARNAME
7067
|| yytoken == Token_TILDE
7068
|| yytoken == Token_UNSET_CAST
7069
|| yytoken == Token_VARIABLE)
7070
{
7071
LogicalAndExpressionAst *__node_140 = 0;
7072
if (!parseLogicalAndExpression(&__node_140))
7073
{
7074
if (!mBlockErrors)
7075
{
7076
expectedSymbol(AstNode::LogicalAndExpressionKind, "logicalAndExpression");
7077
}
7078
return false;
7079
}
7080
(*yynode)->expressionSequence = snoc((*yynode)->expressionSequence, __node_140, memoryPool);
7081
7082
while (yytoken == Token_LOGICAL_XOR)
7083
{
7084
if (yytoken != Token_LOGICAL_XOR)
7085
{
7086
if (!mBlockErrors)
7087
{
7088
expectedToken(yytoken, Token_LOGICAL_XOR, "logical xor");
7089
}
7090
return false;
7091
}
7092
yylex();
7093
7094
LogicalAndExpressionAst *__node_141 = 0;
7095
if (!parseLogicalAndExpression(&__node_141))
7096
{
7097
if (!mBlockErrors)
7098
{
7099
expectedSymbol(AstNode::LogicalAndExpressionKind, "logicalAndExpression");
7100
}
7101
return false;
7102
}
7103
(*yynode)->expressionSequence = snoc((*yynode)->expressionSequence, __node_141, memoryPool);
7104
7105
}
7106
}
7107
else
7108
{
7109
return false;
7110
}
7111
7112
(*yynode)->endToken = tokenStream->index() - 2;
7113
7114
return true;
7115
}
7116
7117
bool Parser::parseMethodBody(MethodBodyAst **yynode)
7118
{
7119
*yynode = create<MethodBodyAst>();
7120
7121
(*yynode)->startToken = tokenStream->index() - 1;
7122
7123
if (yytoken == Token_LBRACE
7124
|| yytoken == Token_SEMICOLON)
7125
{
7126
if (yytoken == Token_SEMICOLON)
7127
{
7128
if (yytoken != Token_SEMICOLON)
7129
{
7130
if (!mBlockErrors)
7131
{
7132
expectedToken(yytoken, Token_SEMICOLON, ";");
7133
}
7134
return false;
7135
}
7136
yylex();
7137
7138
}
7139
else if (yytoken == Token_LBRACE)
7140
{
7141
if (yytoken != Token_LBRACE)
7142
{
7143
if (!mBlockErrors)
7144
{
7145
expectedToken(yytoken, Token_LBRACE, "{");
7146
}
7147
return false;
7148
}
7149
yylex();
7150
7151
InnerStatementListAst *__node_142 = 0;
7152
if (!parseInnerStatementList(&__node_142))
7153
{
7154
if (!mBlockErrors)
7155
{
7156
expectedSymbol(AstNode::InnerStatementListKind, "innerStatementList");
7157
}
7158
return false;
7159
}
7160
(*yynode)->statements = __node_142;
7161
7162
if (yytoken != Token_RBRACE)
7163
{
7164
if (!mBlockErrors)
7165
{
7166
expectedToken(yytoken, Token_RBRACE, "}");
7167
}
7168
return false;
7169
}
7170
yylex();
7171
7172
}
7173
else
7174
{
7175
return false;
7176
}
7177
}
7178
else
7179
{
7180
return false;
7181
}
7182
7183
(*yynode)->endToken = tokenStream->index() - 2;
7184
7185
return true;
7186
}
7187
7188
bool Parser::parseMultiplicativeExpression(MultiplicativeExpressionAst **yynode)
7189
{
7190
*yynode = create<MultiplicativeExpressionAst>();
7191
7192
(*yynode)->startToken = tokenStream->index() - 1;
7193
7194
if (yytoken == Token_ARRAY
7195
|| yytoken == Token_ARRAY_CAST
7196
|| yytoken == Token_AT
7197
|| yytoken == Token_BACKTICK
7198
|| yytoken == Token_BANG
7199
|| yytoken == Token_BOOL_CAST
7200
|| yytoken == Token_CLASS_C
7201
|| yytoken == Token_CLONE
7202
|| yytoken == Token_CONSTANT_ENCAPSED_STRING
7203
|| yytoken == Token_DEC
7204
|| yytoken == Token_DNUMBER
7205
|| yytoken == Token_DOLLAR
7206
|| yytoken == Token_DOUBLE_CAST
7207
|| yytoken == Token_DOUBLE_QUOTE
7208
|| yytoken == Token_EMPTY
7209
|| yytoken == Token_EVAL
7210
|| yytoken == Token_EXIT
7211
|| yytoken == Token_FILE
7212
|| yytoken == Token_FUNC_C
7213
|| yytoken == Token_INC
7214
|| yytoken == Token_INCLUDE
7215
|| yytoken == Token_INCLUDE_ONCE
7216
|| yytoken == Token_INT_CAST
7217
|| yytoken == Token_ISSET
7218
|| yytoken == Token_LINE
7219
|| yytoken == Token_LIST
7220
|| yytoken == Token_LNUMBER
7221
|| yytoken == Token_LPAREN
7222
|| yytoken == Token_METHOD_C
7223
|| yytoken == Token_MINUS
7224
|| yytoken == Token_NEW
7225
|| yytoken == Token_OBJECT_CAST
7226
|| yytoken == Token_PLUS
7227
|| yytoken == Token_REQUIRE
7228
|| yytoken == Token_REQUIRE_ONCE
7229
|| yytoken == Token_START_HEREDOC
7230
|| yytoken == Token_STRING
7231
|| yytoken == Token_STRING_CAST
7232
|| yytoken == Token_STRING_VARNAME
7233
|| yytoken == Token_TILDE
7234
|| yytoken == Token_UNSET_CAST
7235
|| yytoken == Token_VARIABLE)
7236
{
7237
UnaryExpressionAst *__node_143 = 0;
7238
if (!parseUnaryExpression(&__node_143))
7239
{
7240
if (!mBlockErrors)
7241
{
7242
expectedSymbol(AstNode::UnaryExpressionKind, "unaryExpression");
7243
}
7244
return false;
7245
}
7246
(*yynode)->expression = __node_143;
7247
7248
while (yytoken == Token_DIV
7249
|| yytoken == Token_MOD
7250
|| yytoken == Token_MUL)
7251
{
7252
MultiplicativeExpressionRestAst *__node_144 = 0;
7253
if (!parseMultiplicativeExpressionRest(&__node_144))
7254
{
7255
if (!mBlockErrors)
7256
{
7257
expectedSymbol(AstNode::MultiplicativeExpressionRestKind, "multiplicativeExpressionRest");
7258
}
7259
return false;
7260
}
7261
(*yynode)->additionalExpressionSequence = snoc((*yynode)->additionalExpressionSequence, __node_144, memoryPool);
7262
7263
}
7264
}
7265
else
7266
{
7267
return false;
7268
}
7269
7270
(*yynode)->endToken = tokenStream->index() - 2;
7271
7272
return true;
7273
}
7274
7275
bool Parser::parseMultiplicativeExpressionRest(MultiplicativeExpressionRestAst **yynode)
7276
{
7277
*yynode = create<MultiplicativeExpressionRestAst>();
7278
7279
(*yynode)->startToken = tokenStream->index() - 1;
7280
7281
if (yytoken == Token_DIV
7282
|| yytoken == Token_MOD
7283
|| yytoken == Token_MUL)
7284
{
7285
if (yytoken == Token_MUL)
7286
{
7287
if (yytoken != Token_MUL)
7288
{
7289
if (!mBlockErrors)
7290
{
7291
expectedToken(yytoken, Token_MUL, "*");
7292
}
7293
return false;
7294
}
7295
yylex();
7296
7297
(*yynode)->operation = OperationMul;
7298
}
7299
else if (yytoken == Token_DIV)
7300
{
7301
if (yytoken != Token_DIV)
7302
{
7303
if (!mBlockErrors)
7304
{
7305
expectedToken(yytoken, Token_DIV, "/");
7306
}
7307
return false;
7308
}
7309
yylex();
7310
7311
(*yynode)->operation = OperationDiv;
7312
}
7313
else if (yytoken == Token_MOD)
7314
{
7315
if (yytoken != Token_MOD)
7316
{
7317
if (!mBlockErrors)
7318
{
7319
expectedToken(yytoken, Token_MOD, "%");
7320
}
7321
return false;
7322
}
7323
yylex();
7324
7325
(*yynode)->operation = OperationMod;
7326
}
7327
else
7328
{
7329
return false;
7330
}
7331
UnaryExpressionAst *__node_145 = 0;
7332
if (!parseUnaryExpression(&__node_145))
7333
{
7334
if (!mBlockErrors)
7335
{
7336
expectedSymbol(AstNode::UnaryExpressionKind, "unaryExpression");
7337
}
7338
return false;
7339
}
7340
(*yynode)->expression = __node_145;
7341
7342
}
7343
else
7344
{
7345
return false;
7346
}
7347
7348
(*yynode)->endToken = tokenStream->index() - 2;
7349
7350
return true;
7351
}
7352
7353
bool Parser::parseNewElseSingle(NewElseSingleAst **yynode)
7354
{
7355
*yynode = create<NewElseSingleAst>();
7356
7357
(*yynode)->startToken = tokenStream->index() - 1;
7358
7359
if (yytoken == Token_ELSE || yytoken == Token_ENDIF
7360
|| yytoken == Token_EOF)
7361
{
7362
if (yytoken == Token_ELSE)
7363
{
7364
if (yytoken != Token_ELSE)
7365
{
7366
if (!mBlockErrors)
7367
{
7368
expectedToken(yytoken, Token_ELSE, "else");
7369
}
7370
return false;
7371
}
7372
yylex();
7373
7374
if (yytoken != Token_COLON)
7375
{
7376
if (!mBlockErrors)
7377
{
7378
expectedToken(yytoken, Token_COLON, ":");
7379
}
7380
return false;
7381
}
7382
yylex();
7383
7384
InnerStatementListAst *__node_146 = 0;
7385
if (!parseInnerStatementList(&__node_146))
7386
{
7387
if (!mBlockErrors)
7388
{
7389
expectedSymbol(AstNode::InnerStatementListKind, "innerStatementList");
7390
}
7391
return false;
7392
}
7393
(*yynode)->statements = __node_146;
7394
7395
}
7396
else if (true /*epsilon*/)
7397
{
7398
}
7399
else
7400
{
7401
return false;
7402
}
7403
}
7404
else
7405
{
7406
return false;
7407
}
7408
7409
(*yynode)->endToken = tokenStream->index() - 2;
7410
7411
return true;
7412
}
7413
7414
bool Parser::parseNewElseifList(NewElseifListAst **yynode)
7415
{
7416
*yynode = create<NewElseifListAst>();
7417
7418
(*yynode)->startToken = tokenStream->index() - 1;
7419
7420
if (yytoken == Token_ELSEIF || yytoken == Token_ELSE
7421
|| yytoken == Token_ENDIF
7422
|| yytoken == Token_EOF)
7423
{
7424
while (yytoken == Token_ELSEIF)
7425
{
7426
NewelseifListItemAst *__node_147 = 0;
7427
if (!parseNewelseifListItem(&__node_147))
7428
{
7429
if (!mBlockErrors)
7430
{
7431
expectedSymbol(AstNode::NewelseifListItemKind, "newelseifListItem");
7432
}
7433
return false;
7434
}
7435
(*yynode)->newElseifListItemSequence = snoc((*yynode)->newElseifListItemSequence, __node_147, memoryPool);
7436
7437
}
7438
}
7439
else
7440
{
7441
return false;
7442
}
7443
7444
(*yynode)->endToken = tokenStream->index() - 2;
7445
7446
return true;
7447
}
7448
7449
bool Parser::parseNewelseifListItem(NewelseifListItemAst **yynode)
7450
{
7451
*yynode = create<NewelseifListItemAst>();
7452
7453
(*yynode)->startToken = tokenStream->index() - 1;
7454
7455
if (yytoken == Token_ELSEIF)
7456
{
7457
if (yytoken != Token_ELSEIF)
7458
{
7459
if (!mBlockErrors)
7460
{
7461
expectedToken(yytoken, Token_ELSEIF, "elseif");
7462
}
7463
return false;
7464
}
7465
yylex();
7466
7467
if (yytoken != Token_LPAREN)
7468
{
7469
if (!mBlockErrors)
7470
{
7471
expectedToken(yytoken, Token_LPAREN, "(");
7472
}
7473
return false;
7474
}
7475
yylex();
7476
7477
ExprAst *__node_148 = 0;
7478
if (!parseExpr(&__node_148))
7479
{
7480
if (!mBlockErrors)
7481
{
7482
expectedSymbol(AstNode::ExprKind, "expr");
7483
}
7484
return false;
7485
}
7486
(*yynode)->expr = __node_148;
7487
7488
if (yytoken != Token_RPAREN)
7489
{
7490
if (!mBlockErrors)
7491
{
7492
expectedToken(yytoken, Token_RPAREN, ")");
7493
}
7494
return false;
7495
}
7496
yylex();
7497
7498
if (yytoken != Token_COLON)
7499
{
7500
if (!mBlockErrors)
7501
{
7502
expectedToken(yytoken, Token_COLON, ":");
7503
}
7504
return false;
7505
}
7506
yylex();
7507
7508
InnerStatementListAst *__node_149 = 0;
7509
if (!parseInnerStatementList(&__node_149))
7510
{
7511
if (!mBlockErrors)
7512
{
7513
expectedSymbol(AstNode::InnerStatementListKind, "innerStatementList");
7514
}
7515
return false;
7516
}
7517
(*yynode)->statements = __node_149;
7518
7519
}
7520
else
7521
{
7522
return false;
7523
}
7524
7525
(*yynode)->endToken = tokenStream->index() - 2;
7526
7527
return true;
7528
}
7529
7530
bool Parser::parseObjectDimList(ObjectDimListAst **yynode)
7531
{
7532
*yynode = create<ObjectDimListAst>();
7533
7534
(*yynode)->startToken = tokenStream->index() - 1;
7535
7536
if (yytoken == Token_LBRACE
7537
|| yytoken == Token_STRING)
7538
{
7539
VariableNameAst *__node_150 = 0;
7540
if (!parseVariableName(&__node_150))
7541
{
7542
if (!mBlockErrors)
7543
{
7544
expectedSymbol(AstNode::VariableNameKind, "variableName");
7545
}
7546
return false;
7547
}
7548
(*yynode)->variableName = __node_150;
7549
7550
while (yytoken == Token_LBRACE
7551
|| yytoken == Token_LBRACKET)
7552
{
7553
DimListItemAst *__node_151 = 0;
7554
if (!parseDimListItem(&__node_151))
7555
{
7556
if (!mBlockErrors)
7557
{
7558
expectedSymbol(AstNode::DimListItemKind, "dimListItem");
7559
}
7560
return false;
7561
}
7562
(*yynode)->offsetItemsSequence = snoc((*yynode)->offsetItemsSequence, __node_151, memoryPool);
7563
7564
}
7565
}
7566
else
7567
{
7568
return false;
7569
}
7570
7571
(*yynode)->endToken = tokenStream->index() - 2;
7572
7573
return true;
7574
}
7575
7576
bool Parser::parseObjectProperty(ObjectPropertyAst **yynode)
7577
{
7578
*yynode = create<ObjectPropertyAst>();
7579
7580
(*yynode)->startToken = tokenStream->index() - 1;
7581
7582
if (yytoken == Token_DOLLAR
7583
|| yytoken == Token_LBRACE
7584
|| yytoken == Token_STRING
7585
|| yytoken == Token_VARIABLE)
7586
{
7587
if (yytoken == Token_LBRACE
7588
|| yytoken == Token_STRING)
7589
{
7590
ObjectDimListAst *__node_152 = 0;
7591
if (!parseObjectDimList(&__node_152))
7592
{
7593
if (!mBlockErrors)
7594
{
7595
expectedSymbol(AstNode::ObjectDimListKind, "objectDimList");
7596
}
7597
return false;
7598
}
7599
(*yynode)->objectDimList = __node_152;
7600
7601
}
7602
else if (yytoken == Token_DOLLAR
7603
|| yytoken == Token_VARIABLE)
7604
{
7605
VariableWithoutObjectsAst *__node_153 = 0;
7606
if (!parseVariableWithoutObjects(&__node_153))
7607
{
7608
if (!mBlockErrors)
7609
{
7610
expectedSymbol(AstNode::VariableWithoutObjectsKind, "variableWithoutObjects");
7611
}
7612
return false;
7613
}
7614
(*yynode)->variableWithoutObjects = __node_153;
7615
7616
}
7617
else
7618
{
7619
return false;
7620
}
7621
}
7622
else
7623
{
7624
return false;
7625
}
7626
7627
(*yynode)->endToken = tokenStream->index() - 2;
7628
7629
return true;
7630
}
7631
7632
bool Parser::parseOptionalClassModifier(OptionalClassModifierAst **yynode)
7633
{
7634
*yynode = create<OptionalClassModifierAst>();
7635
7636
(*yynode)->startToken = tokenStream->index() - 1;
7637
7638
if (yytoken == Token_ABSTRACT
7639
|| yytoken == Token_FINAL || yytoken == Token_CLASS
7640
|| yytoken == Token_EOF)
7641
{
7642
if (yytoken == Token_ABSTRACT)
7643
{
7644
if (yytoken != Token_ABSTRACT)
7645
{
7646
if (!mBlockErrors)
7647
{
7648
expectedToken(yytoken, Token_ABSTRACT, "abstract");
7649
}
7650
return false;
7651
}
7652
yylex();
7653
7654
(*yynode)->modifier = AbstractClass;
7655
}
7656
else if (yytoken == Token_FINAL)
7657
{
7658
if (yytoken != Token_FINAL)
7659
{
7660
if (!mBlockErrors)
7661
{
7662
expectedToken(yytoken, Token_FINAL, "final");
7663
}
7664
return false;
7665
}
7666
yylex();
7667
7668
(*yynode)->modifier = FinalClass;
7669
}
7670
else if (true /*epsilon*/)
7671
{
7672
}
7673
else
7674
{
7675
return false;
7676
}
7677
}
7678
else
7679
{
7680
return false;
7681
}
7682
7683
(*yynode)->endToken = tokenStream->index() - 2;
7684
7685
return true;
7686
}
7687
7688
bool Parser::parseOptionalModifiers(OptionalModifiersAst **yynode)
7689
{
7690
*yynode = create<OptionalModifiersAst>();
7691
7692
(*yynode)->startToken = tokenStream->index() - 1;
7693
7694
if (yytoken == Token_ABSTRACT
7695
|| yytoken == Token_FINAL
7696
|| yytoken == Token_PRIVATE
7697
|| yytoken == Token_PROTECTED
7698
|| yytoken == Token_PUBLIC
7699
|| yytoken == Token_STATIC || yytoken == Token_EOF
7700
|| yytoken == Token_FUNCTION
7701
|| yytoken == Token_VARIABLE)
7702
{
7703
while (yytoken == Token_ABSTRACT
7704
|| yytoken == Token_FINAL
7705
|| yytoken == Token_PRIVATE
7706
|| yytoken == Token_PROTECTED
7707
|| yytoken == Token_PUBLIC
7708
|| yytoken == Token_STATIC)
7709
{
7710
if (yytoken == Token_PUBLIC)
7711
{
7712
if (yytoken != Token_PUBLIC)
7713
{
7714
if (!mBlockErrors)
7715
{
7716
expectedToken(yytoken, Token_PUBLIC, "public");
7717
}
7718
return false;
7719
}
7720
yylex();
7721
7722
(*yynode)->modifiers |= ModifierPublic;
7723
}
7724
else if (yytoken == Token_PROTECTED)
7725
{
7726
if (yytoken != Token_PROTECTED)
7727
{
7728
if (!mBlockErrors)
7729
{
7730
expectedToken(yytoken, Token_PROTECTED, "protected");
7731
}
7732
return false;
7733
}
7734
yylex();
7735
7736
(*yynode)->modifiers |= ModifierProtected;
7737
}
7738
else if (yytoken == Token_PRIVATE)
7739
{
7740
if (yytoken != Token_PRIVATE)
7741
{
7742
if (!mBlockErrors)
7743
{
7744
expectedToken(yytoken, Token_PRIVATE, "private");
7745
}
7746
return false;
7747
}
7748
yylex();
7749
7750
(*yynode)->modifiers |= ModifierPrivate;
7751
}
7752
else if (yytoken == Token_STATIC)
7753
{
7754
if (yytoken != Token_STATIC)
7755
{
7756
if (!mBlockErrors)
7757
{
7758
expectedToken(yytoken, Token_STATIC, "static");
7759
}
7760
return false;
7761
}
7762
yylex();
7763
7764
(*yynode)->modifiers |= ModifierStatic;
7765
}
7766
else if (yytoken == Token_ABSTRACT)
7767
{
7768
if (yytoken != Token_ABSTRACT)
7769
{
7770
if (!mBlockErrors)
7771
{
7772
expectedToken(yytoken, Token_ABSTRACT, "abstract");
7773
}
7774
return false;
7775
}
7776
yylex();
7777
7778
(*yynode)->modifiers |= ModifierAbstract;
7779
}
7780
else if (yytoken == Token_FINAL)
7781
{
7782
if (yytoken != Token_FINAL)
7783
{
7784
if (!mBlockErrors)
7785
{
7786
expectedToken(yytoken, Token_FINAL, "final");
7787
}
7788
return false;
7789
}
7790
yylex();
7791
7792
(*yynode)->modifiers |= ModifierFinal;
7793
}
7794
else if (true /*epsilon*/)
7795
{
7796
}
7797
else
7798
{
7799
return false;
7800
}
7801
}
7802
}
7803
else
7804
{
7805
return false;
7806
}
7807
7808
(*yynode)->endToken = tokenStream->index() - 2;
7809
7810
return true;
7811
}
7812
7813
bool Parser::parseParameter(ParameterAst **yynode)
7814
{
7815
*yynode = create<ParameterAst>();
7816
7817
(*yynode)->startToken = tokenStream->index() - 1;
7818
(*yynode)->arrayType = -1;
7819
(*yynode)->isRef = -1;
7820
7821
if (yytoken == Token_ARRAY
7822
|| yytoken == Token_BIT_AND
7823
|| yytoken == Token_STRING
7824
|| yytoken == Token_VARIABLE)
7825
{
7826
if (yytoken == Token_STRING)
7827
{
7828
IdentifierAst *__node_154 = 0;
7829
if (!parseIdentifier(&__node_154))
7830
{
7831
if (!mBlockErrors)
7832
{
7833
expectedSymbol(AstNode::IdentifierKind, "identifier");
7834
}
7835
return false;
7836
}
7837
(*yynode)->parameterType = __node_154;
7838
7839
}
7840
else if (yytoken == Token_ARRAY)
7841
{
7842
if (yytoken != Token_ARRAY)
7843
{
7844
if (!mBlockErrors)
7845
{
7846
expectedToken(yytoken, Token_ARRAY, "array");
7847
}
7848
return false;
7849
}
7850
(*yynode)->arrayType = tokenStream->index() - 1;
7851
yylex();
7852
7853
}
7854
else if (true /*epsilon*/)
7855
{
7856
}
7857
else
7858
{
7859
return false;
7860
}
7861
if (yytoken == Token_BIT_AND)
7862
{
7863
if (yytoken != Token_BIT_AND)
7864
{
7865
if (!mBlockErrors)
7866
{
7867
expectedToken(yytoken, Token_BIT_AND, "&");
7868
}
7869
return false;
7870
}
7871
(*yynode)->isRef = tokenStream->index() - 1;
7872
yylex();
7873
7874
}
7875
else if (true /*epsilon*/)
7876
{
7877
}
7878
else
7879
{
7880
return false;
7881
}
7882
VariableIdentifierAst *__node_155 = 0;
7883
if (!parseVariableIdentifier(&__node_155))
7884
{
7885
if (!mBlockErrors)
7886
{
7887
expectedSymbol(AstNode::VariableIdentifierKind, "variableIdentifier");
7888
}
7889
return false;
7890
}
7891
(*yynode)->variable = __node_155;
7892
7893
if (yytoken == Token_ASSIGN)
7894
{
7895
if (yytoken != Token_ASSIGN)
7896
{
7897
if (!mBlockErrors)
7898
{
7899
expectedToken(yytoken, Token_ASSIGN, "=");
7900
}
7901
return false;
7902
}
7903
yylex();
7904
7905
StaticScalarAst *__node_156 = 0;
7906
if (!parseStaticScalar(&__node_156))
7907
{
7908
if (!mBlockErrors)
7909
{
7910
expectedSymbol(AstNode::StaticScalarKind, "staticScalar");
7911
}
7912
return false;
7913
}
7914
(*yynode)->defaultValue = __node_156;
7915
7916
}
7917
else if (true /*epsilon*/)
7918
{
7919
}
7920
else
7921
{
7922
return false;
7923
}
7924
}
7925
else
7926
{
7927
return false;
7928
}
7929
7930
(*yynode)->endToken = tokenStream->index() - 2;
7931
7932
return true;
7933
}
7934
7935
bool Parser::parseParameterList(ParameterListAst **yynode)
7936
{
7937
*yynode = create<ParameterListAst>();
7938
7939
(*yynode)->startToken = tokenStream->index() - 1;
7940
7941
if (yytoken == Token_ARRAY
7942
|| yytoken == Token_BIT_AND
7943
|| yytoken == Token_STRING
7944
|| yytoken == Token_VARIABLE || yytoken == Token_EOF
7945
|| yytoken == Token_RPAREN)
7946
{
7947
if (yytoken == Token_ARRAY
7948
|| yytoken == Token_BIT_AND
7949
|| yytoken == Token_STRING
7950
|| yytoken == Token_VARIABLE)
7951
{
7952
ParameterAst *__node_157 = 0;
7953
if (!parseParameter(&__node_157))
7954
{
7955
if (!mBlockErrors)
7956
{
7957
expectedSymbol(AstNode::ParameterKind, "parameter");
7958
}
7959
return false;
7960
}
7961
(*yynode)->parametersSequence = snoc((*yynode)->parametersSequence, __node_157, memoryPool);
7962
7963
while (yytoken == Token_COMMA)
7964
{
7965
if (yytoken != Token_COMMA)
7966
{
7967
if (!mBlockErrors)
7968
{
7969
expectedToken(yytoken, Token_COMMA, ",");
7970
}
7971
return false;
7972
}
7973
yylex();
7974
7975
ParameterAst *__node_158 = 0;
7976
if (!parseParameter(&__node_158))
7977
{
7978
if (!mBlockErrors)
7979
{
7980
expectedSymbol(AstNode::ParameterKind, "parameter");
7981
}
7982
return false;
7983
}
7984
(*yynode)->parametersSequence = snoc((*yynode)->parametersSequence, __node_158, memoryPool);
7985
7986
}
7987
}
7988
else if (true /*epsilon*/)
7989
{
7990
}
7991
else
7992
{
7993
return false;
7994
}
7995
}
7996
else
7997
{
7998
return false;
7999
}
8000
8001
(*yynode)->endToken = tokenStream->index() - 2;
8002
8003
return true;
8004
}
8005
8006
bool Parser::parsePostprefixOperator(PostprefixOperatorAst **yynode)
8007
{
8008
*yynode = create<PostprefixOperatorAst>();
8009
8010
(*yynode)->startToken = tokenStream->index() - 1;
8011
(*yynode)->op = -1;
8012
(*yynode)->op = -1;
8013
8014
if (yytoken == Token_DEC
8015
|| yytoken == Token_INC)
8016
{
8017
if (yytoken == Token_INC)
8018
{
8019
if (yytoken != Token_INC)
8020
{
8021
if (!mBlockErrors)
8022
{
8023
expectedToken(yytoken, Token_INC, "++");
8024
}
8025
return false;
8026
}
8027
(*yynode)->op = tokenStream->index() - 1;
8028
yylex();
8029
8030
}
8031
else if (yytoken == Token_DEC)
8032
{
8033
if (yytoken != Token_DEC)
8034
{
8035
if (!mBlockErrors)
8036
{
8037
expectedToken(yytoken, Token_DEC, "--");
8038
}
8039
return false;
8040
}
8041
(*yynode)->op = tokenStream->index() - 1;
8042
yylex();
8043
8044
}
8045
else
8046
{
8047
return false;
8048
}
8049
}
8050
else
8051
{
8052
return false;
8053
}
8054
8055
(*yynode)->endToken = tokenStream->index() - 2;
8056
8057
return true;
8058
}
8059
8060
bool Parser::parsePrintExpression(PrintExpressionAst **yynode)
8061
{
8062
*yynode = create<PrintExpressionAst>();
8063
8064
(*yynode)->startToken = tokenStream->index() - 1;
8065
(*yynode)->print = -1;
8066
8067
if (yytoken == Token_ARRAY
8068
|| yytoken == Token_ARRAY_CAST
8069
|| yytoken == Token_AT
8070
|| yytoken == Token_BACKTICK
8071
|| yytoken == Token_BANG
8072
|| yytoken == Token_BOOL_CAST
8073
|| yytoken == Token_CLASS_C
8074
|| yytoken == Token_CLONE
8075
|| yytoken == Token_CONSTANT_ENCAPSED_STRING
8076
|| yytoken == Token_DEC
8077
|| yytoken == Token_DNUMBER
8078
|| yytoken == Token_DOLLAR
8079
|| yytoken == Token_DOUBLE_CAST
8080
|| yytoken == Token_DOUBLE_QUOTE
8081
|| yytoken == Token_EMPTY
8082
|| yytoken == Token_EVAL
8083
|| yytoken == Token_EXIT
8084
|| yytoken == Token_FILE
8085
|| yytoken == Token_FUNC_C
8086
|| yytoken == Token_INC
8087
|| yytoken == Token_INCLUDE
8088
|| yytoken == Token_INCLUDE_ONCE
8089
|| yytoken == Token_INT_CAST
8090
|| yytoken == Token_ISSET
8091
|| yytoken == Token_LINE
8092
|| yytoken == Token_LIST
8093
|| yytoken == Token_LNUMBER
8094
|| yytoken == Token_LPAREN
8095
|| yytoken == Token_METHOD_C
8096
|| yytoken == Token_MINUS
8097
|| yytoken == Token_NEW
8098
|| yytoken == Token_OBJECT_CAST
8099
|| yytoken == Token_PLUS
8100
|| yytoken == Token_PRINT
8101
|| yytoken == Token_REQUIRE
8102
|| yytoken == Token_REQUIRE_ONCE
8103
|| yytoken == Token_START_HEREDOC
8104
|| yytoken == Token_STRING
8105
|| yytoken == Token_STRING_CAST
8106
|| yytoken == Token_STRING_VARNAME
8107
|| yytoken == Token_TILDE
8108
|| yytoken == Token_UNSET_CAST
8109
|| yytoken == Token_VARIABLE)
8110
{
8111
while (yytoken == Token_PRINT)
8112
{
8113
if (yytoken != Token_PRINT)
8114
{
8115
if (!mBlockErrors)
8116
{
8117
expectedToken(yytoken, Token_PRINT, "print");
8118
}
8119
return false;
8120
}
8121
(*yynode)->print = tokenStream->index() - 1;
8122
yylex();
8123
8124
}
8125
AssignmentExpressionAst *__node_159 = 0;
8126
if (!parseAssignmentExpression(&__node_159))
8127
{
8128
if (!mBlockErrors)
8129
{
8130
expectedSymbol(AstNode::AssignmentExpressionKind, "assignmentExpression");
8131
}
8132
return false;
8133
}
8134
(*yynode)->expression = __node_159;
8135
8136
}
8137
else
8138
{
8139
return false;
8140
}
8141
8142
(*yynode)->endToken = tokenStream->index() - 2;
8143
8144
return true;
8145
}
8146
8147
bool Parser::parseRelationalExpression(RelationalExpressionAst **yynode)
8148
{
8149
*yynode = create<RelationalExpressionAst>();
8150
8151
(*yynode)->startToken = tokenStream->index() - 1;
8152
8153
if (yytoken == Token_ARRAY
8154
|| yytoken == Token_ARRAY_CAST
8155
|| yytoken == Token_AT
8156
|| yytoken == Token_BACKTICK
8157
|| yytoken == Token_BANG
8158
|| yytoken == Token_BOOL_CAST
8159
|| yytoken == Token_CLASS_C
8160
|| yytoken == Token_CLONE
8161
|| yytoken == Token_CONSTANT_ENCAPSED_STRING
8162
|| yytoken == Token_DEC
8163
|| yytoken == Token_DNUMBER
8164
|| yytoken == Token_DOLLAR
8165
|| yytoken == Token_DOUBLE_CAST
8166
|| yytoken == Token_DOUBLE_QUOTE
8167
|| yytoken == Token_EMPTY
8168
|| yytoken == Token_EVAL
8169
|| yytoken == Token_EXIT
8170
|| yytoken == Token_FILE
8171
|| yytoken == Token_FUNC_C
8172
|| yytoken == Token_INC
8173
|| yytoken == Token_INCLUDE
8174
|| yytoken == Token_INCLUDE_ONCE
8175
|| yytoken == Token_INT_CAST
8176
|| yytoken == Token_ISSET
8177
|| yytoken == Token_LINE
8178
|| yytoken == Token_LIST
8179
|| yytoken == Token_LNUMBER
8180
|| yytoken == Token_LPAREN
8181
|| yytoken == Token_METHOD_C
8182
|| yytoken == Token_MINUS
8183
|| yytoken == Token_NEW
8184
|| yytoken == Token_OBJECT_CAST
8185
|| yytoken == Token_PLUS
8186
|| yytoken == Token_REQUIRE
8187
|| yytoken == Token_REQUIRE_ONCE
8188
|| yytoken == Token_START_HEREDOC
8189
|| yytoken == Token_STRING
8190
|| yytoken == Token_STRING_CAST
8191
|| yytoken == Token_STRING_VARNAME
8192
|| yytoken == Token_TILDE
8193
|| yytoken == Token_UNSET_CAST
8194
|| yytoken == Token_VARIABLE)
8195
{
8196
ShiftExpressionAst *__node_160 = 0;
8197
if (!parseShiftExpression(&__node_160))
8198
{
8199
if (!mBlockErrors)
8200
{
8201
expectedSymbol(AstNode::ShiftExpressionKind, "shiftExpression");
8202
}
8203
return false;
8204
}
8205
(*yynode)->expression = __node_160;
8206
8207
if (yytoken == Token_IS_GREATER
8208
|| yytoken == Token_IS_GREATER_OR_EQUAL
8209
|| yytoken == Token_IS_SMALLER
8210
|| yytoken == Token_IS_SMALLER_OR_EQUAL)
8211
{
8212
do
8213
{
8214
RelationalExpressionRestAst *__node_161 = 0;
8215
if (!parseRelationalExpressionRest(&__node_161))
8216
{
8217
if (!mBlockErrors)
8218
{
8219
expectedSymbol(AstNode::RelationalExpressionRestKind, "relationalExpressionRest");
8220
}
8221
return false;
8222
}
8223
(*yynode)->additionalExpressionSequence = snoc((*yynode)->additionalExpressionSequence, __node_161, memoryPool);
8224
8225
}
8226
while (yytoken == Token_IS_GREATER
8227
|| yytoken == Token_IS_GREATER_OR_EQUAL
8228
|| yytoken == Token_IS_SMALLER
8229
|| yytoken == Token_IS_SMALLER_OR_EQUAL);
8230
}
8231
else if (yytoken == Token_INSTANCEOF)
8232
{
8233
if (yytoken != Token_INSTANCEOF)
8234
{
8235
if (!mBlockErrors)
8236
{
8237
expectedToken(yytoken, Token_INSTANCEOF, "instanceof");
8238
}
8239
return false;
8240
}
8241
yylex();
8242
8243
ClassNameReferenceAst *__node_162 = 0;
8244
if (!parseClassNameReference(&__node_162))
8245
{
8246
if (!mBlockErrors)
8247
{
8248
expectedSymbol(AstNode::ClassNameReferenceKind, "classNameReference");
8249
}
8250
return false;
8251
}
8252
(*yynode)->instanceofType = __node_162;
8253
8254
}
8255
else if (true /*epsilon*/)
8256
{
8257
}
8258
else
8259
{
8260
return false;
8261
}
8262
}
8263
else
8264
{
8265
return false;
8266
}
8267
8268
(*yynode)->endToken = tokenStream->index() - 2;
8269
8270
return true;
8271
}
8272
8273
bool Parser::parseRelationalExpressionRest(RelationalExpressionRestAst **yynode)
8274
{
8275
*yynode = create<RelationalExpressionRestAst>();
8276
8277
(*yynode)->startToken = tokenStream->index() - 1;
8278
8279
if (yytoken == Token_IS_GREATER
8280
|| yytoken == Token_IS_GREATER_OR_EQUAL
8281
|| yytoken == Token_IS_SMALLER
8282
|| yytoken == Token_IS_SMALLER_OR_EQUAL)
8283
{
8284
if (yytoken == Token_IS_SMALLER)
8285
{
8286
if (yytoken != Token_IS_SMALLER)
8287
{
8288
if (!mBlockErrors)
8289
{
8290
expectedToken(yytoken, Token_IS_SMALLER, "<");
8291
}
8292
return false;
8293
}
8294
yylex();
8295
8296
}
8297
else if (yytoken == Token_IS_GREATER)
8298
{
8299
if (yytoken != Token_IS_GREATER)
8300
{
8301
if (!mBlockErrors)
8302
{
8303
expectedToken(yytoken, Token_IS_GREATER, ">");
8304
}
8305
return false;
8306
}
8307
yylex();
8308
8309
}
8310
else if (yytoken == Token_IS_SMALLER_OR_EQUAL)
8311
{
8312
if (yytoken != Token_IS_SMALLER_OR_EQUAL)
8313
{
8314
if (!mBlockErrors)
8315
{
8316
expectedToken(yytoken, Token_IS_SMALLER_OR_EQUAL, "<=");
8317
}
8318
return false;
8319
}
8320
yylex();
8321
8322
}
8323
else if (yytoken == Token_IS_GREATER_OR_EQUAL)
8324
{
8325
if (yytoken != Token_IS_GREATER_OR_EQUAL)
8326
{
8327
if (!mBlockErrors)
8328
{
8329
expectedToken(yytoken, Token_IS_GREATER_OR_EQUAL, ">=");
8330
}
8331
return false;
8332
}
8333
yylex();
8334
8335
}
8336
else
8337
{
8338
return false;
8339
}
8340
ShiftExpressionAst *__node_163 = 0;
8341
if (!parseShiftExpression(&__node_163))
8342
{
8343
if (!mBlockErrors)
8344
{
8345
expectedSymbol(AstNode::ShiftExpressionKind, "shiftExpression");
8346
}
8347
return false;
8348
}
8349
(*yynode)->expression = __node_163;
8350
8351
}
8352
else
8353
{
8354
return false;
8355
}
8356
8357
(*yynode)->endToken = tokenStream->index() - 2;
8358
8359
return true;
8360
}
8361
8362
bool Parser::parseScalar(ScalarAst **yynode)
8363
{
8364
*yynode = create<ScalarAst>();
8365
8366
(*yynode)->startToken = tokenStream->index() - 1;
8367
(*yynode)->varname = -1;
8368
8369
if (yytoken == Token_CLASS_C
8370
|| yytoken == Token_CONSTANT_ENCAPSED_STRING
8371
|| yytoken == Token_DNUMBER
8372
|| yytoken == Token_DOUBLE_QUOTE
8373
|| yytoken == Token_FILE
8374
|| yytoken == Token_FUNC_C
8375
|| yytoken == Token_LINE
8376
|| yytoken == Token_LNUMBER
8377
|| yytoken == Token_METHOD_C
8378
|| yytoken == Token_START_HEREDOC
8379
|| yytoken == Token_STRING
8380
|| yytoken == Token_STRING_VARNAME)
8381
{
8382
if (yytoken == Token_CLASS_C
8383
|| yytoken == Token_CONSTANT_ENCAPSED_STRING
8384
|| yytoken == Token_DNUMBER
8385
|| yytoken == Token_FILE
8386
|| yytoken == Token_FUNC_C
8387
|| yytoken == Token_LINE
8388
|| yytoken == Token_LNUMBER
8389
|| yytoken == Token_METHOD_C)
8390
{
8391
CommonScalarAst *__node_164 = 0;
8392
if (!parseCommonScalar(&__node_164))
8393
{
8394
if (!mBlockErrors)
8395
{
8396
expectedSymbol(AstNode::CommonScalarKind, "commonScalar");
8397
}
8398
return false;
8399
}
8400
(*yynode)->commonScalar = __node_164;
8401
8402
}
8403
else if (yytoken == Token_STRING)
8404
{
8405
ConstantOrClassConstAst *__node_165 = 0;
8406
if (!parseConstantOrClassConst(&__node_165))
8407
{
8408
if (!mBlockErrors)
8409
{
8410
expectedSymbol(AstNode::ConstantOrClassConstKind, "constantOrClassConst");
8411
}
8412
return false;
8413
}
8414
(*yynode)->constantOrClassConst = __node_165;
8415
8416
}
8417
else if (yytoken == Token_STRING_VARNAME)
8418
{
8419
if (yytoken != Token_STRING_VARNAME)
8420
{
8421
if (!mBlockErrors)
8422
{
8423
expectedToken(yytoken, Token_STRING_VARNAME, "string varname");
8424
}
8425
return false;
8426
}
8427
(*yynode)->varname = tokenStream->index() - 1;
8428
yylex();
8429
8430
}
8431
else if (yytoken == Token_DOUBLE_QUOTE)
8432
{
8433
if (yytoken != Token_DOUBLE_QUOTE)
8434
{
8435
if (!mBlockErrors)
8436
{
8437
expectedToken(yytoken, Token_DOUBLE_QUOTE, "\"");
8438
}
8439
return false;
8440
}
8441
yylex();
8442
8443
EncapsListAst *__node_166 = 0;
8444
if (!parseEncapsList(&__node_166))
8445
{
8446
if (!mBlockErrors)
8447
{
8448
expectedSymbol(AstNode::EncapsListKind, "encapsList");
8449
}
8450
return false;
8451
}
8452
(*yynode)->encapsList = __node_166;
8453
8454
if (yytoken != Token_DOUBLE_QUOTE)
8455
{
8456
if (!mBlockErrors)
8457
{
8458
expectedToken(yytoken, Token_DOUBLE_QUOTE, "\"");
8459
}
8460
return false;
8461
}
8462
yylex();
8463
8464
}
8465
else if (yytoken == Token_START_HEREDOC)
8466
{
8467
if (yytoken != Token_START_HEREDOC)
8468
{
8469
if (!mBlockErrors)
8470
{
8471
expectedToken(yytoken, Token_START_HEREDOC, "start heredoc");
8472
}
8473
return false;
8474
}
8475
yylex();
8476
8477
EncapsListAst *__node_167 = 0;
8478
if (!parseEncapsList(&__node_167))
8479
{
8480
if (!mBlockErrors)
8481
{
8482
expectedSymbol(AstNode::EncapsListKind, "encapsList");
8483
}
8484
return false;
8485
}
8486
(*yynode)->encapsList = __node_167;
8487
8488
if (yytoken != Token_END_HEREDOC)
8489
{
8490
if (!mBlockErrors)
8491
{
8492
expectedToken(yytoken, Token_END_HEREDOC, "end heredoc");
8493
}
8494
return false;
8495
}
8496
yylex();
8497
8498
}
8499
else
8500
{
8501
return false;
8502
}
8503
}
8504
else
8505
{
8506
return false;
8507
}
8508
8509
(*yynode)->endToken = tokenStream->index() - 2;
8510
8511
return true;
8512
}
8513
8514
bool Parser::parseSemicolonOrCloseTag(SemicolonOrCloseTagAst **yynode)
8515
{
8516
*yynode = create<SemicolonOrCloseTagAst>();
8517
8518
(*yynode)->startToken = tokenStream->index() - 1;
8519
8520
if (yytoken == Token_CLOSE_TAG
8521
|| yytoken == Token_SEMICOLON)
8522
{
8523
if (yytoken == Token_SEMICOLON)
8524
{
8525
if (yytoken != Token_SEMICOLON)
8526
{
8527
if (!mBlockErrors)
8528
{
8529
expectedToken(yytoken, Token_SEMICOLON, ";");
8530
}
8531
return false;
8532
}
8533
yylex();
8534
8535
}
8536
else if (yytoken == Token_CLOSE_TAG)
8537
{
8538
if (yytoken != Token_CLOSE_TAG)
8539
{
8540
if (!mBlockErrors)
8541
{
8542
expectedToken(yytoken, Token_CLOSE_TAG, "?>");
8543
}
8544
return false;
8545
}
8546
yylex();
8547
8548
}
8549
else
8550
{
8551
return false;
8552
}
8553
}
8554
else
8555
{
8556
return false;
8557
}
8558
8559
(*yynode)->endToken = tokenStream->index() - 2;
8560
8561
return true;
8562
}
8563
8564
bool Parser::parseShiftExpression(ShiftExpressionAst **yynode)
8565
{
8566
*yynode = create<ShiftExpressionAst>();
8567
8568
(*yynode)->startToken = tokenStream->index() - 1;
8569
8570
if (yytoken == Token_ARRAY
8571
|| yytoken == Token_ARRAY_CAST
8572
|| yytoken == Token_AT
8573
|| yytoken == Token_BACKTICK
8574
|| yytoken == Token_BANG
8575
|| yytoken == Token_BOOL_CAST
8576
|| yytoken == Token_CLASS_C
8577
|| yytoken == Token_CLONE
8578
|| yytoken == Token_CONSTANT_ENCAPSED_STRING
8579
|| yytoken == Token_DEC
8580
|| yytoken == Token_DNUMBER
8581
|| yytoken == Token_DOLLAR
8582
|| yytoken == Token_DOUBLE_CAST
8583
|| yytoken == Token_DOUBLE_QUOTE
8584
|| yytoken == Token_EMPTY
8585
|| yytoken == Token_EVAL
8586
|| yytoken == Token_EXIT
8587
|| yytoken == Token_FILE
8588
|| yytoken == Token_FUNC_C
8589
|| yytoken == Token_INC
8590
|| yytoken == Token_INCLUDE
8591
|| yytoken == Token_INCLUDE_ONCE
8592
|| yytoken == Token_INT_CAST
8593
|| yytoken == Token_ISSET
8594
|| yytoken == Token_LINE
8595
|| yytoken == Token_LIST
8596
|| yytoken == Token_LNUMBER
8597
|| yytoken == Token_LPAREN
8598
|| yytoken == Token_METHOD_C
8599
|| yytoken == Token_MINUS
8600
|| yytoken == Token_NEW
8601
|| yytoken == Token_OBJECT_CAST
8602
|| yytoken == Token_PLUS
8603
|| yytoken == Token_REQUIRE
8604
|| yytoken == Token_REQUIRE_ONCE
8605
|| yytoken == Token_START_HEREDOC
8606
|| yytoken == Token_STRING
8607
|| yytoken == Token_STRING_CAST
8608
|| yytoken == Token_STRING_VARNAME
8609
|| yytoken == Token_TILDE
8610
|| yytoken == Token_UNSET_CAST
8611
|| yytoken == Token_VARIABLE)
8612
{
8613
AdditiveExpressionAst *__node_168 = 0;
8614
if (!parseAdditiveExpression(&__node_168))
8615
{
8616
if (!mBlockErrors)
8617
{
8618
expectedSymbol(AstNode::AdditiveExpressionKind, "additiveExpression");
8619
}
8620
return false;
8621
}
8622
(*yynode)->expression = __node_168;
8623
8624
while (yytoken == Token_SL
8625
|| yytoken == Token_SR)
8626
{
8627
ShiftExpressionRestAst *__node_169 = 0;
8628
if (!parseShiftExpressionRest(&__node_169))
8629
{
8630
if (!mBlockErrors)
8631
{
8632
expectedSymbol(AstNode::ShiftExpressionRestKind, "shiftExpressionRest");
8633
}
8634
return false;
8635
}
8636
(*yynode)->additionalExpressionSequence = snoc((*yynode)->additionalExpressionSequence, __node_169, memoryPool);
8637
8638
}
8639
}
8640
else
8641
{
8642
return false;
8643
}
8644
8645
(*yynode)->endToken = tokenStream->index() - 2;
8646
8647
return true;
8648
}
8649
8650
bool Parser::parseShiftExpressionRest(ShiftExpressionRestAst **yynode)
8651
{
8652
*yynode = create<ShiftExpressionRestAst>();
8653
8654
(*yynode)->startToken = tokenStream->index() - 1;
8655
8656
if (yytoken == Token_SL
8657
|| yytoken == Token_SR)
8658
{
8659
if (yytoken == Token_SL)
8660
{
8661
if (yytoken != Token_SL)
8662
{
8663
if (!mBlockErrors)
8664
{
8665
expectedToken(yytoken, Token_SL, "<<");
8666
}
8667
return false;
8668
}
8669
yylex();
8670
8671
}
8672
else if (yytoken == Token_SR)
8673
{
8674
if (yytoken != Token_SR)
8675
{
8676
if (!mBlockErrors)
8677
{
8678
expectedToken(yytoken, Token_SR, ">>");
8679
}
8680
return false;
8681
}
8682
yylex();
8683
8684
}
8685
else
8686
{
8687
return false;
8688
}
8689
AdditiveExpressionAst *__node_170 = 0;
8690
if (!parseAdditiveExpression(&__node_170))
8691
{
8692
if (!mBlockErrors)
8693
{
8694
expectedSymbol(AstNode::AdditiveExpressionKind, "additiveExpression");
8695
}
8696
return false;
8697
}
8698
(*yynode)->expression = __node_170;
8699
8700
}
8701
else
8702
{
8703
return false;
8704
}
8705
8706
(*yynode)->endToken = tokenStream->index() - 2;
8707
8708
return true;
8709
}
8710
8711
bool Parser::parseStart(StartAst **yynode)
8712
{
8713
*yynode = create<StartAst>();
8714
8715
(*yynode)->startToken = tokenStream->index() - 1;
8716
8717
if (yytoken == Token_ABSTRACT
8718
|| yytoken == Token_ARRAY
8719
|| yytoken == Token_ARRAY_CAST
8720
|| yytoken == Token_AT
8721
|| yytoken == Token_BACKTICK
8722
|| yytoken == Token_BANG
8723
|| yytoken == Token_BOOL_CAST
8724
|| yytoken == Token_BREAK
8725
|| yytoken == Token_CLASS
8726
|| yytoken == Token_CLASS_C
8727
|| yytoken == Token_CLONE
8728
|| yytoken == Token_CLOSE_TAG
8729
|| yytoken == Token_CONSTANT_ENCAPSED_STRING
8730
|| yytoken == Token_CONTINUE
8731
|| yytoken == Token_DEC
8732
|| yytoken == Token_DECLARE
8733
|| yytoken == Token_DNUMBER
8734
|| yytoken == Token_DO
8735
|| yytoken == Token_DOLLAR
8736
|| yytoken == Token_DOUBLE_CAST
8737
|| yytoken == Token_DOUBLE_QUOTE
8738
|| yytoken == Token_ECHO
8739
|| yytoken == Token_EMPTY
8740
|| yytoken == Token_EVAL
8741
|| yytoken == Token_EXIT
8742
|| yytoken == Token_FILE
8743
|| yytoken == Token_FINAL
8744
|| yytoken == Token_FOR
8745
|| yytoken == Token_FOREACH
8746
|| yytoken == Token_FUNCTION
8747
|| yytoken == Token_FUNC_C
8748
|| yytoken == Token_GLOBAL
8749
|| yytoken == Token_HALT_COMPILER
8750
|| yytoken == Token_IF
8751
|| yytoken == Token_INC
8752
|| yytoken == Token_INCLUDE
8753
|| yytoken == Token_INCLUDE_ONCE
8754
|| yytoken == Token_INLINE_HTML
8755
|| yytoken == Token_INTERFACE
8756
|| yytoken == Token_INT_CAST
8757
|| yytoken == Token_ISSET
8758
|| yytoken == Token_LBRACE
8759
|| yytoken == Token_LINE
8760
|| yytoken == Token_LIST
8761
|| yytoken == Token_LNUMBER
8762
|| yytoken == Token_LPAREN
8763
|| yytoken == Token_METHOD_C
8764
|| yytoken == Token_MINUS
8765
|| yytoken == Token_NEW
8766
|| yytoken == Token_OBJECT_CAST
8767
|| yytoken == Token_OPEN_TAG
8768
|| yytoken == Token_OPEN_TAG_WITH_ECHO
8769
|| yytoken == Token_PLUS
8770
|| yytoken == Token_PRINT
8771
|| yytoken == Token_REQUIRE
8772
|| yytoken == Token_REQUIRE_ONCE
8773
|| yytoken == Token_RETURN
8774
|| yytoken == Token_SEMICOLON
8775
|| yytoken == Token_START_HEREDOC
8776
|| yytoken == Token_STATIC
8777
|| yytoken == Token_STRING
8778
|| yytoken == Token_STRING_CAST
8779
|| yytoken == Token_STRING_VARNAME
8780
|| yytoken == Token_SWITCH
8781
|| yytoken == Token_THROW
8782
|| yytoken == Token_TILDE
8783
|| yytoken == Token_TRY
8784
|| yytoken == Token_UNSET
8785
|| yytoken == Token_UNSET_CAST
8786
|| yytoken == Token_VARIABLE
8787
|| yytoken == Token_WHILE || yytoken == Token_EOF)
8788
{
8789
InnerStatementListAst *__node_171 = 0;
8790
if (!parseInnerStatementList(&__node_171))
8791
{
8792
if (!mBlockErrors)
8793
{
8794
expectedSymbol(AstNode::InnerStatementListKind, "innerStatementList");
8795
}
8796
return false;
8797
}
8798
(*yynode)->statements = __node_171;
8799
8800
if (Token_EOF != yytoken)
8801
{
8802
return false;
8803
}
8804
}
8805
else
8806
{
8807
return false;
8808
}
8809
8810
(*yynode)->endToken = tokenStream->index() - 2;
8811
8812
return true;
8813
}
8814
8815
bool Parser::parseStatement(StatementAst **yynode)
8816
{
8817
*yynode = create<StatementAst>();
8818
8819
(*yynode)->startToken = tokenStream->index() - 1;
8820
8821
if (yytoken == Token_ARRAY
8822
|| yytoken == Token_ARRAY_CAST
8823
|| yytoken == Token_AT
8824
|| yytoken == Token_BACKTICK
8825
|| yytoken == Token_BANG
8826
|| yytoken == Token_BOOL_CAST
8827
|| yytoken == Token_BREAK
8828
|| yytoken == Token_CLASS_C
8829
|| yytoken == Token_CLONE
8830
|| yytoken == Token_CLOSE_TAG
8831
|| yytoken == Token_CONSTANT_ENCAPSED_STRING
8832
|| yytoken == Token_CONTINUE
8833
|| yytoken == Token_DEC
8834
|| yytoken == Token_DECLARE
8835
|| yytoken == Token_DNUMBER
8836
|| yytoken == Token_DO
8837
|| yytoken == Token_DOLLAR
8838
|| yytoken == Token_DOUBLE_CAST
8839
|| yytoken == Token_DOUBLE_QUOTE
8840
|| yytoken == Token_ECHO
8841
|| yytoken == Token_EMPTY
8842
|| yytoken == Token_EVAL
8843
|| yytoken == Token_EXIT
8844
|| yytoken == Token_FILE
8845
|| yytoken == Token_FOR
8846
|| yytoken == Token_FOREACH
8847
|| yytoken == Token_FUNC_C
8848
|| yytoken == Token_GLOBAL
8849
|| yytoken == Token_IF
8850
|| yytoken == Token_INC
8851
|| yytoken == Token_INCLUDE
8852
|| yytoken == Token_INCLUDE_ONCE
8853
|| yytoken == Token_INLINE_HTML
8854
|| yytoken == Token_INT_CAST
8855
|| yytoken == Token_ISSET
8856
|| yytoken == Token_LBRACE
8857
|| yytoken == Token_LINE
8858
|| yytoken == Token_LIST
8859
|| yytoken == Token_LNUMBER
8860
|| yytoken == Token_LPAREN
8861
|| yytoken == Token_METHOD_C
8862
|| yytoken == Token_MINUS
8863
|| yytoken == Token_NEW
8864
|| yytoken == Token_OBJECT_CAST
8865
|| yytoken == Token_OPEN_TAG
8866
|| yytoken == Token_OPEN_TAG_WITH_ECHO
8867
|| yytoken == Token_PLUS
8868
|| yytoken == Token_PRINT
8869
|| yytoken == Token_REQUIRE
8870
|| yytoken == Token_REQUIRE_ONCE
8871
|| yytoken == Token_RETURN
8872
|| yytoken == Token_SEMICOLON
8873
|| yytoken == Token_START_HEREDOC
8874
|| yytoken == Token_STATIC
8875
|| yytoken == Token_STRING
8876
|| yytoken == Token_STRING_CAST
8877
|| yytoken == Token_STRING_VARNAME
8878
|| yytoken == Token_SWITCH
8879
|| yytoken == Token_THROW
8880
|| yytoken == Token_TILDE
8881
|| yytoken == Token_TRY
8882
|| yytoken == Token_UNSET
8883
|| yytoken == Token_UNSET_CAST
8884
|| yytoken == Token_VARIABLE
8885
|| yytoken == Token_WHILE)
8886
{
8887
if (yytoken == Token_LBRACE)
8888
{
8889
if (yytoken != Token_LBRACE)
8890
{
8891
if (!mBlockErrors)
8892
{
8893
expectedToken(yytoken, Token_LBRACE, "{");
8894
}
8895
return false;
8896
}
8897
yylex();
8898
8899
InnerStatementListAst *__node_172 = 0;
8900
if (!parseInnerStatementList(&__node_172))
8901
{
8902
if (!mBlockErrors)
8903
{
8904
expectedSymbol(AstNode::InnerStatementListKind, "innerStatementList");
8905
}
8906
return false;
8907
}
8908
(*yynode)->statements = __node_172;
8909
8910
if (yytoken != Token_RBRACE)
8911
{
8912
if (!mBlockErrors)
8913
{
8914
expectedToken(yytoken, Token_RBRACE, "}");
8915
}
8916
return false;
8917
}
8918
yylex();
8919
8920
}
8921
else if (yytoken == Token_IF)
8922
{
8923
if (yytoken != Token_IF)
8924
{
8925
if (!mBlockErrors)
8926
{
8927
expectedToken(yytoken, Token_IF, "if");
8928
}
8929
return false;
8930
}
8931
yylex();
8932
8933
if (yytoken != Token_LPAREN)
8934
{
8935
if (!mBlockErrors)
8936
{
8937
expectedToken(yytoken, Token_LPAREN, "(");
8938
}
8939
return false;
8940
}
8941
yylex();
8942
8943
ExprAst *__node_173 = 0;
8944
if (!parseExpr(&__node_173))
8945
{
8946
if (!mBlockErrors)
8947
{
8948
expectedSymbol(AstNode::ExprKind, "expr");
8949
}
8950
return false;
8951
}
8952
(*yynode)->ifExpr = __node_173;
8953
8954
if (yytoken != Token_RPAREN)
8955
{
8956
if (!mBlockErrors)
8957
{
8958
expectedToken(yytoken, Token_RPAREN, ")");
8959
}
8960
return false;
8961
}
8962
yylex();
8963
8964
if (yytoken == Token_COLON)
8965
{
8966
if (yytoken != Token_COLON)
8967
{
8968
if (!mBlockErrors)
8969
{
8970
expectedToken(yytoken, Token_COLON, ":");
8971
}
8972
return false;
8973
}
8974
yylex();
8975
8976
InnerStatementListAst *__node_174 = 0;
8977
if (!parseInnerStatementList(&__node_174))
8978
{
8979
if (!mBlockErrors)
8980
{
8981
expectedSymbol(AstNode::InnerStatementListKind, "innerStatementList");
8982
}
8983
return false;
8984
}
8985
(*yynode)->statements = __node_174;
8986
8987
NewElseifListAst *__node_175 = 0;
8988
if (!parseNewElseifList(&__node_175))
8989
{
8990
if (!mBlockErrors)
8991
{
8992
expectedSymbol(AstNode::NewElseifListKind, "newElseifList");
8993
}
8994
return false;
8995
}
8996
NewElseSingleAst *__node_176 = 0;
8997
if (!parseNewElseSingle(&__node_176))
8998
{
8999
if (!mBlockErrors)
9000
{
9001
expectedSymbol(AstNode::NewElseSingleKind, "newElseSingle");
9002
}
9003
return false;
9004
}
9005
if (yytoken != Token_ENDIF)
9006
{
9007
if (!mBlockErrors)
9008
{
9009
expectedToken(yytoken, Token_ENDIF, "endif");
9010
}
9011
return false;
9012
}
9013
yylex();
9014
9015
SemicolonOrCloseTagAst *__node_177 = 0;
9016
if (!parseSemicolonOrCloseTag(&__node_177))
9017
{
9018
if (!mBlockErrors)
9019
{
9020
expectedSymbol(AstNode::SemicolonOrCloseTagKind, "semicolonOrCloseTag");
9021
}
9022
return false;
9023
}
9024
}
9025
else if (yytoken == Token_ARRAY
9026
|| yytoken == Token_ARRAY_CAST
9027
|| yytoken == Token_AT
9028
|| yytoken == Token_BACKTICK
9029
|| yytoken == Token_BANG
9030
|| yytoken == Token_BOOL_CAST
9031
|| yytoken == Token_BREAK
9032
|| yytoken == Token_CLASS_C
9033
|| yytoken == Token_CLONE
9034
|| yytoken == Token_CLOSE_TAG
9035
|| yytoken == Token_CONSTANT_ENCAPSED_STRING
9036
|| yytoken == Token_CONTINUE
9037
|| yytoken == Token_DEC
9038
|| yytoken == Token_DECLARE
9039
|| yytoken == Token_DNUMBER
9040
|| yytoken == Token_DO
9041
|| yytoken == Token_DOLLAR
9042
|| yytoken == Token_DOUBLE_CAST
9043
|| yytoken == Token_DOUBLE_QUOTE
9044
|| yytoken == Token_ECHO
9045
|| yytoken == Token_EMPTY
9046
|| yytoken == Token_EVAL
9047
|| yytoken == Token_EXIT
9048
|| yytoken == Token_FILE
9049
|| yytoken == Token_FOR
9050
|| yytoken == Token_FOREACH
9051
|| yytoken == Token_FUNC_C
9052
|| yytoken == Token_GLOBAL
9053
|| yytoken == Token_IF
9054
|| yytoken == Token_INC
9055
|| yytoken == Token_INCLUDE
9056
|| yytoken == Token_INCLUDE_ONCE
9057
|| yytoken == Token_INLINE_HTML
9058
|| yytoken == Token_INT_CAST
9059
|| yytoken == Token_ISSET
9060
|| yytoken == Token_LBRACE
9061
|| yytoken == Token_LINE
9062
|| yytoken == Token_LIST
9063
|| yytoken == Token_LNUMBER
9064
|| yytoken == Token_LPAREN
9065
|| yytoken == Token_METHOD_C
9066
|| yytoken == Token_MINUS
9067
|| yytoken == Token_NEW
9068
|| yytoken == Token_OBJECT_CAST
9069
|| yytoken == Token_OPEN_TAG
9070
|| yytoken == Token_OPEN_TAG_WITH_ECHO
9071
|| yytoken == Token_PLUS
9072
|| yytoken == Token_PRINT
9073
|| yytoken == Token_REQUIRE
9074
|| yytoken == Token_REQUIRE_ONCE
9075
|| yytoken == Token_RETURN
9076
|| yytoken == Token_SEMICOLON
9077
|| yytoken == Token_START_HEREDOC
9078
|| yytoken == Token_STATIC
9079
|| yytoken == Token_STRING
9080
|| yytoken == Token_STRING_CAST
9081
|| yytoken == Token_STRING_VARNAME
9082
|| yytoken == Token_SWITCH
9083
|| yytoken == Token_THROW
9084
|| yytoken == Token_TILDE
9085
|| yytoken == Token_TRY
9086
|| yytoken == Token_UNSET
9087
|| yytoken == Token_UNSET_CAST
9088
|| yytoken == Token_VARIABLE
9089
|| yytoken == Token_WHILE)
9090
{
9091
StatementAst *__node_178 = 0;
9092
if (!parseStatement(&__node_178))
9093
{
9094
if (!mBlockErrors)
9095
{
9096
expectedSymbol(AstNode::StatementKind, "statement");
9097
}
9098
return false;
9099
}
9100
(*yynode)->ifStatement = __node_178;
9101
9102
ElseifListAst *__node_179 = 0;
9103
if (!parseElseifList(&__node_179))
9104
{
9105
if (!mBlockErrors)
9106
{
9107
expectedSymbol(AstNode::ElseifListKind, "elseifList");
9108
}
9109
return false;
9110
}
9111
(*yynode)->elseifList = __node_179;
9112
9113
ElseSingleAst *__node_180 = 0;
9114
if (!parseElseSingle(&__node_180))
9115
{
9116
if (!mBlockErrors)
9117
{
9118
expectedSymbol(AstNode::ElseSingleKind, "elseSingle");
9119
}
9120
return false;
9121
}
9122
(*yynode)->elseSingle = __node_180;
9123
9124
}
9125
else
9126
{
9127
return false;
9128
}
9129
}
9130
else if (yytoken == Token_WHILE)
9131
{
9132
if (yytoken != Token_WHILE)
9133
{
9134
if (!mBlockErrors)
9135
{
9136
expectedToken(yytoken, Token_WHILE, "while");
9137
}
9138
return false;
9139
}
9140
yylex();
9141
9142
if (yytoken != Token_LPAREN)
9143
{
9144
if (!mBlockErrors)
9145
{
9146
expectedToken(yytoken, Token_LPAREN, "(");
9147
}
9148
return false;
9149
}
9150
yylex();
9151
9152
ExprAst *__node_181 = 0;
9153
if (!parseExpr(&__node_181))
9154
{
9155
if (!mBlockErrors)
9156
{
9157
expectedSymbol(AstNode::ExprKind, "expr");
9158
}
9159
return false;
9160
}
9161
(*yynode)->whileExpr = __node_181;
9162
9163
if (yytoken != Token_RPAREN)
9164
{
9165
if (!mBlockErrors)
9166
{
9167
expectedToken(yytoken, Token_RPAREN, ")");
9168
}
9169
return false;
9170
}
9171
yylex();
9172
9173
WhileStatementAst *__node_182 = 0;
9174
if (!parseWhileStatement(&__node_182))
9175
{
9176
if (!mBlockErrors)
9177
{
9178
expectedSymbol(AstNode::WhileStatementKind, "whileStatement");
9179
}
9180
return false;
9181
}
9182
(*yynode)->whilteStatement = __node_182;
9183
9184
}
9185
else if (yytoken == Token_FOR)
9186
{
9187
if (yytoken != Token_FOR)
9188
{
9189
if (!mBlockErrors)
9190
{
9191
expectedToken(yytoken, Token_FOR, "for");
9192
}
9193
return false;
9194
}
9195
yylex();
9196
9197
if (yytoken != Token_LPAREN)
9198
{
9199
if (!mBlockErrors)
9200
{
9201
expectedToken(yytoken, Token_LPAREN, "(");
9202
}
9203
return false;
9204
}
9205
yylex();
9206
9207
ForExprAst *__node_183 = 0;
9208
if (!parseForExpr(&__node_183))
9209
{
9210
if (!mBlockErrors)
9211
{
9212
expectedSymbol(AstNode::ForExprKind, "forExpr");
9213
}
9214
return false;
9215
}
9216
(*yynode)->forExpr1 = __node_183;
9217
9218
if (yytoken != Token_SEMICOLON)
9219
{
9220
if (!mBlockErrors)
9221
{
9222
expectedToken(yytoken, Token_SEMICOLON, ";");
9223
}
9224
return false;
9225
}
9226
yylex();
9227
9228
ForExprAst *__node_184 = 0;
9229
if (!parseForExpr(&__node_184))
9230
{
9231
if (!mBlockErrors)
9232
{
9233
expectedSymbol(AstNode::ForExprKind, "forExpr");
9234
}
9235
return false;
9236
}
9237
(*yynode)->forExpr2 = __node_184;
9238
9239
if (yytoken != Token_SEMICOLON)
9240
{
9241
if (!mBlockErrors)
9242
{
9243
expectedToken(yytoken, Token_SEMICOLON, ";");
9244
}
9245
return false;
9246
}
9247
yylex();
9248
9249
ForExprAst *__node_185 = 0;
9250
if (!parseForExpr(&__node_185))
9251
{
9252
if (!mBlockErrors)
9253
{
9254
expectedSymbol(AstNode::ForExprKind, "forExpr");
9255
}
9256
return false;
9257
}
9258
(*yynode)->forExpr3 = __node_185;
9259
9260
if (yytoken != Token_RPAREN)
9261
{
9262
if (!mBlockErrors)
9263
{
9264
expectedToken(yytoken, Token_RPAREN, ")");
9265
}
9266
return false;
9267
}
9268
yylex();
9269
9270
ForStatementAst *__node_186 = 0;
9271
if (!parseForStatement(&__node_186))
9272
{
9273
if (!mBlockErrors)
9274
{
9275
expectedSymbol(AstNode::ForStatementKind, "forStatement");
9276
}
9277
return false;
9278
}
9279
(*yynode)->forStatement = __node_186;
9280
9281
}
9282
else if (yytoken == Token_SWITCH)
9283
{
9284
if (yytoken != Token_SWITCH)
9285
{
9286
if (!mBlockErrors)
9287
{
9288
expectedToken(yytoken, Token_SWITCH, "switch");
9289
}
9290
return false;
9291
}
9292
yylex();
9293
9294
if (yytoken != Token_LPAREN)
9295
{
9296
if (!mBlockErrors)
9297
{
9298
expectedToken(yytoken, Token_LPAREN, "(");
9299
}
9300
return false;
9301
}
9302
yylex();
9303
9304
ExprAst *__node_187 = 0;
9305
if (!parseExpr(&__node_187))
9306
{
9307
if (!mBlockErrors)
9308
{
9309
expectedSymbol(AstNode::ExprKind, "expr");
9310
}
9311
return false;
9312
}
9313
(*yynode)->swtichExpr = __node_187;
9314
9315
if (yytoken != Token_RPAREN)
9316
{
9317
if (!mBlockErrors)
9318
{
9319
expectedToken(yytoken, Token_RPAREN, ")");
9320
}
9321
return false;
9322
}
9323
yylex();
9324
9325
SwitchCaseListAst *__node_188 = 0;
9326
if (!parseSwitchCaseList(&__node_188))
9327
{
9328
if (!mBlockErrors)
9329
{
9330
expectedSymbol(AstNode::SwitchCaseListKind, "switchCaseList");
9331
}
9332
return false;
9333
}
9334
(*yynode)->switchCaseList = __node_188;
9335
9336
}
9337
else if (yytoken == Token_FOREACH)
9338
{
9339
if (yytoken != Token_FOREACH)
9340
{
9341
if (!mBlockErrors)
9342
{
9343
expectedToken(yytoken, Token_FOREACH, "foreach");
9344
}
9345
return false;
9346
}
9347
yylex();
9348
9349
if (yytoken != Token_LPAREN)
9350
{
9351
if (!mBlockErrors)
9352
{
9353
expectedToken(yytoken, Token_LPAREN, "(");
9354
}
9355
return false;
9356
}
9357
yylex();
9358
9359
bool blockErrors_2 = blockErrors(true);
9360
qint64 try_startToken_2 = tokenStream->index() - 1;
9361
ParserState *try_startState_2 = copyCurrentState();
9362
{
9363
VariableAst *__node_189 = 0;
9364
if (!parseVariable(&__node_189))
9365
{
9366
goto __catch_2;
9367
}
9368
(*yynode)->foreachVar = __node_189;
9369
9370
if (yytoken != Token_AS)
9371
goto __catch_2;
9372
yylex();
9373
9374
ForeachVariableAst *__node_190 = 0;
9375
if (!parseForeachVariable(&__node_190))
9376
{
9377
goto __catch_2;
9378
}
9379
(*yynode)->foreachVarAsVar = __node_190;
9380
9381
}
9382
blockErrors(blockErrors_2);
9383
if (try_startState_2)
9384
delete try_startState_2;
9385
9386
if (false) // the only way to enter here is using goto
9387
{
9388
__catch_2:
9389
if (try_startState_2)
9390
{
9391
restoreState(try_startState_2);
9392
delete try_startState_2;
9393
}
9394
blockErrors(blockErrors_2);
9395
rewind(try_startToken_2);
9396
9397
ExprAst *__node_191 = 0;
9398
if (!parseExpr(&__node_191))
9399
{
9400
if (!mBlockErrors)
9401
{
9402
expectedSymbol(AstNode::ExprKind, "expr");
9403
}
9404
return false;
9405
}
9406
(*yynode)->foreachExpr = __node_191;
9407
9408
if (yytoken != Token_AS)
9409
{
9410
if (!mBlockErrors)
9411
{
9412
expectedToken(yytoken, Token_AS, "as");
9413
}
9414
return false;
9415
}
9416
yylex();
9417
9418
VariableIdentifierAst *__node_192 = 0;
9419
if (!parseVariableIdentifier(&__node_192))
9420
{
9421
if (!mBlockErrors)
9422
{
9423
expectedSymbol(AstNode::VariableIdentifierKind, "variableIdentifier");
9424
}
9425
return false;
9426
}
9427
(*yynode)->foreachExprAsVar = __node_192;
9428
9429
}
9430
9431
if (yytoken == Token_DOUBLE_ARROW)
9432
{
9433
if (yytoken != Token_DOUBLE_ARROW)
9434
{
9435
if (!mBlockErrors)
9436
{
9437
expectedToken(yytoken, Token_DOUBLE_ARROW, "=>");
9438
}
9439
return false;
9440
}
9441
yylex();
9442
9443
ForeachVariableAst *__node_193 = 0;
9444
if (!parseForeachVariable(&__node_193))
9445
{
9446
if (!mBlockErrors)
9447
{
9448
expectedSymbol(AstNode::ForeachVariableKind, "foreachVariable");
9449
}
9450
return false;
9451
}
9452
(*yynode)->foreachVariable = __node_193;
9453
9454
}
9455
else if (true /*epsilon*/)
9456
{
9457
}
9458
else
9459
{
9460
return false;
9461
}
9462
if (yytoken != Token_RPAREN)
9463
{
9464
if (!mBlockErrors)
9465
{
9466
expectedToken(yytoken, Token_RPAREN, ")");
9467
}
9468
return false;
9469
}
9470
yylex();
9471
9472
ForeachStatementAst *__node_194 = 0;
9473
if (!parseForeachStatement(&__node_194))
9474
{
9475
if (!mBlockErrors)
9476
{
9477
expectedSymbol(AstNode::ForeachStatementKind, "foreachStatement");
9478
}
9479
return false;
9480
}
9481
(*yynode)->foreachStatement = __node_194;
9482
9483
}
9484
else if (yytoken == Token_DECLARE)
9485
{
9486
if (yytoken != Token_DECLARE)
9487
{
9488
if (!mBlockErrors)
9489
{
9490
expectedToken(yytoken, Token_DECLARE, "declare");
9491
}
9492
return false;
9493
}
9494
yylex();
9495
9496
if (yytoken != Token_LPAREN)
9497
{
9498
if (!mBlockErrors)
9499
{
9500
expectedToken(yytoken, Token_LPAREN, "(");
9501
}
9502
return false;
9503
}
9504
yylex();
9505
9506
DeclareItemAst *__node_195 = 0;
9507
if (!parseDeclareItem(&__node_195))
9508
{
9509
if (!mBlockErrors)
9510
{
9511
expectedSymbol(AstNode::DeclareItemKind, "declareItem");
9512
}
9513
return false;
9514
}
9515
(*yynode)->declareItem = __node_195;
9516
9517
while (yytoken == Token_COMMA)
9518
{
9519
if (yytoken != Token_COMMA)
9520
{
9521
if (!mBlockErrors)
9522
{
9523
expectedToken(yytoken, Token_COMMA, ",");
9524
}
9525
return false;
9526
}
9527
yylex();
9528
9529
DeclareItemAst *__node_196 = 0;
9530
if (!parseDeclareItem(&__node_196))
9531
{
9532
if (!mBlockErrors)
9533
{
9534
expectedSymbol(AstNode::DeclareItemKind, "declareItem");
9535
}
9536
return false;
9537
}
9538
(*yynode)->declareItem = __node_196;
9539
9540
}
9541
if (yytoken != Token_RPAREN)
9542
{
9543
if (!mBlockErrors)
9544
{
9545
expectedToken(yytoken, Token_RPAREN, ")");
9546
}
9547
return false;
9548
}
9549
yylex();
9550
9551
DeclareStatementAst *__node_197 = 0;
9552
if (!parseDeclareStatement(&__node_197))
9553
{
9554
if (!mBlockErrors)
9555
{
9556
expectedSymbol(AstNode::DeclareStatementKind, "declareStatement");
9557
}
9558
return false;
9559
}
9560
}
9561
else if (yytoken == Token_SEMICOLON)
9562
{
9563
if (yytoken != Token_SEMICOLON)
9564
{
9565
if (!mBlockErrors)
9566
{
9567
expectedToken(yytoken, Token_SEMICOLON, ";");
9568
}
9569
return false;
9570
}
9571
yylex();
9572
9573
}
9574
else if (yytoken == Token_TRY)
9575
{
9576
if (yytoken != Token_TRY)
9577
{
9578
if (!mBlockErrors)
9579
{
9580
expectedToken(yytoken, Token_TRY, "try");
9581
}
9582
return false;
9583
}
9584
yylex();
9585
9586
if (yytoken != Token_LBRACE)
9587
{
9588
if (!mBlockErrors)
9589
{
9590
expectedToken(yytoken, Token_LBRACE, "{");
9591
}
9592
return false;
9593
}
9594
yylex();
9595
9596
InnerStatementListAst *__node_198 = 0;
9597
if (!parseInnerStatementList(&__node_198))
9598
{
9599
if (!mBlockErrors)
9600
{
9601
expectedSymbol(AstNode::InnerStatementListKind, "innerStatementList");
9602
}
9603
return false;
9604
}
9605
(*yynode)->statements = __node_198;
9606
9607
if (yytoken != Token_RBRACE)
9608
{
9609
if (!mBlockErrors)
9610
{
9611
expectedToken(yytoken, Token_RBRACE, "}");
9612
}
9613
return false;
9614
}
9615
yylex();
9616
9617
while (yytoken == Token_CATCH)
9618
{
9619
CatchItemAst *__node_199 = 0;
9620
if (!parseCatchItem(&__node_199))
9621
{
9622
if (!mBlockErrors)
9623
{
9624
expectedSymbol(AstNode::CatchItemKind, "catchItem");
9625
}
9626
return false;
9627
}
9628
(*yynode)->catchesSequence = snoc((*yynode)->catchesSequence, __node_199, memoryPool);
9629
9630
}
9631
}
9632
else if (yytoken == Token_UNSET)
9633
{
9634
if (yytoken != Token_UNSET)
9635
{
9636
if (!mBlockErrors)
9637
{
9638
expectedToken(yytoken, Token_UNSET, "unset");
9639
}
9640
return false;
9641
}
9642
yylex();
9643
9644
if (yytoken != Token_LPAREN)
9645
{
9646
if (!mBlockErrors)
9647
{
9648
expectedToken(yytoken, Token_LPAREN, "(");
9649
}
9650
return false;
9651
}
9652
yylex();
9653
9654
VariableAst *__node_200 = 0;
9655
if (!parseVariable(&__node_200))
9656
{
9657
if (!mBlockErrors)
9658
{
9659
expectedSymbol(AstNode::VariableKind, "variable");
9660
}
9661
return false;
9662
}
9663
(*yynode)->unsetVariablesSequence = snoc((*yynode)->unsetVariablesSequence, __node_200, memoryPool);
9664
9665
while (yytoken == Token_COMMA)
9666
{
9667
if (yytoken != Token_COMMA)
9668
{
9669
if (!mBlockErrors)
9670
{
9671
expectedToken(yytoken, Token_COMMA, ",");
9672
}
9673
return false;
9674
}
9675
yylex();
9676
9677
VariableAst *__node_201 = 0;
9678
if (!parseVariable(&__node_201))
9679
{
9680
if (!mBlockErrors)
9681
{
9682
expectedSymbol(AstNode::VariableKind, "variable");
9683
}
9684
return false;
9685
}
9686
(*yynode)->unsetVariablesSequence = snoc((*yynode)->unsetVariablesSequence, __node_201, memoryPool);
9687
9688
}
9689
if (yytoken != Token_RPAREN)
9690
{
9691
if (!mBlockErrors)
9692
{
9693
expectedToken(yytoken, Token_RPAREN, ")");
9694
}
9695
return false;
9696
}
9697
yylex();
9698
9699
SemicolonOrCloseTagAst *__node_202 = 0;
9700
if (!parseSemicolonOrCloseTag(&__node_202))
9701
{
9702
if (!mBlockErrors)
9703
{
9704
expectedSymbol(AstNode::SemicolonOrCloseTagKind, "semicolonOrCloseTag");
9705
}
9706
return false;
9707
}
9708
}
9709
else if (yytoken == Token_ARRAY
9710
|| yytoken == Token_ARRAY_CAST
9711
|| yytoken == Token_AT
9712
|| yytoken == Token_BACKTICK
9713
|| yytoken == Token_BANG
9714
|| yytoken == Token_BOOL_CAST
9715
|| yytoken == Token_CLASS_C
9716
|| yytoken == Token_CLONE
9717
|| yytoken == Token_CONSTANT_ENCAPSED_STRING
9718
|| yytoken == Token_DEC
9719
|| yytoken == Token_DNUMBER
9720
|| yytoken == Token_DOLLAR
9721
|| yytoken == Token_DOUBLE_CAST
9722
|| yytoken == Token_DOUBLE_QUOTE
9723
|| yytoken == Token_EMPTY
9724
|| yytoken == Token_EVAL
9725
|| yytoken == Token_EXIT
9726
|| yytoken == Token_FILE
9727
|| yytoken == Token_FUNC_C
9728
|| yytoken == Token_INC
9729
|| yytoken == Token_INCLUDE
9730
|| yytoken == Token_INCLUDE_ONCE
9731
|| yytoken == Token_INT_CAST
9732
|| yytoken == Token_ISSET
9733
|| yytoken == Token_LINE
9734
|| yytoken == Token_LIST
9735
|| yytoken == Token_LNUMBER
9736
|| yytoken == Token_LPAREN
9737
|| yytoken == Token_METHOD_C
9738
|| yytoken == Token_MINUS
9739
|| yytoken == Token_NEW
9740
|| yytoken == Token_OBJECT_CAST
9741
|| yytoken == Token_PLUS
9742
|| yytoken == Token_PRINT
9743
|| yytoken == Token_REQUIRE
9744
|| yytoken == Token_REQUIRE_ONCE
9745
|| yytoken == Token_START_HEREDOC
9746
|| yytoken == Token_STRING
9747
|| yytoken == Token_STRING_CAST
9748
|| yytoken == Token_STRING_VARNAME
9749
|| yytoken == Token_TILDE
9750
|| yytoken == Token_UNSET_CAST
9751
|| yytoken == Token_VARIABLE)
9752
{
9753
ExprAst *__node_203 = 0;
9754
if (!parseExpr(&__node_203))
9755
{
9756
if (!mBlockErrors)
9757
{
9758
expectedSymbol(AstNode::ExprKind, "expr");
9759
}
9760
return false;
9761
}
9762
(*yynode)->expr = __node_203;
9763
9764
SemicolonOrCloseTagAst *__node_204 = 0;
9765
if (!parseSemicolonOrCloseTag(&__node_204))
9766
{
9767
if (!mBlockErrors)
9768
{
9769
expectedSymbol(AstNode::SemicolonOrCloseTagKind, "semicolonOrCloseTag");
9770
}
9771
return false;
9772
}
9773
}
9774
else if (yytoken == Token_DO)
9775
{
9776
if (yytoken != Token_DO)
9777
{
9778
if (!mBlockErrors)
9779
{
9780
expectedToken(yytoken, Token_DO, "do");
9781
}
9782
return false;
9783
}
9784
yylex();
9785
9786
StatementAst *__node_205 = 0;
9787
if (!parseStatement(&__node_205))
9788
{
9789
if (!mBlockErrors)
9790
{
9791
expectedSymbol(AstNode::StatementKind, "statement");
9792
}
9793
return false;
9794
}
9795
(*yynode)->doStatement = __node_205;
9796
9797
if (yytoken != Token_WHILE)
9798
{
9799
if (!mBlockErrors)
9800
{
9801
expectedToken(yytoken, Token_WHILE, "while");
9802
}
9803
return false;
9804
}
9805
yylex();
9806
9807
if (yytoken != Token_LPAREN)
9808
{
9809
if (!mBlockErrors)
9810
{
9811
expectedToken(yytoken, Token_LPAREN, "(");
9812
}
9813
return false;
9814
}
9815
yylex();
9816
9817
ExprAst *__node_206 = 0;
9818
if (!parseExpr(&__node_206))
9819
{
9820
if (!mBlockErrors)
9821
{
9822
expectedSymbol(AstNode::ExprKind, "expr");
9823
}
9824
return false;
9825
}
9826
(*yynode)->whilteExpr = __node_206;
9827
9828
if (yytoken != Token_RPAREN)
9829
{
9830
if (!mBlockErrors)
9831
{
9832
expectedToken(yytoken, Token_RPAREN, ")");
9833
}
9834
return false;
9835
}
9836
yylex();
9837
9838
SemicolonOrCloseTagAst *__node_207 = 0;
9839
if (!parseSemicolonOrCloseTag(&__node_207))
9840
{
9841
if (!mBlockErrors)
9842
{
9843
expectedSymbol(AstNode::SemicolonOrCloseTagKind, "semicolonOrCloseTag");
9844
}
9845
return false;
9846
}
9847
}
9848
else if (yytoken == Token_BREAK)
9849
{
9850
if (yytoken != Token_BREAK)
9851
{
9852
if (!mBlockErrors)
9853
{
9854
expectedToken(yytoken, Token_BREAK, "break");
9855
}
9856
return false;
9857
}
9858
yylex();
9859
9860
if (yytoken == Token_ARRAY
9861
|| yytoken == Token_ARRAY_CAST
9862
|| yytoken == Token_AT
9863
|| yytoken == Token_BACKTICK
9864
|| yytoken == Token_BANG
9865
|| yytoken == Token_BOOL_CAST
9866
|| yytoken == Token_CLASS_C
9867
|| yytoken == Token_CLONE
9868
|| yytoken == Token_CONSTANT_ENCAPSED_STRING
9869
|| yytoken == Token_DEC
9870
|| yytoken == Token_DNUMBER
9871
|| yytoken == Token_DOLLAR
9872
|| yytoken == Token_DOUBLE_CAST
9873
|| yytoken == Token_DOUBLE_QUOTE
9874
|| yytoken == Token_EMPTY
9875
|| yytoken == Token_EVAL
9876
|| yytoken == Token_EXIT
9877
|| yytoken == Token_FILE
9878
|| yytoken == Token_FUNC_C
9879
|| yytoken == Token_INC
9880
|| yytoken == Token_INCLUDE
9881
|| yytoken == Token_INCLUDE_ONCE
9882
|| yytoken == Token_INT_CAST
9883
|| yytoken == Token_ISSET
9884
|| yytoken == Token_LINE
9885
|| yytoken == Token_LIST
9886
|| yytoken == Token_LNUMBER
9887
|| yytoken == Token_LPAREN
9888
|| yytoken == Token_METHOD_C
9889
|| yytoken == Token_MINUS
9890
|| yytoken == Token_NEW
9891
|| yytoken == Token_OBJECT_CAST
9892
|| yytoken == Token_PLUS
9893
|| yytoken == Token_PRINT
9894
|| yytoken == Token_REQUIRE
9895
|| yytoken == Token_REQUIRE_ONCE
9896
|| yytoken == Token_START_HEREDOC
9897
|| yytoken == Token_STRING
9898
|| yytoken == Token_STRING_CAST
9899
|| yytoken == Token_STRING_VARNAME
9900
|| yytoken == Token_TILDE
9901
|| yytoken == Token_UNSET_CAST
9902
|| yytoken == Token_VARIABLE)
9903
{
9904
ExprAst *__node_208 = 0;
9905
if (!parseExpr(&__node_208))
9906
{
9907
if (!mBlockErrors)
9908
{
9909
expectedSymbol(AstNode::ExprKind, "expr");
9910
}
9911
return false;
9912
}
9913
(*yynode)->breakExpr = __node_208;
9914
9915
}
9916
else if (true /*epsilon*/)
9917
{
9918
}
9919
else
9920
{
9921
return false;
9922
}
9923
SemicolonOrCloseTagAst *__node_209 = 0;
9924
if (!parseSemicolonOrCloseTag(&__node_209))
9925
{
9926
if (!mBlockErrors)
9927
{
9928
expectedSymbol(AstNode::SemicolonOrCloseTagKind, "semicolonOrCloseTag");
9929
}
9930
return false;
9931
}
9932
}
9933
else if (yytoken == Token_CONTINUE)
9934
{
9935
if (yytoken != Token_CONTINUE)
9936
{
9937
if (!mBlockErrors)
9938
{
9939
expectedToken(yytoken, Token_CONTINUE, "continue");
9940
}
9941
return false;
9942
}
9943
yylex();
9944
9945
if (yytoken == Token_ARRAY
9946
|| yytoken == Token_ARRAY_CAST
9947
|| yytoken == Token_AT
9948
|| yytoken == Token_BACKTICK
9949
|| yytoken == Token_BANG
9950
|| yytoken == Token_BOOL_CAST
9951
|| yytoken == Token_CLASS_C
9952
|| yytoken == Token_CLONE
9953
|| yytoken == Token_CONSTANT_ENCAPSED_STRING
9954
|| yytoken == Token_DEC
9955
|| yytoken == Token_DNUMBER
9956
|| yytoken == Token_DOLLAR
9957
|| yytoken == Token_DOUBLE_CAST
9958
|| yytoken == Token_DOUBLE_QUOTE
9959
|| yytoken == Token_EMPTY
9960
|| yytoken == Token_EVAL
9961
|| yytoken == Token_EXIT
9962
|| yytoken == Token_FILE
9963
|| yytoken == Token_FUNC_C
9964
|| yytoken == Token_INC
9965
|| yytoken == Token_INCLUDE
9966
|| yytoken == Token_INCLUDE_ONCE
9967
|| yytoken == Token_INT_CAST
9968
|| yytoken == Token_ISSET
9969
|| yytoken == Token_LINE
9970
|| yytoken == Token_LIST
9971
|| yytoken == Token_LNUMBER
9972
|| yytoken == Token_LPAREN
9973
|| yytoken == Token_METHOD_C
9974
|| yytoken == Token_MINUS
9975
|| yytoken == Token_NEW
9976
|| yytoken == Token_OBJECT_CAST
9977
|| yytoken == Token_PLUS
9978
|| yytoken == Token_PRINT
9979
|| yytoken == Token_REQUIRE
9980
|| yytoken == Token_REQUIRE_ONCE
9981
|| yytoken == Token_START_HEREDOC
9982
|| yytoken == Token_STRING
9983
|| yytoken == Token_STRING_CAST
9984
|| yytoken == Token_STRING_VARNAME
9985
|| yytoken == Token_TILDE
9986
|| yytoken == Token_UNSET_CAST
9987
|| yytoken == Token_VARIABLE)
9988
{
9989
ExprAst *__node_210 = 0;
9990
if (!parseExpr(&__node_210))
9991
{
9992
if (!mBlockErrors)
9993
{
9994
expectedSymbol(AstNode::ExprKind, "expr");
9995
}
9996
return false;
9997
}
9998
(*yynode)->continueExpr = __node_210;
9999
10000
}
10001
else if (true /*epsilon*/)
10002
{
10003
}
10004
else
10005
{
10006
return false;
10007
}
10008
SemicolonOrCloseTagAst *__node_211 = 0;
10009
if (!parseSemicolonOrCloseTag(&__node_211))
10010
{
10011
if (!mBlockErrors)
10012
{
10013
expectedSymbol(AstNode::SemicolonOrCloseTagKind, "semicolonOrCloseTag");
10014
}
10015
return false;
10016
}
10017
}
10018
else if (yytoken == Token_RETURN)
10019
{
10020
if (yytoken != Token_RETURN)
10021
{
10022
if (!mBlockErrors)
10023
{
10024
expectedToken(yytoken, Token_RETURN, "return");
10025
}
10026
return false;
10027
}
10028
yylex();
10029
10030
if (yytoken == Token_ARRAY
10031
|| yytoken == Token_ARRAY_CAST
10032
|| yytoken == Token_AT
10033
|| yytoken == Token_BACKTICK
10034
|| yytoken == Token_BANG
10035
|| yytoken == Token_BOOL_CAST
10036
|| yytoken == Token_CLASS_C
10037
|| yytoken == Token_CLONE
10038
|| yytoken == Token_CONSTANT_ENCAPSED_STRING
10039
|| yytoken == Token_DEC
10040
|| yytoken == Token_DNUMBER
10041
|| yytoken == Token_DOLLAR
10042
|| yytoken == Token_DOUBLE_CAST
10043
|| yytoken == Token_DOUBLE_QUOTE
10044
|| yytoken == Token_EMPTY
10045
|| yytoken == Token_EVAL
10046
|| yytoken == Token_EXIT
10047
|| yytoken == Token_FILE
10048
|| yytoken == Token_FUNC_C
10049
|| yytoken == Token_INC
10050
|| yytoken == Token_INCLUDE
10051
|| yytoken == Token_INCLUDE_ONCE
10052
|| yytoken == Token_INT_CAST
10053
|| yytoken == Token_ISSET
10054
|| yytoken == Token_LINE
10055
|| yytoken == Token_LIST
10056
|| yytoken == Token_LNUMBER
10057
|| yytoken == Token_LPAREN
10058
|| yytoken == Token_METHOD_C
10059
|| yytoken == Token_MINUS
10060
|| yytoken == Token_NEW
10061
|| yytoken == Token_OBJECT_CAST
10062
|| yytoken == Token_PLUS
10063
|| yytoken == Token_PRINT
10064
|| yytoken == Token_REQUIRE
10065
|| yytoken == Token_REQUIRE_ONCE
10066
|| yytoken == Token_START_HEREDOC
10067
|| yytoken == Token_STRING
10068
|| yytoken == Token_STRING_CAST
10069
|| yytoken == Token_STRING_VARNAME
10070
|| yytoken == Token_TILDE
10071
|| yytoken == Token_UNSET_CAST
10072
|| yytoken == Token_VARIABLE)
10073
{
10074
ExprAst *__node_212 = 0;
10075
if (!parseExpr(&__node_212))
10076
{
10077
if (!mBlockErrors)
10078
{
10079
expectedSymbol(AstNode::ExprKind, "expr");
10080
}
10081
return false;
10082
}
10083
(*yynode)->returnExpr = __node_212;
10084
10085
}
10086
else if (true /*epsilon*/)
10087
{
10088
}
10089
else
10090
{
10091
return false;
10092
}
10093
SemicolonOrCloseTagAst *__node_213 = 0;
10094
if (!parseSemicolonOrCloseTag(&__node_213))
10095
{
10096
if (!mBlockErrors)
10097
{
10098
expectedSymbol(AstNode::SemicolonOrCloseTagKind, "semicolonOrCloseTag");
10099
}
10100
return false;
10101
}
10102
}
10103
else if (yytoken == Token_GLOBAL)
10104
{
10105
if (yytoken != Token_GLOBAL)
10106
{
10107
if (!mBlockErrors)
10108
{
10109
expectedToken(yytoken, Token_GLOBAL, "global");
10110
}
10111
return false;
10112
}
10113
yylex();
10114
10115
GlobalVarAst *__node_214 = 0;
10116
if (!parseGlobalVar(&__node_214))
10117
{
10118
if (!mBlockErrors)
10119
{
10120
expectedSymbol(AstNode::GlobalVarKind, "globalVar");
10121
}
10122
return false;
10123
}
10124
(*yynode)->globalVarsSequence = snoc((*yynode)->globalVarsSequence, __node_214, memoryPool);
10125
10126
while (yytoken == Token_COMMA)
10127
{
10128
if (yytoken != Token_COMMA)
10129
{
10130
if (!mBlockErrors)
10131
{
10132
expectedToken(yytoken, Token_COMMA, ",");
10133
}
10134
return false;
10135
}
10136
yylex();
10137
10138
GlobalVarAst *__node_215 = 0;
10139
if (!parseGlobalVar(&__node_215))
10140
{
10141
if (!mBlockErrors)
10142
{
10143
expectedSymbol(AstNode::GlobalVarKind, "globalVar");
10144
}
10145
return false;
10146
}
10147
(*yynode)->globalVarsSequence = snoc((*yynode)->globalVarsSequence, __node_215, memoryPool);
10148
10149
}
10150
SemicolonOrCloseTagAst *__node_216 = 0;
10151
if (!parseSemicolonOrCloseTag(&__node_216))
10152
{
10153
if (!mBlockErrors)
10154
{
10155
expectedSymbol(AstNode::SemicolonOrCloseTagKind, "semicolonOrCloseTag");
10156
}
10157
return false;
10158
}
10159
}
10160
else if (yytoken == Token_STATIC)
10161
{
10162
if (yytoken != Token_STATIC)
10163
{
10164
if (!mBlockErrors)
10165
{
10166
expectedToken(yytoken, Token_STATIC, "static");
10167
}
10168
return false;
10169
}
10170
yylex();
10171
10172
StaticVarAst *__node_217 = 0;
10173
if (!parseStaticVar(&__node_217))
10174
{
10175
if (!mBlockErrors)
10176
{
10177
expectedSymbol(AstNode::StaticVarKind, "staticVar");
10178
}
10179
return false;
10180
}
10181
(*yynode)->staticVarsSequence = snoc((*yynode)->staticVarsSequence, __node_217, memoryPool);
10182
10183
while (yytoken == Token_COMMA)
10184
{
10185
if (yytoken != Token_COMMA)
10186
{
10187
if (!mBlockErrors)
10188
{
10189
expectedToken(yytoken, Token_COMMA, ",");
10190
}
10191
return false;
10192
}
10193
yylex();
10194
10195
StaticVarAst *__node_218 = 0;
10196
if (!parseStaticVar(&__node_218))
10197
{
10198
if (!mBlockErrors)
10199
{
10200
expectedSymbol(AstNode::StaticVarKind, "staticVar");
10201
}
10202
return false;
10203
}
10204
(*yynode)->staticVarsSequence = snoc((*yynode)->staticVarsSequence, __node_218, memoryPool);
10205
10206
}
10207
SemicolonOrCloseTagAst *__node_219 = 0;
10208
if (!parseSemicolonOrCloseTag(&__node_219))
10209
{
10210
if (!mBlockErrors)
10211
{
10212
expectedSymbol(AstNode::SemicolonOrCloseTagKind, "semicolonOrCloseTag");
10213
}
10214
return false;
10215
}
10216
}
10217
else if (yytoken == Token_ECHO)
10218
{
10219
if (yytoken != Token_ECHO)
10220
{
10221
if (!mBlockErrors)
10222
{
10223
expectedToken(yytoken, Token_ECHO, "echo");
10224
}
10225
return false;
10226
}
10227
yylex();
10228
10229
ExprAst *__node_220 = 0;
10230
if (!parseExpr(&__node_220))
10231
{
10232
if (!mBlockErrors)
10233
{
10234
expectedSymbol(AstNode::ExprKind, "expr");
10235
}
10236
return false;
10237
}
10238
(*yynode)->echoExprsSequence = snoc((*yynode)->echoExprsSequence, __node_220, memoryPool);
10239
10240
while (yytoken == Token_COMMA)
10241
{
10242
if (yytoken != Token_COMMA)
10243
{
10244
if (!mBlockErrors)
10245
{
10246
expectedToken(yytoken, Token_COMMA, ",");
10247
}
10248
return false;
10249
}
10250
yylex();
10251
10252
ExprAst *__node_221 = 0;
10253
if (!parseExpr(&__node_221))
10254
{
10255
if (!mBlockErrors)
10256
{
10257
expectedSymbol(AstNode::ExprKind, "expr");
10258
}
10259
return false;
10260
}
10261
(*yynode)->echoExprsSequence = snoc((*yynode)->echoExprsSequence, __node_221, memoryPool);
10262
10263
}
10264
SemicolonOrCloseTagAst *__node_222 = 0;
10265
if (!parseSemicolonOrCloseTag(&__node_222))
10266
{
10267
if (!mBlockErrors)
10268
{
10269
expectedSymbol(AstNode::SemicolonOrCloseTagKind, "semicolonOrCloseTag");
10270
}
10271
return false;
10272
}
10273
}
10274
else if (yytoken == Token_THROW)
10275
{
10276
if (yytoken != Token_THROW)
10277
{
10278
if (!mBlockErrors)
10279
{
10280
expectedToken(yytoken, Token_THROW, "throw");
10281
}
10282
return false;
10283
}
10284
yylex();
10285
10286
ExprAst *__node_223 = 0;
10287
if (!parseExpr(&__node_223))
10288
{
10289
if (!mBlockErrors)
10290
{
10291
expectedSymbol(AstNode::ExprKind, "expr");
10292
}
10293
return false;
10294
}
10295
(*yynode)->throwExpr = __node_223;
10296
10297
SemicolonOrCloseTagAst *__node_224 = 0;
10298
if (!parseSemicolonOrCloseTag(&__node_224))
10299
{
10300
if (!mBlockErrors)
10301
{
10302
expectedSymbol(AstNode::SemicolonOrCloseTagKind, "semicolonOrCloseTag");
10303
}
10304
return false;
10305
}
10306
}
10307
else if (yytoken == Token_CLOSE_TAG)
10308
{
10309
if (yytoken != Token_CLOSE_TAG)
10310
{
10311
if (!mBlockErrors)
10312
{
10313
expectedToken(yytoken, Token_CLOSE_TAG, "?>");
10314
}
10315
return false;
10316
}
10317
yylex();
10318
10319
}
10320
else if (yytoken == Token_OPEN_TAG)
10321
{
10322
if (yytoken != Token_OPEN_TAG)
10323
{
10324
if (!mBlockErrors)
10325
{
10326
expectedToken(yytoken, Token_OPEN_TAG, "<?");
10327
}
10328
return false;
10329
}
10330
yylex();
10331
10332
}
10333
else if (yytoken == Token_OPEN_TAG_WITH_ECHO)
10334
{
10335
if (yytoken != Token_OPEN_TAG_WITH_ECHO)
10336
{
10337
if (!mBlockErrors)
10338
{
10339
expectedToken(yytoken, Token_OPEN_TAG_WITH_ECHO, "<?=");
10340
}
10341
return false;
10342
}
10343
yylex();
10344
10345
ExprAst *__node_225 = 0;
10346
if (!parseExpr(&__node_225))
10347
{
10348
if (!mBlockErrors)
10349
{
10350
expectedSymbol(AstNode::ExprKind, "expr");
10351
}
10352
return false;
10353
}
10354
(*yynode)->expr = __node_225;
10355
10356
SemicolonOrCloseTagAst *__node_226 = 0;
10357
if (!parseSemicolonOrCloseTag(&__node_226))
10358
{
10359
if (!mBlockErrors)
10360
{
10361
expectedSymbol(AstNode::SemicolonOrCloseTagKind, "semicolonOrCloseTag");
10362
}
10363
return false;
10364
}
10365
}
10366
else if (yytoken == Token_INLINE_HTML)
10367
{
10368
if (yytoken != Token_INLINE_HTML)
10369
{
10370
if (!mBlockErrors)
10371
{
10372
expectedToken(yytoken, Token_INLINE_HTML, "inline html");
10373
}
10374
return false;
10375
}
10376
yylex();
10377
10378
}
10379
else
10380
{
10381
return false;
10382
}
10383
}
10384
else
10385
{
10386
return false;
10387
}
10388
10389
(*yynode)->endToken = tokenStream->index() - 2;
10390
10391
return true;
10392
}
10393
10394
bool Parser::parseStaticArrayPairValue(StaticArrayPairValueAst **yynode)
10395
{
10396
*yynode = create<StaticArrayPairValueAst>();
10397
10398
(*yynode)->startToken = tokenStream->index() - 1;
10399
10400
if (yytoken == Token_ARRAY
10401
|| yytoken == Token_CLASS_C
10402
|| yytoken == Token_CONSTANT_ENCAPSED_STRING
10403
|| yytoken == Token_DNUMBER
10404
|| yytoken == Token_FILE
10405
|| yytoken == Token_FUNC_C
10406
|| yytoken == Token_LINE
10407
|| yytoken == Token_LNUMBER
10408
|| yytoken == Token_METHOD_C
10409
|| yytoken == Token_MINUS
10410
|| yytoken == Token_PLUS
10411
|| yytoken == Token_STRING)
10412
{
10413
StaticScalarAst *__node_227 = 0;
10414
if (!parseStaticScalar(&__node_227))
10415
{
10416
if (!mBlockErrors)
10417
{
10418
expectedSymbol(AstNode::StaticScalarKind, "staticScalar");
10419
}
10420
return false;
10421
}
10422
(*yynode)->val1Sequence = snoc((*yynode)->val1Sequence, __node_227, memoryPool);
10423
10424
if (yytoken == Token_DOUBLE_ARROW)
10425
{
10426
if (yytoken != Token_DOUBLE_ARROW)
10427
{
10428
if (!mBlockErrors)
10429
{
10430
expectedToken(yytoken, Token_DOUBLE_ARROW, "=>");
10431
}
10432
return false;
10433
}
10434
yylex();
10435
10436
StaticScalarAst *__node_228 = 0;
10437
if (!parseStaticScalar(&__node_228))
10438
{
10439
if (!mBlockErrors)
10440
{
10441
expectedSymbol(AstNode::StaticScalarKind, "staticScalar");
10442
}
10443
return false;
10444
}
10445
(*yynode)->val2Sequence = snoc((*yynode)->val2Sequence, __node_228, memoryPool);
10446
10447
}
10448
else if (true /*epsilon*/)
10449
{
10450
}
10451
else
10452
{
10453
return false;
10454
}
10455
}
10456
else
10457
{
10458
return false;
10459
}
10460
10461
(*yynode)->endToken = tokenStream->index() - 2;
10462
10463
return true;
10464
}
10465
10466
bool Parser::parseStaticMember(StaticMemberAst **yynode)
10467
{
10468
*yynode = create<StaticMemberAst>();
10469
10470
(*yynode)->startToken = tokenStream->index() - 1;
10471
10472
if (yytoken == Token_STRING)
10473
{
10474
IdentifierAst *__node_229 = 0;
10475
if (!parseIdentifier(&__node_229))
10476
{
10477
if (!mBlockErrors)
10478
{
10479
expectedSymbol(AstNode::IdentifierKind, "identifier");
10480
}
10481
return false;
10482
}
10483
(*yynode)->className = __node_229;
10484
10485
if (yytoken != Token_PAAMAYIM_NEKUDOTAYIM)
10486
{
10487
if (!mBlockErrors)
10488
{
10489
expectedToken(yytoken, Token_PAAMAYIM_NEKUDOTAYIM, "::");
10490
}
10491
return false;
10492
}
10493
yylex();
10494
10495
VariableWithoutObjectsAst *__node_230 = 0;
10496
if (!parseVariableWithoutObjects(&__node_230))
10497
{
10498
if (!mBlockErrors)
10499
{
10500
expectedSymbol(AstNode::VariableWithoutObjectsKind, "variableWithoutObjects");
10501
}
10502
return false;
10503
}
10504
(*yynode)->variable = __node_230;
10505
10506
}
10507
else
10508
{
10509
return false;
10510
}
10511
10512
(*yynode)->endToken = tokenStream->index() - 2;
10513
10514
return true;
10515
}
10516
10517
bool Parser::parseStaticScalar(StaticScalarAst **yynode)
10518
{
10519
*yynode = create<StaticScalarAst>();
10520
10521
(*yynode)->startToken = tokenStream->index() - 1;
10522
(*yynode)->array = -1;
10523
10524
if (yytoken == Token_ARRAY
10525
|| yytoken == Token_CLASS_C
10526
|| yytoken == Token_CONSTANT_ENCAPSED_STRING
10527
|| yytoken == Token_DNUMBER
10528
|| yytoken == Token_FILE
10529
|| yytoken == Token_FUNC_C
10530
|| yytoken == Token_LINE
10531
|| yytoken == Token_LNUMBER
10532
|| yytoken == Token_METHOD_C
10533
|| yytoken == Token_MINUS
10534
|| yytoken == Token_PLUS
10535
|| yytoken == Token_STRING)
10536
{
10537
if (yytoken == Token_CLASS_C
10538
|| yytoken == Token_CONSTANT_ENCAPSED_STRING
10539
|| yytoken == Token_DNUMBER
10540
|| yytoken == Token_FILE
10541
|| yytoken == Token_FUNC_C
10542
|| yytoken == Token_LINE
10543
|| yytoken == Token_LNUMBER
10544
|| yytoken == Token_METHOD_C)
10545
{
10546
CommonScalarAst *__node_231 = 0;
10547
if (!parseCommonScalar(&__node_231))
10548
{
10549
if (!mBlockErrors)
10550
{
10551
expectedSymbol(AstNode::CommonScalarKind, "commonScalar");
10552
}
10553
return false;
10554
}
10555
(*yynode)->value = __node_231;
10556
10557
}
10558
else if (yytoken == Token_STRING)
10559
{
10560
ConstantOrClassConstAst *__node_232 = 0;
10561
if (!parseConstantOrClassConst(&__node_232))
10562
{
10563
if (!mBlockErrors)
10564
{
10565
expectedSymbol(AstNode::ConstantOrClassConstKind, "constantOrClassConst");
10566
}
10567
return false;
10568
}
10569
(*yynode)->constantOrClassConst = __node_232;
10570
10571
}
10572
else if (yytoken == Token_PLUS)
10573
{
10574
if (yytoken != Token_PLUS)
10575
{
10576
if (!mBlockErrors)
10577
{
10578
expectedToken(yytoken, Token_PLUS, "+");
10579
}
10580
return false;
10581
}
10582
yylex();
10583
10584
StaticScalarAst *__node_233 = 0;
10585
if (!parseStaticScalar(&__node_233))
10586
{
10587
if (!mBlockErrors)
10588
{
10589
expectedSymbol(AstNode::StaticScalarKind, "staticScalar");
10590
}
10591
return false;
10592
}
10593
(*yynode)->plusValue = __node_233;
10594
10595
}
10596
else if (yytoken == Token_MINUS)
10597
{
10598
if (yytoken != Token_MINUS)
10599
{
10600
if (!mBlockErrors)
10601
{
10602
expectedToken(yytoken, Token_MINUS, "-");
10603
}
10604
return false;
10605
}
10606
yylex();
10607
10608
StaticScalarAst *__node_234 = 0;
10609
if (!parseStaticScalar(&__node_234))
10610
{
10611
if (!mBlockErrors)
10612
{
10613
expectedSymbol(AstNode::StaticScalarKind, "staticScalar");
10614
}
10615
return false;
10616
}
10617
(*yynode)->minusValue = __node_234;
10618
10619
}
10620
else if (yytoken == Token_ARRAY)
10621
{
10622
if (yytoken != Token_ARRAY)
10623
{
10624
if (!mBlockErrors)
10625
{
10626
expectedToken(yytoken, Token_ARRAY, "array");
10627
}
10628
return false;
10629
}
10630
(*yynode)->array = tokenStream->index() - 1;
10631
yylex();
10632
10633
if (yytoken != Token_LPAREN)
10634
{
10635
if (!mBlockErrors)
10636
{
10637
expectedToken(yytoken, Token_LPAREN, "(");
10638
}
10639
return false;
10640
}
10641
yylex();
10642
10643
if (yytoken == Token_ARRAY
10644
|| yytoken == Token_CLASS_C
10645
|| yytoken == Token_CONSTANT_ENCAPSED_STRING
10646
|| yytoken == Token_DNUMBER
10647
|| yytoken == Token_FILE
10648
|| yytoken == Token_FUNC_C
10649
|| yytoken == Token_LINE
10650
|| yytoken == Token_LNUMBER
10651
|| yytoken == Token_METHOD_C
10652
|| yytoken == Token_MINUS
10653
|| yytoken == Token_PLUS
10654
|| yytoken == Token_STRING)
10655
{
10656
StaticArrayPairValueAst *__node_235 = 0;
10657
if (!parseStaticArrayPairValue(&__node_235))
10658
{
10659
if (!mBlockErrors)
10660
{
10661
expectedSymbol(AstNode::StaticArrayPairValueKind, "staticArrayPairValue");
10662
}
10663
return false;
10664
}
10665
(*yynode)->arrayValuesSequence = snoc((*yynode)->arrayValuesSequence, __node_235, memoryPool);
10666
10667
while (yytoken == Token_COMMA)
10668
{
10669
if (yytoken != Token_COMMA)
10670
{
10671
if (!mBlockErrors)
10672
{
10673
expectedToken(yytoken, Token_COMMA, ",");
10674
}
10675
return false;
10676
}
10677
yylex();
10678
10679
if (yytoken == Token_RPAREN)
10680
{
10681
break;
10682
}
10683
StaticArrayPairValueAst *__node_236 = 0;
10684
if (!parseStaticArrayPairValue(&__node_236))
10685
{
10686
if (!mBlockErrors)
10687
{
10688
expectedSymbol(AstNode::StaticArrayPairValueKind, "staticArrayPairValue");
10689
}
10690
return false;
10691
}
10692
(*yynode)->arrayValuesSequence = snoc((*yynode)->arrayValuesSequence, __node_236, memoryPool);
10693
10694
}
10695
}
10696
else if (true /*epsilon*/)
10697
{
10698
}
10699
else
10700
{
10701
return false;
10702
}
10703
if (yytoken != Token_RPAREN)
10704
{
10705
if (!mBlockErrors)
10706
{
10707
expectedToken(yytoken, Token_RPAREN, ")");
10708
}
10709
return false;
10710
}
10711
yylex();
10712
10713
}
10714
else
10715
{
10716
return false;
10717
}
10718
}
10719
else
10720
{
10721
return false;
10722
}
10723
10724
(*yynode)->endToken = tokenStream->index() - 2;
10725
10726
return true;
10727
}
10728
10729
bool Parser::parseStaticVar(StaticVarAst **yynode)
10730
{
10731
*yynode = create<StaticVarAst>();
10732
10733
(*yynode)->startToken = tokenStream->index() - 1;
10734
10735
if (yytoken == Token_VARIABLE)
10736
{
10737
VariableIdentifierAst *__node_237 = 0;
10738
if (!parseVariableIdentifier(&__node_237))
10739
{
10740
if (!mBlockErrors)
10741
{
10742
expectedSymbol(AstNode::VariableIdentifierKind, "variableIdentifier");
10743
}
10744
return false;
10745
}
10746
(*yynode)->var = __node_237;
10747
10748
if (yytoken == Token_ASSIGN)
10749
{
10750
if (yytoken != Token_ASSIGN)
10751
{
10752
if (!mBlockErrors)
10753
{
10754
expectedToken(yytoken, Token_ASSIGN, "=");
10755
}
10756
return false;
10757
}
10758
yylex();
10759
10760
StaticScalarAst *__node_238 = 0;
10761
if (!parseStaticScalar(&__node_238))
10762
{
10763
if (!mBlockErrors)
10764
{
10765
expectedSymbol(AstNode::StaticScalarKind, "staticScalar");
10766
}
10767
return false;
10768
}
10769
(*yynode)->value = __node_238;
10770
10771
}
10772
else if (true /*epsilon*/)
10773
{
10774
}
10775
else
10776
{
10777
return false;
10778
}
10779
}
10780
else
10781
{
10782
return false;
10783
}
10784
10785
(*yynode)->endToken = tokenStream->index() - 2;
10786
10787
return true;
10788
}
10789
10790
bool Parser::parseSwitchCaseList(SwitchCaseListAst **yynode)
10791
{
10792
*yynode = create<SwitchCaseListAst>();
10793
10794
(*yynode)->startToken = tokenStream->index() - 1;
10795
10796
if (yytoken == Token_COLON
10797
|| yytoken == Token_LBRACE)
10798
{
10799
if (yytoken == Token_LBRACE)
10800
{
10801
if (yytoken != Token_LBRACE)
10802
{
10803
if (!mBlockErrors)
10804
{
10805
expectedToken(yytoken, Token_LBRACE, "{");
10806
}
10807
return false;
10808
}
10809
yylex();
10810
10811
if (yytoken == Token_SEMICOLON)
10812
{
10813
if (yytoken != Token_SEMICOLON)
10814
{
10815
if (!mBlockErrors)
10816
{
10817
expectedToken(yytoken, Token_SEMICOLON, ";");
10818
}
10819
return false;
10820
}
10821
yylex();
10822
10823
}
10824
else if (true /*epsilon*/)
10825
{
10826
}
10827
else
10828
{
10829
return false;
10830
}
10831
CaseListAst *__node_239 = 0;
10832
if (!parseCaseList(&__node_239))
10833
{
10834
if (!mBlockErrors)
10835
{
10836
expectedSymbol(AstNode::CaseListKind, "caseList");
10837
}
10838
return false;
10839
}
10840
(*yynode)->caseList = __node_239;
10841
10842
if (yytoken != Token_RBRACE)
10843
{
10844
if (!mBlockErrors)
10845
{
10846
expectedToken(yytoken, Token_RBRACE, "}");
10847
}
10848
return false;
10849
}
10850
yylex();
10851
10852
}
10853
else if (yytoken == Token_COLON)
10854
{
10855
if (yytoken != Token_COLON)
10856
{
10857
if (!mBlockErrors)
10858
{
10859
expectedToken(yytoken, Token_COLON, ":");
10860
}
10861
return false;
10862
}
10863
yylex();
10864
10865
if (yytoken == Token_SEMICOLON)
10866
{
10867
if (yytoken != Token_SEMICOLON)
10868
{
10869
if (!mBlockErrors)
10870
{
10871
expectedToken(yytoken, Token_SEMICOLON, ";");
10872
}
10873
return false;
10874
}
10875
yylex();
10876
10877
}
10878
else if (true /*epsilon*/)
10879
{
10880
}
10881
else
10882
{
10883
return false;
10884
}
10885
CaseListAst *__node_240 = 0;
10886
if (!parseCaseList(&__node_240))
10887
{
10888
if (!mBlockErrors)
10889
{
10890
expectedSymbol(AstNode::CaseListKind, "caseList");
10891
}
10892
return false;
10893
}
10894
(*yynode)->caseList = __node_240;
10895
10896
if (yytoken != Token_ENDSWITCH)
10897
{
10898
if (!mBlockErrors)
10899
{
10900
expectedToken(yytoken, Token_ENDSWITCH, "endswitch");
10901
}
10902
return false;
10903
}
10904
yylex();
10905
10906
SemicolonOrCloseTagAst *__node_241 = 0;
10907
if (!parseSemicolonOrCloseTag(&__node_241))
10908
{
10909
if (!mBlockErrors)
10910
{
10911
expectedSymbol(AstNode::SemicolonOrCloseTagKind, "semicolonOrCloseTag");
10912
}
10913
return false;
10914
}
10915
}
10916
else
10917
{
10918
return false;
10919
}
10920
}
10921
else
10922
{
10923
return false;
10924
}
10925
10926
(*yynode)->endToken = tokenStream->index() - 2;
10927
10928
return true;
10929
}
10930
10931
bool Parser::parseTopStatement(TopStatementAst **yynode)
10932
{
10933
*yynode = create<TopStatementAst>();
10934
10935
(*yynode)->startToken = tokenStream->index() - 1;
10936
10937
if (yytoken == Token_ABSTRACT
10938
|| yytoken == Token_ARRAY
10939
|| yytoken == Token_ARRAY_CAST
10940
|| yytoken == Token_AT
10941
|| yytoken == Token_BACKTICK
10942
|| yytoken == Token_BANG
10943
|| yytoken == Token_BOOL_CAST
10944
|| yytoken == Token_BREAK
10945
|| yytoken == Token_CLASS
10946
|| yytoken == Token_CLASS_C
10947
|| yytoken == Token_CLONE
10948
|| yytoken == Token_CLOSE_TAG
10949
|| yytoken == Token_CONSTANT_ENCAPSED_STRING
10950
|| yytoken == Token_CONTINUE
10951
|| yytoken == Token_DEC
10952
|| yytoken == Token_DECLARE
10953
|| yytoken == Token_DNUMBER
10954
|| yytoken == Token_DO
10955
|| yytoken == Token_DOLLAR
10956
|| yytoken == Token_DOUBLE_CAST
10957
|| yytoken == Token_DOUBLE_QUOTE
10958
|| yytoken == Token_ECHO
10959
|| yytoken == Token_EMPTY
10960
|| yytoken == Token_EVAL
10961
|| yytoken == Token_EXIT
10962
|| yytoken == Token_FILE
10963
|| yytoken == Token_FINAL
10964
|| yytoken == Token_FOR
10965
|| yytoken == Token_FOREACH
10966
|| yytoken == Token_FUNCTION
10967
|| yytoken == Token_FUNC_C
10968
|| yytoken == Token_GLOBAL
10969
|| yytoken == Token_HALT_COMPILER
10970
|| yytoken == Token_IF
10971
|| yytoken == Token_INC
10972
|| yytoken == Token_INCLUDE
10973
|| yytoken == Token_INCLUDE_ONCE
10974
|| yytoken == Token_INLINE_HTML
10975
|| yytoken == Token_INTERFACE
10976
|| yytoken == Token_INT_CAST
10977
|| yytoken == Token_ISSET
10978
|| yytoken == Token_LBRACE
10979
|| yytoken == Token_LINE
10980
|| yytoken == Token_LIST
10981
|| yytoken == Token_LNUMBER
10982
|| yytoken == Token_LPAREN
10983
|| yytoken == Token_METHOD_C
10984
|| yytoken == Token_MINUS
10985
|| yytoken == Token_NEW
10986
|| yytoken == Token_OBJECT_CAST
10987
|| yytoken == Token_OPEN_TAG
10988
|| yytoken == Token_OPEN_TAG_WITH_ECHO
10989
|| yytoken == Token_PLUS
10990
|| yytoken == Token_PRINT
10991
|| yytoken == Token_REQUIRE
10992
|| yytoken == Token_REQUIRE_ONCE
10993
|| yytoken == Token_RETURN
10994
|| yytoken == Token_SEMICOLON
10995
|| yytoken == Token_START_HEREDOC
10996
|| yytoken == Token_STATIC
10997
|| yytoken == Token_STRING
10998
|| yytoken == Token_STRING_CAST
10999
|| yytoken == Token_STRING_VARNAME
11000
|| yytoken == Token_SWITCH
11001
|| yytoken == Token_THROW
11002
|| yytoken == Token_TILDE
11003
|| yytoken == Token_TRY
11004
|| yytoken == Token_UNSET
11005
|| yytoken == Token_UNSET_CAST
11006
|| yytoken == Token_VARIABLE
11007
|| yytoken == Token_WHILE)
11008
{
11009
if (yytoken == Token_ARRAY
11010
|| yytoken == Token_ARRAY_CAST
11011
|| yytoken == Token_AT
11012
|| yytoken == Token_BACKTICK
11013
|| yytoken == Token_BANG
11014
|| yytoken == Token_BOOL_CAST
11015
|| yytoken == Token_BREAK
11016
|| yytoken == Token_CLASS_C
11017
|| yytoken == Token_CLONE
11018
|| yytoken == Token_CLOSE_TAG
11019
|| yytoken == Token_CONSTANT_ENCAPSED_STRING
11020
|| yytoken == Token_CONTINUE
11021
|| yytoken == Token_DEC
11022
|| yytoken == Token_DECLARE
11023
|| yytoken == Token_DNUMBER
11024
|| yytoken == Token_DO
11025
|| yytoken == Token_DOLLAR
11026
|| yytoken == Token_DOUBLE_CAST
11027
|| yytoken == Token_DOUBLE_QUOTE
11028
|| yytoken == Token_ECHO
11029
|| yytoken == Token_EMPTY
11030
|| yytoken == Token_EVAL
11031
|| yytoken == Token_EXIT
11032
|| yytoken == Token_FILE
11033
|| yytoken == Token_FOR
11034
|| yytoken == Token_FOREACH
11035
|| yytoken == Token_FUNC_C
11036
|| yytoken == Token_GLOBAL
11037
|| yytoken == Token_IF
11038
|| yytoken == Token_INC
11039
|| yytoken == Token_INCLUDE
11040
|| yytoken == Token_INCLUDE_ONCE
11041
|| yytoken == Token_INLINE_HTML
11042
|| yytoken == Token_INT_CAST
11043
|| yytoken == Token_ISSET
11044
|| yytoken == Token_LBRACE
11045
|| yytoken == Token_LINE
11046
|| yytoken == Token_LIST
11047
|| yytoken == Token_LNUMBER
11048
|| yytoken == Token_LPAREN
11049
|| yytoken == Token_METHOD_C
11050
|| yytoken == Token_MINUS
11051
|| yytoken == Token_NEW
11052
|| yytoken == Token_OBJECT_CAST
11053
|| yytoken == Token_OPEN_TAG
11054
|| yytoken == Token_OPEN_TAG_WITH_ECHO
11055
|| yytoken == Token_PLUS
11056
|| yytoken == Token_PRINT
11057
|| yytoken == Token_REQUIRE
11058
|| yytoken == Token_REQUIRE_ONCE
11059
|| yytoken == Token_RETURN
11060
|| yytoken == Token_SEMICOLON
11061
|| yytoken == Token_START_HEREDOC
11062
|| yytoken == Token_STATIC
11063
|| yytoken == Token_STRING
11064
|| yytoken == Token_STRING_CAST
11065
|| yytoken == Token_STRING_VARNAME
11066
|| yytoken == Token_SWITCH
11067
|| yytoken == Token_THROW
11068
|| yytoken == Token_TILDE
11069
|| yytoken == Token_TRY
11070
|| yytoken == Token_UNSET
11071
|| yytoken == Token_UNSET_CAST
11072
|| yytoken == Token_VARIABLE
11073
|| yytoken == Token_WHILE)
11074
{
11075
StatementAst *__node_242 = 0;
11076
if (!parseStatement(&__node_242))
11077
{
11078
if (!mBlockErrors)
11079
{
11080
expectedSymbol(AstNode::StatementKind, "statement");
11081
}
11082
return false;
11083
}
11084
(*yynode)->statement = __node_242;
11085
11086
}
11087
else if (yytoken == Token_FUNCTION)
11088
{
11089
FunctionDeclarationStatementAst *__node_243 = 0;
11090
if (!parseFunctionDeclarationStatement(&__node_243))
11091
{
11092
if (!mBlockErrors)
11093
{
11094
expectedSymbol(AstNode::FunctionDeclarationStatementKind, "functionDeclarationStatement");
11095
}
11096
return false;
11097
}
11098
(*yynode)->functionDeclaration = __node_243;
11099
11100
}
11101
else if (yytoken == Token_ABSTRACT
11102
|| yytoken == Token_CLASS
11103
|| yytoken == Token_FINAL)
11104
{
11105
ClassDeclarationStatementAst *__node_244 = 0;
11106
if (!parseClassDeclarationStatement(&__node_244))
11107
{
11108
if (!mBlockErrors)
11109
{
11110
expectedSymbol(AstNode::ClassDeclarationStatementKind, "classDeclarationStatement");
11111
}
11112
return false;
11113
}
11114
(*yynode)->classDeclaration = __node_244;
11115
11116
}
11117
else if (yytoken == Token_INTERFACE)
11118
{
11119
InterfaceDeclarationStatementAst *__node_245 = 0;
11120
if (!parseInterfaceDeclarationStatement(&__node_245))
11121
{
11122
if (!mBlockErrors)
11123
{
11124
expectedSymbol(AstNode::InterfaceDeclarationStatementKind, "interfaceDeclarationStatement");
11125
}
11126
return false;
11127
}
11128
(*yynode)->interfaceDeclaration = __node_245;
11129
11130
}
11131
else if (yytoken == Token_HALT_COMPILER)
11132
{
11133
if (yytoken != Token_HALT_COMPILER)
11134
{
11135
if (!mBlockErrors)
11136
{
11137
expectedToken(yytoken, Token_HALT_COMPILER, "halt compiler");
11138
}
11139
return false;
11140
}
11141
yylex();
11142
11143
if (yytoken != Token_LPAREN)
11144
{
11145
if (!mBlockErrors)
11146
{
11147
expectedToken(yytoken, Token_LPAREN, "(");
11148
}
11149
return false;
11150
}
11151
yylex();
11152
11153
if (yytoken != Token_RPAREN)
11154
{
11155
if (!mBlockErrors)
11156
{
11157
expectedToken(yytoken, Token_RPAREN, ")");
11158
}
11159
return false;
11160
}
11161
yylex();
11162
11163
if (yytoken != Token_SEMICOLON)
11164
{
11165
if (!mBlockErrors)
11166
{
11167
expectedToken(yytoken, Token_SEMICOLON, ";");
11168
}
11169
return false;
11170
}
11171
yylex();
11172
11173
}
11174
else
11175
{
11176
return false;
11177
}
11178
}
11179
else
11180
{
11181
return false;
11182
}
11183
11184
(*yynode)->endToken = tokenStream->index() - 2;
11185
11186
return true;
11187
}
11188
11189
bool Parser::parseUnaryExpression(UnaryExpressionAst **yynode)
11190
{
11191
*yynode = create<UnaryExpressionAst>();
11192
11193
(*yynode)->startToken = tokenStream->index() - 1;
11194
11195
if (yytoken == Token_ARRAY
11196
|| yytoken == Token_ARRAY_CAST
11197
|| yytoken == Token_AT
11198
|| yytoken == Token_BACKTICK
11199
|| yytoken == Token_BANG
11200
|| yytoken == Token_BOOL_CAST
11201
|| yytoken == Token_CLASS_C
11202
|| yytoken == Token_CLONE
11203
|| yytoken == Token_CONSTANT_ENCAPSED_STRING
11204
|| yytoken == Token_DEC
11205
|| yytoken == Token_DNUMBER
11206
|| yytoken == Token_DOLLAR
11207
|| yytoken == Token_DOUBLE_CAST
11208
|| yytoken == Token_DOUBLE_QUOTE
11209
|| yytoken == Token_EMPTY
11210
|| yytoken == Token_EVAL
11211
|| yytoken == Token_EXIT
11212
|| yytoken == Token_FILE
11213
|| yytoken == Token_FUNC_C
11214
|| yytoken == Token_INC
11215
|| yytoken == Token_INCLUDE
11216
|| yytoken == Token_INCLUDE_ONCE
11217
|| yytoken == Token_INT_CAST
11218
|| yytoken == Token_ISSET
11219
|| yytoken == Token_LINE
11220
|| yytoken == Token_LIST
11221
|| yytoken == Token_LNUMBER
11222
|| yytoken == Token_LPAREN
11223
|| yytoken == Token_METHOD_C
11224
|| yytoken == Token_MINUS
11225
|| yytoken == Token_NEW
11226
|| yytoken == Token_OBJECT_CAST
11227
|| yytoken == Token_PLUS
11228
|| yytoken == Token_REQUIRE
11229
|| yytoken == Token_REQUIRE_ONCE
11230
|| yytoken == Token_START_HEREDOC
11231
|| yytoken == Token_STRING
11232
|| yytoken == Token_STRING_CAST
11233
|| yytoken == Token_STRING_VARNAME
11234
|| yytoken == Token_TILDE
11235
|| yytoken == Token_UNSET_CAST
11236
|| yytoken == Token_VARIABLE)
11237
{
11238
if (yytoken == Token_MINUS)
11239
{
11240
if (yytoken != Token_MINUS)
11241
{
11242
if (!mBlockErrors)
11243
{
11244
expectedToken(yytoken, Token_MINUS, "-");
11245
}
11246
return false;
11247
}
11248
yylex();
11249
11250
UnaryExpressionAst *__node_246 = 0;
11251
if (!parseUnaryExpression(&__node_246))
11252
{
11253
if (!mBlockErrors)
11254
{
11255
expectedSymbol(AstNode::UnaryExpressionKind, "unaryExpression");
11256
}
11257
return false;
11258
}
11259
(*yynode)->unaryExpression = __node_246;
11260
11261
}
11262
else if (yytoken == Token_PLUS)
11263
{
11264
if (yytoken != Token_PLUS)
11265
{
11266
if (!mBlockErrors)
11267
{
11268
expectedToken(yytoken, Token_PLUS, "+");
11269
}
11270
return false;
11271
}
11272
yylex();
11273
11274
UnaryExpressionAst *__node_247 = 0;
11275
if (!parseUnaryExpression(&__node_247))
11276
{
11277
if (!mBlockErrors)
11278
{
11279
expectedSymbol(AstNode::UnaryExpressionKind, "unaryExpression");
11280
}
11281
return false;
11282
}
11283
(*yynode)->unaryExpression = __node_247;
11284
11285
}
11286
else if (yytoken == Token_BANG)
11287
{
11288
if (yytoken != Token_BANG)
11289
{
11290
if (!mBlockErrors)
11291
{
11292
expectedToken(yytoken, Token_BANG, "!");
11293
}
11294
return false;
11295
}
11296
yylex();
11297
11298
UnaryExpressionAst *__node_248 = 0;
11299
if (!parseUnaryExpression(&__node_248))
11300
{
11301
if (!mBlockErrors)
11302
{
11303
expectedSymbol(AstNode::UnaryExpressionKind, "unaryExpression");
11304
}
11305
return false;
11306
}
11307
(*yynode)->unaryExpression = __node_248;
11308
11309
}
11310
else if (yytoken == Token_TILDE)
11311
{
11312
if (yytoken != Token_TILDE)
11313
{
11314
if (!mBlockErrors)
11315
{
11316
expectedToken(yytoken, Token_TILDE, "~");
11317
}
11318
return false;
11319
}
11320
yylex();
11321
11322
UnaryExpressionAst *__node_249 = 0;
11323
if (!parseUnaryExpression(&__node_249))
11324
{
11325
if (!mBlockErrors)
11326
{
11327
expectedSymbol(AstNode::UnaryExpressionKind, "unaryExpression");
11328
}
11329
return false;
11330
}
11331
(*yynode)->unaryExpression = __node_249;
11332
11333
}
11334
else if (yytoken == Token_INT_CAST)
11335
{
11336
if (yytoken != Token_INT_CAST)
11337
{
11338
if (!mBlockErrors)
11339
{
11340
expectedToken(yytoken, Token_INT_CAST, "int cast");
11341
}
11342
return false;
11343
}
11344
yylex();
11345
11346
UnaryExpressionAst *__node_250 = 0;
11347
if (!parseUnaryExpression(&__node_250))
11348
{
11349
if (!mBlockErrors)
11350
{
11351
expectedSymbol(AstNode::UnaryExpressionKind, "unaryExpression");
11352
}
11353
return false;
11354
}
11355
(*yynode)->unaryExpression = __node_250;
11356
11357
(*yynode)->castType = CastInt;
11358
}
11359
else if (yytoken == Token_DOUBLE_CAST)
11360
{
11361
if (yytoken != Token_DOUBLE_CAST)
11362
{
11363
if (!mBlockErrors)
11364
{
11365
expectedToken(yytoken, Token_DOUBLE_CAST, "double cast");
11366
}
11367
return false;
11368
}
11369
yylex();
11370
11371
UnaryExpressionAst *__node_251 = 0;
11372
if (!parseUnaryExpression(&__node_251))
11373
{
11374
if (!mBlockErrors)
11375
{
11376
expectedSymbol(AstNode::UnaryExpressionKind, "unaryExpression");
11377
}
11378
return false;
11379
}
11380
(*yynode)->unaryExpression = __node_251;
11381
11382
(*yynode)->castType = CastDouble;
11383
}
11384
else if (yytoken == Token_STRING_CAST)
11385
{
11386
if (yytoken != Token_STRING_CAST)
11387
{
11388
if (!mBlockErrors)
11389
{
11390
expectedToken(yytoken, Token_STRING_CAST, "string cast");
11391
}
11392
return false;
11393
}
11394
yylex();
11395
11396
UnaryExpressionAst *__node_252 = 0;
11397
if (!parseUnaryExpression(&__node_252))
11398
{
11399
if (!mBlockErrors)
11400
{
11401
expectedSymbol(AstNode::UnaryExpressionKind, "unaryExpression");
11402
}
11403
return false;
11404
}
11405
(*yynode)->unaryExpression = __node_252;
11406
11407
(*yynode)->castType = CastString;
11408
}
11409
else if (yytoken == Token_ARRAY_CAST)
11410
{
11411
if (yytoken != Token_ARRAY_CAST)
11412
{
11413
if (!mBlockErrors)
11414
{
11415
expectedToken(yytoken, Token_ARRAY_CAST, "array cast");
11416
}
11417
return false;
11418
}
11419
yylex();
11420
11421
UnaryExpressionAst *__node_253 = 0;
11422
if (!parseUnaryExpression(&__node_253))
11423
{
11424
if (!mBlockErrors)
11425
{
11426
expectedSymbol(AstNode::UnaryExpressionKind, "unaryExpression");
11427
}
11428
return false;
11429
}
11430
(*yynode)->unaryExpression = __node_253;
11431
11432
(*yynode)->castType = CastArray;
11433
}
11434
else if (yytoken == Token_OBJECT_CAST)
11435
{
11436
if (yytoken != Token_OBJECT_CAST)
11437
{
11438
if (!mBlockErrors)
11439
{
11440
expectedToken(yytoken, Token_OBJECT_CAST, "object cast");
11441
}
11442
return false;
11443
}
11444
yylex();
11445
11446
UnaryExpressionAst *__node_254 = 0;
11447
if (!parseUnaryExpression(&__node_254))
11448
{
11449
if (!mBlockErrors)
11450
{
11451
expectedSymbol(AstNode::UnaryExpressionKind, "unaryExpression");
11452
}
11453
return false;
11454
}
11455
(*yynode)->unaryExpression = __node_254;
11456
11457
(*yynode)->castType = CastObject;
11458
}
11459
else if (yytoken == Token_BOOL_CAST)
11460
{
11461
if (yytoken != Token_BOOL_CAST)
11462
{
11463
if (!mBlockErrors)
11464
{
11465
expectedToken(yytoken, Token_BOOL_CAST, "bool cast");
11466
}
11467
return false;
11468
}
11469
yylex();
11470
11471
UnaryExpressionAst *__node_255 = 0;
11472
if (!parseUnaryExpression(&__node_255))
11473
{
11474
if (!mBlockErrors)
11475
{
11476
expectedSymbol(AstNode::UnaryExpressionKind, "unaryExpression");
11477
}
11478
return false;
11479
}
11480
(*yynode)->unaryExpression = __node_255;
11481
11482
(*yynode)->castType = CastBool;
11483
}
11484
else if (yytoken == Token_UNSET_CAST)
11485
{
11486
if (yytoken != Token_UNSET_CAST)
11487
{
11488
if (!mBlockErrors)
11489
{
11490
expectedToken(yytoken, Token_UNSET_CAST, "unset cast");
11491
}
11492
return false;
11493
}
11494
yylex();
11495
11496
UnaryExpressionAst *__node_256 = 0;
11497
if (!parseUnaryExpression(&__node_256))
11498
{
11499
if (!mBlockErrors)
11500
{
11501
expectedSymbol(AstNode::UnaryExpressionKind, "unaryExpression");
11502
}
11503
return false;
11504
}
11505
(*yynode)->unaryExpression = __node_256;
11506
11507
(*yynode)->castType = CastUnset;
11508
}
11509
else if (yytoken == Token_AT)
11510
{
11511
if (yytoken != Token_AT)
11512
{
11513
if (!mBlockErrors)
11514
{
11515
expectedToken(yytoken, Token_AT, "@");
11516
}
11517
return false;
11518
}
11519
yylex();
11520
11521
UnaryExpressionAst *__node_257 = 0;
11522
if (!parseUnaryExpression(&__node_257))
11523
{
11524
if (!mBlockErrors)
11525
{
11526
expectedSymbol(AstNode::UnaryExpressionKind, "unaryExpression");
11527
}
11528
return false;
11529
}
11530
(*yynode)->unaryExpression = __node_257;
11531
11532
}
11533
else if (yytoken == Token_LIST)
11534
{
11535
if (yytoken != Token_LIST)
11536
{
11537
if (!mBlockErrors)
11538
{
11539
expectedToken(yytoken, Token_LIST, "list");
11540
}
11541
return false;
11542
}
11543
yylex();
11544
11545
if (yytoken != Token_LPAREN)
11546
{
11547
if (!mBlockErrors)
11548
{
11549
expectedToken(yytoken, Token_LPAREN, "(");
11550
}
11551
return false;
11552
}
11553
yylex();
11554
11555
AssignmentListAst *__node_258 = 0;
11556
if (!parseAssignmentList(&__node_258))
11557
{
11558
if (!mBlockErrors)
11559
{
11560
expectedSymbol(AstNode::AssignmentListKind, "assignmentList");
11561
}
11562
return false;
11563
}
11564
(*yynode)->assignmentList = __node_258;
11565
11566
if (yytoken != Token_RPAREN)
11567
{
11568
if (!mBlockErrors)
11569
{
11570
expectedToken(yytoken, Token_RPAREN, ")");
11571
}
11572
return false;
11573
}
11574
yylex();
11575
11576
if (yytoken != Token_ASSIGN)
11577
{
11578
if (!mBlockErrors)
11579
{
11580
expectedToken(yytoken, Token_ASSIGN, "=");
11581
}
11582
return false;
11583
}
11584
yylex();
11585
11586
UnaryExpressionAst *__node_259 = 0;
11587
if (!parseUnaryExpression(&__node_259))
11588
{
11589
if (!mBlockErrors)
11590
{
11591
expectedSymbol(AstNode::UnaryExpressionKind, "unaryExpression");
11592
}
11593
return false;
11594
}
11595
(*yynode)->unaryExpression = __node_259;
11596
11597
}
11598
else if (yytoken == Token_EXIT)
11599
{
11600
if (yytoken != Token_EXIT)
11601
{
11602
if (!mBlockErrors)
11603
{
11604
expectedToken(yytoken, Token_EXIT, "exit");
11605
}
11606
return false;
11607
}
11608
yylex();
11609
11610
if (yytoken == Token_LPAREN)
11611
{
11612
if (yytoken != Token_LPAREN)
11613
{
11614
if (!mBlockErrors)
11615
{
11616
expectedToken(yytoken, Token_LPAREN, "(");
11617
}
11618
return false;
11619
}
11620
yylex();
11621
11622
if (yytoken == Token_ARRAY
11623
|| yytoken == Token_ARRAY_CAST
11624
|| yytoken == Token_AT
11625
|| yytoken == Token_BACKTICK
11626
|| yytoken == Token_BANG
11627
|| yytoken == Token_BOOL_CAST
11628
|| yytoken == Token_CLASS_C
11629
|| yytoken == Token_CLONE
11630
|| yytoken == Token_CONSTANT_ENCAPSED_STRING
11631
|| yytoken == Token_DEC
11632
|| yytoken == Token_DNUMBER
11633
|| yytoken == Token_DOLLAR
11634
|| yytoken == Token_DOUBLE_CAST
11635
|| yytoken == Token_DOUBLE_QUOTE
11636
|| yytoken == Token_EMPTY
11637
|| yytoken == Token_EVAL
11638
|| yytoken == Token_EXIT
11639
|| yytoken == Token_FILE
11640
|| yytoken == Token_FUNC_C
11641
|| yytoken == Token_INC
11642
|| yytoken == Token_INCLUDE
11643
|| yytoken == Token_INCLUDE_ONCE
11644
|| yytoken == Token_INT_CAST
11645
|| yytoken == Token_ISSET
11646
|| yytoken == Token_LINE
11647
|| yytoken == Token_LIST
11648
|| yytoken == Token_LNUMBER
11649
|| yytoken == Token_LPAREN
11650
|| yytoken == Token_METHOD_C
11651
|| yytoken == Token_MINUS
11652
|| yytoken == Token_NEW
11653
|| yytoken == Token_OBJECT_CAST
11654
|| yytoken == Token_PLUS
11655
|| yytoken == Token_PRINT
11656
|| yytoken == Token_REQUIRE
11657
|| yytoken == Token_REQUIRE_ONCE
11658
|| yytoken == Token_START_HEREDOC
11659
|| yytoken == Token_STRING
11660
|| yytoken == Token_STRING_CAST
11661
|| yytoken == Token_STRING_VARNAME
11662
|| yytoken == Token_TILDE
11663
|| yytoken == Token_UNSET_CAST
11664
|| yytoken == Token_VARIABLE)
11665
{
11666
ExprAst *__node_260 = 0;
11667
if (!parseExpr(&__node_260))
11668
{
11669
if (!mBlockErrors)
11670
{
11671
expectedSymbol(AstNode::ExprKind, "expr");
11672
}
11673
return false;
11674
}
11675
(*yynode)->expression = __node_260;
11676
11677
}
11678
else if (true /*epsilon*/)
11679
{
11680
}
11681
else
11682
{
11683
return false;
11684
}
11685
if (yytoken != Token_RPAREN)
11686
{
11687
if (!mBlockErrors)
11688
{
11689
expectedToken(yytoken, Token_RPAREN, ")");
11690
}
11691
return false;
11692
}
11693
yylex();
11694
11695
}
11696
else if (true /*epsilon*/)
11697
{
11698
}
11699
else
11700
{
11701
return false;
11702
}
11703
}
11704
else if (yytoken == Token_EVAL)
11705
{
11706
if (yytoken != Token_EVAL)
11707
{
11708
if (!mBlockErrors)
11709
{
11710
expectedToken(yytoken, Token_EVAL, "eval");
11711
}
11712
return false;
11713
}
11714
yylex();
11715
11716
if (yytoken != Token_LPAREN)
11717
{
11718
if (!mBlockErrors)
11719
{
11720
expectedToken(yytoken, Token_LPAREN, "(");
11721
}
11722
return false;
11723
}
11724
yylex();
11725
11726
ExprAst *__node_261 = 0;
11727
if (!parseExpr(&__node_261))
11728
{
11729
if (!mBlockErrors)
11730
{
11731
expectedSymbol(AstNode::ExprKind, "expr");
11732
}
11733
return false;
11734
}
11735
(*yynode)->expression = __node_261;
11736
11737
if (yytoken != Token_RPAREN)
11738
{
11739
if (!mBlockErrors)
11740
{
11741
expectedToken(yytoken, Token_RPAREN, ")");
11742
}
11743
return false;
11744
}
11745
yylex();
11746
11747
}
11748
else if (yytoken == Token_INCLUDE)
11749
{
11750
if (yytoken != Token_INCLUDE)
11751
{
11752
if (!mBlockErrors)
11753
{
11754
expectedToken(yytoken, Token_INCLUDE, "include");
11755
}
11756
return false;
11757
}
11758
yylex();
11759
11760
UnaryExpressionAst *__node_262 = 0;
11761
if (!parseUnaryExpression(&__node_262))
11762
{
11763
if (!mBlockErrors)
11764
{
11765
expectedSymbol(AstNode::UnaryExpressionKind, "unaryExpression");
11766
}
11767
return false;
11768
}
11769
(*yynode)->includeExpression = __node_262;
11770
11771
}
11772
else if (yytoken == Token_INCLUDE_ONCE)
11773
{
11774
if (yytoken != Token_INCLUDE_ONCE)
11775
{
11776
if (!mBlockErrors)
11777
{
11778
expectedToken(yytoken, Token_INCLUDE_ONCE, "include_once");
11779
}
11780
return false;
11781
}
11782
yylex();
11783
11784
UnaryExpressionAst *__node_263 = 0;
11785
if (!parseUnaryExpression(&__node_263))
11786
{
11787
if (!mBlockErrors)
11788
{
11789
expectedSymbol(AstNode::UnaryExpressionKind, "unaryExpression");
11790
}
11791
return false;
11792
}
11793
(*yynode)->includeExpression = __node_263;
11794
11795
}
11796
else if (yytoken == Token_REQUIRE)
11797
{
11798
if (yytoken != Token_REQUIRE)
11799
{
11800
if (!mBlockErrors)
11801
{
11802
expectedToken(yytoken, Token_REQUIRE, "require");
11803
}
11804
return false;
11805
}
11806
yylex();
11807
11808
UnaryExpressionAst *__node_264 = 0;
11809
if (!parseUnaryExpression(&__node_264))
11810
{
11811
if (!mBlockErrors)
11812
{
11813
expectedSymbol(AstNode::UnaryExpressionKind, "unaryExpression");
11814
}
11815
return false;
11816
}
11817
(*yynode)->includeExpression = __node_264;
11818
11819
}
11820
else if (yytoken == Token_REQUIRE_ONCE)
11821
{
11822
if (yytoken != Token_REQUIRE_ONCE)
11823
{
11824
if (!mBlockErrors)
11825
{
11826
expectedToken(yytoken, Token_REQUIRE_ONCE, "require_once");
11827
}
11828
return false;
11829
}
11830
yylex();
11831
11832
UnaryExpressionAst *__node_265 = 0;
11833
if (!parseUnaryExpression(&__node_265))
11834
{
11835
if (!mBlockErrors)
11836
{
11837
expectedSymbol(AstNode::UnaryExpressionKind, "unaryExpression");
11838
}
11839
return false;
11840
}
11841
(*yynode)->includeExpression = __node_265;
11842
11843
}
11844
else if (yytoken == Token_ARRAY
11845
|| yytoken == Token_BACKTICK
11846
|| yytoken == Token_CLASS_C
11847
|| yytoken == Token_CLONE
11848
|| yytoken == Token_CONSTANT_ENCAPSED_STRING
11849
|| yytoken == Token_DEC
11850
|| yytoken == Token_DNUMBER
11851
|| yytoken == Token_DOLLAR
11852
|| yytoken == Token_DOUBLE_QUOTE
11853
|| yytoken == Token_EMPTY
11854
|| yytoken == Token_FILE
11855
|| yytoken == Token_FUNC_C
11856
|| yytoken == Token_INC
11857
|| yytoken == Token_ISSET
11858
|| yytoken == Token_LINE
11859
|| yytoken == Token_LNUMBER
11860
|| yytoken == Token_LPAREN
11861
|| yytoken == Token_METHOD_C
11862
|| yytoken == Token_NEW
11863
|| yytoken == Token_START_HEREDOC
11864
|| yytoken == Token_STRING
11865
|| yytoken == Token_STRING_VARNAME
11866
|| yytoken == Token_VARIABLE)
11867
{
11868
UnaryExpressionNotPlusminusAst *__node_266 = 0;
11869
if (!parseUnaryExpressionNotPlusminus(&__node_266))
11870
{
11871
if (!mBlockErrors)
11872
{
11873
expectedSymbol(AstNode::UnaryExpressionNotPlusminusKind, "unaryExpressionNotPlusminus");
11874
}
11875
return false;
11876
}
11877
(*yynode)->unaryExpressionNotPlusminus = __node_266;
11878
11879
}
11880
else
11881
{
11882
return false;
11883
}
11884
}
11885
else
11886
{
11887
return false;
11888
}
11889
11890
(*yynode)->endToken = tokenStream->index() - 2;
11891
11892
return true;
11893
}
11894
11895
bool Parser::parseUnaryExpressionNotPlusminus(UnaryExpressionNotPlusminusAst **yynode)
11896
{
11897
*yynode = create<UnaryExpressionNotPlusminusAst>();
11898
11899
(*yynode)->startToken = tokenStream->index() - 1;
11900
11901
if (yytoken == Token_ARRAY
11902
|| yytoken == Token_BACKTICK
11903
|| yytoken == Token_CLASS_C
11904
|| yytoken == Token_CLONE
11905
|| yytoken == Token_CONSTANT_ENCAPSED_STRING
11906
|| yytoken == Token_DEC
11907
|| yytoken == Token_DNUMBER
11908
|| yytoken == Token_DOLLAR
11909
|| yytoken == Token_DOUBLE_QUOTE
11910
|| yytoken == Token_EMPTY
11911
|| yytoken == Token_FILE
11912
|| yytoken == Token_FUNC_C
11913
|| yytoken == Token_INC
11914
|| yytoken == Token_ISSET
11915
|| yytoken == Token_LINE
11916
|| yytoken == Token_LNUMBER
11917
|| yytoken == Token_LPAREN
11918
|| yytoken == Token_METHOD_C
11919
|| yytoken == Token_NEW
11920
|| yytoken == Token_START_HEREDOC
11921
|| yytoken == Token_STRING
11922
|| yytoken == Token_STRING_VARNAME
11923
|| yytoken == Token_VARIABLE)
11924
{
11925
while (yytoken == Token_DEC
11926
|| yytoken == Token_INC)
11927
{
11928
PostprefixOperatorAst *__node_267 = 0;
11929
if (!parsePostprefixOperator(&__node_267))
11930
{
11931
if (!mBlockErrors)
11932
{
11933
expectedSymbol(AstNode::PostprefixOperatorKind, "postprefixOperator");
11934
}
11935
return false;
11936
}
11937
(*yynode)->prefixOperatorSequence = snoc((*yynode)->prefixOperatorSequence, __node_267, memoryPool);
11938
11939
}
11940
VarExpressionAst *__node_268 = 0;
11941
if (!parseVarExpression(&__node_268))
11942
{
11943
if (!mBlockErrors)
11944
{
11945
expectedSymbol(AstNode::VarExpressionKind, "varExpression");
11946
}
11947
return false;
11948
}
11949
(*yynode)->varExpression = __node_268;
11950
11951
while (yytoken == Token_DEC
11952
|| yytoken == Token_INC)
11953
{
11954
PostprefixOperatorAst *__node_269 = 0;
11955
if (!parsePostprefixOperator(&__node_269))
11956
{
11957
if (!mBlockErrors)
11958
{
11959
expectedSymbol(AstNode::PostprefixOperatorKind, "postprefixOperator");
11960
}
11961
return false;
11962
}
11963
(*yynode)->postfixOperatorSequence = snoc((*yynode)->postfixOperatorSequence, __node_269, memoryPool);
11964
11965
}
11966
}
11967
else
11968
{
11969
return false;
11970
}
11971
11972
(*yynode)->endToken = tokenStream->index() - 2;
11973
11974
return true;
11975
}
11976
11977
bool Parser::parseVarExpression(VarExpressionAst **yynode)
11978
{
11979
*yynode = create<VarExpressionAst>();
11980
11981
(*yynode)->startToken = tokenStream->index() - 1;
11982
11983
if (yytoken == Token_ARRAY
11984
|| yytoken == Token_BACKTICK
11985
|| yytoken == Token_CLASS_C
11986
|| yytoken == Token_CLONE
11987
|| yytoken == Token_CONSTANT_ENCAPSED_STRING
11988
|| yytoken == Token_DNUMBER
11989
|| yytoken == Token_DOLLAR
11990
|| yytoken == Token_DOUBLE_QUOTE
11991
|| yytoken == Token_EMPTY
11992
|| yytoken == Token_FILE
11993
|| yytoken == Token_FUNC_C
11994
|| yytoken == Token_ISSET
11995
|| yytoken == Token_LINE
11996
|| yytoken == Token_LNUMBER
11997
|| yytoken == Token_LPAREN
11998
|| yytoken == Token_METHOD_C
11999
|| yytoken == Token_NEW
12000
|| yytoken == Token_START_HEREDOC
12001
|| yytoken == Token_STRING
12002
|| yytoken == Token_STRING_VARNAME
12003
|| yytoken == Token_VARIABLE)
12004
{
12005
if ((yytoken == Token_DOLLAR
12006
|| yytoken == Token_STRING
12007
|| yytoken == Token_VARIABLE) && ( m_state.varExpressionState == OnlyVariable ))
12008
{
12009
m_state.varExpressionState = Normal;
12010
VariableAst *__node_270 = 0;
12011
if (!parseVariable(&__node_270))
12012
{
12013
if (!mBlockErrors)
12014
{
12015
expectedSymbol(AstNode::VariableKind, "variable");
12016
}
12017
return false;
12018
}
12019
(*yynode)->variable = __node_270;
12020
12021
}
12022
else if ((yytoken == Token_NEW) && ( m_state.varExpressionState == OnlyNewObject ))
12023
{
12024
m_state.varExpressionState = Normal;
12025
VarExpressionNewObjectAst *__node_271 = 0;
12026
if (!parseVarExpressionNewObject(&__node_271))
12027
{
12028
if (!mBlockErrors)
12029
{
12030
expectedSymbol(AstNode::VarExpressionNewObjectKind, "varExpressionNewObject");
12031
}
12032
return false;
12033
}
12034
(*yynode)->newObject = __node_271;
12035
12036
}
12037
else if (yytoken == Token_ARRAY
12038
|| yytoken == Token_BACKTICK
12039
|| yytoken == Token_CLASS_C
12040
|| yytoken == Token_CLONE
12041
|| yytoken == Token_CONSTANT_ENCAPSED_STRING
12042
|| yytoken == Token_DNUMBER
12043
|| yytoken == Token_DOLLAR
12044
|| yytoken == Token_DOUBLE_QUOTE
12045
|| yytoken == Token_EMPTY
12046
|| yytoken == Token_FILE
12047
|| yytoken == Token_FUNC_C
12048
|| yytoken == Token_ISSET
12049
|| yytoken == Token_LINE
12050
|| yytoken == Token_LNUMBER
12051
|| yytoken == Token_LPAREN
12052
|| yytoken == Token_METHOD_C
12053
|| yytoken == Token_NEW
12054
|| yytoken == Token_START_HEREDOC
12055
|| yytoken == Token_STRING
12056
|| yytoken == Token_STRING_VARNAME
12057
|| yytoken == Token_VARIABLE)
12058
{
12059
VarExpressionNormalAst *__node_272 = 0;
12060
if (!parseVarExpressionNormal(&__node_272))
12061
{
12062
if (!mBlockErrors)
12063
{
12064
expectedSymbol(AstNode::VarExpressionNormalKind, "varExpressionNormal");
12065
}
12066
return false;
12067
}
12068
(*yynode)->varExpressionNormal = __node_272;
12069
12070
}
12071
else
12072
{
12073
return false;
12074
}
12075
}
12076
else
12077
{
12078
return false;
12079
}
12080
12081
(*yynode)->endToken = tokenStream->index() - 2;
12082
12083
return true;
12084
}
12085
12086
bool Parser::parseVarExpressionNewObject(VarExpressionNewObjectAst **yynode)
12087
{
12088
*yynode = create<VarExpressionNewObjectAst>();
12089
12090
(*yynode)->startToken = tokenStream->index() - 1;
12091
12092
if (yytoken == Token_NEW)
12093
{
12094
if (yytoken != Token_NEW)
12095
{
12096
if (!mBlockErrors)
12097
{
12098
expectedToken(yytoken, Token_NEW, "new");
12099
}
12100
return false;
12101
}
12102
yylex();
12103
12104
ClassNameReferenceAst *__node_273 = 0;
12105
if (!parseClassNameReference(&__node_273))
12106
{
12107
if (!mBlockErrors)
12108
{
12109
expectedSymbol(AstNode::ClassNameReferenceKind, "classNameReference");
12110
}
12111
return false;
12112
}
12113
(*yynode)->className = __node_273;
12114
12115
CtorArgumentsAst *__node_274 = 0;
12116
if (!parseCtorArguments(&__node_274))
12117
{
12118
if (!mBlockErrors)
12119
{
12120
expectedSymbol(AstNode::CtorArgumentsKind, "ctorArguments");
12121
}
12122
return false;
12123
}
12124
(*yynode)->ctor = __node_274;
12125
12126
}
12127
else
12128
{
12129
return false;
12130
}
12131
12132
(*yynode)->endToken = tokenStream->index() - 2;
12133
12134
return true;
12135
}
12136
12137
bool Parser::parseVarExpressionNormal(VarExpressionNormalAst **yynode)
12138
{
12139
*yynode = create<VarExpressionNormalAst>();
12140
12141
(*yynode)->startToken = tokenStream->index() - 1;
12142
(*yynode)->array = -1;
12143
12144
if (yytoken == Token_ARRAY
12145
|| yytoken == Token_BACKTICK
12146
|| yytoken == Token_CLASS_C
12147
|| yytoken == Token_CLONE
12148
|| yytoken == Token_CONSTANT_ENCAPSED_STRING
12149
|| yytoken == Token_DNUMBER
12150
|| yytoken == Token_DOLLAR
12151
|| yytoken == Token_DOUBLE_QUOTE
12152
|| yytoken == Token_EMPTY
12153
|| yytoken == Token_FILE
12154
|| yytoken == Token_FUNC_C
12155
|| yytoken == Token_ISSET
12156
|| yytoken == Token_LINE
12157
|| yytoken == Token_LNUMBER
12158
|| yytoken == Token_LPAREN
12159
|| yytoken == Token_METHOD_C
12160
|| yytoken == Token_NEW
12161
|| yytoken == Token_START_HEREDOC
12162
|| yytoken == Token_STRING
12163
|| yytoken == Token_STRING_VARNAME
12164
|| yytoken == Token_VARIABLE)
12165
{
12166
if (yytoken == Token_LPAREN)
12167
{
12168
if (yytoken != Token_LPAREN)
12169
{
12170
if (!mBlockErrors)
12171
{
12172
expectedToken(yytoken, Token_LPAREN, "(");
12173
}
12174
return false;
12175
}
12176
yylex();
12177
12178
ExprAst *__node_275 = 0;
12179
if (!parseExpr(&__node_275))
12180
{
12181
if (!mBlockErrors)
12182
{
12183
expectedSymbol(AstNode::ExprKind, "expr");
12184
}
12185
return false;
12186
}
12187
(*yynode)->expression = __node_275;
12188
12189
if (yytoken != Token_RPAREN)
12190
{
12191
if (!mBlockErrors)
12192
{
12193
expectedToken(yytoken, Token_RPAREN, ")");
12194
}
12195
return false;
12196
}
12197
yylex();
12198
12199
}
12200
else if (yytoken == Token_BACKTICK)
12201
{
12202
if (yytoken != Token_BACKTICK)
12203
{
12204
if (!mBlockErrors)
12205
{
12206
expectedToken(yytoken, Token_BACKTICK, "`");
12207
}
12208
return false;
12209
}
12210
yylex();
12211
12212
EncapsListAst *__node_276 = 0;
12213
if (!parseEncapsList(&__node_276))
12214
{
12215
if (!mBlockErrors)
12216
{
12217
expectedSymbol(AstNode::EncapsListKind, "encapsList");
12218
}
12219
return false;
12220
}
12221
(*yynode)->encapsList = __node_276;
12222
12223
if (yytoken != Token_BACKTICK)
12224
{
12225
if (!mBlockErrors)
12226
{
12227
expectedToken(yytoken, Token_BACKTICK, "`");
12228
}
12229
return false;
12230
}
12231
yylex();
12232
12233
}
12234
else if (yytoken == Token_CLASS_C
12235
|| yytoken == Token_CONSTANT_ENCAPSED_STRING
12236
|| yytoken == Token_DNUMBER
12237
|| yytoken == Token_DOLLAR
12238
|| yytoken == Token_DOUBLE_QUOTE
12239
|| yytoken == Token_FILE
12240
|| yytoken == Token_FUNC_C
12241
|| yytoken == Token_LINE
12242
|| yytoken == Token_LNUMBER
12243
|| yytoken == Token_METHOD_C
12244
|| yytoken == Token_START_HEREDOC
12245
|| yytoken == Token_STRING
12246
|| yytoken == Token_STRING_VARNAME
12247
|| yytoken == Token_VARIABLE)
12248
{
12249
bool blockErrors_3 = blockErrors(true);
12250
qint64 try_startToken_3 = tokenStream->index() - 1;
12251
ParserState *try_startState_3 = copyCurrentState();
12252
{
12253
VariableAst *__node_277 = 0;
12254
if (!parseVariable(&__node_277))
12255
{
12256
goto __catch_3;
12257
}
12258
(*yynode)->variable = __node_277;
12259
12260
m_state.varExpressionIsVariable = true;
12261
}
12262
blockErrors(blockErrors_3);
12263
if (try_startState_3)
12264
delete try_startState_3;
12265
12266
if (false) // the only way to enter here is using goto
12267
{
12268
__catch_3:
12269
if (try_startState_3)
12270
{
12271
restoreState(try_startState_3);
12272
delete try_startState_3;
12273
}
12274
blockErrors(blockErrors_3);
12275
rewind(try_startToken_3);
12276
12277
ScalarAst *__node_278 = 0;
12278
if (!parseScalar(&__node_278))
12279
{
12280
if (!mBlockErrors)
12281
{
12282
expectedSymbol(AstNode::ScalarKind, "scalar");
12283
}
12284
return false;
12285
}
12286
(*yynode)->scalar = __node_278;
12287
12288
}
12289
12290
}
12291
else if (yytoken == Token_ARRAY)
12292
{
12293
if (yytoken != Token_ARRAY)
12294
{
12295
if (!mBlockErrors)
12296
{
12297
expectedToken(yytoken, Token_ARRAY, "array");
12298
}
12299
return false;
12300
}
12301
(*yynode)->array = tokenStream->index() - 1;
12302
yylex();
12303
12304
if (yytoken != Token_LPAREN)
12305
{
12306
if (!mBlockErrors)
12307
{
12308
expectedToken(yytoken, Token_LPAREN, "(");
12309
}
12310
return false;
12311
}
12312
yylex();
12313
12314
if (yytoken == Token_ARRAY
12315
|| yytoken == Token_ARRAY_CAST
12316
|| yytoken == Token_AT
12317
|| yytoken == Token_BACKTICK
12318
|| yytoken == Token_BANG
12319
|| yytoken == Token_BIT_AND
12320
|| yytoken == Token_BOOL_CAST
12321
|| yytoken == Token_CLASS_C
12322
|| yytoken == Token_CLONE
12323
|| yytoken == Token_CONSTANT_ENCAPSED_STRING
12324
|| yytoken == Token_DEC
12325
|| yytoken == Token_DNUMBER
12326
|| yytoken == Token_DOLLAR
12327
|| yytoken == Token_DOUBLE_CAST
12328
|| yytoken == Token_DOUBLE_QUOTE
12329
|| yytoken == Token_EMPTY
12330
|| yytoken == Token_EVAL
12331
|| yytoken == Token_EXIT
12332
|| yytoken == Token_FILE
12333
|| yytoken == Token_FUNC_C
12334
|| yytoken == Token_INC
12335
|| yytoken == Token_INCLUDE
12336
|| yytoken == Token_INCLUDE_ONCE
12337
|| yytoken == Token_INT_CAST
12338
|| yytoken == Token_ISSET
12339
|| yytoken == Token_LINE
12340
|| yytoken == Token_LIST
12341
|| yytoken == Token_LNUMBER
12342
|| yytoken == Token_LPAREN
12343
|| yytoken == Token_METHOD_C
12344
|| yytoken == Token_MINUS
12345
|| yytoken == Token_NEW
12346
|| yytoken == Token_OBJECT_CAST
12347
|| yytoken == Token_PLUS
12348
|| yytoken == Token_PRINT
12349
|| yytoken == Token_REQUIRE
12350
|| yytoken == Token_REQUIRE_ONCE
12351
|| yytoken == Token_START_HEREDOC
12352
|| yytoken == Token_STRING
12353
|| yytoken == Token_STRING_CAST
12354
|| yytoken == Token_STRING_VARNAME
12355
|| yytoken == Token_TILDE
12356
|| yytoken == Token_UNSET_CAST
12357
|| yytoken == Token_VARIABLE)
12358
{
12359
ArrayPairValueAst *__node_279 = 0;
12360
if (!parseArrayPairValue(&__node_279))
12361
{
12362
if (!mBlockErrors)
12363
{
12364
expectedSymbol(AstNode::ArrayPairValueKind, "arrayPairValue");
12365
}
12366
return false;
12367
}
12368
(*yynode)->arrayValuesSequence = snoc((*yynode)->arrayValuesSequence, __node_279, memoryPool);
12369
12370
while (yytoken == Token_COMMA)
12371
{
12372
if (yytoken != Token_COMMA)
12373
{
12374
if (!mBlockErrors)
12375
{
12376
expectedToken(yytoken, Token_COMMA, ",");
12377
}
12378
return false;
12379
}
12380
yylex();
12381
12382
if (yytoken == Token_RPAREN)
12383
{
12384
break;
12385
}
12386
ArrayPairValueAst *__node_280 = 0;
12387
if (!parseArrayPairValue(&__node_280))
12388
{
12389
if (!mBlockErrors)
12390
{
12391
expectedSymbol(AstNode::ArrayPairValueKind, "arrayPairValue");
12392
}
12393
return false;
12394
}
12395
(*yynode)->arrayValuesSequence = snoc((*yynode)->arrayValuesSequence, __node_280, memoryPool);
12396
12397
}
12398
}
12399
else if (true /*epsilon*/)
12400
{
12401
}
12402
else
12403
{
12404
return false;
12405
}
12406
if (yytoken != Token_RPAREN)
12407
{
12408
if (!mBlockErrors)
12409
{
12410
expectedToken(yytoken, Token_RPAREN, ")");
12411
}
12412
return false;
12413
}
12414
yylex();
12415
12416
}
12417
else if (yytoken == Token_ISSET)
12418
{
12419
if (yytoken != Token_ISSET)
12420
{
12421
if (!mBlockErrors)
12422
{
12423
expectedToken(yytoken, Token_ISSET, "isset");
12424
}
12425
return false;
12426
}
12427
yylex();
12428
12429
if (yytoken != Token_LPAREN)
12430
{
12431
if (!mBlockErrors)
12432
{
12433
expectedToken(yytoken, Token_LPAREN, "(");
12434
}
12435
return false;
12436
}
12437
yylex();
12438
12439
VariableAst *__node_281 = 0;
12440
if (!parseVariable(&__node_281))
12441
{
12442
if (!mBlockErrors)
12443
{
12444
expectedSymbol(AstNode::VariableKind, "variable");
12445
}
12446
return false;
12447
}
12448
(*yynode)->issetVariableSequence = snoc((*yynode)->issetVariableSequence, __node_281, memoryPool);
12449
12450
while (yytoken == Token_COMMA)
12451
{
12452
if (yytoken != Token_COMMA)
12453
{
12454
if (!mBlockErrors)
12455
{
12456
expectedToken(yytoken, Token_COMMA, ",");
12457
}
12458
return false;
12459
}
12460
yylex();
12461
12462
VariableAst *__node_282 = 0;
12463
if (!parseVariable(&__node_282))
12464
{
12465
if (!mBlockErrors)
12466
{
12467
expectedSymbol(AstNode::VariableKind, "variable");
12468
}
12469
return false;
12470
}
12471
(*yynode)->issetVariableSequence = snoc((*yynode)->issetVariableSequence, __node_282, memoryPool);
12472
12473
}
12474
if (yytoken != Token_RPAREN)
12475
{
12476
if (!mBlockErrors)
12477
{
12478
expectedToken(yytoken, Token_RPAREN, ")");
12479
}
12480
return false;
12481
}
12482
yylex();
12483
12484
}
12485
else if (yytoken == Token_EMPTY)
12486
{
12487
if (yytoken != Token_EMPTY)
12488
{
12489
if (!mBlockErrors)
12490
{
12491
expectedToken(yytoken, Token_EMPTY, "empty");
12492
}
12493
return false;
12494
}
12495
yylex();
12496
12497
if (yytoken != Token_LPAREN)
12498
{
12499
if (!mBlockErrors)
12500
{
12501
expectedToken(yytoken, Token_LPAREN, "(");
12502
}
12503
return false;
12504
}
12505
yylex();
12506
12507
VariableAst *__node_283 = 0;
12508
if (!parseVariable(&__node_283))
12509
{
12510
if (!mBlockErrors)
12511
{
12512
expectedSymbol(AstNode::VariableKind, "variable");
12513
}
12514
return false;
12515
}
12516
(*yynode)->emptyVarialbe = __node_283;
12517
12518
if (yytoken != Token_RPAREN)
12519
{
12520
if (!mBlockErrors)
12521
{
12522
expectedToken(yytoken, Token_RPAREN, ")");
12523
}
12524
return false;
12525
}
12526
yylex();
12527
12528
}
12529
else if (yytoken == Token_NEW)
12530
{
12531
VarExpressionNewObjectAst *__node_284 = 0;
12532
if (!parseVarExpressionNewObject(&__node_284))
12533
{
12534
if (!mBlockErrors)
12535
{
12536
expectedSymbol(AstNode::VarExpressionNewObjectKind, "varExpressionNewObject");
12537
}
12538
return false;
12539
}
12540
(*yynode)->newObject = __node_284;
12541
12542
}
12543
else if (yytoken == Token_CLONE)
12544
{
12545
if (yytoken != Token_CLONE)
12546
{
12547
if (!mBlockErrors)
12548
{
12549
expectedToken(yytoken, Token_CLONE, "clone");
12550
}
12551
return false;
12552
}
12553
yylex();
12554
12555
VarExpressionNormalAst *__node_285 = 0;
12556
if (!parseVarExpressionNormal(&__node_285))
12557
{
12558
if (!mBlockErrors)
12559
{
12560
expectedSymbol(AstNode::VarExpressionNormalKind, "varExpressionNormal");
12561
}
12562
return false;
12563
}
12564
(*yynode)->cloneCar = __node_285;
12565
12566
}
12567
else
12568
{
12569
return false;
12570
}
12571
}
12572
else
12573
{
12574
return false;
12575
}
12576
12577
(*yynode)->endToken = tokenStream->index() - 2;
12578
12579
return true;
12580
}
12581
12582
bool Parser::parseVariable(VariableAst **yynode)
12583
{
12584
*yynode = create<VariableAst>();
12585
12586
(*yynode)->startToken = tokenStream->index() - 1;
12587
12588
if (yytoken == Token_DOLLAR
12589
|| yytoken == Token_STRING
12590
|| yytoken == Token_VARIABLE)
12591
{
12592
BaseVariableWithFunctionCallsAst *__node_286 = 0;
12593
if (!parseBaseVariableWithFunctionCalls(&__node_286))
12594
{
12595
if (!mBlockErrors)
12596
{
12597
expectedSymbol(AstNode::BaseVariableWithFunctionCallsKind, "baseVariableWithFunctionCalls");
12598
}
12599
return false;
12600
}
12601
(*yynode)->var = __node_286;
12602
12603
while (yytoken == Token_OBJECT_OPERATOR)
12604
{
12605
VariablePropertyAst *__node_287 = 0;
12606
if (!parseVariableProperty(&__node_287))
12607
{
12608
if (!mBlockErrors)
12609
{
12610
expectedSymbol(AstNode::VariablePropertyKind, "variableProperty");
12611
}
12612
return false;
12613
}
12614
(*yynode)->variablePropertiesSequence = snoc((*yynode)->variablePropertiesSequence, __node_287, memoryPool);
12615
12616
}
12617
}
12618
else
12619
{
12620
return false;
12621
}
12622
12623
(*yynode)->endToken = tokenStream->index() - 2;
12624
12625
return true;
12626
}
12627
12628
bool Parser::parseVariableIdentifier(VariableIdentifierAst **yynode)
12629
{
12630
*yynode = create<VariableIdentifierAst>();
12631
12632
(*yynode)->startToken = tokenStream->index() - 1;
12633
(*yynode)->variable = -1;
12634
12635
if (yytoken == Token_VARIABLE)
12636
{
12637
if (yytoken != Token_VARIABLE)
12638
{
12639
if (!mBlockErrors)
12640
{
12641
expectedToken(yytoken, Token_VARIABLE, "variable");
12642
}
12643
return false;
12644
}
12645
(*yynode)->variable = tokenStream->index() - 1;
12646
yylex();
12647
12648
}
12649
else
12650
{
12651
return false;
12652
}
12653
12654
(*yynode)->endToken = tokenStream->index() - 2;
12655
12656
return true;
12657
}
12658
12659
bool Parser::parseVariableName(VariableNameAst **yynode)
12660
{
12661
*yynode = create<VariableNameAst>();
12662
12663
(*yynode)->startToken = tokenStream->index() - 1;
12664
12665
if (yytoken == Token_LBRACE
12666
|| yytoken == Token_STRING)
12667
{
12668
if (yytoken == Token_STRING)
12669
{
12670
IdentifierAst *__node_288 = 0;
12671
if (!parseIdentifier(&__node_288))
12672
{
12673
if (!mBlockErrors)
12674
{
12675
expectedSymbol(AstNode::IdentifierKind, "identifier");
12676
}
12677
return false;
12678
}
12679
(*yynode)->name = __node_288;
12680
12681
}
12682
else if (yytoken == Token_LBRACE)
12683
{
12684
if (yytoken != Token_LBRACE)
12685
{
12686
if (!mBlockErrors)
12687
{
12688
expectedToken(yytoken, Token_LBRACE, "{");
12689
}
12690
return false;
12691
}
12692
yylex();
12693
12694
ExprAst *__node_289 = 0;
12695
if (!parseExpr(&__node_289))
12696
{
12697
if (!mBlockErrors)
12698
{
12699
expectedSymbol(AstNode::ExprKind, "expr");
12700
}
12701
return false;
12702
}
12703
(*yynode)->expr = __node_289;
12704
12705
if (yytoken != Token_RBRACE)
12706
{
12707
if (!mBlockErrors)
12708
{
12709
expectedToken(yytoken, Token_RBRACE, "}");
12710
}
12711
return false;
12712
}
12713
yylex();
12714
12715
}
12716
else
12717
{
12718
return false;
12719
}
12720
}
12721
else
12722
{
12723
return false;
12724
}
12725
12726
(*yynode)->endToken = tokenStream->index() - 2;
12727
12728
return true;
12729
}
12730
12731
bool Parser::parseVariableProperty(VariablePropertyAst **yynode)
12732
{
12733
*yynode = create<VariablePropertyAst>();
12734
12735
(*yynode)->startToken = tokenStream->index() - 1;
12736
(*yynode)->isFunctionCall = -1;
12737
12738
if (yytoken == Token_OBJECT_OPERATOR)
12739
{
12740
if (yytoken != Token_OBJECT_OPERATOR)
12741
{
12742
if (!mBlockErrors)
12743
{
12744
expectedToken(yytoken, Token_OBJECT_OPERATOR, "->");
12745
}
12746
return false;
12747
}
12748
yylex();
12749
12750
ObjectPropertyAst *__node_290 = 0;
12751
if (!parseObjectProperty(&__node_290))
12752
{
12753
if (!mBlockErrors)
12754
{
12755
expectedSymbol(AstNode::ObjectPropertyKind, "objectProperty");
12756
}
12757
return false;
12758
}
12759
(*yynode)->objectProperty = __node_290;
12760
12761
if (yytoken == Token_LPAREN)
12762
{
12763
if (yytoken != Token_LPAREN)
12764
{
12765
if (!mBlockErrors)
12766
{
12767
expectedToken(yytoken, Token_LPAREN, "(");
12768
}
12769
return false;
12770
}
12771
(*yynode)->isFunctionCall = tokenStream->index() - 1;
12772
yylex();
12773
12774
FunctionCallParameterListAst *__node_291 = 0;
12775
if (!parseFunctionCallParameterList(&__node_291))
12776
{
12777
if (!mBlockErrors)
12778
{
12779
expectedSymbol(AstNode::FunctionCallParameterListKind, "functionCallParameterList");
12780
}
12781
return false;
12782
}
12783
(*yynode)->parameterList = __node_291;
12784
12785
if (yytoken != Token_RPAREN)
12786
{
12787
if (!mBlockErrors)
12788
{
12789
expectedToken(yytoken, Token_RPAREN, ")");
12790
}
12791
return false;
12792
}
12793
yylex();
12794
12795
}
12796
else if (true /*epsilon*/)
12797
{
12798
}
12799
else
12800
{
12801
return false;
12802
}
12803
}
12804
else
12805
{
12806
return false;
12807
}
12808
12809
(*yynode)->endToken = tokenStream->index() - 2;
12810
12811
return true;
12812
}
12813
12814
bool Parser::parseVariableWithoutObjects(VariableWithoutObjectsAst **yynode)
12815
{
12816
*yynode = create<VariableWithoutObjectsAst>();
12817
12818
(*yynode)->startToken = tokenStream->index() - 1;
12819
12820
if (yytoken == Token_DOLLAR
12821
|| yytoken == Token_VARIABLE)
12822
{
12823
CompoundVariableWithSimpleIndirectReferenceAst *__node_292 = 0;
12824
if (!parseCompoundVariableWithSimpleIndirectReference(&__node_292))
12825
{
12826
if (!mBlockErrors)
12827
{
12828
expectedSymbol(AstNode::CompoundVariableWithSimpleIndirectReferenceKind, "compoundVariableWithSimpleIndirectReference");
12829
}
12830
return false;
12831
}
12832
(*yynode)->variable = __node_292;
12833
12834
while (yytoken == Token_LBRACE
12835
|| yytoken == Token_LBRACKET)
12836
{
12837
DimListItemAst *__node_293 = 0;
12838
if (!parseDimListItem(&__node_293))
12839
{
12840
if (!mBlockErrors)
12841
{
12842
expectedSymbol(AstNode::DimListItemKind, "dimListItem");
12843
}
12844
return false;
12845
}
12846
(*yynode)->offsetItemsSequence = snoc((*yynode)->offsetItemsSequence, __node_293, memoryPool);
12847
12848
}
12849
}
12850
else
12851
{
12852
return false;
12853
}
12854
12855
(*yynode)->endToken = tokenStream->index() - 2;
12856
12857
return true;
12858
}
12859
12860
bool Parser::parseWhileStatement(WhileStatementAst **yynode)
12861
{
12862
*yynode = create<WhileStatementAst>();
12863
12864
(*yynode)->startToken = tokenStream->index() - 1;
12865
12866
if (yytoken == Token_ARRAY
12867
|| yytoken == Token_ARRAY_CAST
12868
|| yytoken == Token_AT
12869
|| yytoken == Token_BACKTICK
12870
|| yytoken == Token_BANG
12871
|| yytoken == Token_BOOL_CAST
12872
|| yytoken == Token_BREAK
12873
|| yytoken == Token_CLASS_C
12874
|| yytoken == Token_CLONE
12875
|| yytoken == Token_CLOSE_TAG
12876
|| yytoken == Token_COLON
12877
|| yytoken == Token_CONSTANT_ENCAPSED_STRING
12878
|| yytoken == Token_CONTINUE
12879
|| yytoken == Token_DEC
12880
|| yytoken == Token_DECLARE
12881
|| yytoken == Token_DNUMBER
12882
|| yytoken == Token_DO
12883
|| yytoken == Token_DOLLAR
12884
|| yytoken == Token_DOUBLE_CAST
12885
|| yytoken == Token_DOUBLE_QUOTE
12886
|| yytoken == Token_ECHO
12887
|| yytoken == Token_EMPTY
12888
|| yytoken == Token_EVAL
12889
|| yytoken == Token_EXIT
12890
|| yytoken == Token_FILE
12891
|| yytoken == Token_FOR
12892
|| yytoken == Token_FOREACH
12893
|| yytoken == Token_FUNC_C
12894
|| yytoken == Token_GLOBAL
12895
|| yytoken == Token_IF
12896
|| yytoken == Token_INC
12897
|| yytoken == Token_INCLUDE
12898
|| yytoken == Token_INCLUDE_ONCE
12899
|| yytoken == Token_INLINE_HTML
12900
|| yytoken == Token_INT_CAST
12901
|| yytoken == Token_ISSET
12902
|| yytoken == Token_LBRACE
12903
|| yytoken == Token_LINE
12904
|| yytoken == Token_LIST
12905
|| yytoken == Token_LNUMBER
12906
|| yytoken == Token_LPAREN
12907
|| yytoken == Token_METHOD_C
12908
|| yytoken == Token_MINUS
12909
|| yytoken == Token_NEW
12910
|| yytoken == Token_OBJECT_CAST
12911
|| yytoken == Token_OPEN_TAG
12912
|| yytoken == Token_OPEN_TAG_WITH_ECHO
12913
|| yytoken == Token_PLUS
12914
|| yytoken == Token_PRINT
12915
|| yytoken == Token_REQUIRE
12916
|| yytoken == Token_REQUIRE_ONCE
12917
|| yytoken == Token_RETURN
12918
|| yytoken == Token_SEMICOLON
12919
|| yytoken == Token_START_HEREDOC
12920
|| yytoken == Token_STATIC
12921
|| yytoken == Token_STRING
12922
|| yytoken == Token_STRING_CAST
12923
|| yytoken == Token_STRING_VARNAME
12924
|| yytoken == Token_SWITCH
12925
|| yytoken == Token_THROW
12926
|| yytoken == Token_TILDE
12927
|| yytoken == Token_TRY
12928
|| yytoken == Token_UNSET
12929
|| yytoken == Token_UNSET_CAST
12930
|| yytoken == Token_VARIABLE
12931
|| yytoken == Token_WHILE)
12932
{
12933
if (yytoken == Token_ARRAY
12934
|| yytoken == Token_ARRAY_CAST
12935
|| yytoken == Token_AT
12936
|| yytoken == Token_BACKTICK
12937
|| yytoken == Token_BANG
12938
|| yytoken == Token_BOOL_CAST
12939
|| yytoken == Token_BREAK
12940
|| yytoken == Token_CLASS_C
12941
|| yytoken == Token_CLONE
12942
|| yytoken == Token_CLOSE_TAG
12943
|| yytoken == Token_CONSTANT_ENCAPSED_STRING
12944
|| yytoken == Token_CONTINUE
12945
|| yytoken == Token_DEC
12946
|| yytoken == Token_DECLARE
12947
|| yytoken == Token_DNUMBER
12948
|| yytoken == Token_DO
12949
|| yytoken == Token_DOLLAR
12950
|| yytoken == Token_DOUBLE_CAST
12951
|| yytoken == Token_DOUBLE_QUOTE
12952
|| yytoken == Token_ECHO
12953
|| yytoken == Token_EMPTY
12954
|| yytoken == Token_EVAL
12955
|| yytoken == Token_EXIT
12956
|| yytoken == Token_FILE
12957
|| yytoken == Token_FOR
12958
|| yytoken == Token_FOREACH
12959
|| yytoken == Token_FUNC_C
12960
|| yytoken == Token_GLOBAL
12961
|| yytoken == Token_IF
12962
|| yytoken == Token_INC
12963
|| yytoken == Token_INCLUDE
12964
|| yytoken == Token_INCLUDE_ONCE
12965
|| yytoken == Token_INLINE_HTML
12966
|| yytoken == Token_INT_CAST
12967
|| yytoken == Token_ISSET
12968
|| yytoken == Token_LBRACE
12969
|| yytoken == Token_LINE
12970
|| yytoken == Token_LIST
12971
|| yytoken == Token_LNUMBER
12972
|| yytoken == Token_LPAREN
12973
|| yytoken == Token_METHOD_C
12974
|| yytoken == Token_MINUS
12975
|| yytoken == Token_NEW
12976
|| yytoken == Token_OBJECT_CAST
12977
|| yytoken == Token_OPEN_TAG
12978
|| yytoken == Token_OPEN_TAG_WITH_ECHO
12979
|| yytoken == Token_PLUS
12980
|| yytoken == Token_PRINT
12981
|| yytoken == Token_REQUIRE
12982
|| yytoken == Token_REQUIRE_ONCE
12983
|| yytoken == Token_RETURN
12984
|| yytoken == Token_SEMICOLON
12985
|| yytoken == Token_START_HEREDOC
12986
|| yytoken == Token_STATIC
12987
|| yytoken == Token_STRING
12988
|| yytoken == Token_STRING_CAST
12989
|| yytoken == Token_STRING_VARNAME
12990
|| yytoken == Token_SWITCH
12991
|| yytoken == Token_THROW
12992
|| yytoken == Token_TILDE
12993
|| yytoken == Token_TRY
12994
|| yytoken == Token_UNSET
12995
|| yytoken == Token_UNSET_CAST
12996
|| yytoken == Token_VARIABLE
12997
|| yytoken == Token_WHILE)
12998
{
12999
StatementAst *__node_294 = 0;
13000
if (!parseStatement(&__node_294))
13001
{
13002
if (!mBlockErrors)
13003
{
13004
expectedSymbol(AstNode::StatementKind, "statement");
13005
}
13006
return false;
13007
}
13008
(*yynode)->statement = __node_294;
13009
13010
}
13011
else if (yytoken == Token_COLON)
13012
{
13013
if (yytoken != Token_COLON)
13014
{
13015
if (!mBlockErrors)
13016
{
13017
expectedToken(yytoken, Token_COLON, ":");
13018
}
13019
return false;
13020
}
13021
yylex();
13022
13023
InnerStatementListAst *__node_295 = 0;
13024
if (!parseInnerStatementList(&__node_295))
13025
{
13026
if (!mBlockErrors)
13027
{
13028
expectedSymbol(AstNode::InnerStatementListKind, "innerStatementList");
13029
}
13030
return false;
13031
}
13032
(*yynode)->statements = __node_295;
13033
13034
if (yytoken != Token_ENDWHILE)
13035
{
13036
if (!mBlockErrors)
13037
{
13038
expectedToken(yytoken, Token_ENDWHILE, "endwhile");
13039
}
13040
return false;
13041
}
13042
yylex();
13043
13044
SemicolonOrCloseTagAst *__node_296 = 0;
13045
if (!parseSemicolonOrCloseTag(&__node_296))
13046
{
13047
if (!mBlockErrors)
13048
{
13049
expectedSymbol(AstNode::SemicolonOrCloseTagKind, "semicolonOrCloseTag");
13050
}
13051
return false;
13052
}
13053
}
13054
else
13055
{
13056
return false;
13057
}
13058
}
13059
else
13060
{
13061
return false;
13062
}
13063
13064
(*yynode)->endToken = tokenStream->index() - 2;
13065
13066
return true;
13067
}
13068
13069
13070
} // end of namespace Php
13071
Loggerhead is a web-based interface for Breezy
Version: 2.0.1