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