b7a13535b8530ebede9e2ad6aeca3971b1d0de25
[phpeclipse.git] / net.sourceforge.phpeclipse / src / net / sourceforge / phpdt / internal / compiler / parser / Parser.java
1 /***********************************************************************************************************************************
2  * Copyright (c) 2002 www.phpeclipse.de All rights reserved. This program and the accompanying material are made available under the
3  * terms of the Common Public License v1.0 which accompanies this distribution, and is available at
4  * http://www.eclipse.org/legal/cpl-v10.html
5  *
6  * Contributors: www.phpeclipse.de
7  **********************************************************************************************************************************/
8 package net.sourceforge.phpdt.internal.compiler.parser;
9
10 import java.util.ArrayList;
11 import java.util.HashMap;
12 import java.util.HashSet;
13
14 import net.sourceforge.phpdt.core.compiler.CharOperation;
15 import net.sourceforge.phpdt.core.compiler.ITerminalSymbols;
16 import net.sourceforge.phpdt.core.compiler.InvalidInputException;
17 import net.sourceforge.phpdt.internal.compiler.impl.CompilerOptions;
18 import net.sourceforge.phpdt.internal.compiler.impl.ReferenceContext;
19 import net.sourceforge.phpdt.internal.compiler.lookup.CompilerModifiers;
20 import net.sourceforge.phpdt.internal.compiler.lookup.TypeConstants;
21 import net.sourceforge.phpdt.internal.compiler.problem.ProblemReporter;
22 import net.sourceforge.phpdt.internal.compiler.problem.ProblemSeverities;
23 import net.sourceforge.phpdt.internal.compiler.util.Util;
24 import net.sourceforge.phpdt.internal.ui.util.PHPFileUtil;
25 import net.sourceforge.phpeclipse.builder.IdentifierIndexManager;
26 import net.sourceforge.phpeclipse.internal.compiler.ast.AND_AND_Expression;
27 import net.sourceforge.phpeclipse.internal.compiler.ast.ASTNode;
28 import net.sourceforge.phpeclipse.internal.compiler.ast.AbstractMethodDeclaration;
29 import net.sourceforge.phpeclipse.internal.compiler.ast.BinaryExpression;
30 import net.sourceforge.phpeclipse.internal.compiler.ast.Block;
31 import net.sourceforge.phpeclipse.internal.compiler.ast.BreakStatement;
32 import net.sourceforge.phpeclipse.internal.compiler.ast.CompilationUnitDeclaration;
33 import net.sourceforge.phpeclipse.internal.compiler.ast.ConditionalExpression;
34 import net.sourceforge.phpeclipse.internal.compiler.ast.ContinueStatement;
35 import net.sourceforge.phpeclipse.internal.compiler.ast.EqualExpression;
36 import net.sourceforge.phpeclipse.internal.compiler.ast.Expression;
37 import net.sourceforge.phpeclipse.internal.compiler.ast.FieldDeclaration;
38 import net.sourceforge.phpeclipse.internal.compiler.ast.FieldReference;
39 import net.sourceforge.phpeclipse.internal.compiler.ast.IfStatement;
40 import net.sourceforge.phpeclipse.internal.compiler.ast.ImportReference;
41 import net.sourceforge.phpeclipse.internal.compiler.ast.InstanceOfExpression;
42 import net.sourceforge.phpeclipse.internal.compiler.ast.MethodDeclaration;
43 import net.sourceforge.phpeclipse.internal.compiler.ast.OR_OR_Expression;
44 import net.sourceforge.phpeclipse.internal.compiler.ast.OperatorIds;
45 import net.sourceforge.phpeclipse.internal.compiler.ast.ReturnStatement;
46 import net.sourceforge.phpeclipse.internal.compiler.ast.SingleTypeReference;
47 import net.sourceforge.phpeclipse.internal.compiler.ast.Statement;
48 import net.sourceforge.phpeclipse.internal.compiler.ast.StringLiteral;
49 import net.sourceforge.phpeclipse.internal.compiler.ast.StringLiteralDQ;
50 import net.sourceforge.phpeclipse.internal.compiler.ast.StringLiteralSQ;
51 import net.sourceforge.phpeclipse.internal.compiler.ast.TypeDeclaration;
52 import net.sourceforge.phpeclipse.internal.compiler.ast.TypeReference;
53 import net.sourceforge.phpeclipse.ui.overlaypages.ProjectPrefUtil;
54
55 import org.eclipse.core.resources.IFile;
56 import org.eclipse.core.resources.IProject;
57 import org.eclipse.core.resources.IResource;
58 import org.eclipse.core.runtime.IPath;
59
60 public class Parser implements ITerminalSymbols, CompilerModifiers, ParserBasicInformation {
61         protected final static int StackIncrement = 255;
62
63         protected int stateStackTop;
64
65         // protected int[] stack = new int[StackIncrement];
66
67         public int firstToken; // handle for multiple parsing goals
68
69         public int lastAct; // handle for multiple parsing goals
70
71         // protected RecoveredElement currentElement;
72
73         public static boolean VERBOSE_RECOVERY = false;
74
75         protected boolean diet = false; // tells the scanner to jump over some
76
77         /**
78          * the PHP token scanner
79          */
80         public Scanner scanner;
81
82         int token;
83
84         protected int modifiers;
85
86         protected int modifiersSourceStart;
87
88         protected Parser(ProblemReporter problemReporter) {
89                 this.problemReporter = problemReporter;
90                 this.options = problemReporter.options;
91                 this.token = TokenNameEOF;
92                 this.initializeScanner();
93         }
94
95         public void setFileToParse(IFile fileToParse) {
96                 this.token = TokenNameEOF;
97                 this.initializeScanner();
98         }
99
100         /**
101          * ClassDeclaration Constructor.
102          *
103          * @param s
104          * @param sess
105          *          Description of Parameter
106          * @see
107          */
108         public Parser(IFile fileToParse) {
109                 // if (keywordMap == null) {
110                 // keywordMap = new HashMap();
111                 // for (int i = 0; i < PHP_KEYWORS.length; i++) {
112                 // keywordMap.put(PHP_KEYWORS[i], new Integer(PHP_KEYWORD_TOKEN[i]));
113                 // }
114                 // }
115                 // this.currentPHPString = 0;
116                 // PHPParserSuperclass.fileToParse = fileToParse;
117                 // this.phpList = null;
118                 this.includesList = null;
119                 // this.str = "";
120                 this.token = TokenNameEOF;
121                 // this.chIndx = 0;
122                 // this.rowCount = 1;
123                 // this.columnCount = 0;
124                 // this.phpEnd = false;
125                 // getNextToken();
126                 this.initializeScanner();
127         }
128
129         public void initializeScanner() {
130                 this.scanner = new Scanner(false /* comment */, false /* whitespace */, this.options
131                                 .getSeverity(CompilerOptions.NonExternalizedString) != ProblemSeverities.Ignore /* nls */, false, false,
132                                 this.options.taskTags/* taskTags */, this.options.taskPriorites/* taskPriorities */, true/* isTaskCaseSensitive */);
133         }
134
135         /**
136          * Create marker for the parse error
137          */
138         // private void setMarker(String message, int charStart, int charEnd, int
139         // errorLevel) {
140         // setMarker(fileToParse, message, charStart, charEnd, errorLevel);
141         // }
142         /**
143          * This method will throw the SyntaxError. It will add the good lines and
144          * columns to the Error
145          *
146          * @param error
147          *          the error message
148          * @throws SyntaxError
149          *           the error raised
150          */
151         private void throwSyntaxError(String error) {
152                 int problemStartPosition = scanner.getCurrentTokenStartPosition();
153                 int problemEndPosition = scanner.getCurrentTokenEndPosition() + 1;
154                 if (scanner.source.length <= problemEndPosition && problemEndPosition > 0) {
155                         problemEndPosition = scanner.source.length - 1;
156                         if (problemStartPosition > 0 && problemStartPosition >= problemEndPosition && problemEndPosition > 0) {
157                                 problemStartPosition = problemEndPosition - 1;
158                         }
159                 }
160                 throwSyntaxError(error, problemStartPosition, problemEndPosition);
161         }
162
163         /**
164          * This method will throw the SyntaxError. It will add the good lines and
165          * columns to the Error
166          *
167          * @param error
168          *          the error message
169          * @throws SyntaxError
170          *           the error raised
171          */
172         // private void throwSyntaxError(String error, int startRow) {
173         // throw new SyntaxError(startRow, 0, " ", error);
174         // }
175         private void throwSyntaxError(String error, int problemStartPosition, int problemEndPosition) {
176                 if (referenceContext != null) {
177                         problemReporter.phpParsingError(new String[] { error }, problemStartPosition, problemEndPosition, referenceContext,
178                                         compilationUnit.compilationResult);
179                 }
180                 throw new SyntaxError(1, 0, " ", error);
181         }
182
183         private void reportSyntaxError(String error) {
184                 int problemStartPosition = scanner.getCurrentTokenStartPosition();
185                 int problemEndPosition = scanner.getCurrentTokenEndPosition();
186                 reportSyntaxError(error, problemStartPosition, problemEndPosition + 1);
187         }
188
189         private void reportSyntaxError(String error, int problemStartPosition, int problemEndPosition) {
190                 if (referenceContext != null) {
191                         problemReporter.phpParsingError(new String[] { error }, problemStartPosition, problemEndPosition, referenceContext,
192                                         compilationUnit.compilationResult);
193                 }
194         }
195
196         // private void reportSyntaxWarning(String error, int problemStartPosition,
197         // int problemEndPosition) {
198         // if (referenceContext != null) {
199         // problemReporter.phpParsingWarning(new String[] { error },
200         // problemStartPosition, problemEndPosition, referenceContext,
201         // compilationUnit.compilationResult);
202         // }
203         // }
204
205         /**
206          * gets the next token from input
207          */
208         private void getNextToken() {
209                 try {
210                         token = scanner.getNextToken();
211                         if (Scanner.DEBUG) {
212                                 int currentEndPosition = scanner.getCurrentTokenEndPosition();
213                                 int currentStartPosition = scanner.getCurrentTokenStartPosition();
214                                 System.out.print(currentStartPosition + "," + currentEndPosition + ": ");
215                                 System.out.println(scanner.toStringAction(token));
216                         }
217                 } catch (InvalidInputException e) {
218                         token = TokenNameERROR;
219                         String detailedMessage = e.getMessage();
220
221                         if (detailedMessage == Scanner.UNTERMINATED_STRING) {
222                                 throwSyntaxError("Unterminated string.");
223                         } else if (detailedMessage == Scanner.UNTERMINATED_COMMENT) {
224                                 throwSyntaxError("Unterminated commment.");
225                         }
226                 }
227                 return;
228         }
229
230         public void init(String s) {
231                 // this.str = s;
232                 this.token = TokenNameEOF;
233                 this.includesList = new ArrayList();
234                 // this.chIndx = 0;
235                 // this.rowCount = 1;
236                 // this.columnCount = 0;
237                 // this.phpEnd = false;
238                 // this.phpMode = false;
239                 /* scanner initialization */
240                 scanner.setSource(s.toCharArray());
241                 scanner.setPHPMode(false);
242                 astPtr = 0;
243         }
244
245         protected void initialize(boolean phpMode) {
246                 initialize(phpMode, null);
247         }
248
249         protected void initialize(boolean phpMode, IdentifierIndexManager indexManager) {
250                 compilationUnit = null;
251                 referenceContext = null;
252                 this.includesList = new ArrayList();
253                 // this.indexManager = indexManager;
254                 // this.str = "";
255                 this.token = TokenNameEOF;
256                 // this.chIndx = 0;
257                 // this.rowCount = 1;
258                 // this.columnCount = 0;
259                 // this.phpEnd = false;
260                 // this.phpMode = phpMode;
261                 scanner.setPHPMode(phpMode);
262                 astPtr = 0;
263         }
264
265         /**
266          * Parses a string with php tags i.e. '&lt;body&gt; &lt;?php phpinfo() ?&gt;
267          * &lt;/body&gt;'
268          */
269         public void parse(String s) {
270                 parse(s, null);
271         }
272
273         /**
274          * Parses a string with php tags i.e. '&lt;body&gt; &lt;?php phpinfo() ?&gt;
275          * &lt;/body&gt;'
276          */
277         public void parse(String s, HashMap variables) {
278                 fMethodVariables = variables;
279                 fStackUnassigned = new ArrayList();
280                 init(s);
281                 parse();
282         }
283
284         /**
285          * Parses a string with php tags i.e. '&lt;body&gt; &lt;?php phpinfo() ?&gt;
286          * &lt;/body&gt;'
287          */
288         protected void parse() {
289                 if (scanner.compilationUnit != null) {
290                         IResource resource = scanner.compilationUnit.getResource();
291                         if (resource != null && resource instanceof IFile) {
292                                 // set the package name
293                                 consumePackageDeclarationName((IFile) resource);
294                         }
295                 }
296                 getNextToken();
297                 do {
298                         try {
299                                 if (token != TokenNameEOF && token != TokenNameERROR) {
300                                         statementList();
301                                 }
302                                 if (token != TokenNameEOF) {
303                                         if (token == TokenNameERROR) {
304                                                 throwSyntaxError("Scanner error (Found unknown token: " + scanner.toStringAction(token) + ")");
305                                         }
306                                         if (token == TokenNameRPAREN) {
307                                                 throwSyntaxError("Too many closing ')'; end-of-file not reached.");
308                                         }
309                                         if (token == TokenNameRBRACE) {
310                                                 throwSyntaxError("Too many closing '}'; end-of-file not reached.");
311                                         }
312                                         if (token == TokenNameRBRACKET) {
313                                                 throwSyntaxError("Too many closing ']'; end-of-file not reached.");
314                                         }
315                                         if (token == TokenNameLPAREN) {
316                                                 throwSyntaxError("Read character '('; end-of-file not reached.");
317                                         }
318                                         if (token == TokenNameLBRACE) {
319                                                 throwSyntaxError("Read character '{';  end-of-file not reached.");
320                                         }
321                                         if (token == TokenNameLBRACKET) {
322                                                 throwSyntaxError("Read character '[';  end-of-file not reached.");
323                                         }
324                                         throwSyntaxError("End-of-file not reached.");
325                                 }
326                                 break;
327                         } catch (SyntaxError syntaxError) {
328                                 // syntaxError.printStackTrace();
329                                 break;
330                         }
331                 } while (true);
332
333                 endParse(0);
334         }
335
336         /**
337          * Parses a string with php tags i.e. '&lt;body&gt; &lt;?php phpinfo() ?&gt;
338          * &lt;/body&gt;'
339          */
340         public void parseFunction(String s, HashMap variables) {
341                 init(s);
342                 scanner.phpMode = true;
343                 parseFunction(variables);
344         }
345
346         /**
347          * Parses a string with php tags i.e. '&lt;body&gt; &lt;?php phpinfo() ?&gt;
348          * &lt;/body&gt;'
349          */
350         protected void parseFunction(HashMap variables) {
351                 getNextToken();
352                 boolean hasModifiers = member_modifiers();
353                 if (token == TokenNamefunction) {
354                         if (!hasModifiers) {
355                                 checkAndSetModifiers(AccPublic);
356                         }
357                         this.fMethodVariables = variables;
358
359                         MethodDeclaration methodDecl = new MethodDeclaration(null);
360                         methodDecl.declarationSourceStart = scanner.getCurrentTokenStartPosition();
361                         methodDecl.modifiers = this.modifiers;
362                         methodDecl.type = MethodDeclaration.METHOD_DEFINITION;
363                         try {
364                                 getNextToken();
365                                 functionDefinition(methodDecl);
366                         } catch (SyntaxError sytaxErr1) {
367                                 return;
368                         } finally {
369                                 int sourceEnd = methodDecl.sourceEnd;
370                                 if (sourceEnd <= 0 || methodDecl.declarationSourceStart > sourceEnd) {
371                                         sourceEnd = methodDecl.declarationSourceStart + 1;
372                                 }
373                                 methodDecl.sourceEnd = sourceEnd;
374                                 methodDecl.declarationSourceEnd = sourceEnd;
375                         }
376                 }
377         }
378
379         protected CompilationUnitDeclaration endParse(int act) {
380
381                 this.lastAct = act;
382
383                 // if (currentElement != null) {
384                 // currentElement.topElement().updateParseTree();
385                 // if (VERBOSE_RECOVERY) {
386                 // System.out.print(Util.bind("parser.syntaxRecovery")); //$NON-NLS-1$
387                 // System.out.println("--------------------------"); //$NON-NLS-1$
388                 // System.out.println(compilationUnit);
389                 // System.out.println("----------------------------------"); //$NON-NLS-1$
390                 // }
391                 // } else {
392                 if (diet & VERBOSE_RECOVERY) {
393                         System.out.print(Util.bind("parser.regularParse")); //$NON-NLS-1$
394                         System.out.println("--------------------------"); //$NON-NLS-1$
395                         System.out.println(compilationUnit);
396                         System.out.println("----------------------------------"); //$NON-NLS-1$
397                 }
398                 // }
399                 if (scanner.recordLineSeparator) {
400                         compilationUnit.compilationResult.lineSeparatorPositions = scanner.getLineEnds();
401                 }
402                 if (scanner.taskTags != null) {
403                         for (int i = 0; i < scanner.foundTaskCount; i++) {
404                                 problemReporter().task(new String(scanner.foundTaskTags[i]), new String(scanner.foundTaskMessages[i]),
405                                                 scanner.foundTaskPriorities[i] == null ? null : new String(scanner.foundTaskPriorities[i]),
406                                                 scanner.foundTaskPositions[i][0], scanner.foundTaskPositions[i][1]);
407                         }
408                 }
409                 compilationUnit.imports = new ImportReference[includesList.size()];
410                 for (int i = 0; i < includesList.size(); i++) {
411                         compilationUnit.imports[i] = (ImportReference) includesList.get(i);
412                 }
413                 return compilationUnit;
414         }
415
416         private Block statementList() {
417                 boolean branchStatement = false;
418                 Statement statement;
419                 int blockStart = scanner.getCurrentTokenStartPosition();
420                 ArrayList blockStatements = new ArrayList();
421                 do {
422                         try {
423                                 statement = statement();
424                                 blockStatements.add(statement);
425                                 if (branchStatement && statement != null) {
426                                         // reportSyntaxError("Unreachable code", statement.sourceStart,
427                                         // statement.sourceEnd);
428                                         problemReporter.unreachableCode(new String(scanner.getCurrentIdentifierSource()), statement.sourceStart,
429                                                         statement.sourceEnd, referenceContext, compilationUnit.compilationResult);
430                                 }
431                                 if ((token == TokenNameRBRACE) || (token == TokenNamecase) || (token == TokenNamedefault) || (token == TokenNameelse)
432                                                 || (token == TokenNameelseif) || (token == TokenNameendif) || (token == TokenNameendfor)
433                                                 || (token == TokenNameendforeach) || (token == TokenNameendwhile) || (token == TokenNameendswitch)
434                                                 || (token == TokenNameenddeclare) || (token == TokenNameEOF) || (token == TokenNameERROR)) {
435                                         return createBlock(blockStart, blockStatements);
436                                 }
437                                 branchStatement = checkUnreachableStatements(statement);
438                         } catch (SyntaxError sytaxErr1) {
439                                 // if an error occured,
440                                 // try to find keywords
441                                 // to parse the rest of the string
442                                 boolean tokenize = scanner.tokenizeStrings;
443                                 if (!tokenize) {
444                                         scanner.tokenizeStrings = true;
445                                 }
446                                 try {
447                                         while (token != TokenNameEOF) {
448                                                 if ((token == TokenNameRBRACE) || (token == TokenNamecase) || (token == TokenNamedefault) || (token == TokenNameelse)
449                                                                 || (token == TokenNameelseif) || (token == TokenNameendif) || (token == TokenNameendfor)
450                                                                 || (token == TokenNameendforeach) || (token == TokenNameendwhile) || (token == TokenNameendswitch)
451                                                                 || (token == TokenNameenddeclare) || (token == TokenNameEOF) || (token == TokenNameERROR)) {
452                                                         return createBlock(blockStart, blockStatements);
453                                                 }
454                                                 if (token == TokenNameif || token == TokenNameswitch || token == TokenNamefor || token == TokenNamewhile
455                                                                 || token == TokenNamedo || token == TokenNameforeach || token == TokenNamecontinue || token == TokenNamebreak
456                                                                 || token == TokenNamereturn || token == TokenNameexit || token == TokenNameecho || token == TokenNameglobal
457                                                                 || token == TokenNamestatic || token == TokenNameunset || token == TokenNamefunction || token == TokenNamedeclare
458                                                                 || token == TokenNametry || token == TokenNamecatch || token == TokenNamethrow || token == TokenNamefinal
459                                                                 || token == TokenNameabstract || token == TokenNameclass || token == TokenNameinterface) {
460                                                         break;
461                                                 }
462                                                 // System.out.println(scanner.toStringAction(token));
463                                                 getNextToken();
464                                                 // System.out.println(scanner.toStringAction(token));
465                                         }
466                                         if (token == TokenNameEOF) {
467                                                 throw sytaxErr1;
468                                         }
469                                 } finally {
470                                         scanner.tokenizeStrings = tokenize;
471                                 }
472                         }
473                 } while (true);
474         }
475
476         /**
477          * @param statement
478          * @return
479          */
480         private boolean checkUnreachableStatements(Statement statement) {
481                 if (statement instanceof ReturnStatement || statement instanceof ContinueStatement || statement instanceof BreakStatement) {
482                         return true;
483                 } else if (statement instanceof IfStatement && ((IfStatement) statement).checkUnreachable) {
484                         return true;
485                 }
486                 return false;
487         }
488
489         /**
490          * @param blockStart
491          * @param blockStatements
492          * @return
493          */
494         private Block createBlock(int blockStart, ArrayList blockStatements) {
495                 int blockEnd = scanner.getCurrentTokenEndPosition();
496                 Block b = Block.EmptyWith(blockStart, blockEnd);
497                 b.statements = new Statement[blockStatements.size()];
498                 blockStatements.toArray(b.statements);
499                 return b;
500         }
501
502         private void functionBody(MethodDeclaration methodDecl) {
503                 // '{' [statement-list] '}'
504                 if (token == TokenNameLBRACE) {
505                         getNextToken();
506                 } else {
507                         methodDecl.sourceEnd = scanner.getCurrentTokenStartPosition() - 1;
508                         throwSyntaxError("'{' expected in compound-statement.");
509                 }
510                 if (token != TokenNameRBRACE) {
511                         statementList();
512                 }
513                 if (token == TokenNameRBRACE) {
514                         methodDecl.sourceEnd = scanner.getCurrentTokenEndPosition();
515                         getNextToken();
516                 } else {
517                         methodDecl.sourceEnd = scanner.getCurrentTokenStartPosition() - 1;
518                         throwSyntaxError("'}' expected in compound-statement.");
519                 }
520         }
521
522         private Statement statement() {
523                 Statement statement = null;
524                 Expression expression;
525                 int sourceStart = scanner.getCurrentTokenStartPosition();
526                 int sourceEnd;
527                 if (token == TokenNameif) {
528                         // T_IF '(' expr ')' statement elseif_list else_single
529                         // T_IF '(' expr ')' ':' inner_statement_list new_elseif_list
530                         // new_else_single T_ENDIF ';'
531                         getNextToken();
532                         if (token == TokenNameLPAREN) {
533                                 getNextToken();
534                         } else {
535                                 throwSyntaxError("'(' expected after 'if' keyword.");
536                         }
537                         expression = expr();
538                         if (token == TokenNameRPAREN) {
539                                 getNextToken();
540                         } else {
541                                 throwSyntaxError("')' expected after 'if' condition.");
542                         }
543                         // create basic IfStatement
544                         IfStatement ifStatement = new IfStatement(expression, null, null, sourceStart, -1);
545                         if (token == TokenNameCOLON) {
546                                 getNextToken();
547                                 ifStatementColon(ifStatement);
548                         } else {
549                                 ifStatement(ifStatement);
550                         }
551                         return ifStatement;
552                 } else if (token == TokenNameswitch) {
553                         getNextToken();
554                         if (token == TokenNameLPAREN) {
555                                 getNextToken();
556                         } else {
557                                 throwSyntaxError("'(' expected after 'switch' keyword.");
558                         }
559                         expr();
560                         if (token == TokenNameRPAREN) {
561                                 getNextToken();
562                         } else {
563                                 throwSyntaxError("')' expected after 'switch' condition.");
564                         }
565                         switchStatement();
566                         return statement;
567                 } else if (token == TokenNamefor) {
568                         getNextToken();
569                         if (token == TokenNameLPAREN) {
570                                 getNextToken();
571                         } else {
572                                 throwSyntaxError("'(' expected after 'for' keyword.");
573                         }
574                         if (token == TokenNameSEMICOLON) {
575                                 getNextToken();
576                         } else {
577                                 expressionList();
578                                 if (token == TokenNameSEMICOLON) {
579                                         getNextToken();
580                                 } else {
581                                         throwSyntaxError("';' expected after 'for'.");
582                                 }
583                         }
584                         if (token == TokenNameSEMICOLON) {
585                                 getNextToken();
586                         } else {
587                                 expressionList();
588                                 if (token == TokenNameSEMICOLON) {
589                                         getNextToken();
590                                 } else {
591                                         throwSyntaxError("';' expected after 'for'.");
592                                 }
593                         }
594                         if (token == TokenNameRPAREN) {
595                                 getNextToken();
596                         } else {
597                                 expressionList();
598                                 if (token == TokenNameRPAREN) {
599                                         getNextToken();
600                                 } else {
601                                         throwSyntaxError("')' expected after 'for'.");
602                                 }
603                         }
604                         forStatement();
605                         return statement;
606                 } else if (token == TokenNamewhile) {
607                         getNextToken();
608                         if (token == TokenNameLPAREN) {
609                                 getNextToken();
610                         } else {
611                                 throwSyntaxError("'(' expected after 'while' keyword.");
612                         }
613                         expr();
614                         if (token == TokenNameRPAREN) {
615                                 getNextToken();
616                         } else {
617                                 throwSyntaxError("')' expected after 'while' condition.");
618                         }
619                         whileStatement();
620                         return statement;
621                 } else if (token == TokenNamedo) {
622                         getNextToken();
623                         if (token == TokenNameLBRACE) {
624                                 getNextToken();
625                                 if (token != TokenNameRBRACE) {
626                                         statementList();
627                                 }
628                                 if (token == TokenNameRBRACE) {
629                                         getNextToken();
630                                 } else {
631                                         throwSyntaxError("'}' expected after 'do' keyword.");
632                                 }
633                         } else {
634                                 statement();
635                         }
636                         if (token == TokenNamewhile) {
637                                 getNextToken();
638                                 if (token == TokenNameLPAREN) {
639                                         getNextToken();
640                                 } else {
641                                         throwSyntaxError("'(' expected after 'while' keyword.");
642                                 }
643                                 expr();
644                                 if (token == TokenNameRPAREN) {
645                                         getNextToken();
646                                 } else {
647                                         throwSyntaxError("')' expected after 'while' condition.");
648                                 }
649                         } else {
650                                 throwSyntaxError("'while' expected after 'do' keyword.");
651                         }
652                         if (token == TokenNameSEMICOLON) {
653                                 getNextToken();
654                         } else {
655                                 if (token != TokenNameINLINE_HTML) {
656                                         throwSyntaxError("';' expected after do-while statement.");
657                                 }
658                                 getNextToken();
659                         }
660                         return statement;
661                 } else if (token == TokenNameforeach) {
662                         getNextToken();
663                         if (token == TokenNameLPAREN) {
664                                 getNextToken();
665                         } else {
666                                 throwSyntaxError("'(' expected after 'foreach' keyword.");
667                         }
668                         expr();
669                         if (token == TokenNameas) {
670                                 getNextToken();
671                         } else {
672                                 throwSyntaxError("'as' expected after 'foreach' exxpression.");
673                         }
674                         // variable();
675                         foreach_variable();
676                         foreach_optional_arg();
677                         if (token == TokenNameEQUAL_GREATER) {
678                                 getNextToken();
679                                 variable(false, false);
680                         }
681                         if (token == TokenNameRPAREN) {
682                                 getNextToken();
683                         } else {
684                                 throwSyntaxError("')' expected after 'foreach' expression.");
685                         }
686                         foreachStatement();
687                         return statement;
688                 } else if (token == TokenNamebreak) {
689                         expression = null;
690                         getNextToken();
691                         if (token != TokenNameSEMICOLON) {
692                                 expression = expr();
693                         }
694                         if (token == TokenNameSEMICOLON) {
695                                 sourceEnd = scanner.getCurrentTokenEndPosition();
696                                 getNextToken();
697                         } else {
698                                 if (token != TokenNameINLINE_HTML) {
699                                         throwSyntaxError("';' expected after 'break'.");
700                                 }
701                                 sourceEnd = scanner.getCurrentTokenEndPosition();
702                                 getNextToken();
703                         }
704                         return new BreakStatement(null, sourceStart, sourceEnd);
705                 } else if (token == TokenNamecontinue) {
706                         expression = null;
707                         getNextToken();
708                         if (token != TokenNameSEMICOLON) {
709                                 expression = expr();
710                         }
711                         if (token == TokenNameSEMICOLON) {
712                                 sourceEnd = scanner.getCurrentTokenEndPosition();
713                                 getNextToken();
714                         } else {
715                                 if (token != TokenNameINLINE_HTML) {
716                                         throwSyntaxError("';' expected after 'continue'.");
717                                 }
718                                 sourceEnd = scanner.getCurrentTokenEndPosition();
719                                 getNextToken();
720                         }
721                         return new ContinueStatement(null, sourceStart, sourceEnd);
722                 } else if (token == TokenNamereturn) {
723                         expression = null;
724                         getNextToken();
725                         if (token != TokenNameSEMICOLON) {
726                                 expression = expr();
727                         }
728                         if (token == TokenNameSEMICOLON) {
729                                 sourceEnd = scanner.getCurrentTokenEndPosition();
730                                 getNextToken();
731                         } else {
732                                 if (token != TokenNameINLINE_HTML) {
733                                         throwSyntaxError("';' expected after 'return'.");
734                                 }
735                                 sourceEnd = scanner.getCurrentTokenEndPosition();
736                                 getNextToken();
737                         }
738                         return new ReturnStatement(expression, sourceStart, sourceEnd);
739                 } else if (token == TokenNameecho) {
740                         getNextToken();
741                         expressionList();
742                         if (token == TokenNameSEMICOLON) {
743                                 getNextToken();
744                         } else {
745                                 if (token != TokenNameINLINE_HTML) {
746                                         throwSyntaxError("';' expected after 'echo' statement.");
747                                 }
748                                 getNextToken();
749                         }
750                         return statement;
751                 } else if (token == TokenNameINLINE_HTML) {
752                         if (scanner.phpExpressionTag) {
753                                 // start of <?= ... ?> block
754                                 getNextToken();
755                                 expr();
756                                 if (token == TokenNameSEMICOLON) {
757                                         getNextToken();
758                                 }
759                                 if (token != TokenNameINLINE_HTML) {
760                                         throwSyntaxError("Missing '?>' for open PHP expression block ('<?=').");
761                                 }
762                         } else {
763                                 getNextToken();
764                         }
765                         return statement;
766                         // } else if (token == TokenNameprint) {
767                         // getNextToken();
768                         // expression();
769                         // if (token == TokenNameSEMICOLON) {
770                         // getNextToken();
771                         // } else {
772                         // if (token != TokenNameStopPHP) {
773                         // throwSyntaxError("';' expected after 'print' statement.");
774                         // }
775                         // getNextToken();
776                         // }
777                         // return;
778                 } else if (token == TokenNameglobal) {
779                         getNextToken();
780                         global_var_list();
781                         if (token == TokenNameSEMICOLON) {
782                                 getNextToken();
783                         } else {
784                                 if (token != TokenNameINLINE_HTML) {
785                                         throwSyntaxError("';' expected after 'global' statement.");
786                                 }
787                                 getNextToken();
788                         }
789                         return statement;
790                 } else if (token == TokenNamestatic) {
791                         getNextToken();
792                         static_var_list();
793                         if (token == TokenNameSEMICOLON) {
794                                 getNextToken();
795                         } else {
796                                 if (token != TokenNameINLINE_HTML) {
797                                         throwSyntaxError("';' expected after 'static' statement.");
798                                 }
799                                 getNextToken();
800                         }
801                         return statement;
802                 } else if (token == TokenNameunset) {
803                         getNextToken();
804                         if (token == TokenNameLPAREN) {
805                                 getNextToken();
806                         } else {
807                                 throwSyntaxError("'(' expected after 'unset' statement.");
808                         }
809                         unset_variables();
810                         if (token == TokenNameRPAREN) {
811                                 getNextToken();
812                         } else {
813                                 throwSyntaxError("')' expected after 'unset' statement.");
814                         }
815                         if (token == TokenNameSEMICOLON) {
816                                 getNextToken();
817                         } else {
818                                 if (token != TokenNameINLINE_HTML) {
819                                         throwSyntaxError("';' expected after 'unset' statement.");
820                                 }
821                                 getNextToken();
822                         }
823                         return statement;
824                 } else if (token == TokenNamefunction) {
825                         MethodDeclaration methodDecl = new MethodDeclaration(this.compilationUnit.compilationResult);
826                         methodDecl.declarationSourceStart = scanner.getCurrentTokenStartPosition();
827                         methodDecl.modifiers = AccDefault;
828                         methodDecl.type = MethodDeclaration.FUNCTION_DEFINITION;
829                         try {
830                                 getNextToken();
831                                 functionDefinition(methodDecl);
832                         } finally {
833                                 sourceEnd = methodDecl.sourceEnd;
834                                 if (sourceEnd <= 0 || methodDecl.declarationSourceStart > sourceEnd) {
835                                         sourceEnd = methodDecl.declarationSourceStart + 1;
836                                 }
837                                 methodDecl.declarationSourceEnd = sourceEnd;
838                                 methodDecl.sourceEnd = sourceEnd;
839                         }
840                         return statement;
841                 } else if (token == TokenNamedeclare) {
842                         // T_DECLARE '(' declare_list ')' declare_statement
843                         getNextToken();
844                         if (token != TokenNameLPAREN) {
845                                 throwSyntaxError("'(' expected in 'declare' statement.");
846                         }
847                         getNextToken();
848                         declare_list();
849                         if (token != TokenNameRPAREN) {
850                                 throwSyntaxError("')' expected in 'declare' statement.");
851                         }
852                         getNextToken();
853                         declare_statement();
854                         return statement;
855                 } else if (token == TokenNametry) {
856                         getNextToken();
857                         if (token != TokenNameLBRACE) {
858                                 throwSyntaxError("'{' expected in 'try' statement.");
859                         }
860                         getNextToken();
861                         statementList();
862                         if (token != TokenNameRBRACE) {
863                                 throwSyntaxError("'}' expected in 'try' statement.");
864                         }
865                         getNextToken();
866                         return statement;
867                 } else if (token == TokenNamecatch) {
868                         getNextToken();
869                         if (token != TokenNameLPAREN) {
870                                 throwSyntaxError("'(' expected in 'catch' statement.");
871                         }
872                         getNextToken();
873                         fully_qualified_class_name();
874                         if (token != TokenNameVariable) {
875                                 throwSyntaxError("Variable expected in 'catch' statement.");
876                         }
877                         addVariableSet();
878                         getNextToken();
879                         if (token != TokenNameRPAREN) {
880                                 throwSyntaxError("')' expected in 'catch' statement.");
881                         }
882                         getNextToken();
883                         if (token != TokenNameLBRACE) {
884                                 throwSyntaxError("'{' expected in 'catch' statement.");
885                         }
886                         getNextToken();
887                         if (token != TokenNameRBRACE) {
888                                 statementList();
889                                 if (token != TokenNameRBRACE) {
890                                         throwSyntaxError("'}' expected in 'catch' statement.");
891                                 }
892                         }
893                         getNextToken();
894                         additional_catches();
895                         return statement;
896                 } else if (token == TokenNamethrow) {
897                         getNextToken();
898                         expr();
899                         if (token == TokenNameSEMICOLON) {
900                                 getNextToken();
901                         } else {
902                                 throwSyntaxError("';' expected after 'throw' exxpression.");
903                         }
904                         return statement;
905                 } else if (token == TokenNamefinal || token == TokenNameabstract || token == TokenNameclass || token == TokenNameinterface) {
906                         try {
907                                 TypeDeclaration typeDecl = new TypeDeclaration(this.compilationUnit.compilationResult);
908                                 typeDecl.declarationSourceStart = scanner.getCurrentTokenStartPosition();
909                                 typeDecl.declarationSourceEnd = scanner.getCurrentTokenEndPosition();
910                                 typeDecl.name = new char[] { ' ' };
911                                 // default super class
912                                 typeDecl.superclass = new SingleTypeReference(TypeConstants.OBJECT, 0);
913                                 compilationUnit.types.add(typeDecl);
914                                 pushOnAstStack(typeDecl);
915                                 unticked_class_declaration_statement(typeDecl);
916                         } finally {
917                                 // reduce stack:
918                                 astPtr--;
919                                 astLengthPtr--;
920                         }
921                         return statement;
922                         // } else {
923                         // throwSyntaxError("Unexpected keyword '" + keyword + "'");
924                 } else if (token == TokenNameLBRACE) {
925                         getNextToken();
926                         if (token != TokenNameRBRACE) {
927                                 statement = statementList();
928                         }
929                         if (token == TokenNameRBRACE) {
930                                 getNextToken();
931                                 return statement;
932                         } else {
933                                 throwSyntaxError("'}' expected.");
934                         }
935                 } else {
936                         if (token != TokenNameSEMICOLON) {
937                                 expr();
938                         }
939                         if (token == TokenNameSEMICOLON) {
940                                 getNextToken();
941                                 return statement;
942                         } else {
943                                 if (token == TokenNameRBRACE) {
944                                         reportSyntaxError("';' expected after expression (Found token: " + scanner.toStringAction(token) + ")");
945                                 } else {
946                                         if (token != TokenNameINLINE_HTML && token != TokenNameEOF) {
947                                                 throwSyntaxError("';' expected after expression (Found token: " + scanner.toStringAction(token) + ")");
948                                         }
949                                         getNextToken();
950                                 }
951                         }
952                 }
953                 // may be null
954                 return statement;
955         }
956
957         private void declare_statement() {
958                 // statement
959                 // | ':' inner_statement_list T_ENDDECLARE ';'
960                 // ;
961                 if (token == TokenNameCOLON) {
962                         getNextToken();
963                         // TODO: implement inner_statement_list();
964                         statementList();
965                         if (token != TokenNameenddeclare) {
966                                 throwSyntaxError("'enddeclare' expected in 'declare' statement.");
967                         }
968                         getNextToken();
969                         if (token != TokenNameSEMICOLON) {
970                                 throwSyntaxError("';' expected after 'enddeclare' keyword.");
971                         }
972                         getNextToken();
973                 } else {
974                         statement();
975                 }
976         }
977
978         private void declare_list() {
979                 // T_STRING '=' static_scalar
980                 // | declare_list ',' T_STRING '=' static_scalar
981                 while (true) {
982                         if (token != TokenNameIdentifier) {
983                                 throwSyntaxError("Identifier expected in 'declare' list.");
984                         }
985                         getNextToken();
986                         if (token != TokenNameEQUAL) {
987                                 throwSyntaxError("'=' expected in 'declare' list.");
988                         }
989                         getNextToken();
990                         static_scalar();
991                         if (token != TokenNameCOMMA) {
992                                 break;
993                         }
994                         getNextToken();
995                 }
996         }
997
998         private void additional_catches() {
999                 while (token == TokenNamecatch) {
1000                         getNextToken();
1001                         if (token != TokenNameLPAREN) {
1002                                 throwSyntaxError("'(' expected in 'catch' statement.");
1003                         }
1004                         getNextToken();
1005                         fully_qualified_class_name();
1006                         if (token != TokenNameVariable) {
1007                                 throwSyntaxError("Variable expected in 'catch' statement.");
1008                         }
1009                         addVariableSet();
1010                         getNextToken();
1011                         if (token != TokenNameRPAREN) {
1012                                 throwSyntaxError("')' expected in 'catch' statement.");
1013                         }
1014                         getNextToken();
1015                         if (token != TokenNameLBRACE) {
1016                                 throwSyntaxError("'{' expected in 'catch' statement.");
1017                         }
1018                         getNextToken();
1019                         if (token != TokenNameRBRACE) {
1020                                 statementList();
1021                         }
1022                         if (token != TokenNameRBRACE) {
1023                                 throwSyntaxError("'}' expected in 'catch' statement.");
1024                         }
1025                         getNextToken();
1026                 }
1027         }
1028
1029         private void foreach_variable() {
1030                 // w_variable
1031                 // | '&' w_variable
1032                 if (token == TokenNameAND) {
1033                         getNextToken();
1034                 }
1035                 w_variable(true);
1036         }
1037
1038         private void foreach_optional_arg() {
1039                 // /* empty */
1040                 // | T_DOUBLE_ARROW foreach_variable
1041                 if (token == TokenNameEQUAL_GREATER) {
1042                         getNextToken();
1043                         foreach_variable();
1044                 }
1045         }
1046
1047         private void global_var_list() {
1048                 // global_var_list:
1049                 // global_var_list ',' global_var
1050                 // | global_var
1051                 HashSet set = peekVariableSet();
1052                 while (true) {
1053                         global_var(set);
1054                         if (token != TokenNameCOMMA) {
1055                                 break;
1056                         }
1057                         getNextToken();
1058                 }
1059         }
1060
1061         private void global_var(HashSet set) {
1062                 // global_var:
1063                 // T_VARIABLE
1064                 // | '$' r_variable
1065                 // | '$' '{' expr '}'
1066                 if (token == TokenNameVariable) {
1067                         if (fMethodVariables != null) {
1068                                 VariableInfo info = new VariableInfo(scanner.getCurrentTokenStartPosition(), VariableInfo.LEVEL_GLOBAL_VAR);
1069                                 fMethodVariables.put(new String(scanner.getCurrentIdentifierSource()), info);
1070                         }
1071                         addVariableSet(set);
1072                         getNextToken();
1073                 } else if (token == TokenNameDOLLAR) {
1074                         getNextToken();
1075                         if (token == TokenNameLBRACE) {
1076                                 getNextToken();
1077                                 expr();
1078                                 if (token != TokenNameRBRACE) {
1079                                         throwSyntaxError("'}' expected in global variable.");
1080                                 }
1081                                 getNextToken();
1082                         } else {
1083                                 r_variable();
1084                         }
1085                 }
1086         }
1087
1088         private void static_var_list() {
1089                 // static_var_list:
1090                 // static_var_list ',' T_VARIABLE
1091                 // | static_var_list ',' T_VARIABLE '=' static_scalar
1092                 // | T_VARIABLE
1093                 // | T_VARIABLE '=' static_scalar,
1094                 HashSet set = peekVariableSet();
1095                 while (true) {
1096                         if (token == TokenNameVariable) {
1097                                 if (fMethodVariables != null) {
1098                                         VariableInfo info = new VariableInfo(scanner.getCurrentTokenStartPosition(), VariableInfo.LEVEL_STATIC_VAR);
1099                                         fMethodVariables.put(new String(scanner.getCurrentIdentifierSource()), info);
1100                                 }
1101                                 addVariableSet(set);
1102                                 getNextToken();
1103                                 if (token == TokenNameEQUAL) {
1104                                         getNextToken();
1105                                         static_scalar();
1106                                 }
1107                                 if (token != TokenNameCOMMA) {
1108                                         break;
1109                                 }
1110                                 getNextToken();
1111                         } else {
1112                                 break;
1113                         }
1114                 }
1115         }
1116
1117         private void unset_variables() {
1118                 // unset_variables:
1119                 // unset_variable
1120                 // | unset_variables ',' unset_variable
1121                 // unset_variable:
1122                 // variable
1123                 while (true) {
1124                         variable(false, false);
1125                         if (token != TokenNameCOMMA) {
1126                                 break;
1127                         }
1128                         getNextToken();
1129                 }
1130         }
1131
1132         private final void initializeModifiers() {
1133                 this.modifiers = 0;
1134                 this.modifiersSourceStart = -1;
1135         }
1136
1137         private final void checkAndSetModifiers(int flag) {
1138                 this.modifiers |= flag;
1139                 if (this.modifiersSourceStart < 0)
1140                         this.modifiersSourceStart = this.scanner.startPosition;
1141         }
1142
1143         private void unticked_class_declaration_statement(TypeDeclaration typeDecl) {
1144                 initializeModifiers();
1145                 if (token == TokenNameinterface) {
1146                         // interface_entry T_STRING
1147                         // interface_extends_list
1148                         // '{' class_statement_list '}'
1149                         checkAndSetModifiers(AccInterface);
1150                         getNextToken();
1151                         typeDecl.modifiers = this.modifiers;
1152                         typeDecl.sourceStart = scanner.getCurrentTokenStartPosition();
1153                         typeDecl.sourceEnd = scanner.getCurrentTokenEndPosition();
1154                         if (token == TokenNameIdentifier || token > TokenNameKEYWORD) {
1155                                 typeDecl.name = scanner.getCurrentIdentifierSource();
1156                                 if (token > TokenNameKEYWORD) {
1157                                         problemReporter.phpKeywordWarning(new String[] { scanner.toStringAction(token) }, scanner.getCurrentTokenStartPosition(),
1158                                                         scanner.getCurrentTokenEndPosition(), referenceContext, compilationUnit.compilationResult);
1159                                         // throwSyntaxError("Don't use a keyword for interface declaration ["
1160                                         // + scanner.toStringAction(token) + "].",
1161                                         // typeDecl.sourceStart, typeDecl.sourceEnd);
1162                                 }
1163                                 getNextToken();
1164                                 interface_extends_list(typeDecl);
1165                         } else {
1166                                 typeDecl.name = new char[] { ' ' };
1167                                 throwSyntaxError("Interface name expected after keyword 'interface'.", typeDecl.sourceStart, typeDecl.sourceEnd);
1168                                 return;
1169                         }
1170                 } else {
1171                         // class_entry_type T_STRING extends_from
1172                         // implements_list
1173                         // '{' class_statement_list'}'
1174                         class_entry_type();
1175                         typeDecl.modifiers = this.modifiers;
1176                         typeDecl.sourceStart = scanner.getCurrentTokenStartPosition();
1177                         typeDecl.sourceEnd = scanner.getCurrentTokenEndPosition();
1178                         // identifier
1179                         // identifier 'extends' identifier
1180                         if (token == TokenNameIdentifier || token > TokenNameKEYWORD) {
1181                                 typeDecl.name = scanner.getCurrentIdentifierSource();
1182                                 if (token > TokenNameKEYWORD) {
1183                                         problemReporter.phpKeywordWarning(new String[] { scanner.toStringAction(token) }, scanner.getCurrentTokenStartPosition(),
1184                                                         scanner.getCurrentTokenEndPosition(), referenceContext, compilationUnit.compilationResult);
1185                                         // throwSyntaxError("Don't use a keyword for class declaration [" +
1186                                         // scanner.toStringAction(token) + "].",
1187                                         // typeDecl.sourceStart, typeDecl.sourceEnd);
1188                                 }
1189                                 getNextToken();
1190                                 // extends_from:
1191                                 // /* empty */
1192                                 // | T_EXTENDS fully_qualified_class_name
1193                                 if (token == TokenNameextends) {
1194                                         interface_extends_list(typeDecl);
1195                                         // getNextToken();
1196                                         // if (token != TokenNameIdentifier) {
1197                                         // throwSyntaxError("Class name expected after keyword
1198                                         // 'extends'.",
1199                                         // scanner.getCurrentTokenStartPosition(), scanner
1200                                         // .getCurrentTokenEndPosition());
1201                                         // }
1202                                 }
1203                                 implements_list(typeDecl);
1204                         } else {
1205                                 typeDecl.name = new char[] { ' ' };
1206                                 throwSyntaxError("Class name expected after keyword 'class'.", typeDecl.sourceStart, typeDecl.sourceEnd);
1207                                 return;
1208                         }
1209                 }
1210                 // '{' class_statement_list '}'
1211                 if (token == TokenNameLBRACE) {
1212                         getNextToken();
1213                         if (token != TokenNameRBRACE) {
1214                                 ArrayList list = new ArrayList();
1215                                 class_statement_list(list);
1216                                 typeDecl.fields = new FieldDeclaration[list.size()];
1217                                 for (int i = 0; i < list.size(); i++) {
1218                                         typeDecl.fields[i] = (FieldDeclaration) list.get(i);
1219                                 }
1220                         }
1221                         if (token == TokenNameRBRACE) {
1222                                 typeDecl.declarationSourceEnd = scanner.getCurrentTokenEndPosition();
1223                                 getNextToken();
1224                         } else {
1225                                 throwSyntaxError("'}' expected at end of class body.");
1226                         }
1227                 } else {
1228                         throwSyntaxError("'{' expected at start of class body.");
1229                 }
1230         }
1231
1232         private void class_entry_type() {
1233                 // T_CLASS
1234                 // | T_ABSTRACT T_CLASS
1235                 // | T_FINAL T_CLASS
1236                 if (token == TokenNameclass) {
1237                         getNextToken();
1238                 } else if (token == TokenNameabstract) {
1239                         checkAndSetModifiers(AccAbstract);
1240                         getNextToken();
1241                         if (token != TokenNameclass) {
1242                                 throwSyntaxError("Keyword 'class' expected after keyword 'abstract'.");
1243                         }
1244                         getNextToken();
1245                 } else if (token == TokenNamefinal) {
1246                         checkAndSetModifiers(AccFinal);
1247                         getNextToken();
1248                         if (token != TokenNameclass) {
1249                                 throwSyntaxError("Keyword 'class' expected after keyword 'final'.");
1250                         }
1251                         getNextToken();
1252                 } else {
1253                         throwSyntaxError("Keyword 'class' 'final' or 'abstract' expected");
1254                 }
1255         }
1256
1257         // private void class_extends(TypeDeclaration typeDecl) {
1258         // // /* empty */
1259         // // | T_EXTENDS interface_list
1260         // if (token == TokenNameextends) {
1261         // getNextToken();
1262         //
1263         // if (token == TokenNameIdentifier) {
1264         // getNextToken();
1265         // } else {
1266         // throwSyntaxError("Class name expected after keyword 'extends'.");
1267         // }
1268         // }
1269         // }
1270
1271         private void interface_extends_list(TypeDeclaration typeDecl) {
1272                 // /* empty */
1273                 // | T_EXTENDS interface_list
1274                 if (token == TokenNameextends) {
1275                         getNextToken();
1276                         interface_list();
1277                 }
1278         }
1279
1280         private void implements_list(TypeDeclaration typeDecl) {
1281                 // /* empty */
1282                 // | T_IMPLEMENTS interface_list
1283                 if (token == TokenNameimplements) {
1284                         getNextToken();
1285                         interface_list();
1286                 }
1287         }
1288
1289         private void interface_list() {
1290                 // interface_list:
1291                 // fully_qualified_class_name
1292                 // | interface_list ',' fully_qualified_class_name
1293                 do {
1294                         if (token == TokenNameIdentifier) {
1295                                 getNextToken();
1296                         } else {
1297                                 throwSyntaxError("Interface name expected after keyword 'implements'.");
1298                         }
1299                         if (token != TokenNameCOMMA) {
1300                                 return;
1301                         }
1302                         getNextToken();
1303                 } while (true);
1304         }
1305
1306         // private void classBody(TypeDeclaration typeDecl) {
1307         // //'{' [class-element-list] '}'
1308         // if (token == TokenNameLBRACE) {
1309         // getNextToken();
1310         // if (token != TokenNameRBRACE) {
1311         // class_statement_list();
1312         // }
1313         // if (token == TokenNameRBRACE) {
1314         // typeDecl.declarationSourceEnd = scanner.getCurrentTokenEndPosition();
1315         // getNextToken();
1316         // } else {
1317         // throwSyntaxError("'}' expected at end of class body.");
1318         // }
1319         // } else {
1320         // throwSyntaxError("'{' expected at start of class body.");
1321         // }
1322         // }
1323         private void class_statement_list(ArrayList list) {
1324                 do {
1325                         try {
1326                                 class_statement(list);
1327                                 if (token == TokenNamepublic || token == TokenNameprotected || token == TokenNameprivate || token == TokenNamestatic
1328                                                 || token == TokenNameabstract || token == TokenNamefinal || token == TokenNamefunction || token == TokenNamevar
1329                                                 || token == TokenNameconst) {
1330                                         continue;
1331                                 }
1332                                 if (token == TokenNameRBRACE) {
1333                                         break;
1334                                 }
1335                                 throwSyntaxError("'}' at end of class statement.");
1336                         } catch (SyntaxError sytaxErr1) {
1337                                 boolean tokenize = scanner.tokenizeStrings;
1338                                 if (!tokenize) {
1339                                         scanner.tokenizeStrings = true;
1340                                 }
1341                                 try {
1342                                         // if an error occured,
1343                                         // try to find keywords
1344                                         // to parse the rest of the string
1345                                         while (token != TokenNameEOF) {
1346                                                 if (token == TokenNamepublic || token == TokenNameprotected || token == TokenNameprivate || token == TokenNamestatic
1347                                                                 || token == TokenNameabstract || token == TokenNamefinal || token == TokenNamefunction || token == TokenNamevar
1348                                                                 || token == TokenNameconst) {
1349                                                         break;
1350                                                 }
1351                                                 // System.out.println(scanner.toStringAction(token));
1352                                                 getNextToken();
1353                                         }
1354                                         if (token == TokenNameEOF) {
1355                                                 throw sytaxErr1;
1356                                         }
1357                                 } finally {
1358                                         scanner.tokenizeStrings = tokenize;
1359                                 }
1360                         }
1361                 } while (true);
1362         }
1363
1364         private void class_statement(ArrayList list) {
1365                 // class_statement:
1366                 // variable_modifiers class_variable_declaration ';'
1367                 // | class_constant_declaration ';'
1368                 // | method_modifiers T_FUNCTION is_reference T_STRING
1369                 // '(' parameter_list ')' method_body
1370                 initializeModifiers();
1371                 int declarationSourceStart = scanner.getCurrentTokenStartPosition();
1372
1373                 if (token == TokenNamevar) {
1374                         checkAndSetModifiers(AccPublic);
1375                         problemReporter.phpVarDeprecatedWarning(scanner.getCurrentTokenStartPosition(), scanner.getCurrentTokenEndPosition(),
1376                                         referenceContext, compilationUnit.compilationResult);
1377                         getNextToken();
1378                         class_variable_declaration(declarationSourceStart, list);
1379                 } else if (token == TokenNameconst) {
1380                         checkAndSetModifiers(AccFinal | AccPublic);
1381                         class_constant_declaration(declarationSourceStart, list);
1382                         if (token != TokenNameSEMICOLON) {
1383                                 throwSyntaxError("';' expected after class const declaration.");
1384                         }
1385                         getNextToken();
1386                 } else {
1387                         boolean hasModifiers = member_modifiers();
1388                         if (token == TokenNamefunction) {
1389                                 if (!hasModifiers) {
1390                                         checkAndSetModifiers(AccPublic);
1391                                 }
1392                                 MethodDeclaration methodDecl = new MethodDeclaration(this.compilationUnit.compilationResult);
1393                                 methodDecl.declarationSourceStart = scanner.getCurrentTokenStartPosition();
1394                                 methodDecl.modifiers = this.modifiers;
1395                                 methodDecl.type = MethodDeclaration.METHOD_DEFINITION;
1396                                 try {
1397                                         getNextToken();
1398                                         functionDefinition(methodDecl);
1399                                 } finally {
1400                                         int sourceEnd = methodDecl.sourceEnd;
1401                                         if (sourceEnd <= 0 || methodDecl.declarationSourceStart > sourceEnd) {
1402                                                 sourceEnd = methodDecl.declarationSourceStart + 1;
1403                                         }
1404                                         methodDecl.declarationSourceEnd = sourceEnd;
1405                                         methodDecl.sourceEnd = sourceEnd;
1406                                 }
1407                         } else {
1408                                 if (!hasModifiers) {
1409                                         throwSyntaxError("'public' 'private' or 'protected' modifier expected for field declarations.");
1410                                 }
1411                                 class_variable_declaration(declarationSourceStart, list);
1412                         }
1413                 }
1414         }
1415
1416         private void class_constant_declaration(int declarationSourceStart, ArrayList list) {
1417                 // class_constant_declaration ',' T_STRING '=' static_scalar
1418                 // | T_CONST T_STRING '=' static_scalar
1419                 if (token != TokenNameconst) {
1420                         throwSyntaxError("'const' keyword expected in class declaration.");
1421                 } else {
1422                         getNextToken();
1423                 }
1424                 while (true) {
1425                         if (token != TokenNameIdentifier) {
1426                                 throwSyntaxError("Identifier expected in class const declaration.");
1427                         }
1428                         FieldDeclaration fieldDeclaration = new FieldDeclaration(scanner.getCurrentIdentifierSource(), scanner
1429                                         .getCurrentTokenStartPosition(), scanner.getCurrentTokenEndPosition());
1430                         fieldDeclaration.modifiers = this.modifiers;
1431                         fieldDeclaration.declarationSourceStart = declarationSourceStart;
1432                         fieldDeclaration.declarationSourceEnd = scanner.getCurrentTokenEndPosition();
1433                         fieldDeclaration.modifiersSourceStart = declarationSourceStart;
1434                         // fieldDeclaration.type
1435                         list.add(fieldDeclaration);
1436                         getNextToken();
1437                         if (token != TokenNameEQUAL) {
1438                                 throwSyntaxError("'=' expected in class const declaration.");
1439                         }
1440                         getNextToken();
1441                         static_scalar();
1442                         if (token != TokenNameCOMMA) {
1443                                 break; // while(true)-loop
1444                         }
1445                         getNextToken();
1446                 }
1447         }
1448
1449         // private void variable_modifiers() {
1450         // // variable_modifiers:
1451         // // non_empty_member_modifiers
1452         // //| T_VAR
1453         // initializeModifiers();
1454         // if (token == TokenNamevar) {
1455         // checkAndSetModifiers(AccPublic);
1456         // reportSyntaxError(
1457         // "Keyword 'var' is deprecated. Please use 'public' 'private' or
1458         // 'protected'
1459         // modifier for field declarations.",
1460         // scanner.getCurrentTokenStartPosition(), scanner
1461         // .getCurrentTokenEndPosition());
1462         // getNextToken();
1463         // } else {
1464         // if (!member_modifiers()) {
1465         // throwSyntaxError("'public' 'private' or 'protected' modifier expected for
1466         // field declarations.");
1467         // }
1468         // }
1469         // }
1470         // private void method_modifiers() {
1471         // //method_modifiers:
1472         // // /* empty */
1473         // //| non_empty_member_modifiers
1474         // initializeModifiers();
1475         // if (!member_modifiers()) {
1476         // checkAndSetModifiers(AccPublic);
1477         // }
1478         // }
1479         private boolean member_modifiers() {
1480                 // T_PUBLIC
1481                 // | T_PROTECTED
1482                 // | T_PRIVATE
1483                 // | T_STATIC
1484                 // | T_ABSTRACT
1485                 // | T_FINAL
1486                 boolean foundToken = false;
1487                 while (true) {
1488                         if (token == TokenNamepublic) {
1489                                 checkAndSetModifiers(AccPublic);
1490                                 getNextToken();
1491                                 foundToken = true;
1492                         } else if (token == TokenNameprotected) {
1493                                 checkAndSetModifiers(AccProtected);
1494                                 getNextToken();
1495                                 foundToken = true;
1496                         } else if (token == TokenNameprivate) {
1497                                 checkAndSetModifiers(AccPrivate);
1498                                 getNextToken();
1499                                 foundToken = true;
1500                         } else if (token == TokenNamestatic) {
1501                                 checkAndSetModifiers(AccStatic);
1502                                 getNextToken();
1503                                 foundToken = true;
1504                         } else if (token == TokenNameabstract) {
1505                                 checkAndSetModifiers(AccAbstract);
1506                                 getNextToken();
1507                                 foundToken = true;
1508                         } else if (token == TokenNamefinal) {
1509                                 checkAndSetModifiers(AccFinal);
1510                                 getNextToken();
1511                                 foundToken = true;
1512                         } else {
1513                                 break;
1514                         }
1515                 }
1516                 return foundToken;
1517         }
1518
1519         private void class_variable_declaration(int declarationSourceStart, ArrayList list) {
1520                 // class_variable_declaration:
1521                 // class_variable_declaration ',' T_VARIABLE
1522                 // | class_variable_declaration ',' T_VARIABLE '=' static_scalar
1523                 // | T_VARIABLE
1524                 // | T_VARIABLE '=' static_scalar
1525                 char[] classVariable;
1526                 do {
1527                         if (token == TokenNameVariable) {
1528                                 classVariable = scanner.getCurrentIdentifierSource();
1529                                 // indexManager.addIdentifierInformation('v', classVariable, buf, -1,
1530                                 // -1);
1531                                 FieldDeclaration fieldDeclaration = new FieldDeclaration(classVariable, scanner.getCurrentTokenStartPosition(), scanner
1532                                                 .getCurrentTokenEndPosition());
1533                                 fieldDeclaration.modifiers = this.modifiers;
1534                                 fieldDeclaration.declarationSourceStart = declarationSourceStart;
1535                                 fieldDeclaration.declarationSourceEnd = scanner.getCurrentTokenEndPosition();
1536                                 fieldDeclaration.modifiersSourceStart = declarationSourceStart;
1537                                 list.add(fieldDeclaration);
1538                                 if (fTypeVariables != null) {
1539                                         VariableInfo info = new VariableInfo(scanner.getCurrentTokenStartPosition(), VariableInfo.LEVEL_CLASS_UNIT);
1540                                         fTypeVariables.put(new String(scanner.getCurrentIdentifierSource()), info);
1541                                 }
1542                                 getNextToken();
1543                                 if (token == TokenNameEQUAL) {
1544                                         getNextToken();
1545                                         static_scalar();
1546                                 }
1547                         } else {
1548                                 // if (token == TokenNamethis) {
1549                                 // throwSyntaxError("'$this' not allowed after keyword 'public'
1550                                 // 'protected' 'private' 'var'.");
1551                                 // }
1552                                 throwSyntaxError("Variable expected after keyword 'public' 'protected' 'private' 'var'.");
1553                         }
1554                         if (token != TokenNameCOMMA) {
1555                                 break;
1556                         }
1557                         getNextToken();
1558                 } while (true);
1559                 if (token != TokenNameSEMICOLON) {
1560                         throwSyntaxError("';' expected after field declaration.");
1561                 }
1562                 getNextToken();
1563         }
1564
1565         private void functionDefinition(MethodDeclaration methodDecl) {
1566                 boolean isAbstract = false;
1567                 if (astPtr == 0) {
1568                         if (compilationUnit != null) {
1569                                 compilationUnit.types.add(methodDecl);
1570                         }
1571                 } else {
1572                         ASTNode node = astStack[astPtr];
1573                         if (node instanceof TypeDeclaration) {
1574                                 TypeDeclaration typeDecl = ((TypeDeclaration) node);
1575                                 if (typeDecl.methods == null) {
1576                                         typeDecl.methods = new AbstractMethodDeclaration[] { methodDecl };
1577                                 } else {
1578                                         AbstractMethodDeclaration[] newMethods;
1579                                         System.arraycopy(typeDecl.methods, 0, newMethods = new AbstractMethodDeclaration[typeDecl.methods.length + 1], 0,
1580                                                         typeDecl.methods.length);
1581                                         newMethods[typeDecl.methods.length] = methodDecl;
1582                                         typeDecl.methods = newMethods;
1583                                 }
1584                                 if ((typeDecl.modifiers & AccAbstract) == AccAbstract) {
1585                                         isAbstract = true;
1586                                 } else if ((typeDecl.modifiers & AccInterface) == AccInterface) {
1587                                         isAbstract = true;
1588                                 }
1589                         }
1590                 }
1591                 try {
1592                         pushFunctionVariableSet();
1593                         functionDeclarator(methodDecl);
1594                         if (token == TokenNameSEMICOLON) {
1595                                 if (!isAbstract) {
1596                                         methodDecl.sourceEnd = scanner.getCurrentTokenStartPosition() - 1;
1597                                         throwSyntaxError("Body declaration expected for method: " + new String(methodDecl.selector));
1598                                 }
1599                                 getNextToken();
1600                                 return;
1601                         }
1602                         functionBody(methodDecl);
1603                 } finally {
1604                         if (!fStackUnassigned.isEmpty()) {
1605                                 fStackUnassigned.remove(fStackUnassigned.size() - 1);
1606                         }
1607                 }
1608         }
1609
1610         private void functionDeclarator(MethodDeclaration methodDecl) {
1611                 // identifier '(' [parameter-list] ')'
1612                 if (token == TokenNameAND) {
1613                         getNextToken();
1614                 }
1615                 methodDecl.sourceStart = scanner.getCurrentTokenStartPosition();
1616                 methodDecl.sourceEnd = scanner.getCurrentTokenEndPosition();
1617                 if (Scanner.isIdentifierOrKeyword(token)) {
1618                         methodDecl.selector = scanner.getCurrentIdentifierSource();
1619                         if (token > TokenNameKEYWORD) {
1620                                 problemReporter.phpKeywordWarning(new String[] { scanner.toStringAction(token) }, scanner.getCurrentTokenStartPosition(),
1621                                                 scanner.getCurrentTokenEndPosition(), referenceContext, compilationUnit.compilationResult);
1622                         }
1623                         getNextToken();
1624                         if (token == TokenNameLPAREN) {
1625                                 getNextToken();
1626                         } else {
1627                                 methodDecl.sourceEnd = scanner.getCurrentTokenStartPosition() - 1;
1628                                 throwSyntaxError("'(' expected in function declaration.");
1629                         }
1630                         if (token != TokenNameRPAREN) {
1631                                 parameter_list(methodDecl);
1632                         }
1633                         if (token != TokenNameRPAREN) {
1634                                 methodDecl.sourceEnd = scanner.getCurrentTokenStartPosition() - 1;
1635                                 throwSyntaxError("')' expected in function declaration.");
1636                         } else {
1637                                 methodDecl.bodyStart = scanner.getCurrentTokenEndPosition() + 1;
1638                                 getNextToken();
1639                         }
1640                 } else {
1641                         methodDecl.selector = "<undefined>".toCharArray();
1642                         methodDecl.sourceEnd = scanner.getCurrentTokenStartPosition() - 1;
1643                         throwSyntaxError("Function name expected after keyword 'function'.");
1644                 }
1645         }
1646
1647         //
1648         private void parameter_list(MethodDeclaration methodDecl) {
1649                 // non_empty_parameter_list
1650                 // | /* empty */
1651                 non_empty_parameter_list(methodDecl, true);
1652         }
1653
1654         private void non_empty_parameter_list(MethodDeclaration methodDecl, boolean empty_allowed) {
1655                 // optional_class_type T_VARIABLE
1656                 // | optional_class_type '&' T_VARIABLE
1657                 // | optional_class_type '&' T_VARIABLE '=' static_scalar
1658                 // | optional_class_type T_VARIABLE '=' static_scalar
1659                 // | non_empty_parameter_list ',' optional_class_type T_VARIABLE
1660                 // | non_empty_parameter_list ',' optional_class_type '&' T_VARIABLE
1661                 // | non_empty_parameter_list ',' optional_class_type '&' T_VARIABLE '='
1662                 // static_scalar
1663                 // | non_empty_parameter_list ',' optional_class_type T_VARIABLE '='
1664                 // static_scalar
1665                 char[] typeIdentifier = null;
1666                 if (token == TokenNameIdentifier || token == TokenNameVariable || token == TokenNameAND) {
1667                         HashSet set = peekVariableSet();
1668                         while (true) {
1669                                 if (token == TokenNameIdentifier) {
1670                                         typeIdentifier = scanner.getCurrentIdentifierSource();
1671                                         getNextToken();
1672                                 }
1673                                 if (token == TokenNameAND) {
1674                                         getNextToken();
1675                                 }
1676                                 if (token == TokenNameVariable) {
1677                                         if (fMethodVariables != null) {
1678                                                 VariableInfo info;
1679                                                 if (methodDecl.type == MethodDeclaration.FUNCTION_DEFINITION) {
1680                                                         info = new VariableInfo(scanner.getCurrentTokenStartPosition(), VariableInfo.LEVEL_FUNCTION_DEFINITION);
1681                                                 } else {
1682                                                         info = new VariableInfo(scanner.getCurrentTokenStartPosition(), VariableInfo.LEVEL_METHOD_DEFINITION);
1683                                                 }
1684                                                 info.typeIdentifier = typeIdentifier;
1685                                                 fMethodVariables.put(new String(scanner.getCurrentIdentifierSource()), info);
1686                                         }
1687                                         addVariableSet(set);
1688                                         getNextToken();
1689                                         if (token == TokenNameEQUAL) {
1690                                                 getNextToken();
1691                                                 static_scalar();
1692                                         }
1693                                 } else {
1694                                         throwSyntaxError("Variable expected in parameter list.");
1695                                 }
1696                                 if (token != TokenNameCOMMA) {
1697                                         break;
1698                                 }
1699                                 getNextToken();
1700                         }
1701                         return;
1702                 }
1703                 if (!empty_allowed) {
1704                         throwSyntaxError("Identifier expected in parameter list.");
1705                 }
1706         }
1707
1708         private void optional_class_type() {
1709                 // /* empty */
1710                 // | T_STRING
1711         }
1712
1713         // private void parameterDeclaration() {
1714         // //variable
1715         // //variable-reference
1716         // if (token == TokenNameAND) {
1717         // getNextToken();
1718         // if (isVariable()) {
1719         // getNextToken();
1720         // } else {
1721         // throwSyntaxError("Variable expected after reference operator '&'.");
1722         // }
1723         // }
1724         // //variable '=' constant
1725         // if (token == TokenNameVariable) {
1726         // getNextToken();
1727         // if (token == TokenNameEQUAL) {
1728         // getNextToken();
1729         // static_scalar();
1730         // }
1731         // return;
1732         // }
1733         // // if (token == TokenNamethis) {
1734         // // throwSyntaxError("Reserved word '$this' not allowed in parameter
1735         // // declaration.");
1736         // // }
1737         // }
1738
1739         private void labeledStatementList() {
1740                 if (token != TokenNamecase && token != TokenNamedefault) {
1741                         throwSyntaxError("'case' or 'default' expected.");
1742                 }
1743                 do {
1744                         if (token == TokenNamecase) {
1745                                 getNextToken();
1746                                 expr(); // constant();
1747                                 if (token == TokenNameCOLON || token == TokenNameSEMICOLON) {
1748                                         getNextToken();
1749                                         if (token == TokenNamecase || token == TokenNamedefault) {
1750                                                 // empty case statement ?
1751                                                 continue;
1752                                         }
1753                                         statementList();
1754                                 }
1755                                 // else if (token == TokenNameSEMICOLON) {
1756                                 // setMarker(
1757                                 // "':' expected after 'case' keyword (Found token: " +
1758                                 // scanner.toStringAction(token) + ")",
1759                                 // scanner.getCurrentTokenStartPosition(),
1760                                 // scanner.getCurrentTokenEndPosition(),
1761                                 // INFO);
1762                                 // getNextToken();
1763                                 // if (token == TokenNamecase) { // empty case statement ?
1764                                 // continue;
1765                                 // }
1766                                 // statementList();
1767                                 // }
1768                                 else {
1769                                         throwSyntaxError("':' character expected after 'case' constant (Found token: " + scanner.toStringAction(token) + ")");
1770                                 }
1771                         } else { // TokenNamedefault
1772                                 getNextToken();
1773                                 if (token == TokenNameCOLON || token == TokenNameSEMICOLON) {
1774                                         getNextToken();
1775                                         if (token == TokenNameRBRACE) {
1776                                                 // empty default case
1777                                                 break;
1778                                         }
1779                                         if (token != TokenNamecase) {
1780                                                 statementList();
1781                                         }
1782                                 } else {
1783                                         throwSyntaxError("':' character expected after 'default'.");
1784                                 }
1785                         }
1786                 } while (token == TokenNamecase || token == TokenNamedefault);
1787         }
1788
1789         private void ifStatementColon(IfStatement iState) {
1790                 // T_IF '(' expr ')' ':' inner_statement_list new_elseif_list
1791                 // new_else_single T_ENDIF ';'
1792                 HashSet assignedVariableSet = null;
1793                 try {
1794                         Block b = inner_statement_list();
1795                         iState.thenStatement = b;
1796                         checkUnreachable(iState, b);
1797                 } finally {
1798                         assignedVariableSet = removeIfVariableSet();
1799                 }
1800                 if (token == TokenNameelseif) {
1801                         try {
1802                                 pushIfVariableSet();
1803                                 new_elseif_list(iState);
1804                         } finally {
1805                                 HashSet set = removeIfVariableSet();
1806                                 if (assignedVariableSet != null && set != null) {
1807                                         assignedVariableSet.addAll(set);
1808                                 }
1809                         }
1810                 }
1811                 try {
1812                         pushIfVariableSet();
1813                         new_else_single(iState);
1814                 } finally {
1815                         HashSet set = removeIfVariableSet();
1816                         if (assignedVariableSet != null) {
1817                                 HashSet topSet = peekVariableSet();
1818                                 if (topSet != null) {
1819                                         if (set != null) {
1820                                                 topSet.addAll(set);
1821                                         }
1822                                         topSet.addAll(assignedVariableSet);
1823                                 }
1824                         }
1825                 }
1826                 if (token != TokenNameendif) {
1827                         throwSyntaxError("'endif' expected.");
1828                 }
1829                 getNextToken();
1830                 if (token != TokenNameSEMICOLON) {
1831                         reportSyntaxError("';' expected after if-statement.");
1832                         iState.sourceEnd = scanner.getCurrentTokenStartPosition();
1833                 } else {
1834                         iState.sourceEnd = scanner.getCurrentTokenEndPosition();
1835                         getNextToken();
1836                 }
1837         }
1838
1839         private void ifStatement(IfStatement iState) {
1840                 // T_IF '(' expr ')' statement elseif_list else_single
1841                 HashSet assignedVariableSet = null;
1842                 try {
1843                         pushIfVariableSet();
1844                         Statement s = statement();
1845                         iState.thenStatement = s;
1846                         checkUnreachable(iState, s);
1847                 } finally {
1848                         assignedVariableSet = removeIfVariableSet();
1849                 }
1850
1851                 if (token == TokenNameelseif) {
1852                         try {
1853                                 pushIfVariableSet();
1854                                 elseif_list(iState);
1855                         } finally {
1856                                 HashSet set = removeIfVariableSet();
1857                                 if (assignedVariableSet != null && set != null) {
1858                                         assignedVariableSet.addAll(set);
1859                                 }
1860                         }
1861                 }
1862                 try {
1863                         pushIfVariableSet();
1864                         else_single(iState);
1865                 } finally {
1866                         HashSet set = removeIfVariableSet();
1867                         if (assignedVariableSet != null) {
1868                                 HashSet topSet = peekVariableSet();
1869                                 if (topSet != null) {
1870                                         if (set != null) {
1871                                                 topSet.addAll(set);
1872                                         }
1873                                         topSet.addAll(assignedVariableSet);
1874                                 }
1875                         }
1876                 }
1877         }
1878
1879         private void elseif_list(IfStatement iState) {
1880                 // /* empty */
1881                 // | elseif_list T_ELSEIF '(' expr ')' statement
1882                 ArrayList conditionList = new ArrayList();
1883                 ArrayList statementList = new ArrayList();
1884                 Expression e;
1885                 Statement s;
1886                 while (token == TokenNameelseif) {
1887                         getNextToken();
1888                         if (token == TokenNameLPAREN) {
1889                                 getNextToken();
1890                         } else {
1891                                 throwSyntaxError("'(' expected after 'elseif' keyword.");
1892                         }
1893                         e = expr();
1894                         conditionList.add(e);
1895                         if (token == TokenNameRPAREN) {
1896                                 getNextToken();
1897                         } else {
1898                                 throwSyntaxError("')' expected after 'elseif' condition.");
1899                         }
1900                         s = statement();
1901                         statementList.add(s);
1902                         checkUnreachable(iState, s);
1903                 }
1904                 iState.elseifConditions = new Expression[conditionList.size()];
1905                 iState.elseifStatements = new Statement[statementList.size()];
1906                 conditionList.toArray(iState.elseifConditions);
1907                 statementList.toArray(iState.elseifStatements);
1908         }
1909
1910         private void new_elseif_list(IfStatement iState) {
1911                 // /* empty */
1912                 // | new_elseif_list T_ELSEIF '(' expr ')' ':' inner_statement_list
1913                 ArrayList conditionList = new ArrayList();
1914                 ArrayList statementList = new ArrayList();
1915                 Expression e;
1916                 Block b;
1917                 while (token == TokenNameelseif) {
1918                         getNextToken();
1919                         if (token == TokenNameLPAREN) {
1920                                 getNextToken();
1921                         } else {
1922                                 throwSyntaxError("'(' expected after 'elseif' keyword.");
1923                         }
1924                         e = expr();
1925                         conditionList.add(e);
1926                         if (token == TokenNameRPAREN) {
1927                                 getNextToken();
1928                         } else {
1929                                 throwSyntaxError("')' expected after 'elseif' condition.");
1930                         }
1931                         if (token == TokenNameCOLON) {
1932                                 getNextToken();
1933                         } else {
1934                                 throwSyntaxError("':' expected after 'elseif' keyword.");
1935                         }
1936                         b = inner_statement_list();
1937                         statementList.add(b);
1938                         checkUnreachable(iState, b);
1939                 }
1940                 iState.elseifConditions = new Expression[conditionList.size()];
1941                 iState.elseifStatements = new Statement[statementList.size()];
1942                 conditionList.toArray(iState.elseifConditions);
1943                 statementList.toArray(iState.elseifStatements);
1944         }
1945
1946         private void else_single(IfStatement iState) {
1947                 // /* empty */
1948                 // T_ELSE statement
1949                 if (token == TokenNameelse) {
1950                         getNextToken();
1951                         Statement s = statement();
1952                         iState.elseStatement = s;
1953                         checkUnreachable(iState, s);
1954                 } else {
1955                         iState.checkUnreachable = false;
1956                 }
1957                 iState.sourceEnd = scanner.getCurrentTokenStartPosition();
1958         }
1959
1960         private void new_else_single(IfStatement iState) {
1961                 // /* empty */
1962                 // | T_ELSE ':' inner_statement_list
1963                 if (token == TokenNameelse) {
1964                         getNextToken();
1965                         if (token == TokenNameCOLON) {
1966                                 getNextToken();
1967                         } else {
1968                                 throwSyntaxError("':' expected after 'else' keyword.");
1969                         }
1970                         Block b = inner_statement_list();
1971                         iState.elseStatement = b;
1972                         checkUnreachable(iState, b);
1973                 } else {
1974                         iState.checkUnreachable = false;
1975                 }
1976         }
1977
1978         private Block inner_statement_list() {
1979                 // inner_statement_list inner_statement
1980                 // /* empty */
1981                 return statementList();
1982         }
1983
1984         /**
1985          * @param iState
1986          * @param b
1987          */
1988         private void checkUnreachable(IfStatement iState, Statement s) {
1989                 if (s instanceof Block) {
1990                         Block b = (Block) s;
1991                         if (b.statements == null || b.statements.length == 0) {
1992                                 iState.checkUnreachable = false;
1993                         } else {
1994                                 int off = b.statements.length - 1;
1995                                 if (!(b.statements[off] instanceof ReturnStatement) && !(b.statements[off] instanceof ContinueStatement)
1996                                                 && !(b.statements[off] instanceof BreakStatement)) {
1997                                         if (!(b.statements[off] instanceof IfStatement) || !((IfStatement) b.statements[off]).checkUnreachable) {
1998                                                 iState.checkUnreachable = false;
1999                                         }
2000                                 }
2001                         }
2002                 } else {
2003                         if (!(s instanceof ReturnStatement) && !(s instanceof ContinueStatement) && !(s instanceof BreakStatement)) {
2004                                 if (!(s instanceof IfStatement) || !((IfStatement) s).checkUnreachable) {
2005                                         iState.checkUnreachable = false;
2006                                 }
2007                         }
2008                 }
2009         }
2010
2011         // private void elseifStatementList() {
2012         // do {
2013         // elseifStatement();
2014         // switch (token) {
2015         // case TokenNameelse:
2016         // getNextToken();
2017         // if (token == TokenNameCOLON) {
2018         // getNextToken();
2019         // if (token != TokenNameendif) {
2020         // statementList();
2021         // }
2022         // return;
2023         // } else {
2024         // if (token == TokenNameif) { //'else if'
2025         // getNextToken();
2026         // } else {
2027         // throwSyntaxError("':' expected after 'else'.");
2028         // }
2029         // }
2030         // break;
2031         // case TokenNameelseif:
2032         // getNextToken();
2033         // break;
2034         // default:
2035         // return;
2036         // }
2037         // } while (true);
2038         // }
2039
2040         // private void elseifStatement() {
2041         // if (token == TokenNameLPAREN) {
2042         // getNextToken();
2043         // expr();
2044         // if (token != TokenNameRPAREN) {
2045         // throwSyntaxError("')' expected in else-if-statement.");
2046         // }
2047         // getNextToken();
2048         // if (token != TokenNameCOLON) {
2049         // throwSyntaxError("':' expected in else-if-statement.");
2050         // }
2051         // getNextToken();
2052         // if (token != TokenNameendif) {
2053         // statementList();
2054         // }
2055         // }
2056         // }
2057
2058         private void switchStatement() {
2059                 if (token == TokenNameCOLON) {
2060                         // ':' [labeled-statement-list] 'endswitch' ';'
2061                         getNextToken();
2062                         labeledStatementList();
2063                         if (token != TokenNameendswitch) {
2064                                 throwSyntaxError("'endswitch' expected.");
2065                         }
2066                         getNextToken();
2067                         if (token != TokenNameSEMICOLON) {
2068                                 throwSyntaxError("';' expected after switch-statement.");
2069                         }
2070                         getNextToken();
2071                 } else {
2072                         // '{' [labeled-statement-list] '}'
2073                         if (token != TokenNameLBRACE) {
2074                                 throwSyntaxError("'{' expected in switch statement.");
2075                         }
2076                         getNextToken();
2077                         if (token != TokenNameRBRACE) {
2078                                 labeledStatementList();
2079                         }
2080                         if (token != TokenNameRBRACE) {
2081                                 throwSyntaxError("'}' expected in switch statement.");
2082                         }
2083                         getNextToken();
2084                 }
2085         }
2086
2087         private void forStatement() {
2088                 if (token == TokenNameCOLON) {
2089                         getNextToken();
2090                         statementList();
2091                         if (token != TokenNameendfor) {
2092                                 throwSyntaxError("'endfor' expected.");
2093                         }
2094                         getNextToken();
2095                         if (token != TokenNameSEMICOLON) {
2096                                 throwSyntaxError("';' expected after for-statement.");
2097                         }
2098                         getNextToken();
2099                 } else {
2100                         statement();
2101                 }
2102         }
2103
2104         private void whileStatement() {
2105                 // ':' statement-list 'endwhile' ';'
2106                 if (token == TokenNameCOLON) {
2107                         getNextToken();
2108                         statementList();
2109                         if (token != TokenNameendwhile) {
2110                                 throwSyntaxError("'endwhile' expected.");
2111                         }
2112                         getNextToken();
2113                         if (token != TokenNameSEMICOLON) {
2114                                 throwSyntaxError("';' expected after while-statement.");
2115                         }
2116                         getNextToken();
2117                 } else {
2118                         statement();
2119                 }
2120         }
2121
2122         private void foreachStatement() {
2123                 if (token == TokenNameCOLON) {
2124                         getNextToken();
2125                         statementList();
2126                         if (token != TokenNameendforeach) {
2127                                 throwSyntaxError("'endforeach' expected.");
2128                         }
2129                         getNextToken();
2130                         if (token != TokenNameSEMICOLON) {
2131                                 throwSyntaxError("';' expected after foreach-statement.");
2132                         }
2133                         getNextToken();
2134                 } else {
2135                         statement();
2136                 }
2137         }
2138
2139         // private void exitStatus() {
2140         // if (token == TokenNameLPAREN) {
2141         // getNextToken();
2142         // } else {
2143         // throwSyntaxError("'(' expected in 'exit-status'.");
2144         // }
2145         // if (token != TokenNameRPAREN) {
2146         // expression();
2147         // }
2148         // if (token == TokenNameRPAREN) {
2149         // getNextToken();
2150         // } else {
2151         // throwSyntaxError("')' expected after 'exit-status'.");
2152         // }
2153         // }
2154         private void expressionList() {
2155                 do {
2156                         expr();
2157                         if (token == TokenNameCOMMA) {
2158                                 getNextToken();
2159                         } else {
2160                                 break;
2161                         }
2162                 } while (true);
2163         }
2164
2165         private Expression expr() {
2166                 // r_variable
2167                 // | expr_without_variable
2168                 // if (token!=TokenNameEOF) {
2169                 if (Scanner.TRACE) {
2170                         System.out.println("TRACE: expr()");
2171                 }
2172                 return expr_without_variable(true);
2173                 // }
2174         }
2175
2176         private Expression expr_without_variable(boolean only_variable) {
2177                 int exprSourceStart = scanner.getCurrentTokenStartPosition();
2178                 int exprSourceEnd = scanner.getCurrentTokenEndPosition();
2179                 Expression expression = new Expression();
2180                 expression.sourceStart = exprSourceStart;
2181                 // default, may be overwritten
2182                 expression.sourceEnd = exprSourceEnd;
2183                 try {
2184                         // internal_functions_in_yacc
2185                         // | T_CLONE expr
2186                         // | T_PRINT expr
2187                         // | '(' expr ')'
2188                         // | '@' expr
2189                         // | '+' expr
2190                         // | '-' expr
2191                         // | '!' expr
2192                         // | '~' expr
2193                         // | T_INC rw_variable
2194                         // | T_DEC rw_variable
2195                         // | T_INT_CAST expr
2196                         // | T_DOUBLE_CAST expr
2197                         // | T_STRING_CAST expr
2198                         // | T_ARRAY_CAST expr
2199                         // | T_OBJECT_CAST expr
2200                         // | T_BOOL_CAST expr
2201                         // | T_UNSET_CAST expr
2202                         // | T_EXIT exit_expr
2203                         // | scalar
2204                         // | T_ARRAY '(' array_pair_list ')'
2205                         // | '`' encaps_list '`'
2206                         // | T_LIST '(' assignment_list ')' '=' expr
2207                         // | T_NEW class_name_reference ctor_arguments
2208                         // | variable '=' expr
2209                         // | variable '=' '&' variable
2210                         // | variable '=' '&' T_NEW class_name_reference ctor_arguments
2211                         // | variable T_PLUS_EQUAL expr
2212                         // | variable T_MINUS_EQUAL expr
2213                         // | variable T_MUL_EQUAL expr
2214                         // | variable T_DIV_EQUAL expr
2215                         // | variable T_CONCAT_EQUAL expr
2216                         // | variable T_MOD_EQUAL expr
2217                         // | variable T_AND_EQUAL expr
2218                         // | variable T_OR_EQUAL expr
2219                         // | variable T_XOR_EQUAL expr
2220                         // | variable T_SL_EQUAL expr
2221                         // | variable T_SR_EQUAL expr
2222                         // | rw_variable T_INC
2223                         // | rw_variable T_DEC
2224                         // | expr T_BOOLEAN_OR expr
2225                         // | expr T_BOOLEAN_AND expr
2226                         // | expr T_LOGICAL_OR expr
2227                         // | expr T_LOGICAL_AND expr
2228                         // | expr T_LOGICAL_XOR expr
2229                         // | expr '|' expr
2230                         // | expr '&' expr
2231                         // | expr '^' expr
2232                         // | expr '.' expr
2233                         // | expr '+' expr
2234                         // | expr '-' expr
2235                         // | expr '*' expr
2236                         // | expr '/' expr
2237                         // | expr '%' expr
2238                         // | expr T_SL expr
2239                         // | expr T_SR expr
2240                         // | expr T_IS_IDENTICAL expr
2241                         // | expr T_IS_NOT_IDENTICAL expr
2242                         // | expr T_IS_EQUAL expr
2243                         // | expr T_IS_NOT_EQUAL expr
2244                         // | expr '<' expr
2245                         // | expr T_IS_SMALLER_OR_EQUAL expr
2246                         // | expr '>' expr
2247                         // | expr T_IS_GREATER_OR_EQUAL expr
2248                         // | expr T_INSTANCEOF class_name_reference
2249                         // | expr '?' expr ':' expr
2250                         if (Scanner.TRACE) {
2251                                 System.out.println("TRACE: expr_without_variable() PART 1");
2252                         }
2253                         switch (token) {
2254                         case TokenNameisset:
2255                                 // T_ISSET '(' isset_variables ')'
2256                                 getNextToken();
2257                                 if (token != TokenNameLPAREN) {
2258                                         throwSyntaxError("'(' expected after keyword 'isset'");
2259                                 }
2260                                 getNextToken();
2261                                 isset_variables();
2262                                 if (token != TokenNameRPAREN) {
2263                                         throwSyntaxError("')' expected after keyword 'isset'");
2264                                 }
2265                                 getNextToken();
2266                                 break;
2267                         case TokenNameempty:
2268                                 getNextToken();
2269                                 if (token != TokenNameLPAREN) {
2270                                         throwSyntaxError("'(' expected after keyword 'empty'");
2271                                 }
2272                                 getNextToken();
2273                                 variable(true, false);
2274                                 if (token != TokenNameRPAREN) {
2275                                         throwSyntaxError("')' expected after keyword 'empty'");
2276                                 }
2277                                 getNextToken();
2278                                 break;
2279                         case TokenNameeval:
2280                         case TokenNameinclude:
2281                         case TokenNameinclude_once:
2282                         case TokenNamerequire:
2283                         case TokenNamerequire_once:
2284                                 internal_functions_in_yacc();
2285                                 break;
2286                         // | '(' expr ')'
2287                         case TokenNameLPAREN:
2288                                 getNextToken();
2289                                 expr();
2290                                 if (token == TokenNameRPAREN) {
2291                                         getNextToken();
2292                                 } else {
2293                                         throwSyntaxError("')' expected in expression.");
2294                                 }
2295                                 break;
2296                         // | T_CLONE expr
2297                         // | T_PRINT expr
2298                         // | '@' expr
2299                         // | '+' expr
2300                         // | '-' expr
2301                         // | '!' expr
2302                         // | '~' expr
2303                         // | T_INT_CAST expr
2304                         // | T_DOUBLE_CAST expr
2305                         // | T_STRING_CAST expr
2306                         // | T_ARRAY_CAST expr
2307                         // | T_OBJECT_CAST expr
2308                         // | T_BOOL_CAST expr
2309                         // | T_UNSET_CAST expr
2310                         case TokenNameclone:
2311                         case TokenNameprint:
2312                         case TokenNameAT:
2313                         case TokenNamePLUS:
2314                         case TokenNameMINUS:
2315                         case TokenNameNOT:
2316                         case TokenNameTWIDDLE:
2317                         case TokenNameintCAST:
2318                         case TokenNamedoubleCAST:
2319                         case TokenNamestringCAST:
2320                         case TokenNamearrayCAST:
2321                         case TokenNameobjectCAST:
2322                         case TokenNameboolCAST:
2323                         case TokenNameunsetCAST:
2324                                 getNextToken();
2325                                 expr();
2326                                 break;
2327                         case TokenNameexit:
2328                                 getNextToken();
2329                                 exit_expr();
2330                                 break;
2331                         // scalar:
2332                         // T_STRING
2333                         // | T_STRING_VARNAME
2334                         // | class_constant
2335                         // | T_START_HEREDOC encaps_list T_END_HEREDOC
2336                         // | '`' encaps_list '`'
2337                         // | common_scalar
2338                         // | '`' encaps_list '`'
2339                         // case TokenNameEncapsedString0:
2340                         // scanner.encapsedStringStack.push(new Character('`'));
2341                         // getNextToken();
2342                         // try {
2343                         // if (token == TokenNameEncapsedString0) {
2344                         // } else {
2345                         // encaps_list();
2346                         // if (token != TokenNameEncapsedString0) {
2347                         // throwSyntaxError("\'`\' expected at end of string" + "(Found token: " +
2348                         // scanner.toStringAction(token) + " )");
2349                         // }
2350                         // }
2351                         // } finally {
2352                         // scanner.encapsedStringStack.pop();
2353                         // getNextToken();
2354                         // }
2355                         // break;
2356                         // // | '\'' encaps_list '\''
2357                         // case TokenNameEncapsedString1:
2358                         // scanner.encapsedStringStack.push(new Character('\''));
2359                         // getNextToken();
2360                         // try {
2361                         // exprSourceStart = scanner.getCurrentTokenStartPosition();
2362                         // if (token == TokenNameEncapsedString1) {
2363                         // expression = new
2364                         // StringLiteralSQ(scanner.getCurrentStringLiteralSource(exprSourceStart),
2365                         // exprSourceStart, scanner
2366                         // .getCurrentTokenEndPosition());
2367                         // } else {
2368                         // encaps_list();
2369                         // if (token != TokenNameEncapsedString1) {
2370                         // throwSyntaxError("\'\'\' expected at end of string" + "(Found token: "
2371                         // + scanner.toStringAction(token) + " )");
2372                         // } else {
2373                         // expression = new
2374                         // StringLiteralSQ(scanner.getCurrentStringLiteralSource(exprSourceStart),
2375                         // exprSourceStart, scanner
2376                         // .getCurrentTokenEndPosition());
2377                         // }
2378                         // }
2379                         // } finally {
2380                         // scanner.encapsedStringStack.pop();
2381                         // getNextToken();
2382                         // }
2383                         // break;
2384                         // //| '"' encaps_list '"'
2385                         // case TokenNameEncapsedString2:
2386                         // scanner.encapsedStringStack.push(new Character('"'));
2387                         // getNextToken();
2388                         // try {
2389                         // exprSourceStart = scanner.getCurrentTokenStartPosition();
2390                         // if (token == TokenNameEncapsedString2) {
2391                         // expression = new
2392                         // StringLiteralDQ(scanner.getCurrentStringLiteralSource(exprSourceStart),
2393                         // exprSourceStart, scanner
2394                         // .getCurrentTokenEndPosition());
2395                         // } else {
2396                         // encaps_list();
2397                         // if (token != TokenNameEncapsedString2) {
2398                         // throwSyntaxError("'\"' expected at end of string" + "(Found token: " +
2399                         // scanner.toStringAction(token) + " )");
2400                         // } else {
2401                         // expression = new
2402                         // StringLiteralDQ(scanner.getCurrentStringLiteralSource(exprSourceStart),
2403                         // exprSourceStart, scanner
2404                         // .getCurrentTokenEndPosition());
2405                         // }
2406                         // }
2407                         // } finally {
2408                         // scanner.encapsedStringStack.pop();
2409                         // getNextToken();
2410                         // }
2411                         // break;
2412                         case TokenNameStringDoubleQuote:
2413                                 expression = new StringLiteralDQ(scanner.getCurrentStringLiteralSource(), scanner.getCurrentTokenStartPosition(), scanner
2414                                                 .getCurrentTokenEndPosition());
2415                                 common_scalar();
2416                                 break;
2417                         case TokenNameStringSingleQuote:
2418                                 expression = new StringLiteralSQ(scanner.getCurrentStringLiteralSource(), scanner.getCurrentTokenStartPosition(), scanner
2419                                                 .getCurrentTokenEndPosition());
2420                                 common_scalar();
2421                                 break;
2422                         case TokenNameIntegerLiteral:
2423                         case TokenNameDoubleLiteral:
2424                         case TokenNameStringInterpolated:
2425                         case TokenNameFILE:
2426                         case TokenNameLINE:
2427                         case TokenNameCLASS_C:
2428                         case TokenNameMETHOD_C:
2429                         case TokenNameFUNC_C:
2430                                 common_scalar();
2431                                 break;
2432                         case TokenNameHEREDOC:
2433                                 getNextToken();
2434                                 break;
2435                         case TokenNamearray:
2436                                 // T_ARRAY '(' array_pair_list ')'
2437                                 getNextToken();
2438                                 if (token == TokenNameLPAREN) {
2439                                         getNextToken();
2440                                         if (token == TokenNameRPAREN) {
2441                                                 getNextToken();
2442                                                 break;
2443                                         }
2444                                         array_pair_list();
2445                                         if (token != TokenNameRPAREN) {
2446                                                 throwSyntaxError("')' or ',' expected after keyword 'array'" + "(Found token: " + scanner.toStringAction(token) + ")");
2447                                         }
2448                                         getNextToken();
2449                                 } else {
2450                                         throwSyntaxError("'(' expected after keyword 'array'" + "(Found token: " + scanner.toStringAction(token) + ")");
2451                                 }
2452                                 break;
2453                         case TokenNamelist:
2454                                 // | T_LIST '(' assignment_list ')' '=' expr
2455                                 getNextToken();
2456                                 if (token == TokenNameLPAREN) {
2457                                         getNextToken();
2458                                         assignment_list();
2459                                         if (token != TokenNameRPAREN) {
2460                                                 throwSyntaxError("')' expected after 'list' keyword.");
2461                                         }
2462                                         getNextToken();
2463                                         if (token != TokenNameEQUAL) {
2464                                                 throwSyntaxError("'=' expected after 'list' keyword.");
2465                                         }
2466                                         getNextToken();
2467                                         expr();
2468                                 } else {
2469                                         throwSyntaxError("'(' expected after 'list' keyword.");
2470                                 }
2471                                 break;
2472                         case TokenNamenew:
2473                                 // | T_NEW class_name_reference ctor_arguments
2474                                 getNextToken();
2475                                 Expression typeRef = class_name_reference();
2476                                 ctor_arguments();
2477                                 if (typeRef != null) {
2478                                         expression = typeRef;
2479                                 }
2480                                 break;
2481                         // | T_INC rw_variable
2482                         // | T_DEC rw_variable
2483                         case TokenNamePLUS_PLUS:
2484                         case TokenNameMINUS_MINUS:
2485                                 getNextToken();
2486                                 rw_variable();
2487                                 break;
2488                         // | variable '=' expr
2489                         // | variable '=' '&' variable
2490                         // | variable '=' '&' T_NEW class_name_reference ctor_arguments
2491                         // | variable T_PLUS_EQUAL expr
2492                         // | variable T_MINUS_EQUAL expr
2493                         // | variable T_MUL_EQUAL expr
2494                         // | variable T_DIV_EQUAL expr
2495                         // | variable T_CONCAT_EQUAL expr
2496                         // | variable T_MOD_EQUAL expr
2497                         // | variable T_AND_EQUAL expr
2498                         // | variable T_OR_EQUAL expr
2499                         // | variable T_XOR_EQUAL expr
2500                         // | variable T_SL_EQUAL expr
2501                         // | variable T_SR_EQUAL expr
2502                         // | rw_variable T_INC
2503                         // | rw_variable T_DEC
2504                         case TokenNameIdentifier:
2505                                 char[] ident = scanner.getCurrentTokenSource();
2506                                 Expression lhsIdentifier = identifier(true, true);
2507                                 if (lhsIdentifier != null) {
2508                                         expression = lhsIdentifier;
2509                                 }
2510                                 if (token == TokenNameEQUAL || token == TokenNamePLUS_EQUAL
2511                                                 || token == TokenNameMINUS_EQUAL || token == TokenNameMULTIPLY_EQUAL || token == TokenNameDIVIDE_EQUAL
2512                                                 || token == TokenNameDOT_EQUAL || token == TokenNameREMAINDER_EQUAL || token == TokenNameAND_EQUAL
2513                                                 || token == TokenNameOR_EQUAL || token == TokenNameXOR_EQUAL || token == TokenNameRIGHT_SHIFT_EQUAL
2514                                                 || token == TokenNameLEFT_SHIFT_EQUAL) {
2515                                         String error = "Assignment operator '"+scanner.toStringAction(token)+"' not allowed after identifier '"+new String(ident)+"' (use 'define(...)' to define constants).";
2516                                         throwSyntaxError(error);
2517                                 }
2518                                 break;
2519                         case TokenNameVariable:
2520                         case TokenNameDOLLAR:
2521                                 boolean rememberedVar = false;
2522                                 Expression lhs = variable(true, true);
2523                                 if (lhs != null && lhs instanceof FieldReference && token != TokenNameEQUAL && token != TokenNamePLUS_EQUAL
2524                                                 && token != TokenNameMINUS_EQUAL && token != TokenNameMULTIPLY_EQUAL && token != TokenNameDIVIDE_EQUAL
2525                                                 && token != TokenNameDOT_EQUAL && token != TokenNameREMAINDER_EQUAL && token != TokenNameAND_EQUAL
2526                                                 && token != TokenNameOR_EQUAL && token != TokenNameXOR_EQUAL && token != TokenNameRIGHT_SHIFT_EQUAL
2527                                                 && token != TokenNameLEFT_SHIFT_EQUAL) {
2528                                         FieldReference ref = (FieldReference) lhs;
2529                                         if (!containsVariableSet(ref.token)) {
2530                                                 problemReporter.uninitializedLocalVariable(new String(ref.token), ref.sourceStart(), ref.sourceEnd(), referenceContext,
2531                                                                 compilationUnit.compilationResult);
2532                                                 addVariableSet(ref.token);
2533                                         }
2534                                 }
2535
2536                                 switch (token) {
2537                                 case TokenNameEQUAL:
2538                                         if (lhs != null && lhs instanceof FieldReference) {
2539                                                 addVariableSet(((FieldReference) lhs).token);
2540                                         }
2541                                         getNextToken();
2542                                         if (token == TokenNameAND) {
2543                                                 getNextToken();
2544                                                 if (token == TokenNamenew) {
2545                                                         // | variable '=' '&' T_NEW class_name_reference
2546                                                         // ctor_arguments
2547                                                         getNextToken();
2548                                                         SingleTypeReference classRef = class_name_reference();
2549                                                         ctor_arguments();
2550                                                         if (classRef != null) {
2551                                                                 if (lhs != null && lhs instanceof FieldReference) {
2552                                                                         // example:
2553                                                                         // $var = & new Object();
2554                                                                         if (fMethodVariables != null) {
2555                                                                                 VariableInfo lhsInfo = new VariableInfo(((FieldReference) lhs).sourceStart());
2556                                                                                 lhsInfo.reference = classRef;
2557                                                                                 lhsInfo.typeIdentifier = classRef.token;
2558                                                                                 fMethodVariables.put(new String(((FieldReference) lhs).token), lhsInfo);
2559                                                                                 rememberedVar = true;
2560                                                                         }
2561                                                                 }
2562                                                         }
2563                                                 } else {
2564                                                         Expression rhs = variable(false, false);
2565                                                         if (rhs != null && rhs instanceof FieldReference && lhs != null && lhs instanceof FieldReference) {
2566                                                                 // example:
2567                                                                 // $var = &$ref;
2568                                                                 if (fMethodVariables != null) {
2569                                                                         VariableInfo rhsInfo = (VariableInfo) fMethodVariables.get(((FieldReference) rhs).token);
2570                                                                         if (rhsInfo != null && rhsInfo.reference != null) {
2571                                                                                 VariableInfo lhsInfo = new VariableInfo(((FieldReference) lhs).sourceStart());
2572                                                                                 lhsInfo.reference = rhsInfo.reference;
2573                                                                                 lhsInfo.typeIdentifier = rhsInfo.typeIdentifier;
2574                                                                                 fMethodVariables.put(new String(((FieldReference) lhs).token), lhsInfo);
2575                                                                                 rememberedVar = true;
2576                                                                         }
2577                                                                 }
2578                                                         }
2579                                                 }
2580                                         } else {
2581                                                 Expression rhs = expr();
2582                                                 if (lhs != null && lhs instanceof FieldReference) {
2583                                                         if (rhs != null && rhs instanceof FieldReference) {
2584                                                                 // example:
2585                                                                 // $var = $ref;
2586                                                                 if (fMethodVariables != null) {
2587                                                                         VariableInfo rhsInfo = (VariableInfo) fMethodVariables.get(((FieldReference) rhs).token);
2588                                                                         if (rhsInfo != null && rhsInfo.reference != null) {
2589                                                                                 VariableInfo lhsInfo = new VariableInfo(((FieldReference) lhs).sourceStart());
2590                                                                                 lhsInfo.reference = rhsInfo.reference;
2591                                                                                 lhsInfo.typeIdentifier = rhsInfo.typeIdentifier;
2592                                                                                 fMethodVariables.put(new String(((FieldReference) lhs).token), lhsInfo);
2593                                                                                 rememberedVar = true;
2594                                                                         }
2595                                                                 }
2596                                                         } else if (rhs != null && rhs instanceof SingleTypeReference) {
2597                                                                 // example:
2598                                                                 // $var = new Object();
2599                                                                 if (fMethodVariables != null) {
2600                                                                         VariableInfo lhsInfo = new VariableInfo(((FieldReference) lhs).sourceStart());
2601                                                                         lhsInfo.reference = (SingleTypeReference) rhs;
2602                                                                         lhsInfo.typeIdentifier = ((SingleTypeReference) rhs).token;
2603                                                                         fMethodVariables.put(new String(((FieldReference) lhs).token), lhsInfo);
2604                                                                         rememberedVar = true;
2605                                                                 }
2606                                                         }
2607                                                 }
2608                                         }
2609                                         if (rememberedVar == false && lhs != null && lhs instanceof FieldReference) {
2610                                                 if (fMethodVariables != null) {
2611                                                         VariableInfo lhsInfo = new VariableInfo(((FieldReference) lhs).sourceStart());
2612                                                         fMethodVariables.put(new String(((FieldReference) lhs).token), lhsInfo);
2613                                                 }
2614                                         }
2615                                         break;
2616                                 case TokenNamePLUS_EQUAL:
2617                                 case TokenNameMINUS_EQUAL:
2618                                 case TokenNameMULTIPLY_EQUAL:
2619                                 case TokenNameDIVIDE_EQUAL:
2620                                 case TokenNameDOT_EQUAL:
2621                                 case TokenNameREMAINDER_EQUAL:
2622                                 case TokenNameAND_EQUAL:
2623                                 case TokenNameOR_EQUAL:
2624                                 case TokenNameXOR_EQUAL:
2625                                 case TokenNameRIGHT_SHIFT_EQUAL:
2626                                 case TokenNameLEFT_SHIFT_EQUAL:
2627                                         if (lhs != null && lhs instanceof FieldReference) {
2628                                                 addVariableSet(((FieldReference) lhs).token);
2629                                         }
2630                                         getNextToken();
2631                                         expr();
2632                                         break;
2633                                 case TokenNamePLUS_PLUS:
2634                                 case TokenNameMINUS_MINUS:
2635                                         getNextToken();
2636                                         break;
2637                                 default:
2638                                         if (!only_variable) {
2639                                                 throwSyntaxError("Variable expression not allowed (found token '" + scanner.toStringAction(token) + "').");
2640                                         }
2641                                         if (lhs != null) {
2642                                                 expression = lhs;
2643                                         }
2644                                 }
2645                                 break;
2646                         default:
2647                                 if (token != TokenNameINLINE_HTML) {
2648                                         if (token > TokenNameKEYWORD) {
2649                                                 getNextToken();
2650                                                 break;
2651                                         } else {
2652                                                 // System.out.println(scanner.getCurrentTokenStartPosition());
2653                                                 // System.out.println(scanner.getCurrentTokenEndPosition());
2654
2655                                                 throwSyntaxError("Error in expression (found token '" + scanner.toStringAction(token) + "').");
2656                                         }
2657                                 }
2658                                 return expression;
2659                         }
2660                         if (Scanner.TRACE) {
2661                                 System.out.println("TRACE: expr_without_variable() PART 2");
2662                         }
2663                         // | expr T_BOOLEAN_OR expr
2664                         // | expr T_BOOLEAN_AND expr
2665                         // | expr T_LOGICAL_OR expr
2666                         // | expr T_LOGICAL_AND expr
2667                         // | expr T_LOGICAL_XOR expr
2668                         // | expr '|' expr
2669                         // | expr '&' expr
2670                         // | expr '^' expr
2671                         // | expr '.' expr
2672                         // | expr '+' expr
2673                         // | expr '-' expr
2674                         // | expr '*' expr
2675                         // | expr '/' expr
2676                         // | expr '%' expr
2677                         // | expr T_SL expr
2678                         // | expr T_SR expr
2679                         // | expr T_IS_IDENTICAL expr
2680                         // | expr T_IS_NOT_IDENTICAL expr
2681                         // | expr T_IS_EQUAL expr
2682                         // | expr T_IS_NOT_EQUAL expr
2683                         // | expr '<' expr
2684                         // | expr T_IS_SMALLER_OR_EQUAL expr
2685                         // | expr '>' expr
2686                         // | expr T_IS_GREATER_OR_EQUAL expr
2687                         while (true) {
2688                                 switch (token) {
2689                                 case TokenNameOR_OR:
2690                                         getNextToken();
2691                                         expression = new OR_OR_Expression(expression, expr(), token);
2692                                         break;
2693                                 case TokenNameAND_AND:
2694                                         getNextToken();
2695                                         expression = new AND_AND_Expression(expression, expr(), token);
2696                                         break;
2697                                 case TokenNameEQUAL_EQUAL:
2698                                         getNextToken();
2699                                         expression = new EqualExpression(expression, expr(), token);
2700                                         break;
2701                                 case TokenNameand:
2702                                 case TokenNameor:
2703                                 case TokenNamexor:
2704                                 case TokenNameAND:
2705                                 case TokenNameOR:
2706                                 case TokenNameXOR:
2707                                 case TokenNameDOT:
2708                                 case TokenNamePLUS:
2709                                 case TokenNameMINUS:
2710                                 case TokenNameMULTIPLY:
2711                                 case TokenNameDIVIDE:
2712                                 case TokenNameREMAINDER:
2713                                 case TokenNameLEFT_SHIFT:
2714                                 case TokenNameRIGHT_SHIFT:
2715                                 case TokenNameEQUAL_EQUAL_EQUAL:
2716                                 case TokenNameNOT_EQUAL_EQUAL:
2717                                 case TokenNameNOT_EQUAL:
2718                                 case TokenNameLESS:
2719                                 case TokenNameLESS_EQUAL:
2720                                 case TokenNameGREATER:
2721                                 case TokenNameGREATER_EQUAL:
2722                                         getNextToken();
2723                                         expression = new BinaryExpression(expression, expr(), token);
2724                                         break;
2725                                 // | expr T_INSTANCEOF class_name_reference
2726                                 // | expr '?' expr ':' expr
2727                                 case TokenNameinstanceof:
2728                                         getNextToken();
2729                                         TypeReference classRef = class_name_reference();
2730                                         if (classRef != null) {
2731                                                 expression = new InstanceOfExpression(expression, classRef, OperatorIds.INSTANCEOF);
2732                                                 expression.sourceStart = exprSourceStart;
2733                                                 expression.sourceEnd = scanner.getCurrentTokenEndPosition();
2734                                         }
2735                                         break;
2736                                 case TokenNameQUESTION:
2737                                         getNextToken();
2738                                         Expression valueIfTrue = expr();
2739                                         if (token != TokenNameCOLON) {
2740                                                 throwSyntaxError("':' expected in conditional expression.");
2741                                         }
2742                                         getNextToken();
2743                                         Expression valueIfFalse = expr();
2744
2745                                         expression = new ConditionalExpression(expression, valueIfTrue, valueIfFalse);
2746                                         break;
2747                                 default:
2748                                         return expression;
2749                                 }
2750                         }
2751                 } catch (SyntaxError e) {
2752                         // try to find next token after expression with errors:
2753                         if (token == TokenNameSEMICOLON) {
2754                                 getNextToken();
2755                                 return expression;
2756                         }
2757                         if (token == TokenNameRBRACE || token == TokenNameRPAREN || token == TokenNameRBRACKET) {
2758                                 getNextToken();
2759                                 return expression;
2760                         }
2761                         throw e;
2762                 }
2763         }
2764
2765         private SingleTypeReference class_name_reference() {
2766                 // class_name_reference:
2767                 // T_STRING
2768                 // | dynamic_class_name_reference
2769                 SingleTypeReference ref = null;
2770                 if (Scanner.TRACE) {
2771                         System.out.println("TRACE: class_name_reference()");
2772                 }
2773                 if (token == TokenNameIdentifier) {
2774                         ref = new SingleTypeReference(scanner.getCurrentIdentifierSource(), scanner.getCurrentTokenStartPosition());
2775                         getNextToken();
2776                 } else {
2777                         ref = null;
2778                         dynamic_class_name_reference();
2779                 }
2780                 return ref;
2781         }
2782
2783         private void dynamic_class_name_reference() {
2784                 // dynamic_class_name_reference:
2785                 // base_variable T_OBJECT_OPERATOR object_property
2786                 // dynamic_class_name_variable_properties
2787                 // | base_variable
2788                 if (Scanner.TRACE) {
2789                         System.out.println("TRACE: dynamic_class_name_reference()");
2790                 }
2791                 base_variable();
2792                 if (token == TokenNameMINUS_GREATER) {
2793                         getNextToken();
2794                         object_property();
2795                         dynamic_class_name_variable_properties();
2796                 }
2797         }
2798
2799         private void dynamic_class_name_variable_properties() {
2800                 // dynamic_class_name_variable_properties:
2801                 // dynamic_class_name_variable_properties
2802                 // dynamic_class_name_variable_property
2803                 // | /* empty */
2804                 if (Scanner.TRACE) {
2805                         System.out.println("TRACE: dynamic_class_name_variable_properties()");
2806                 }
2807                 while (token == TokenNameMINUS_GREATER) {
2808                         dynamic_class_name_variable_property();
2809                 }
2810         }
2811
2812         private void dynamic_class_name_variable_property() {
2813                 // dynamic_class_name_variable_property:
2814                 // T_OBJECT_OPERATOR object_property
2815                 if (Scanner.TRACE) {
2816                         System.out.println("TRACE: dynamic_class_name_variable_property()");
2817                 }
2818                 if (token == TokenNameMINUS_GREATER) {
2819                         getNextToken();
2820                         object_property();
2821                 }
2822         }
2823
2824         private void ctor_arguments() {
2825                 // ctor_arguments:
2826                 // /* empty */
2827                 // | '(' function_call_parameter_list ')'
2828                 if (token == TokenNameLPAREN) {
2829                         getNextToken();
2830                         if (token == TokenNameRPAREN) {
2831                                 getNextToken();
2832                                 return;
2833                         }
2834                         non_empty_function_call_parameter_list();
2835                         if (token != TokenNameRPAREN) {
2836                                 throwSyntaxError("')' expected in ctor_arguments.");
2837                         }
2838                         getNextToken();
2839                 }
2840         }
2841
2842         private void assignment_list() {
2843                 // assignment_list:
2844                 // assignment_list ',' assignment_list_element
2845                 // | assignment_list_element
2846                 while (true) {
2847                         assignment_list_element();
2848                         if (token != TokenNameCOMMA) {
2849                                 break;
2850                         }
2851                         getNextToken();
2852                 }
2853         }
2854
2855         private void assignment_list_element() {
2856                 // assignment_list_element:
2857                 // variable
2858                 // | T_LIST '(' assignment_list ')'
2859                 // | /* empty */
2860                 if (token == TokenNameVariable) {
2861                         variable(true, false);
2862                 } else if (token == TokenNameDOLLAR) {
2863                         variable(false, false);
2864                 } else {
2865                         if (token == TokenNamelist) {
2866                                 getNextToken();
2867                                 if (token == TokenNameLPAREN) {
2868                                         getNextToken();
2869                                         assignment_list();
2870                                         if (token != TokenNameRPAREN) {
2871                                                 throwSyntaxError("')' expected after 'list' keyword.");
2872                                         }
2873                                         getNextToken();
2874                                 } else {
2875                                         throwSyntaxError("'(' expected after 'list' keyword.");
2876                                 }
2877                         }
2878                 }
2879         }
2880
2881         private void array_pair_list() {
2882                 // array_pair_list:
2883                 // /* empty */
2884                 // | non_empty_array_pair_list possible_comma
2885                 non_empty_array_pair_list();
2886                 if (token == TokenNameCOMMA) {
2887                         getNextToken();
2888                 }
2889         }
2890
2891         private void non_empty_array_pair_list() {
2892                 // non_empty_array_pair_list:
2893                 // non_empty_array_pair_list ',' expr T_DOUBLE_ARROW expr
2894                 // | non_empty_array_pair_list ',' expr
2895                 // | expr T_DOUBLE_ARROW expr
2896                 // | expr
2897                 // | non_empty_array_pair_list ',' expr T_DOUBLE_ARROW '&' w_variable
2898                 // | non_empty_array_pair_list ',' '&' w_variable
2899                 // | expr T_DOUBLE_ARROW '&' w_variable
2900                 // | '&' w_variable
2901                 while (true) {
2902                         if (token == TokenNameAND) {
2903                                 getNextToken();
2904                                 variable(true, false);
2905                         } else {
2906                                 expr();
2907                                 if (token == TokenNameAND) {
2908                                         getNextToken();
2909                                         variable(true, false);
2910                                 } else if (token == TokenNameEQUAL_GREATER) {
2911                                         getNextToken();
2912                                         if (token == TokenNameAND) {
2913                                                 getNextToken();
2914                                                 variable(true, false);
2915                                         } else {
2916                                                 expr();
2917                                         }
2918                                 }
2919                         }
2920                         if (token != TokenNameCOMMA) {
2921                                 return;
2922                         }
2923                         getNextToken();
2924                         if (token == TokenNameRPAREN) {
2925                                 return;
2926                         }
2927                 }
2928         }
2929
2930         // private void variableList() {
2931         // do {
2932         // variable();
2933         // if (token == TokenNameCOMMA) {
2934         // getNextToken();
2935         // } else {
2936         // break;
2937         // }
2938         // } while (true);
2939         // }
2940         private Expression variable_without_objects(boolean lefthandside, boolean ignoreVar) {
2941                 // variable_without_objects:
2942                 // reference_variable
2943                 // | simple_indirect_reference reference_variable
2944                 if (Scanner.TRACE) {
2945                         System.out.println("TRACE: variable_without_objects()");
2946                 }
2947                 while (token == TokenNameDOLLAR) {
2948                         getNextToken();
2949                 }
2950                 return reference_variable(lefthandside, ignoreVar);
2951         }
2952
2953         private Expression function_call(boolean lefthandside, boolean ignoreVar) {
2954                 // function_call:
2955                 // T_STRING '(' function_call_parameter_list ')'
2956                 // | class_constant '(' function_call_parameter_list ')'
2957                 // | static_member '(' function_call_parameter_list ')'
2958                 // | variable_without_objects '(' function_call_parameter_list ')'
2959                 char[] defineName = null;
2960                 char[] ident = null;
2961                 int startPos = 0;
2962                 int endPos = 0;
2963                 Expression ref = null;
2964                 if (Scanner.TRACE) {
2965                         System.out.println("TRACE: function_call()");
2966                 }
2967                 if (token == TokenNameIdentifier) {
2968                         ident = scanner.getCurrentIdentifierSource();
2969                         defineName = ident;
2970                         startPos = scanner.getCurrentTokenStartPosition();
2971                         endPos = scanner.getCurrentTokenEndPosition();
2972                         getNextToken();
2973                         switch (token) {
2974                         case TokenNamePAAMAYIM_NEKUDOTAYIM:
2975                                 // static member:
2976                                 defineName = null;
2977                                 getNextToken();
2978                                 if (token == TokenNameIdentifier) {
2979                                         // class _constant
2980                                         getNextToken();
2981                                 } else {
2982                                         // static member:
2983                                         variable_without_objects(true, false);
2984                                 }
2985                                 break;
2986                         }
2987                 } else {
2988                         ref = variable_without_objects(lefthandside, ignoreVar);
2989                 }
2990                 if (token != TokenNameLPAREN) {
2991                         if (defineName != null) {
2992                                 // does this identifier contain only uppercase characters?
2993                                 if (defineName.length == 3) {
2994                                         if (defineName[0] == 'd' && defineName[1] == 'i' && defineName[2] == 'e') {
2995                                                 defineName = null;
2996                                         }
2997                                 } else if (defineName.length == 4) {
2998                                         if (defineName[0] == 't' && defineName[1] == 'r' && defineName[2] == 'u' && defineName[3] == 'e') {
2999                                                 defineName = null;
3000                                         } else if (defineName[0] == 'n' && defineName[1] == 'u' && defineName[2] == 'l' && defineName[3] == 'l') {
3001                                                 defineName = null;
3002                                         }
3003                                 } else if (defineName.length == 5) {
3004                                         if (defineName[0] == 'f' && defineName[1] == 'a' && defineName[2] == 'l' && defineName[3] == 's' && defineName[4] == 'e') {
3005                                                 defineName = null;
3006                                         }
3007                                 }
3008                                 if (defineName != null) {
3009                                         for (int i = 0; i < defineName.length; i++) {
3010                                                 if (Character.isLowerCase(defineName[i])) {
3011                                                         problemReporter.phpUppercaseIdentifierWarning(startPos, endPos, referenceContext, compilationUnit.compilationResult);
3012                                                         break;
3013                                                 }
3014                                         }
3015                                 }
3016                         }
3017                         // TODO is this ok ?
3018                         return ref;
3019                         // throwSyntaxError("'(' expected in function call.");
3020                 }
3021                 getNextToken();
3022                 if (token == TokenNameRPAREN) {
3023                         getNextToken();
3024                         return ref;
3025                 }
3026                 non_empty_function_call_parameter_list();
3027                 if (token != TokenNameRPAREN) {
3028                         String functionName;
3029                         if (ident == null) {
3030                                 functionName = new String(" ");
3031                         } else {
3032                                 functionName = new String(ident);
3033                         }
3034                         throwSyntaxError("')' expected in function call (" + functionName + ").");
3035                 }
3036                 getNextToken();
3037                 return ref;
3038         }
3039
3040         // private void function_call_parameter_list() {
3041         // function_call_parameter_list:
3042         // non_empty_function_call_parameter_list { $$ = $1; }
3043         // | /* empty */
3044         // }
3045         private void non_empty_function_call_parameter_list() {
3046                 // non_empty_function_call_parameter_list:
3047                 // expr_without_variable
3048                 // | variable
3049                 // | '&' w_variable
3050                 // | non_empty_function_call_parameter_list ',' expr_without_variable
3051                 // | non_empty_function_call_parameter_list ',' variable
3052                 // | non_empty_function_call_parameter_list ',' '&' w_variable
3053                 if (Scanner.TRACE) {
3054                         System.out.println("TRACE: non_empty_function_call_parameter_list()");
3055                 }
3056                 while (true) {
3057                         if (token == TokenNameAND) {
3058                                 getNextToken();
3059                                 w_variable(true);
3060                         } else {
3061                                 // if (token == TokenNameIdentifier || token ==
3062                                 // TokenNameVariable
3063                                 // || token == TokenNameDOLLAR) {
3064                                 // variable();
3065                                 // } else {
3066                                 expr_without_variable(true);
3067                                 // }
3068                         }
3069                         if (token != TokenNameCOMMA) {
3070                                 break;
3071                         }
3072                         getNextToken();
3073                 }
3074         }
3075
3076         private void fully_qualified_class_name() {
3077                 if (token == TokenNameIdentifier) {
3078                         getNextToken();
3079                 } else {
3080                         throwSyntaxError("Class name expected.");
3081                 }
3082         }
3083
3084         private void static_member() {
3085                 // static_member:
3086                 // fully_qualified_class_name T_PAAMAYIM_NEKUDOTAYIM
3087                 // variable_without_objects
3088                 if (Scanner.TRACE) {
3089                         System.out.println("TRACE: static_member()");
3090                 }
3091                 fully_qualified_class_name();
3092                 if (token != TokenNamePAAMAYIM_NEKUDOTAYIM) {
3093                         throwSyntaxError("'::' expected after class name (static_member).");
3094                 }
3095                 getNextToken();
3096                 variable_without_objects(false, false);
3097         }
3098
3099         private Expression base_variable_with_function_calls(boolean lefthandside, boolean ignoreVar) {
3100                 // base_variable_with_function_calls:
3101                 // base_variable
3102                 // | function_call
3103                 if (Scanner.TRACE) {
3104                         System.out.println("TRACE: base_variable_with_function_calls()");
3105                 }
3106                 return function_call(lefthandside, ignoreVar);
3107         }
3108
3109         private Expression base_variable() {
3110                 // base_variable:
3111                 // reference_variable
3112                 // | simple_indirect_reference reference_variable
3113                 // | static_member
3114                 Expression ref = null;
3115                 if (Scanner.TRACE) {
3116                         System.out.println("TRACE: base_variable()");
3117                 }
3118                 if (token == TokenNameIdentifier) {
3119                         static_member();
3120                 } else {
3121                         while (token == TokenNameDOLLAR) {
3122                                 getNextToken();
3123                         }
3124                         reference_variable(false, false);
3125                 }
3126                 return ref;
3127         }
3128
3129         // private void simple_indirect_reference() {
3130         // // simple_indirect_reference:
3131         // // '$'
3132         // //| simple_indirect_reference '$'
3133         // }
3134         private Expression reference_variable(boolean lefthandside, boolean ignoreVar) {
3135                 // reference_variable:
3136                 // reference_variable '[' dim_offset ']'
3137                 // | reference_variable '{' expr '}'
3138                 // | compound_variable
3139                 Expression ref = null;
3140                 if (Scanner.TRACE) {
3141                         System.out.println("TRACE: reference_variable()");
3142                 }
3143                 ref = compound_variable(lefthandside, ignoreVar);
3144                 while (true) {
3145                         if (token == TokenNameLBRACE) {
3146                                 ref = null;
3147                                 getNextToken();
3148                                 expr();
3149                                 if (token != TokenNameRBRACE) {
3150                                         throwSyntaxError("'}' expected in reference variable.");
3151                                 }
3152                                 getNextToken();
3153                         } else if (token == TokenNameLBRACKET) {
3154                                 if (ref != null && ref instanceof FieldReference) {
3155                                         FieldReference fref = (FieldReference) ref;
3156                                         addVariableSet(fref.token);
3157                                 }
3158                                 ref = null;
3159                                 getNextToken();
3160                                 if (token != TokenNameRBRACKET) {
3161                                         expr();
3162                                         // dim_offset();
3163                                         if (token != TokenNameRBRACKET) {
3164                                                 throwSyntaxError("']' expected in reference variable.");
3165                                         }
3166                                 }
3167                                 getNextToken();
3168                         } else {
3169                                 break;
3170                         }
3171                 }
3172                 return ref;
3173         }
3174
3175         private Expression compound_variable(boolean lefthandside, boolean ignoreVar) {
3176                 // compound_variable:
3177                 // T_VARIABLE
3178                 // | '$' '{' expr '}'
3179                 if (Scanner.TRACE) {
3180                         System.out.println("TRACE: compound_variable()");
3181                 }
3182                 if (token == TokenNameVariable) {
3183                         if (!lefthandside) {
3184                                 if (!containsVariableSet()) {
3185                                         // reportSyntaxError("The local variable " + new
3186                                         // String(scanner.getCurrentIdentifierSource())
3187                                         // + " may not have been initialized");
3188                                         problemReporter.uninitializedLocalVariable(new String(scanner.getCurrentIdentifierSource()), scanner
3189                                                         .getCurrentTokenStartPosition(), scanner.getCurrentTokenEndPosition(), referenceContext,
3190                                                         compilationUnit.compilationResult);
3191                                 }
3192                         } else {
3193                                 if (!ignoreVar) {
3194                                         addVariableSet();
3195                                 }
3196                         }
3197                         FieldReference ref = new FieldReference(scanner.getCurrentIdentifierSource(), scanner.getCurrentTokenStartPosition());
3198                         getNextToken();
3199                         return ref;
3200                 } else {
3201                         // because of simple_indirect_reference
3202                         while (token == TokenNameDOLLAR) {
3203                                 getNextToken();
3204                         }
3205                         if (token != TokenNameLBRACE) {
3206                                 reportSyntaxError("'{' expected after compound variable token '$'.");
3207                                 return null;
3208                         }
3209                         getNextToken();
3210                         expr();
3211                         if (token != TokenNameRBRACE) {
3212                                 throwSyntaxError("'}' expected after compound variable token '$'.");
3213                         }
3214                         getNextToken();
3215                 }
3216                 return null;
3217         } // private void dim_offset() { // // dim_offset: // // /* empty */
3218
3219         // // | expr
3220         // expr();
3221         // }
3222         private void object_property() {
3223                 // object_property:
3224                 // object_dim_list
3225                 // | variable_without_objects
3226                 if (Scanner.TRACE) {
3227                         System.out.println("TRACE: object_property()");
3228                 }
3229                 if (token == TokenNameVariable || token == TokenNameDOLLAR) {
3230                         variable_without_objects(false, false);
3231                 } else {
3232                         object_dim_list();
3233                 }
3234         }
3235
3236         private void object_dim_list() {
3237                 // object_dim_list:
3238                 // object_dim_list '[' dim_offset ']'
3239                 // | object_dim_list '{' expr '}'
3240                 // | variable_name
3241                 if (Scanner.TRACE) {
3242                         System.out.println("TRACE: object_dim_list()");
3243                 }
3244                 variable_name();
3245                 while (true) {
3246                         if (token == TokenNameLBRACE) {
3247                                 getNextToken();
3248                                 expr();
3249                                 if (token != TokenNameRBRACE) {
3250                                         throwSyntaxError("'}' expected in object_dim_list.");
3251                                 }
3252                                 getNextToken();
3253                         } else if (token == TokenNameLBRACKET) {
3254                                 getNextToken();
3255                                 if (token == TokenNameRBRACKET) {
3256                                         getNextToken();
3257                                         continue;
3258                                 }
3259                                 expr();
3260                                 if (token != TokenNameRBRACKET) {
3261                                         throwSyntaxError("']' expected in object_dim_list.");
3262                                 }
3263                                 getNextToken();
3264                         } else {
3265                                 break;
3266                         }
3267                 }
3268         }
3269
3270         private void variable_name() {
3271                 // variable_name:
3272                 // T_STRING
3273                 // | '{' expr '}'
3274                 if (Scanner.TRACE) {
3275                         System.out.println("TRACE: variable_name()");
3276                 }
3277                 if (token == TokenNameIdentifier || token > TokenNameKEYWORD) {
3278                         if (token > TokenNameKEYWORD) {
3279                                 // TODO show a warning "Keyword used as variable" ?
3280                         }
3281                         getNextToken();
3282                 } else {
3283                         if (token != TokenNameLBRACE) {
3284                                 throwSyntaxError("'{' expected in variable name.");
3285                         }
3286                         getNextToken();
3287                         expr();
3288                         if (token != TokenNameRBRACE) {
3289                                 throwSyntaxError("'}' expected in variable name.");
3290                         }
3291                         getNextToken();
3292                 }
3293         }
3294
3295         private void r_variable() {
3296                 variable(false, false);
3297         }
3298
3299         private void w_variable(boolean lefthandside) {
3300                 variable(lefthandside, false);
3301         }
3302
3303         private void rw_variable() {
3304                 variable(false, false);
3305         }
3306
3307         private Expression variable(boolean lefthandside, boolean ignoreVar) {
3308                 // variable:
3309                 // base_variable_with_function_calls T_OBJECT_OPERATOR
3310                 // object_property method_or_not variable_properties
3311                 // | base_variable_with_function_calls
3312                 Expression ref = base_variable_with_function_calls(lefthandside, ignoreVar);
3313                 if (token == TokenNameMINUS_GREATER) {
3314                         ref = null;
3315                         getNextToken();
3316                         object_property();
3317                         method_or_not();
3318                         variable_properties();
3319                 }
3320                 return ref;
3321         }
3322
3323         private void variable_properties() {
3324                 // variable_properties:
3325                 // variable_properties variable_property
3326                 // | /* empty */
3327                 while (token == TokenNameMINUS_GREATER) {
3328                         variable_property();
3329                 }
3330         }
3331
3332         private void variable_property() {
3333                 // variable_property:
3334                 // T_OBJECT_OPERATOR object_property method_or_not
3335                 if (Scanner.TRACE) {
3336                         System.out.println("TRACE: variable_property()");
3337                 }
3338                 if (token == TokenNameMINUS_GREATER) {
3339                         getNextToken();
3340                         object_property();
3341                         method_or_not();
3342                 } else {
3343                         throwSyntaxError("'->' expected in variable_property.");
3344                 }
3345         }
3346
3347         private Expression identifier(boolean lefthandside, boolean ignoreVar) {
3348                 // variable:
3349                 // base_variable_with_function_calls T_OBJECT_OPERATOR
3350                 // object_property method_or_not variable_properties
3351                 // | base_variable_with_function_calls
3352                 return base_variable_with_function_calls(lefthandside, ignoreVar);
3353         }
3354
3355         private void method_or_not() {
3356                 // method_or_not:
3357                 // '(' function_call_parameter_list ')'
3358                 // | /* empty */
3359                 if (Scanner.TRACE) {
3360                         System.out.println("TRACE: method_or_not()");
3361                 }
3362                 if (token == TokenNameLPAREN) {
3363                         getNextToken();
3364                         if (token == TokenNameRPAREN) {
3365                                 getNextToken();
3366                                 return;
3367                         }
3368                         non_empty_function_call_parameter_list();
3369                         if (token != TokenNameRPAREN) {
3370                                 throwSyntaxError("')' expected in method_or_not.");
3371                         }
3372                         getNextToken();
3373                 }
3374         }
3375
3376         private void exit_expr() {
3377                 // /* empty */
3378                 // | '(' ')'
3379                 // | '(' expr ')'
3380                 if (token != TokenNameLPAREN) {
3381                         return;
3382                 }
3383                 getNextToken();
3384                 if (token == TokenNameRPAREN) {
3385                         getNextToken();
3386                         return;
3387                 }
3388                 expr();
3389                 if (token != TokenNameRPAREN) {
3390                         throwSyntaxError("')' expected after keyword 'exit'");
3391                 }
3392                 getNextToken();
3393         }
3394
3395         // private void encaps_list() {
3396         // // encaps_list encaps_var
3397         // // | encaps_list T_STRING
3398         // // | encaps_list T_NUM_STRING
3399         // // | encaps_list T_ENCAPSED_AND_WHITESPACE
3400         // // | encaps_list T_CHARACTER
3401         // // | encaps_list T_BAD_CHARACTER
3402         // // | encaps_list '['
3403         // // | encaps_list ']'
3404         // // | encaps_list '{'
3405         // // | encaps_list '}'
3406         // // | encaps_list T_OBJECT_OPERATOR
3407         // // | /* empty */
3408         // while (true) {
3409         // switch (token) {
3410         // case TokenNameSTRING:
3411         // getNextToken();
3412         // break;
3413         // case TokenNameLBRACE:
3414         // // scanner.encapsedStringStack.pop();
3415         // getNextToken();
3416         // break;
3417         // case TokenNameRBRACE:
3418         // // scanner.encapsedStringStack.pop();
3419         // getNextToken();
3420         // break;
3421         // case TokenNameLBRACKET:
3422         // // scanner.encapsedStringStack.pop();
3423         // getNextToken();
3424         // break;
3425         // case TokenNameRBRACKET:
3426         // // scanner.encapsedStringStack.pop();
3427         // getNextToken();
3428         // break;
3429         // case TokenNameMINUS_GREATER:
3430         // // scanner.encapsedStringStack.pop();
3431         // getNextToken();
3432         // break;
3433         // case TokenNameVariable:
3434         // case TokenNameDOLLAR_LBRACE:
3435         // case TokenNameLBRACE_DOLLAR:
3436         // encaps_var();
3437         // break;
3438         // default:
3439         // char encapsedChar = ((Character)
3440         // scanner.encapsedStringStack.peek()).charValue();
3441         // if (encapsedChar == '$') {
3442         // scanner.encapsedStringStack.pop();
3443         // encapsedChar = ((Character)
3444         // scanner.encapsedStringStack.peek()).charValue();
3445         // switch (encapsedChar) {
3446         // case '`':
3447         // if (token == TokenNameEncapsedString0) {
3448         // return;
3449         // }
3450         // token = TokenNameSTRING;
3451         // continue;
3452         // case '\'':
3453         // if (token == TokenNameEncapsedString1) {
3454         // return;
3455         // }
3456         // token = TokenNameSTRING;
3457         // continue;
3458         // case '"':
3459         // if (token == TokenNameEncapsedString2) {
3460         // return;
3461         // }
3462         // token = TokenNameSTRING;
3463         // continue;
3464         // }
3465         // }
3466         // return;
3467         // }
3468         // }
3469         // }
3470
3471         // private void encaps_var() {
3472         // // T_VARIABLE
3473         // // | T_VARIABLE '[' encaps_var_offset ']'
3474         // // | T_VARIABLE T_OBJECT_OPERATOR T_STRING
3475         // // | T_DOLLAR_OPEN_CURLY_BRACES expr '}'
3476         // // | T_DOLLAR_OPEN_CURLY_BRACES T_STRING_VARNAME '[' expr ']' '}'
3477         // // | T_CURLY_OPEN variable '}'
3478         // switch (token) {
3479         // case TokenNameVariable:
3480         // getNextToken();
3481         // if (token == TokenNameLBRACKET) {
3482         // getNextToken();
3483         // expr(); //encaps_var_offset();
3484         // if (token != TokenNameRBRACKET) {
3485         // throwSyntaxError("']' expected after variable.");
3486         // }
3487         // // scanner.encapsedStringStack.pop();
3488         // getNextToken();
3489         // // }
3490         // } else if (token == TokenNameMINUS_GREATER) {
3491         // getNextToken();
3492         // if (token != TokenNameIdentifier) {
3493         // throwSyntaxError("Identifier expected after '->'.");
3494         // }
3495         // // scanner.encapsedStringStack.pop();
3496         // getNextToken();
3497         // }
3498         // // else {
3499         // // // scanner.encapsedStringStack.pop();
3500         // // int tempToken = TokenNameSTRING;
3501         // // if (!scanner.encapsedStringStack.isEmpty()
3502         // // && (token == TokenNameEncapsedString0
3503         // // || token == TokenNameEncapsedString1
3504         // // || token == TokenNameEncapsedString2 || token ==
3505         // // TokenNameERROR)) {
3506         // // char encapsedChar = ((Character)
3507         // // scanner.encapsedStringStack.peek())
3508         // // .charValue();
3509         // // switch (token) {
3510         // // case TokenNameEncapsedString0 :
3511         // // if (encapsedChar == '`') {
3512         // // tempToken = TokenNameEncapsedString0;
3513         // // }
3514         // // break;
3515         // // case TokenNameEncapsedString1 :
3516         // // if (encapsedChar == '\'') {
3517         // // tempToken = TokenNameEncapsedString1;
3518         // // }
3519         // // break;
3520         // // case TokenNameEncapsedString2 :
3521         // // if (encapsedChar == '"') {
3522         // // tempToken = TokenNameEncapsedString2;
3523         // // }
3524         // // break;
3525         // // case TokenNameERROR :
3526         // // if (scanner.source[scanner.currentPosition - 1] == '\\') {
3527         // // scanner.currentPosition--;
3528         // // getNextToken();
3529         // // }
3530         // // break;
3531         // // }
3532         // // }
3533         // // token = tempToken;
3534         // // }
3535         // break;
3536         // case TokenNameDOLLAR_LBRACE:
3537         // getNextToken();
3538         // if (token == TokenNameDOLLAR_LBRACE) {
3539         // encaps_var();
3540         // } else if (token == TokenNameIdentifier) {
3541         // getNextToken();
3542         // if (token == TokenNameLBRACKET) {
3543         // getNextToken();
3544         // // if (token == TokenNameRBRACKET) {
3545         // // getNextToken();
3546         // // } else {
3547         // expr();
3548         // if (token != TokenNameRBRACKET) {
3549         // throwSyntaxError("']' expected after '${'.");
3550         // }
3551         // getNextToken();
3552         // // }
3553         // }
3554         // } else {
3555         // expr();
3556         // }
3557         // if (token != TokenNameRBRACE) {
3558         // throwSyntaxError("'}' expected.");
3559         // }
3560         // getNextToken();
3561         // break;
3562         // case TokenNameLBRACE_DOLLAR:
3563         // getNextToken();
3564         // if (token == TokenNameLBRACE_DOLLAR) {
3565         // encaps_var();
3566         // } else if (token == TokenNameIdentifier || token > TokenNameKEYWORD) {
3567         // getNextToken();
3568         // if (token == TokenNameLBRACKET) {
3569         // getNextToken();
3570         // // if (token == TokenNameRBRACKET) {
3571         // // getNextToken();
3572         // // } else {
3573         // expr();
3574         // if (token != TokenNameRBRACKET) {
3575         // throwSyntaxError("']' expected.");
3576         // }
3577         // getNextToken();
3578         // // }
3579         // } else if (token == TokenNameMINUS_GREATER) {
3580         // getNextToken();
3581         // if (token != TokenNameIdentifier && token != TokenNameVariable) {
3582         // throwSyntaxError("String or Variable token expected.");
3583         // }
3584         // getNextToken();
3585         // if (token == TokenNameLBRACKET) {
3586         // getNextToken();
3587         // // if (token == TokenNameRBRACKET) {
3588         // // getNextToken();
3589         // // } else {
3590         // expr();
3591         // if (token != TokenNameRBRACKET) {
3592         // throwSyntaxError("']' expected after '${'.");
3593         // }
3594         // getNextToken();
3595         // // }
3596         // }
3597         // }
3598         // // if (token != TokenNameRBRACE) {
3599         // // throwSyntaxError("'}' expected after '{$'.");
3600         // // }
3601         // // // scanner.encapsedStringStack.pop();
3602         // // getNextToken();
3603         // } else {
3604         // expr();
3605         // if (token != TokenNameRBRACE) {
3606         // throwSyntaxError("'}' expected.");
3607         // }
3608         // // scanner.encapsedStringStack.pop();
3609         // getNextToken();
3610         // }
3611         // break;
3612         // }
3613         // }
3614
3615         // private void encaps_var_offset() {
3616         // // T_STRING
3617         // // | T_NUM_STRING
3618         // // | T_VARIABLE
3619         // switch (token) {
3620         // case TokenNameSTRING:
3621         // getNextToken();
3622         // break;
3623         // case TokenNameIntegerLiteral:
3624         // getNextToken();
3625         // break;
3626         // case TokenNameVariable:
3627         // getNextToken();
3628         // break;
3629         // case TokenNameIdentifier:
3630         // getNextToken();
3631         // break;
3632         // default:
3633         // throwSyntaxError("Variable or String token expected.");
3634         // break;
3635         // }
3636         // }
3637
3638         private void internal_functions_in_yacc() {
3639                 // int start = 0;
3640                 switch (token) {
3641                 // case TokenNameisset:
3642                 // // T_ISSET '(' isset_variables ')'
3643                 // getNextToken();
3644                 // if (token != TokenNameLPAREN) {
3645                 // throwSyntaxError("'(' expected after keyword 'isset'");
3646                 // }
3647                 // getNextToken();
3648                 // isset_variables();
3649                 // if (token != TokenNameRPAREN) {
3650                 // throwSyntaxError("')' expected after keyword 'isset'");
3651                 // }
3652                 // getNextToken();
3653                 // break;
3654                 // case TokenNameempty:
3655                 // // T_EMPTY '(' variable ')'
3656                 // getNextToken();
3657                 // if (token != TokenNameLPAREN) {
3658                 // throwSyntaxError("'(' expected after keyword 'empty'");
3659                 // }
3660                 // getNextToken();
3661                 // variable(false);
3662                 // if (token != TokenNameRPAREN) {
3663                 // throwSyntaxError("')' expected after keyword 'empty'");
3664                 // }
3665                 // getNextToken();
3666                 // break;
3667                 case TokenNameinclude:
3668                         // T_INCLUDE expr
3669                         checkFileName(token);
3670                         break;
3671                 case TokenNameinclude_once:
3672                         // T_INCLUDE_ONCE expr
3673                         checkFileName(token);
3674                         break;
3675                 case TokenNameeval:
3676                         // T_EVAL '(' expr ')'
3677                         getNextToken();
3678                         if (token != TokenNameLPAREN) {
3679                                 throwSyntaxError("'(' expected after keyword 'eval'");
3680                         }
3681                         getNextToken();
3682                         expr();
3683                         if (token != TokenNameRPAREN) {
3684                                 throwSyntaxError("')' expected after keyword 'eval'");
3685                         }
3686                         getNextToken();
3687                         break;
3688                 case TokenNamerequire:
3689                         // T_REQUIRE expr
3690                         checkFileName(token);
3691                         break;
3692                 case TokenNamerequire_once:
3693                         // T_REQUIRE_ONCE expr
3694                         checkFileName(token);
3695                         break;
3696                 }
3697         }
3698
3699         /**
3700          * Parse and check the include file name
3701          *
3702          * @param includeToken
3703          */
3704         private void checkFileName(int includeToken) {
3705                 // <include-token> expr
3706                 int start = scanner.getCurrentTokenStartPosition();
3707                 boolean hasLPAREN = false;
3708                 getNextToken();
3709                 if (token == TokenNameLPAREN) {
3710                         hasLPAREN = true;
3711                         getNextToken();
3712                 }
3713                 Expression expression = expr();
3714                 if (hasLPAREN) {
3715                         if (token == TokenNameRPAREN) {
3716                                 getNextToken();
3717                         } else {
3718                                 throwSyntaxError("')' expected for keyword '" + scanner.toStringAction(includeToken) + "'");
3719                         }
3720                 }
3721                 char[] currTokenSource = scanner.getCurrentTokenSource(start);
3722                 IFile file = null;
3723                 if (scanner.compilationUnit != null) {
3724                         IResource resource = scanner.compilationUnit.getResource();
3725                         if (resource != null && resource instanceof IFile) {
3726                                 file = (IFile) resource;
3727                         }
3728                 }
3729                 char[][] tokens;
3730                 tokens = new char[1][];
3731                 tokens[0] = currTokenSource;
3732
3733                 ImportReference impt = new ImportReference(tokens, currTokenSource, start, scanner.getCurrentTokenEndPosition(), false);
3734                 impt.declarationSourceEnd = impt.sourceEnd;
3735                 impt.declarationEnd = impt.declarationSourceEnd;
3736                 // endPosition is just before the ;
3737                 impt.declarationSourceStart = start;
3738                 includesList.add(impt);
3739
3740                 if (expression instanceof StringLiteral) {
3741                         StringLiteral literal = (StringLiteral) expression;
3742                         char[] includeName = literal.source();
3743                         if (includeName.length == 0) {
3744                                 reportSyntaxError("Empty filename after keyword '" + scanner.toStringAction(includeToken) + "'", literal.sourceStart,
3745                                                 literal.sourceStart + 1);
3746                         }
3747                         String includeNameString = new String(includeName);
3748                         if (literal instanceof StringLiteralDQ) {
3749                                 if (includeNameString.indexOf('$') >= 0) {
3750                                         // assuming that the filename contains a variable => no filename check
3751                                         return;
3752                                 }
3753                         }
3754                         if (includeNameString.startsWith("http://")) {
3755                                 // assuming external include location
3756                                 return;
3757                         }
3758                         if (file != null) {
3759                                 // check the filename:
3760                                 // System.out.println(new String(compilationUnit.getFileName())+" - "+
3761                                 // expression.toStringExpression());
3762                                 IProject project = file.getProject();
3763                                 if (project != null) {
3764                                         IPath path = PHPFileUtil.determineFilePath(includeNameString, file, project);
3765
3766                                         if (path == null) {
3767                                                 // SyntaxError: "File: << >> doesn't exist in project."
3768                                                 String[] args = { expression.toStringExpression(), project.getLocation().toString() };
3769                                                 problemReporter.phpIncludeNotExistWarning(args, literal.sourceStart, literal.sourceEnd, referenceContext,
3770                                                                 compilationUnit.compilationResult);
3771                                         } else {
3772                                                 try {
3773                                                         String filePath = path.toString();
3774                                                         String ext = file.getRawLocation().getFileExtension();
3775                                                         int fileExtensionLength = ext == null ? 0 : ext.length() + 1;
3776
3777                                                         impt.tokens = CharOperation.splitOn('/', filePath.toCharArray(), 0, filePath.length() - fileExtensionLength);
3778                                                         impt.setFile(PHPFileUtil.createFile(path, project));
3779                                                 } catch (Exception e) {
3780                                                         // the file is outside of the workspace
3781                                                 }
3782                                         }
3783                                 }
3784                         }
3785                 }
3786         }
3787
3788         private void isset_variables() {
3789                 // variable
3790                 // | isset_variables ','
3791                 if (token == TokenNameRPAREN) {
3792                         throwSyntaxError("Variable expected after keyword 'isset'");
3793                 }
3794                 while (true) {
3795                         variable(true, false);
3796                         if (token == TokenNameCOMMA) {
3797                                 getNextToken();
3798                         } else {
3799                                 break;
3800                         }
3801                 }
3802         }
3803
3804         private boolean common_scalar() {
3805                 // common_scalar:
3806                 // T_LNUMBER
3807                 // | T_DNUMBER
3808                 // | T_CONSTANT_ENCAPSED_STRING
3809                 // | T_LINE
3810                 // | T_FILE
3811                 // | T_CLASS_C
3812                 // | T_METHOD_C
3813                 // | T_FUNC_C
3814                 switch (token) {
3815                 case TokenNameIntegerLiteral:
3816                         getNextToken();
3817                         return true;
3818                 case TokenNameDoubleLiteral:
3819                         getNextToken();
3820                         return true;
3821                 case TokenNameStringDoubleQuote:
3822                         getNextToken();
3823                         return true;
3824                 case TokenNameStringSingleQuote:
3825                         getNextToken();
3826                         return true;
3827                 case TokenNameStringInterpolated:
3828                         getNextToken();
3829                         return true;
3830                 case TokenNameFILE:
3831                         getNextToken();
3832                         return true;
3833                 case TokenNameLINE:
3834                         getNextToken();
3835                         return true;
3836                 case TokenNameCLASS_C:
3837                         getNextToken();
3838                         return true;
3839                 case TokenNameMETHOD_C:
3840                         getNextToken();
3841                         return true;
3842                 case TokenNameFUNC_C:
3843                         getNextToken();
3844                         return true;
3845                 }
3846                 return false;
3847         }
3848
3849         private void scalar() {
3850                 // scalar:
3851                 // T_STRING
3852                 // | T_STRING_VARNAME
3853                 // | class_constant
3854                 // | common_scalar
3855                 // | '"' encaps_list '"'
3856                 // | '\'' encaps_list '\''
3857                 // | T_START_HEREDOC encaps_list T_END_HEREDOC
3858                 throwSyntaxError("Not yet implemented (scalar).");
3859         }
3860
3861         private void static_scalar() {
3862                 // static_scalar: /* compile-time evaluated scalars */
3863                 // common_scalar
3864                 // | T_STRING
3865                 // | '+' static_scalar
3866                 // | '-' static_scalar
3867                 // | T_ARRAY '(' static_array_pair_list ')'
3868                 // | static_class_constant
3869                 if (common_scalar()) {
3870                         return;
3871                 }
3872                 switch (token) {
3873                 case TokenNameIdentifier:
3874                         getNextToken();
3875                         // static_class_constant:
3876                         // T_STRING T_PAAMAYIM_NEKUDOTAYIM T_STRING
3877                         if (token == TokenNamePAAMAYIM_NEKUDOTAYIM) {
3878                                 getNextToken();
3879                                 if (token == TokenNameIdentifier) {
3880                                         getNextToken();
3881                                 } else {
3882                                         throwSyntaxError("Identifier expected after '::' operator.");
3883                                 }
3884                         }
3885                         break;
3886                 case TokenNameEncapsedString0:
3887                         try {
3888                                 scanner.currentCharacter = scanner.source[scanner.currentPosition++];
3889                                 while (scanner.currentCharacter != '`') {
3890                                         if (scanner.currentCharacter == '\\') {
3891                                                 scanner.currentPosition++;
3892                                         }
3893                                         scanner.currentCharacter = scanner.source[scanner.currentPosition++];
3894                                 }
3895                                 getNextToken();
3896                         } catch (IndexOutOfBoundsException e) {
3897                                 throwSyntaxError("'`' expected at end of static string.");
3898                         }
3899                         break;
3900                 // case TokenNameEncapsedString1:
3901                 // try {
3902                 // scanner.currentCharacter = scanner.source[scanner.currentPosition++];
3903                 // while (scanner.currentCharacter != '\'') {
3904                 // if (scanner.currentCharacter == '\\') {
3905                 // scanner.currentPosition++;
3906                 // }
3907                 // scanner.currentCharacter = scanner.source[scanner.currentPosition++];
3908                 // }
3909                 // getNextToken();
3910                 // } catch (IndexOutOfBoundsException e) {
3911                 // throwSyntaxError("'\'' expected at end of static string.");
3912                 // }
3913                 // break;
3914                 // case TokenNameEncapsedString2:
3915                 // try {
3916                 // scanner.currentCharacter = scanner.source[scanner.currentPosition++];
3917                 // while (scanner.currentCharacter != '"') {
3918                 // if (scanner.currentCharacter == '\\') {
3919                 // scanner.currentPosition++;
3920                 // }
3921                 // scanner.currentCharacter = scanner.source[scanner.currentPosition++];
3922                 // }
3923                 // getNextToken();
3924                 // } catch (IndexOutOfBoundsException e) {
3925                 // throwSyntaxError("'\"' expected at end of static string.");
3926                 // }
3927                 // break;
3928                 case TokenNameStringSingleQuote:
3929                         getNextToken();
3930                         break;
3931                 case TokenNameStringDoubleQuote:
3932                         getNextToken();
3933                         break;
3934                 case TokenNamePLUS:
3935                         getNextToken();
3936                         static_scalar();
3937                         break;
3938                 case TokenNameMINUS:
3939                         getNextToken();
3940                         static_scalar();
3941                         break;
3942                 case TokenNamearray:
3943                         getNextToken();
3944                         if (token != TokenNameLPAREN) {
3945                                 throwSyntaxError("'(' expected after keyword 'array'");
3946                         }
3947                         getNextToken();
3948                         if (token == TokenNameRPAREN) {
3949                                 getNextToken();
3950                                 break;
3951                         }
3952                         non_empty_static_array_pair_list();
3953                         if (token != TokenNameRPAREN) {
3954                                 throwSyntaxError("')' or ',' expected after keyword 'array'");
3955                         }
3956                         getNextToken();
3957                         break;
3958                 // case TokenNamenull :
3959                 // getNextToken();
3960                 // break;
3961                 // case TokenNamefalse :
3962                 // getNextToken();
3963                 // break;
3964                 // case TokenNametrue :
3965                 // getNextToken();
3966                 // break;
3967                 default:
3968                         throwSyntaxError("Static scalar/constant expected.");
3969                 }
3970         }
3971
3972         private void non_empty_static_array_pair_list() {
3973                 // non_empty_static_array_pair_list:
3974                 // non_empty_static_array_pair_list ',' static_scalar T_DOUBLE_ARROW
3975                 // static_scalar
3976                 // | non_empty_static_array_pair_list ',' static_scalar
3977                 // | static_scalar T_DOUBLE_ARROW static_scalar
3978                 // | static_scalar
3979                 while (true) {
3980                         static_scalar();
3981                         if (token == TokenNameEQUAL_GREATER) {
3982                                 getNextToken();
3983                                 static_scalar();
3984                         }
3985                         if (token != TokenNameCOMMA) {
3986                                 break;
3987                         }
3988                         getNextToken();
3989                         if (token == TokenNameRPAREN) {
3990                                 break;
3991                         }
3992                 }
3993         }
3994
3995         // public void reportSyntaxError() { //int act, int currentKind, int
3996         // // stateStackTop) {
3997         // /* remember current scanner position */
3998         // int startPos = scanner.startPosition;
3999         // int currentPos = scanner.currentPosition;
4000         //
4001         // this.checkAndReportBracketAnomalies(problemReporter());
4002         // /* reset scanner where it was */
4003         // scanner.startPosition = startPos;
4004         // scanner.currentPosition = currentPos;
4005         // }
4006
4007         public static final int RoundBracket = 0;
4008
4009         public static final int SquareBracket = 1;
4010
4011         public static final int CurlyBracket = 2;
4012
4013         public static final int BracketKinds = 3;
4014
4015         protected int[] nestedMethod; // the ptr is nestedType
4016
4017         protected int nestedType, dimensions;
4018
4019         // variable set stack
4020         final static int VariableStackIncrement = 10;
4021
4022         HashMap fTypeVariables = null;
4023
4024         HashMap fMethodVariables = null;
4025
4026         ArrayList fStackUnassigned = new ArrayList();
4027
4028         // ast stack
4029         final static int AstStackIncrement = 100;
4030
4031         protected int astPtr;
4032
4033         protected ASTNode[] astStack = new ASTNode[AstStackIncrement];
4034
4035         protected int astLengthPtr;
4036
4037         protected int[] astLengthStack;
4038
4039         ASTNode[] noAstNodes = new ASTNode[AstStackIncrement];
4040
4041         public CompilationUnitDeclaration compilationUnit; /*
4042                                                                                                                                                                                                                          * the result from parse()
4043                                                                                                                                                                                                                          */
4044
4045         protected ReferenceContext referenceContext;
4046
4047         protected ProblemReporter problemReporter;
4048
4049         protected CompilerOptions options;
4050
4051         private ArrayList includesList;
4052
4053         // protected CompilationResult compilationResult;
4054         /**
4055          * Returns this parser's problem reporter initialized with its reference
4056          * context. Also it is assumed that a problem is going to be reported, so
4057          * initializes the compilation result's line positions.
4058          */
4059         public ProblemReporter problemReporter() {
4060                 if (scanner.recordLineSeparator) {
4061                         compilationUnit.compilationResult.lineSeparatorPositions = scanner.getLineEnds();
4062                 }
4063                 problemReporter.referenceContext = referenceContext;
4064                 return problemReporter;
4065         }
4066
4067         /*
4068          * Reconsider the entire source looking for inconsistencies in {} () []
4069          */
4070         // public boolean checkAndReportBracketAnomalies(ProblemReporter
4071         // problemReporter) {
4072         // scanner.wasAcr = false;
4073         // boolean anomaliesDetected = false;
4074         // try {
4075         // char[] source = scanner.source;
4076         // int[] leftCount = { 0, 0, 0 };
4077         // int[] rightCount = { 0, 0, 0 };
4078         // int[] depths = { 0, 0, 0 };
4079         // int[][] leftPositions = new int[][] { new int[10], new int[10], new int[10]
4080         // };
4081         // int[][] leftDepths = new int[][] { new int[10], new int[10], new int[10] };
4082         // int[][] rightPositions = new int[][] { new int[10], new int[10], new
4083         // int[10] };
4084         // int[][] rightDepths = new int[][] { new int[10], new int[10], new int[10]
4085         // };
4086         // scanner.currentPosition = scanner.initialPosition; //starting
4087         // // point
4088         // // (first-zero-based
4089         // // char)
4090         // while (scanner.currentPosition < scanner.eofPosition) { //loop for
4091         // // jumping
4092         // // over
4093         // // comments
4094         // try {
4095         // // ---------Consume white space and handles
4096         // // startPosition---------
4097         // boolean isWhiteSpace;
4098         // do {
4099         // scanner.startPosition = scanner.currentPosition;
4100         // // if (((scanner.currentCharacter =
4101         // // source[scanner.currentPosition++]) == '\\') &&
4102         // // (source[scanner.currentPosition] == 'u')) {
4103         // // isWhiteSpace = scanner.jumpOverUnicodeWhiteSpace();
4104         // // } else {
4105         // if (scanner.recordLineSeparator && ((scanner.currentCharacter == '\r') ||
4106         // (scanner.currentCharacter == '\n'))) {
4107         // if (scanner.lineEnds[scanner.linePtr] < scanner.startPosition) {
4108         // // only record line positions we have not
4109         // // recorded yet
4110         // scanner.pushLineSeparator();
4111         // }
4112         // }
4113         // isWhiteSpace = CharOperation.isWhitespace(scanner.currentCharacter);
4114         // // }
4115         // } while (isWhiteSpace && (scanner.currentPosition < scanner.eofPosition));
4116         // // -------consume token until } is found---------
4117         // switch (scanner.currentCharacter) {
4118         // case '{': {
4119         // int index = leftCount[CurlyBracket]++;
4120         // if (index == leftPositions[CurlyBracket].length) {
4121         // System.arraycopy(leftPositions[CurlyBracket], 0,
4122         // (leftPositions[CurlyBracket] = new int[index * 2]), 0, index);
4123         // System.arraycopy(leftDepths[CurlyBracket], 0, (leftDepths[CurlyBracket] =
4124         // new int[index * 2]), 0, index);
4125         // }
4126         // leftPositions[CurlyBracket][index] = scanner.startPosition;
4127         // leftDepths[CurlyBracket][index] = depths[CurlyBracket]++;
4128         // }
4129         // break;
4130         // case '}': {
4131         // int index = rightCount[CurlyBracket]++;
4132         // if (index == rightPositions[CurlyBracket].length) {
4133         // System.arraycopy(rightPositions[CurlyBracket], 0,
4134         // (rightPositions[CurlyBracket] = new int[index * 2]), 0, index);
4135         // System.arraycopy(rightDepths[CurlyBracket], 0, (rightDepths[CurlyBracket] =
4136         // new int[index * 2]), 0, index);
4137         // }
4138         // rightPositions[CurlyBracket][index] = scanner.startPosition;
4139         // rightDepths[CurlyBracket][index] = --depths[CurlyBracket];
4140         // }
4141         // break;
4142         // case '(': {
4143         // int index = leftCount[RoundBracket]++;
4144         // if (index == leftPositions[RoundBracket].length) {
4145         // System.arraycopy(leftPositions[RoundBracket], 0,
4146         // (leftPositions[RoundBracket] = new int[index * 2]), 0, index);
4147         // System.arraycopy(leftDepths[RoundBracket], 0, (leftDepths[RoundBracket] =
4148         // new int[index * 2]), 0, index);
4149         // }
4150         // leftPositions[RoundBracket][index] = scanner.startPosition;
4151         // leftDepths[RoundBracket][index] = depths[RoundBracket]++;
4152         // }
4153         // break;
4154         // case ')': {
4155         // int index = rightCount[RoundBracket]++;
4156         // if (index == rightPositions[RoundBracket].length) {
4157         // System.arraycopy(rightPositions[RoundBracket], 0,
4158         // (rightPositions[RoundBracket] = new int[index * 2]), 0, index);
4159         // System.arraycopy(rightDepths[RoundBracket], 0, (rightDepths[RoundBracket] =
4160         // new int[index * 2]), 0, index);
4161         // }
4162         // rightPositions[RoundBracket][index] = scanner.startPosition;
4163         // rightDepths[RoundBracket][index] = --depths[RoundBracket];
4164         // }
4165         // break;
4166         // case '[': {
4167         // int index = leftCount[SquareBracket]++;
4168         // if (index == leftPositions[SquareBracket].length) {
4169         // System.arraycopy(leftPositions[SquareBracket], 0,
4170         // (leftPositions[SquareBracket] = new int[index * 2]), 0, index);
4171         // System.arraycopy(leftDepths[SquareBracket], 0, (leftDepths[SquareBracket] =
4172         // new int[index * 2]), 0, index);
4173         // }
4174         // leftPositions[SquareBracket][index] = scanner.startPosition;
4175         // leftDepths[SquareBracket][index] = depths[SquareBracket]++;
4176         // }
4177         // break;
4178         // case ']': {
4179         // int index = rightCount[SquareBracket]++;
4180         // if (index == rightPositions[SquareBracket].length) {
4181         // System.arraycopy(rightPositions[SquareBracket], 0,
4182         // (rightPositions[SquareBracket] = new int[index * 2]), 0, index);
4183         // System.arraycopy(rightDepths[SquareBracket], 0, (rightDepths[SquareBracket]
4184         // = new int[index * 2]), 0, index);
4185         // }
4186         // rightPositions[SquareBracket][index] = scanner.startPosition;
4187         // rightDepths[SquareBracket][index] = --depths[SquareBracket];
4188         // }
4189         // break;
4190         // case '\'': {
4191         // if (scanner.getNextChar('\\')) {
4192         // scanner.scanEscapeCharacter();
4193         // } else { // consume next character
4194         // scanner.unicodeAsBackSlash = false;
4195         // // if (((scanner.currentCharacter =
4196         // // source[scanner.currentPosition++]) ==
4197         // // '\\') &&
4198         // // (source[scanner.currentPosition] ==
4199         // // 'u')) {
4200         // // scanner.getNextUnicodeChar();
4201         // // } else {
4202         // if (scanner.withoutUnicodePtr != 0) {
4203         // scanner.withoutUnicodeBuffer[++scanner.withoutUnicodePtr] =
4204         // scanner.currentCharacter;
4205         // }
4206         // // }
4207         // }
4208         // scanner.getNextChar('\'');
4209         // break;
4210         // }
4211         // case '"':
4212         // // consume next character
4213         // scanner.unicodeAsBackSlash = false;
4214         // // if (((scanner.currentCharacter =
4215         // // source[scanner.currentPosition++]) == '\\') &&
4216         // // (source[scanner.currentPosition] == 'u')) {
4217         // // scanner.getNextUnicodeChar();
4218         // // } else {
4219         // if (scanner.withoutUnicodePtr != 0) {
4220         // scanner.withoutUnicodeBuffer[++scanner.withoutUnicodePtr] =
4221         // scanner.currentCharacter;
4222         // }
4223         // // }
4224         // while (scanner.currentCharacter != '"') {
4225         // if (scanner.currentCharacter == '\r') {
4226         // if (source[scanner.currentPosition] == '\n')
4227         // scanner.currentPosition++;
4228         // break; // the string cannot go further that
4229         // // the line
4230         // }
4231         // if (scanner.currentCharacter == '\n') {
4232         // break; // the string cannot go further that
4233         // // the line
4234         // }
4235         // if (scanner.currentCharacter == '\\') {
4236         // scanner.scanEscapeCharacter();
4237         // }
4238         // // consume next character
4239         // scanner.unicodeAsBackSlash = false;
4240         // // if (((scanner.currentCharacter =
4241         // // source[scanner.currentPosition++]) == '\\')
4242         // // && (source[scanner.currentPosition] == 'u'))
4243         // // {
4244         // // scanner.getNextUnicodeChar();
4245         // // } else {
4246         // if (scanner.withoutUnicodePtr != 0) {
4247         // scanner.withoutUnicodeBuffer[++scanner.withoutUnicodePtr] =
4248         // scanner.currentCharacter;
4249         // }
4250         // // }
4251         // }
4252         // break;
4253         // case '/': {
4254         // int test;
4255         // if ((test = scanner.getNextChar('/', '*')) == 0) { //line
4256         // // comment
4257         // //get the next char
4258         // if (((scanner.currentCharacter = source[scanner.currentPosition++]) ==
4259         // '\\')
4260         // && (source[scanner.currentPosition] == 'u')) {
4261         // //-------------unicode traitement
4262         // // ------------
4263         // int c1 = 0, c2 = 0, c3 = 0, c4 = 0;
4264         // scanner.currentPosition++;
4265         // while (source[scanner.currentPosition] == 'u') {
4266         // scanner.currentPosition++;
4267         // }
4268         // if ((c1 = Character.getNumericValue(source[scanner.currentPosition++])) >
4269         // 15 || c1 < 0
4270         // || (c2 = Character.getNumericValue(source[scanner.currentPosition++])) > 15
4271         // || c2 < 0
4272         // || (c3 = Character.getNumericValue(source[scanner.currentPosition++])) > 15
4273         // || c3 < 0
4274         // || (c4 = Character.getNumericValue(source[scanner.currentPosition++])) > 15
4275         // || c4 < 0) { //error
4276         // // don't
4277         // // care of the
4278         // // value
4279         // scanner.currentCharacter = 'A';
4280         // } //something different from \n and \r
4281         // else {
4282         // scanner.currentCharacter = (char) (((c1 * 16 + c2) * 16 + c3) * 16 + c4);
4283         // }
4284         // }
4285         // while (scanner.currentCharacter != '\r' && scanner.currentCharacter !=
4286         // '\n') {
4287         // //get the next char
4288         // scanner.startPosition = scanner.currentPosition;
4289         // if (((scanner.currentCharacter = source[scanner.currentPosition++]) ==
4290         // '\\')
4291         // && (source[scanner.currentPosition] == 'u')) {
4292         // //-------------unicode traitement
4293         // // ------------
4294         // int c1 = 0, c2 = 0, c3 = 0, c4 = 0;
4295         // scanner.currentPosition++;
4296         // while (source[scanner.currentPosition] == 'u') {
4297         // scanner.currentPosition++;
4298         // }
4299         // if ((c1 = Character.getNumericValue(source[scanner.currentPosition++])) >
4300         // 15 || c1 < 0
4301         // || (c2 = Character.getNumericValue(source[scanner.currentPosition++])) > 15
4302         // || c2 < 0
4303         // || (c3 = Character.getNumericValue(source[scanner.currentPosition++])) > 15
4304         // || c3 < 0
4305         // || (c4 = Character.getNumericValue(source[scanner.currentPosition++])) > 15
4306         // || c4 < 0) { //error
4307         // // don't
4308         // // care of the
4309         // // value
4310         // scanner.currentCharacter = 'A';
4311         // } //something different from \n
4312         // // and \r
4313         // else {
4314         // scanner.currentCharacter = (char) (((c1 * 16 + c2) * 16 + c3) * 16 + c4);
4315         // }
4316         // }
4317         // }
4318         // if (scanner.recordLineSeparator && ((scanner.currentCharacter == '\r') ||
4319         // (scanner.currentCharacter == '\n'))) {
4320         // if (scanner.lineEnds[scanner.linePtr] < scanner.startPosition) {
4321         // // only record line positions we
4322         // // have not recorded yet
4323         // scanner.pushLineSeparator();
4324         // if (this.scanner.taskTags != null) {
4325         // this.scanner.checkTaskTag(this.scanner.getCurrentTokenStartPosition(),
4326         // this.scanner
4327         // .getCurrentTokenEndPosition());
4328         // }
4329         // }
4330         // }
4331         // break;
4332         // }
4333         // if (test > 0) { //traditional and annotation
4334         // // comment
4335         // boolean star = false;
4336         // // consume next character
4337         // scanner.unicodeAsBackSlash = false;
4338         // // if (((scanner.currentCharacter =
4339         // // source[scanner.currentPosition++]) ==
4340         // // '\\') &&
4341         // // (source[scanner.currentPosition] ==
4342         // // 'u')) {
4343         // // scanner.getNextUnicodeChar();
4344         // // } else {
4345         // if (scanner.withoutUnicodePtr != 0) {
4346         // scanner.withoutUnicodeBuffer[++scanner.withoutUnicodePtr] =
4347         // scanner.currentCharacter;
4348         // }
4349         // // }
4350         // if (scanner.currentCharacter == '*') {
4351         // star = true;
4352         // }
4353         // //get the next char
4354         // if (((scanner.currentCharacter = source[scanner.currentPosition++]) ==
4355         // '\\')
4356         // && (source[scanner.currentPosition] == 'u')) {
4357         // //-------------unicode traitement
4358         // // ------------
4359         // int c1 = 0, c2 = 0, c3 = 0, c4 = 0;
4360         // scanner.currentPosition++;
4361         // while (source[scanner.currentPosition] == 'u') {
4362         // scanner.currentPosition++;
4363         // }
4364         // if ((c1 = Character.getNumericValue(source[scanner.currentPosition++])) >
4365         // 15 || c1 < 0
4366         // || (c2 = Character.getNumericValue(source[scanner.currentPosition++])) > 15
4367         // || c2 < 0
4368         // || (c3 = Character.getNumericValue(source[scanner.currentPosition++])) > 15
4369         // || c3 < 0
4370         // || (c4 = Character.getNumericValue(source[scanner.currentPosition++])) > 15
4371         // || c4 < 0) { //error
4372         // // don't
4373         // // care of the
4374         // // value
4375         // scanner.currentCharacter = 'A';
4376         // } //something different from * and /
4377         // else {
4378         // scanner.currentCharacter = (char) (((c1 * 16 + c2) * 16 + c3) * 16 + c4);
4379         // }
4380         // }
4381         // //loop until end of comment */
4382         // while ((scanner.currentCharacter != '/') || (!star)) {
4383         // star = scanner.currentCharacter == '*';
4384         // //get next char
4385         // if (((scanner.currentCharacter = source[scanner.currentPosition++]) ==
4386         // '\\')
4387         // && (source[scanner.currentPosition] == 'u')) {
4388         // //-------------unicode traitement
4389         // // ------------
4390         // int c1 = 0, c2 = 0, c3 = 0, c4 = 0;
4391         // scanner.currentPosition++;
4392         // while (source[scanner.currentPosition] == 'u') {
4393         // scanner.currentPosition++;
4394         // }
4395         // if ((c1 = Character.getNumericValue(source[scanner.currentPosition++])) >
4396         // 15 || c1 < 0
4397         // || (c2 = Character.getNumericValue(source[scanner.currentPosition++])) > 15
4398         // || c2 < 0
4399         // || (c3 = Character.getNumericValue(source[scanner.currentPosition++])) > 15
4400         // || c3 < 0
4401         // || (c4 = Character.getNumericValue(source[scanner.currentPosition++])) > 15
4402         // || c4 < 0) { //error
4403         // // don't
4404         // // care of the
4405         // // value
4406         // scanner.currentCharacter = 'A';
4407         // } //something different from * and
4408         // // /
4409         // else {
4410         // scanner.currentCharacter = (char) (((c1 * 16 + c2) * 16 + c3) * 16 + c4);
4411         // }
4412         // }
4413         // }
4414         // if (this.scanner.taskTags != null) {
4415         // this.scanner.checkTaskTag(this.scanner.getCurrentTokenStartPosition(),
4416         // this.scanner.getCurrentTokenEndPosition());
4417         // }
4418         // break;
4419         // }
4420         // break;
4421         // }
4422         // default:
4423         // if (Scanner.isPHPIdentifierStart(scanner.currentCharacter)) {
4424         // scanner.scanIdentifierOrKeyword(false);
4425         // break;
4426         // }
4427         // if (Character.isDigit(scanner.currentCharacter)) {
4428         // scanner.scanNumber(false);
4429         // break;
4430         // }
4431         // }
4432         // //-----------------end switch while
4433         // // try--------------------
4434         // } catch (IndexOutOfBoundsException e) {
4435         // break; // read until EOF
4436         // } catch (InvalidInputException e) {
4437         // return false; // no clue
4438         // }
4439         // }
4440         // if (scanner.recordLineSeparator) {
4441         // compilationUnit.compilationResult.lineSeparatorPositions =
4442         // scanner.getLineEnds();
4443         // }
4444         // // check placement anomalies against other kinds of brackets
4445         // for (int kind = 0; kind < BracketKinds; kind++) {
4446         // for (int leftIndex = leftCount[kind] - 1; leftIndex >= 0; leftIndex--) {
4447         // int start = leftPositions[kind][leftIndex]; // deepest
4448         // // first
4449         // // find matching closing bracket
4450         // int depth = leftDepths[kind][leftIndex];
4451         // int end = -1;
4452         // for (int i = 0; i < rightCount[kind]; i++) {
4453         // int pos = rightPositions[kind][i];
4454         // // want matching bracket further in source with same
4455         // // depth
4456         // if ((pos > start) && (depth == rightDepths[kind][i])) {
4457         // end = pos;
4458         // break;
4459         // }
4460         // }
4461         // if (end < 0) { // did not find a good closing match
4462         // problemReporter.unmatchedBracket(start, referenceContext,
4463         // compilationUnit.compilationResult);
4464         // return true;
4465         // }
4466         // // check if even number of opening/closing other brackets
4467         // // in between this pair of brackets
4468         // int balance = 0;
4469         // for (int otherKind = 0; (balance == 0) && (otherKind < BracketKinds);
4470         // otherKind++) {
4471         // for (int i = 0; i < leftCount[otherKind]; i++) {
4472         // int pos = leftPositions[otherKind][i];
4473         // if ((pos > start) && (pos < end))
4474         // balance++;
4475         // }
4476         // for (int i = 0; i < rightCount[otherKind]; i++) {
4477         // int pos = rightPositions[otherKind][i];
4478         // if ((pos > start) && (pos < end))
4479         // balance--;
4480         // }
4481         // if (balance != 0) {
4482         // problemReporter.unmatchedBracket(start, referenceContext,
4483         // compilationUnit.compilationResult); //bracket
4484         // // anomaly
4485         // return true;
4486         // }
4487         // }
4488         // }
4489         // // too many opening brackets ?
4490         // for (int i = rightCount[kind]; i < leftCount[kind]; i++) {
4491         // anomaliesDetected = true;
4492         // problemReporter.unmatchedBracket(leftPositions[kind][leftCount[kind] - i -
4493         // 1], referenceContext,
4494         // compilationUnit.compilationResult);
4495         // }
4496         // // too many closing brackets ?
4497         // for (int i = leftCount[kind]; i < rightCount[kind]; i++) {
4498         // anomaliesDetected = true;
4499         // problemReporter.unmatchedBracket(rightPositions[kind][i], referenceContext,
4500         // compilationUnit.compilationResult);
4501         // }
4502         // if (anomaliesDetected)
4503         // return true;
4504         // }
4505         // return anomaliesDetected;
4506         // } catch (ArrayStoreException e) { // jdk1.2.2 jit bug
4507         // return anomaliesDetected;
4508         // } catch (NullPointerException e) { // jdk1.2.2 jit bug
4509         // return anomaliesDetected;
4510         // }
4511         // }
4512         protected void pushOnAstLengthStack(int pos) {
4513                 try {
4514                         astLengthStack[++astLengthPtr] = pos;
4515                 } catch (IndexOutOfBoundsException e) {
4516                         int oldStackLength = astLengthStack.length;
4517                         int[] oldPos = astLengthStack;
4518                         astLengthStack = new int[oldStackLength + StackIncrement];
4519                         System.arraycopy(oldPos, 0, astLengthStack, 0, oldStackLength);
4520                         astLengthStack[astLengthPtr] = pos;
4521                 }
4522         }
4523
4524         protected void pushOnAstStack(ASTNode node) {
4525                 /*
4526                  * add a new obj on top of the ast stack
4527                  */
4528                 try {
4529                         astStack[++astPtr] = node;
4530                 } catch (IndexOutOfBoundsException e) {
4531                         int oldStackLength = astStack.length;
4532                         ASTNode[] oldStack = astStack;
4533                         astStack = new ASTNode[oldStackLength + AstStackIncrement];
4534                         System.arraycopy(oldStack, 0, astStack, 0, oldStackLength);
4535                         astPtr = oldStackLength;
4536                         astStack[astPtr] = node;
4537                 }
4538                 try {
4539                         astLengthStack[++astLengthPtr] = 1;
4540                 } catch (IndexOutOfBoundsException e) {
4541                         int oldStackLength = astLengthStack.length;
4542                         int[] oldPos = astLengthStack;
4543                         astLengthStack = new int[oldStackLength + AstStackIncrement];
4544                         System.arraycopy(oldPos, 0, astLengthStack, 0, oldStackLength);
4545                         astLengthStack[astLengthPtr] = 1;
4546                 }
4547         }
4548
4549         protected void resetModifiers() {
4550                 this.modifiers = AccDefault;
4551                 this.modifiersSourceStart = -1; // <-- see comment into
4552                 // modifiersFlag(int)
4553                 this.scanner.commentPtr = -1;
4554         }
4555
4556         protected void consumePackageDeclarationName(IFile file) {
4557                 // create a package name similar to java package names
4558                 String projectPath = ProjectPrefUtil.getDocumentRoot(file.getProject()).toString();
4559                 String filePath = file.getRawLocation().toString();
4560                 String ext = file.getRawLocation().getFileExtension();
4561                 int fileExtensionLength = ext == null ? 0 : ext.length() + 1;
4562                 ImportReference impt;
4563                 char[][] tokens;
4564                 if (filePath.startsWith(projectPath)) {
4565                         tokens = CharOperation
4566                                         .splitOn('/', filePath.toCharArray(), projectPath.length() + 1, filePath.length() - fileExtensionLength);
4567                 } else {
4568                         String name = file.getName();
4569                         tokens = new char[1][];
4570                         tokens[0] = name.substring(0, name.length() - fileExtensionLength).toCharArray();
4571                 }
4572
4573                 this.compilationUnit.currentPackage = impt = new ImportReference(tokens, new char[0], 0, 0, true);
4574
4575                 impt.declarationSourceStart = 0;
4576                 impt.declarationSourceEnd = 0;
4577                 impt.declarationEnd = 0;
4578                 // endPosition is just before the ;
4579
4580         }
4581
4582         public final static String[] GLOBALS = { "$this", "$_COOKIE", "$_ENV", "$_FILES", "$_GET", "$GLOBALS", "$_POST", "$_REQUEST",
4583                         "$_SESSION", "$_SERVER" };
4584
4585         /**
4586          *
4587          */
4588         private void pushFunctionVariableSet() {
4589                 HashSet set = new HashSet();
4590                 if (fStackUnassigned.isEmpty()) {
4591                         for (int i = 0; i < GLOBALS.length; i++) {
4592                                 set.add(GLOBALS[i]);
4593                         }
4594                 }
4595                 fStackUnassigned.add(set);
4596         }
4597
4598         private void pushIfVariableSet() {
4599                 if (!fStackUnassigned.isEmpty()) {
4600                         HashSet set = new HashSet();
4601                         fStackUnassigned.add(set);
4602                 }
4603         }
4604
4605         private HashSet removeIfVariableSet() {
4606                 if (!fStackUnassigned.isEmpty()) {
4607                         return (HashSet) fStackUnassigned.remove(fStackUnassigned.size() - 1);
4608                 }
4609                 return null;
4610         }
4611
4612         /**
4613          * Returns the <i>set of assigned variables </i> returns null if no Set is
4614          * defined at the current scanner position
4615          */
4616         private HashSet peekVariableSet() {
4617                 if (!fStackUnassigned.isEmpty()) {
4618                         return (HashSet) fStackUnassigned.get(fStackUnassigned.size() - 1);
4619                 }
4620                 return null;
4621         }
4622
4623         /**
4624          * add the current identifier source to the <i>set of assigned variables </i>
4625          *
4626          * @param set
4627          */
4628         private void addVariableSet(HashSet set) {
4629                 if (set != null) {
4630                         set.add(new String(scanner.getCurrentTokenSource()));
4631                 }
4632         }
4633
4634         /**
4635          * add the current identifier source to the <i>set of assigned variables </i>
4636          *
4637          */
4638         private void addVariableSet() {
4639                 HashSet set = peekVariableSet();
4640                 if (set != null) {
4641                         set.add(new String(scanner.getCurrentTokenSource()));
4642                 }
4643         }
4644
4645         /**
4646          * add the current identifier source to the <i>set of assigned variables </i>
4647          *
4648          */
4649         private void addVariableSet(char[] token) {
4650                 HashSet set = peekVariableSet();
4651                 if (set != null) {
4652                         set.add(new String(token));
4653                 }
4654         }
4655
4656         /**
4657          * check if the current identifier source is in the <i>set of assigned
4658          * variables </i> Returns true, if no set is defined for the current scanner
4659          * position
4660          *
4661          */
4662         private boolean containsVariableSet() {
4663                 return containsVariableSet(scanner.getCurrentTokenSource());
4664         }
4665
4666         private boolean containsVariableSet(char[] token) {
4667
4668                 if (!fStackUnassigned.isEmpty()) {
4669                         HashSet set;
4670                         String str = new String(token);
4671                         for (int i = 0; i < fStackUnassigned.size(); i++) {
4672                                 set = (HashSet) fStackUnassigned.get(i);
4673                                 if (set.contains(str)) {
4674                                         return true;
4675                                 }
4676                         }
4677                         return false;
4678                 }
4679                 return true;
4680         }
4681 }