1) Added missing strings for italic, underline and strike through.
[phpeclipse.git] / net.sourceforge.phpeclipse / src / net / sourceforge / phpdt / internal / compiler / parser / Parser.java
index d2b5e96..cef140f 100644 (file)
@@ -1,17 +1,47 @@
-/*******************************************************************************
- * Copyright (c) 2002 Klaus Hartlage - www.eclipseproject.de All rights
- * reserved. This program and the accompanying material are made available under
- * the terms of the Common Public License v1.0 which accompanies this
- * distribution, and is available at http://www.eclipse.org/legal/cpl-v10.html
- * 
- * Contributors: Klaus Hartlage - www.eclipseproject.de
- ******************************************************************************/
+/***********************************************************************************************************************************
+ * Copyright (c) 2002 www.phpeclipse.de All rights reserved. This program and the accompanying material are made available under the
+ * terms of the Common Public License v1.0 which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/cpl-v10.html
+ *
+ * Contributors: www.phpeclipse.de
+ **********************************************************************************************************************************/
 package net.sourceforge.phpdt.internal.compiler.parser;
+
 import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.HashSet;
 
 import net.sourceforge.phpdt.core.compiler.CharOperation;
 import net.sourceforge.phpdt.core.compiler.ITerminalSymbols;
 import net.sourceforge.phpdt.core.compiler.InvalidInputException;
+import net.sourceforge.phpdt.core.compiler.ITerminalSymbols.TokenName;
+import net.sourceforge.phpdt.internal.compiler.ast.AND_AND_Expression;
+import net.sourceforge.phpdt.internal.compiler.ast.ASTNode;
+import net.sourceforge.phpdt.internal.compiler.ast.AbstractMethodDeclaration;
+import net.sourceforge.phpdt.internal.compiler.ast.BinaryExpression;
+import net.sourceforge.phpdt.internal.compiler.ast.Block;
+import net.sourceforge.phpdt.internal.compiler.ast.BreakStatement;
+import net.sourceforge.phpdt.internal.compiler.ast.CompilationUnitDeclaration;
+import net.sourceforge.phpdt.internal.compiler.ast.ConditionalExpression;
+import net.sourceforge.phpdt.internal.compiler.ast.ContinueStatement;
+import net.sourceforge.phpdt.internal.compiler.ast.EqualExpression;
+import net.sourceforge.phpdt.internal.compiler.ast.Expression;
+import net.sourceforge.phpdt.internal.compiler.ast.FieldDeclaration;
+import net.sourceforge.phpdt.internal.compiler.ast.FieldReference;
+import net.sourceforge.phpdt.internal.compiler.ast.IfStatement;
+import net.sourceforge.phpdt.internal.compiler.ast.ImportReference;
+import net.sourceforge.phpdt.internal.compiler.ast.InstanceOfExpression;
+import net.sourceforge.phpdt.internal.compiler.ast.MethodDeclaration;
+import net.sourceforge.phpdt.internal.compiler.ast.OR_OR_Expression;
+import net.sourceforge.phpdt.internal.compiler.ast.OperatorIds;
+import net.sourceforge.phpdt.internal.compiler.ast.ReturnStatement;
+import net.sourceforge.phpdt.internal.compiler.ast.SingleTypeReference;
+import net.sourceforge.phpdt.internal.compiler.ast.Statement;
+import net.sourceforge.phpdt.internal.compiler.ast.StringLiteral;
+import net.sourceforge.phpdt.internal.compiler.ast.StringLiteralDQ;
+import net.sourceforge.phpdt.internal.compiler.ast.StringLiteralSQ;
+import net.sourceforge.phpdt.internal.compiler.ast.TypeDeclaration;
+import net.sourceforge.phpdt.internal.compiler.ast.TypeReference;
 import net.sourceforge.phpdt.internal.compiler.impl.CompilerOptions;
 import net.sourceforge.phpdt.internal.compiler.impl.ReferenceContext;
 import net.sourceforge.phpdt.internal.compiler.lookup.CompilerModifiers;
@@ -19,126 +49,105 @@ import net.sourceforge.phpdt.internal.compiler.lookup.TypeConstants;
 import net.sourceforge.phpdt.internal.compiler.problem.ProblemReporter;
 import net.sourceforge.phpdt.internal.compiler.problem.ProblemSeverities;
 import net.sourceforge.phpdt.internal.compiler.util.Util;
-import net.sourceforge.phpeclipse.internal.compiler.ast.AbstractMethodDeclaration;
-import net.sourceforge.phpeclipse.internal.compiler.ast.AstNode;
-import net.sourceforge.phpeclipse.internal.compiler.ast.CompilationUnitDeclaration;
-import net.sourceforge.phpeclipse.internal.compiler.ast.FieldDeclaration;
-import net.sourceforge.phpeclipse.internal.compiler.ast.ImportReference;
-import net.sourceforge.phpeclipse.internal.compiler.ast.MethodDeclaration;
-import net.sourceforge.phpeclipse.internal.compiler.ast.SingleTypeReference;
-import net.sourceforge.phpeclipse.internal.compiler.ast.TypeDeclaration;
+import net.sourceforge.phpdt.internal.core.util.PHPFileUtil;
+import net.sourceforge.phpeclipse.builder.IdentifierIndexManager;
+//import net.sourceforge.phpeclipse.ui.overlaypages.ProjectPrefUtil;
 
 import org.eclipse.core.resources.IFile;
-public class Parser //extends PHPParserSuperclass
-               implements ITerminalSymbols, CompilerModifiers, ParserBasicInformation {
-       //internal data for the automat
+import org.eclipse.core.resources.IProject;
+import org.eclipse.core.resources.IResource;
+import org.eclipse.core.runtime.IPath;
+
+public class Parser implements ITerminalSymbols, CompilerModifiers,
+               ParserBasicInformation {
        protected final static int StackIncrement = 255;
+
        protected int stateStackTop;
-       protected int[] stack = new int[StackIncrement];
-       public int firstToken; // handle for multiple parsing goals
-       public int lastAct; //handle for multiple parsing goals
-       protected RecoveredElement currentElement;
+
+       // protected int[] stack = new int[StackIncrement];
+
+       public TokenName firstToken; // handle for multiple parsing goals
+
+       public int lastAct; // handle for multiple parsing goals
+
+       // protected RecoveredElement currentElement;
+
        public static boolean VERBOSE_RECOVERY = false;
-       protected boolean diet = false; //tells the scanner to jump over some
-       // parts of the code/expressions like
-       // method bodies
-       //scanner token
+
+       protected boolean diet = false; // tells the scanner to jump over some
+
+       /**
+        * the PHP token scanner
+        */
        public Scanner scanner;
-       private ArrayList phpList;
-       private int currentPHPString;
-       private boolean phpEnd;
-       // private static HashMap keywordMap = null;
-       private String str;
-       // current character
-       //  char ch;
-       // current token
-       int token;
-       // row counter for syntax errors:
-       //int rowCount;
-       // column counter for syntax errors:
-       //int columnCount;
-       //int chIndx;
-       //
-       //      // current identifier
-       //      String identifier;
-       Long longNumber;
-       Double doubleNumber;
-       private String stringValue;
-       /** Contains the current expression. */
-       // private StringBuffer expression;
-       //private boolean phpMode;
+
+       TokenName token;
+
        protected int modifiers;
+
        protected int modifiersSourceStart;
+
        protected Parser(ProblemReporter problemReporter) {
                this.problemReporter = problemReporter;
                this.options = problemReporter.options;
-               this.currentPHPString = 0;
-               //              PHPParserSuperclass.fileToParse = fileToParse;
-               this.phpList = null;
-               this.str = "";
-               this.token = TokenNameEOF;
-               //    this.chIndx = 0;
-               //    this.rowCount = 1;
-               //    this.columnCount = 0;
-               this.phpEnd = false;
-               //   getNextToken();
-               this.initializeScanner();
-       }
-       public void setFileToParse(IFile fileToParse) {
-               this.currentPHPString = 0;
-               //    PHPParserSuperclass.fileToParse = fileToParse;
-               this.phpList = null;
-               this.str = "";
-               this.token = TokenNameEOF;
-               this.phpEnd = false;
+               this.token = TokenName.EOF;
                this.initializeScanner();
        }
+
+//     public void setFileToParse(IFile fileToParse) {
+//             this.token = TokenName.EOF;
+//             this.initializeScanner();
+//     }
+
        /**
         * ClassDeclaration Constructor.
-        * 
+        *
         * @param s
         * @param sess
         *            Description of Parameter
         * @see
         */
-       public Parser(IFile fileToParse) {
-               //    if (keywordMap == null) {
-               //      keywordMap = new HashMap();
-               //      for (int i = 0; i < PHP_KEYWORS.length; i++) {
-               //        keywordMap.put(PHP_KEYWORS[i], new Integer(PHP_KEYWORD_TOKEN[i]));
-               //      }
-               //    }
-               this.currentPHPString = 0;
-               //    PHPParserSuperclass.fileToParse = fileToParse;
-               this.phpList = null;
-               this.str = "";
-               this.token = TokenNameEOF;
-               //    this.chIndx = 0;
-               //    this.rowCount = 1;
-               //    this.columnCount = 0;
-               this.phpEnd = false;
-               //   getNextToken();
-               this.initializeScanner();
-       }
+//     public Parser(IFile fileToParse) {
+//             // if (keywordMap == null) {
+//             // keywordMap = new HashMap();
+//             // for (int i = 0; i < PHP_KEYWORS.length; i++) {
+//             // keywordMap.put(PHP_KEYWORS[i], new Integer(PHP_KEYWORD_TOKEN[i]));
+//             // }
+//             // }
+//             // this.currentPHPString = 0;
+//             // PHPParserSuperclass.fileToParse = fileToParse;
+//             // this.phpList = null;
+//             this.includesList = null;
+//             // this.str = "";
+//             this.token = TokenName.EOF;
+//             // this.chIndx = 0;
+//             // this.rowCount = 1;
+//             // this.columnCount = 0;
+//             // this.phpEnd = false;
+//             // getNextToken();
+//             this.initializeScanner();
+//     }
+
        public void initializeScanner() {
                this.scanner = new Scanner(
                                false /* comment */,
                                false /* whitespace */,
                                this.options.getSeverity(CompilerOptions.NonExternalizedString) != ProblemSeverities.Ignore /* nls */,
                                false, false, this.options.taskTags/* taskTags */,
-                               this.options.taskPriorites/* taskPriorities */);
+                               this.options.taskPriorites/* taskPriorities */, true/* isTaskCaseSensitive */);
        }
+
        /**
         * Create marker for the parse error
         */
-       //  private void setMarker(String message, int charStart, int charEnd, int
+       // private void setMarker(String message, int charStart, int charEnd, int
        // errorLevel) {
-       //    setMarker(fileToParse, message, charStart, charEnd, errorLevel);
-       //  }
+       // setMarker(fileToParse, message, charStart, charEnd, errorLevel);
+       // }
        /**
         * This method will throw the SyntaxError. It will add the good lines and
         * columns to the Error
-        * 
+        *
         * @param error
         *            the error message
         * @throws SyntaxError
@@ -146,201 +155,281 @@ public class Parser //extends PHPParserSuperclass
         */
        private void throwSyntaxError(String error) {
                int problemStartPosition = scanner.getCurrentTokenStartPosition();
-               int problemEndPosition = scanner.getCurrentTokenEndPosition();
-               throwSyntaxError(error, problemStartPosition, problemEndPosition + 1);
+               int problemEndPosition = scanner.getCurrentTokenEndPosition() + 1;
+               if (scanner.source.length <= problemEndPosition
+                               && problemEndPosition > 0) {
+                       problemEndPosition = scanner.source.length - 1;
+                       if (problemStartPosition > 0
+                                       && problemStartPosition >= problemEndPosition
+                                       && problemEndPosition > 0) {
+                               problemStartPosition = problemEndPosition - 1;
+                       }
+               }
+               throwSyntaxError(error, problemStartPosition, problemEndPosition);
        }
+
        /**
         * This method will throw the SyntaxError. It will add the good lines and
         * columns to the Error
-        * 
+        *
         * @param error
         *            the error message
         * @throws SyntaxError
         *             the error raised
         */
-       //  private void throwSyntaxError(String error, int startRow) {
-       //    throw new SyntaxError(startRow, 0, " ", error);
-       //  }
+       // private void throwSyntaxError(String error, int startRow) {
+       // throw new SyntaxError(startRow, 0, " ", error);
+       // }
        private void throwSyntaxError(String error, int problemStartPosition,
                        int problemEndPosition) {
-               problemReporter.phpParsingError(new String[]{error},
-                               problemStartPosition, problemEndPosition, referenceContext,
-                               compilationUnit.compilationResult);
+               if (referenceContext != null) {
+                       problemReporter.phpParsingError(new String[] { error },
+                                       problemStartPosition, problemEndPosition, referenceContext,
+                                       compilationUnit.compilationResult);
+               }
                throw new SyntaxError(1, 0, " ", error);
        }
-       private void reportSyntaxError(String error, int problemStartPosition,
-                       int problemEndPosition) {
-               problemReporter.phpParsingError(new String[]{error},
-                               problemStartPosition, problemEndPosition, referenceContext,
-                               compilationUnit.compilationResult);
+
+       private void reportSyntaxError(String error) {
+               int problemStartPosition = scanner.getCurrentTokenStartPosition();
+               int problemEndPosition = scanner.getCurrentTokenEndPosition();
+               reportSyntaxError(error, problemStartPosition, problemEndPosition + 1);
        }
-       private void reportSyntaxWarning(String error, int problemStartPosition,
+
+       private void reportSyntaxError(String error, int problemStartPosition,
                        int problemEndPosition) {
-               problemReporter.phpParsingWarning(new String[]{error},
-                               problemStartPosition, problemEndPosition, referenceContext,
-                               compilationUnit.compilationResult);
+               if (referenceContext != null) {
+                       problemReporter.phpParsingError(new String[] { error },
+                                       problemStartPosition, problemEndPosition, referenceContext,
+                                       compilationUnit.compilationResult);
+               }
        }
+
+       // private void reportSyntaxWarning(String error, int problemStartPosition,
+       // int problemEndPosition) {
+       // if (referenceContext != null) {
+       // problemReporter.phpParsingWarning(new String[] { error },
+       // problemStartPosition, problemEndPosition, referenceContext,
+       // compilationUnit.compilationResult);
+       // }
+       // }
+
        /**
-        * Method Declaration.
-        * 
-        * @see
-        */
-       //  private void getChar() {
-       //    if (str.length() > chIndx) {
-       //      ch = str.charAt(chIndx++);
-       //
-       //      return;
-       //    }
-       //
-       //    chIndx = str.length() + 1;
-       //    ch = ' ';
-       //    // token = TokenNameEOF;
-       //    phpEnd = true;
-       //  }
-       /**
-        * gets the next token from input
+        * Read the next token from input
         */
        private void getNextToken() {
                try {
                        token = scanner.getNextToken();
                        if (Scanner.DEBUG) {
-                               int currentEndPosition = scanner.getCurrentTokenEndPosition();
-                               int currentStartPosition = scanner
-                                               .getCurrentTokenStartPosition();
-                               System.out.print(currentStartPosition + ","
-                                               + currentEndPosition + ": ");
+                               int currentEndPosition   = scanner.getCurrentTokenEndPosition();
+                               int currentStartPosition = scanner.getCurrentTokenStartPosition();
+
+                               System.out.print ("getNextToken: from " + currentStartPosition + " to " + currentEndPosition + ": ");
                                System.out.println(scanner.toStringAction(token));
                        }
                } catch (InvalidInputException e) {
-                       token = TokenNameERROR;
+                       token = TokenName.ERROR;
+                       String detailedMessage = e.getMessage();
+
+                       if (detailedMessage == Scanner.UNTERMINATED_STRING) {
+                               throwSyntaxError("Unterminated string.");
+                       } else if (detailedMessage == Scanner.UNTERMINATED_COMMENT) {
+                               throwSyntaxError("Unterminated commment.");
+                       }
                }
                return;
        }
+
        public void init(String s) {
-               this.str = s;
-               this.token = TokenNameEOF;
-               //    this.chIndx = 0;
-               //    this.rowCount = 1;
-               //    this.columnCount = 0;
-               this.phpEnd = false;
-               //    this.phpMode = false;
+               // this.str = s;
+               this.token = TokenName.EOF;
+               this.includesList = new ArrayList();
+               // this.chIndx = 0;
+               // this.rowCount = 1;
+               // this.columnCount = 0;
+               // this.phpEnd = false;
+               // this.phpMode = false;
                /* scanner initialization */
                scanner.setSource(s.toCharArray());
                scanner.setPHPMode(false);
+               astPtr = 0;
        }
+
        protected void initialize(boolean phpMode) {
+               initialize(phpMode, null);
+       }
+
+       protected void initialize(boolean phpMode,
+                       IdentifierIndexManager indexManager) {
                compilationUnit = null;
                referenceContext = null;
-               this.str = "";
-               this.token = TokenNameEOF;
-               //    this.chIndx = 0;
-               //    this.rowCount = 1;
-               //    this.columnCount = 0;
-               this.phpEnd = false;
-               //    this.phpMode = phpMode;
+               this.includesList = new ArrayList();
+               // this.indexManager = indexManager;
+               // this.str = "";
+               this.token = TokenName.EOF;
+               // this.chIndx = 0;
+               // this.rowCount = 1;
+               // this.columnCount = 0;
+               // this.phpEnd = false;
+               // this.phpMode = phpMode;
                scanner.setPHPMode(phpMode);
+               astPtr = 0;
        }
+
        /**
         * Parses a string with php tags i.e. '&lt;body&gt; &lt;?php phpinfo() ?&gt;
         * &lt;/body&gt;'
         */
        public void parse(String s) {
+               parse(s, null);
+       }
+
+       /**
+        * Parses a string with php tags i.e. '&lt;body&gt; &lt;?php phpinfo() ?&gt;
+        * &lt;/body&gt;'
+        */
+       public void parse(String s, HashMap variables) {
+               fMethodVariables = variables;
+               fStackUnassigned = new ArrayList();
                init(s);
                parse();
        }
+
        /**
         * Parses a string with php tags i.e. '&lt;body&gt; &lt;?php phpinfo() ?&gt;
         * &lt;/body&gt;'
+        *
+        * The main entry point when parsing a file
         */
        protected void parse() {
+               if (scanner.compilationUnit != null) {
+                       IResource resource = scanner.compilationUnit.getResource();
+                       if (resource != null && resource instanceof IFile) {
+                               // set the package name
+                               consumePackageDeclarationName((IFile) resource);
+                       }
+               }
+
                getNextToken();
+
                do {
                        try {
-                               if (token != TokenNameEOF && token != TokenNameERROR) {
-                                       statementList();
+                               if (token != TokenName.EOF &&                       // If we are not at the end of file
+                                   token != TokenName.ERROR) {                     // and have no error
+                                       statementList();                                // build the statement list for the entire file
                                }
-                               if (token != TokenNameEOF) {
-                                       if (token == TokenNameERROR) {
-                                               throwSyntaxError("Scanner error (Found unknown token: "
-                                                               + scanner.toStringAction(token) + ")");
-                                       }
-                                       if (token == TokenNameRPAREN) {
-                                               throwSyntaxError("Too many closing ')'; end-of-file not reached.");
-                                       }
-                                       if (token == TokenNameRBRACE) {
-                                               throwSyntaxError("Too many closing '}'; end-of-file not reached.");
-                                       }
-                                       if (token == TokenNameRBRACKET) {
-                                               throwSyntaxError("Too many closing ']'; end-of-file not reached.");
-                                       }
-                                       if (token == TokenNameLPAREN) {
-                                               throwSyntaxError("Read character '('; end-of-file not reached.");
-                                       }
-                                       if (token == TokenNameLBRACE) {
-                                               throwSyntaxError("Read character '{';  end-of-file not reached.");
-                                       }
-                                       if (token == TokenNameLBRACKET) {
-                                               throwSyntaxError("Read character '[';  end-of-file not reached.");
-                                       }
-                                       throwSyntaxError("End-of-file not reached.");
-                               }
-                               break;
-                       } catch (SyntaxError sytaxErr1) {
-                               // setMarker(sytaxErr1.getMessage(), sytaxErr1.getLine(),
-                               // ERROR);
-                               //        setMarker(sytaxErr1.getMessage(),
-                               // scanner.getCurrentTokenStartPosition(),
-                               // scanner.getCurrentTokenEndPosition(), ERROR);
-                               try {
-                                       // if an error occured,
-                                       // try to find keywords 'class' or 'function'
-                                       // to parse the rest of the string
-                                       while (token != TokenNameEOF && token != TokenNameERROR) {
-                                               if (token == TokenNameabstract
-                                                               || token == TokenNamefinal
-                                                               || token == TokenNameclass
-                                                               || token == TokenNamefunction) {
+
+                               if (token != TokenName.EOF) {
+                                       switch (token) {
+                                               case ERROR:
+                                                       throwSyntaxError("Scanner error (Found unknown token: " + scanner.toStringAction(token) + ")");
+                                                       break;
+
+                                               case RPAREN:
+                                                       throwSyntaxError("Too many closing ')'; end-of-file not reached.");
+                                                       break;
+
+                                           case RBRACE:
+                                                       throwSyntaxError("Too many closing '}'; end-of-file not reached.");
+                                                       break;
+
+                                               case RBRACKET:
+                                                       throwSyntaxError("Too many closing ']'; end-of-file not reached.");
+                                                       break;
+
+                                               case LPAREN:
+                                                       throwSyntaxError("Read character '('; end-of-file not reached.");
+                                                       break;
+
+                                               case LBRACE:
+                                                       throwSyntaxError("Read character '{';  end-of-file not reached.");
+                                                       break;
+
+                                               case LBRACKET:
+                                                       throwSyntaxError("Read character '[';  end-of-file not reached.");
+                                                       break;
+
+                                               default:
+                                                       throwSyntaxError("End-of-file not reached.");
                                                        break;
-                                               }
-                                               getNextToken();
-                                       }
-                                       if (token == TokenNameEOF || token == TokenNameERROR) {
-                                               break;
                                        }
-                               } catch (SyntaxError sytaxErr2) {
-                                       //    setMarker(sytaxErr2.getMessage(), sytaxErr2.getLine(),
-                                       // ERROR);
-                                       //          setMarker(sytaxErr2.getMessage(),
-                                       // scanner.getCurrentTokenStartPosition(),
-                                       // scanner.getCurrentTokenEndPosition(), ERROR);
-                                       break;
                                }
+                               break;
+                       } catch (SyntaxError syntaxError) {
+                               // syntaxError.printStackTrace();
+                               break;
                        }
                } while (true);
 
                endParse(0);
        }
 
+       /**
+        * Parses a string with php tags i.e. '&lt;body&gt; &lt;?php phpinfo() ?&gt;
+        * &lt;/body&gt;'
+        */
+       public void parseFunction(String s, HashMap variables) {
+               init(s);
+               scanner.phpMode = true;
+               parseFunction(variables);
+       }
+
+       /**
+        * Parses a string with php tags i.e. '&lt;body&gt; &lt;?php phpinfo() ?&gt;
+        * &lt;/body&gt;'
+        */
+       protected void parseFunction(HashMap variables) {
+               getNextToken();
+               boolean hasModifiers = member_modifiers();
+               if (token == TokenName.FUNCTION) {
+                       if (!hasModifiers) {
+                               checkAndSetModifiers(AccPublic);
+                       }
+                       this.fMethodVariables = variables;
+
+                       MethodDeclaration methodDecl = new MethodDeclaration(null);
+                       methodDecl.declarationSourceStart = scanner
+                                       .getCurrentTokenStartPosition();
+                       methodDecl.modifiers = this.modifiers;
+                       methodDecl.type = MethodDeclaration.METHOD_DEFINITION;
+                       try {
+                               getNextToken();
+                               functionDefinition(methodDecl);
+                       } catch (SyntaxError sytaxErr1) {
+                               return;
+                       } finally {
+                               int sourceEnd = methodDecl.sourceEnd;
+                               if (sourceEnd <= 0
+                                               || methodDecl.declarationSourceStart > sourceEnd) {
+                                       sourceEnd = methodDecl.declarationSourceStart + 1;
+                               }
+                               methodDecl.sourceEnd = sourceEnd;
+                               methodDecl.declarationSourceEnd = sourceEnd;
+                       }
+               }
+       }
+
        protected CompilationUnitDeclaration endParse(int act) {
 
                this.lastAct = act;
 
-               if (currentElement != null) {
-                       currentElement.topElement().updateParseTree();
-                       if (VERBOSE_RECOVERY) {
-                               System.out.print(Util.bind("parser.syntaxRecovery")); //$NON-NLS-1$
-                               System.out.println("--------------------------"); //$NON-NLS-1$
-                               System.out.println(compilationUnit);
-                               System.out.println("----------------------------------"); //$NON-NLS-1$
-                       }
-               } else {
-                       if (diet & VERBOSE_RECOVERY) {
-                               System.out.print(Util.bind("parser.regularParse")); //$NON-NLS-1$
-                               System.out.println("--------------------------"); //$NON-NLS-1$
-                               System.out.println(compilationUnit);
-                               System.out.println("----------------------------------"); //$NON-NLS-1$
-                       }
+               // if (currentElement != null) {
+               // currentElement.topElement().updateParseTree();
+               // if (VERBOSE_RECOVERY) {
+               // System.out.print(Util.bind("parser.syntaxRecovery")); //$NON-NLS-1$
+               // System.out.println("--------------------------"); //$NON-NLS-1$
+               // System.out.println(compilationUnit);
+               // System.out.println("----------------------------------");
+               // //$NON-NLS-1$
+               // }
+               // } else {
+               if (diet & VERBOSE_RECOVERY) {
+                       System.out.print(Util.bind("parser.regularParse")); //$NON-NLS-1$
+                       System.out.println("--------------------------"); //$NON-NLS-1$
+                       System.out.println(compilationUnit);
+                       System.out.println("----------------------------------"); //$NON-NLS-1$
                }
+               // }
                if (scanner.recordLineSeparator) {
                        compilationUnit.compilationResult.lineSeparatorPositions = scanner
                                        .getLineEnds();
@@ -350,699 +439,897 @@ public class Parser //extends PHPParserSuperclass
                                problemReporter().task(
                                                new String(scanner.foundTaskTags[i]),
                                                new String(scanner.foundTaskMessages[i]),
-                                               scanner.foundTaskPriorities[i] == null
-                                                               ? null
+                                               scanner.foundTaskPriorities[i] == null ? null
                                                                : new String(scanner.foundTaskPriorities[i]),
                                                scanner.foundTaskPositions[i][0],
                                                scanner.foundTaskPositions[i][1]);
                        }
                }
+               compilationUnit.imports = new ImportReference[includesList.size()];
+               for (int i = 0; i < includesList.size(); i++) {
+                       compilationUnit.imports[i] = (ImportReference) includesList.get(i);
+               }
                return compilationUnit;
        }
-       //  public PHPOutlineInfo parseInfo(Object parent, String s) {
-       //    PHPOutlineInfo outlineInfo = new PHPOutlineInfo(parent);
-       //    // Stack stack = new Stack();
-       //    // stack.push(outlineInfo.getDeclarations());
-       //    this.str = s;
-       //    this.token = TokenNameEOF;
-       //    // this.chIndx = 0;
-       //    // this.rowCount = 1;
-       //    // this.columnCount = 0;
-       //    this.phpEnd = false;
-       //    this.phpMode = false;
-       //    scanner.setSource(s.toCharArray());
-       //    scanner.setPHPMode(false);
-       //    
-       //    getNextToken();
-       //    parseDeclarations(outlineInfo, outlineInfo.getDeclarations(), false);
-       //    
-       //    return outlineInfo;
-       //  }
-       private boolean isVariable() {
-               return token == TokenNameVariable; //  || token == TokenNamethis;
-       }
-       //  private void parseDeclarations(PHPOutlineInfo outlineInfo,
-       //      OutlineableWithChildren current, boolean goBack) {
-       //    char[] ident;
-       //    // PHPClassDeclaration current = (PHPClassDeclaration) stack.peek();
-       //    PHPSegmentWithChildren temp;
-       //    int counter = 0;
-       //    IPreferenceStore store =
-       // PHPeclipsePlugin.getDefault().getPreferenceStore();
-       //    try {
-       //      while (token != TokenNameEOF && token != TokenNameERROR) {
-       //        if (token == TokenNameVariable) {
-       //          ident = scanner.getCurrentIdentifierSource();
-       //          outlineInfo.addVariable(new String(ident));
-       //          getNextToken();
-       //        } else if (token == TokenNamevar) {
-       //          getNextToken();
-       //          if (token == TokenNameVariable
-       //              && store.getBoolean(PHPeclipsePlugin.PHP_OUTLINE_VAR)) {
-       //            ident = scanner.getCurrentIdentifierSource();
-       //            //substring(1) added because PHPVarDeclaration doesn't
-       //            // need the $ anymore
-       //            String variableName = new String(ident).substring(1);
-       //            outlineInfo.addVariable(variableName);
-       //            getNextToken();
-       //            if (token != TokenNameSEMICOLON) {
-       //              getNextToken();
-       //              ident = scanner.getCurrentTokenSource();
-       //              if (token > TokenNameKEYWORD) {
-       //                current.add(new PHPVarDeclaration(current, variableName,
-       //                // chIndx - ident.length,
-       //                    scanner.getCurrentTokenStartPosition(), new String(ident)));
-       //              } else {
-       //                switch (token) {
-       //                  case TokenNameVariable :
-       //                  case TokenNamethis :
-       //                    current.add(new PHPVarDeclaration(current, variableName,
-       //                    // chIndx -
-       //                        // ident.length,
-       //                        scanner.getCurrentTokenStartPosition(), new String(
-       //                            ident)));
-       //                    break;
-       //                  case TokenNameIdentifier :
-       //                    current.add(new PHPVarDeclaration(current, variableName,
-       //                    // chIndx -
-       //                        // ident.length,
-       //                        scanner.getCurrentTokenStartPosition(), new String(
-       //                            ident)));
-       //                    break;
-       //                  case TokenNameDoubleLiteral :
-       //                    current.add(new PHPVarDeclaration(current, variableName
-       //                        + doubleNumber,
-       //                    // chIndx -
-       //                        // ident.length,
-       //                        scanner.getCurrentTokenStartPosition(), new String(
-       //                            ident)));
-       //                    break;
-       //                  case TokenNameIntegerLiteral :
-       //                    current.add(new PHPVarDeclaration(current, variableName,
-       //                    // chIndx -
-       //                        // ident.length,
-       //                        scanner.getCurrentTokenStartPosition(), new String(
-       //                            ident)));
-       //                    break;
-       //                  case TokenNameStringInterpolated :
-       //                  case TokenNameStringLiteral :
-       //                    current.add(new PHPVarDeclaration(current, variableName,
-       //                    // chIndx -
-       //                        // ident.length,
-       //                        scanner.getCurrentTokenStartPosition(), new String(
-       //                            ident)));
-       //                    break;
-       //                  case TokenNameStringConstant :
-       //                    current.add(new PHPVarDeclaration(current, variableName,
-       //                    // chIndx -
-       //                        // ident.length,
-       //                        scanner.getCurrentTokenStartPosition(), new String(
-       //                            ident)));
-       //                    break;
-       //                  default :
-       //                    current.add(new PHPVarDeclaration(current, variableName,
-       //                    // chIndx -
-       //                        // ident.length
-       //                        scanner.getCurrentTokenStartPosition()));
-       //                    break;
-       //                }
-       //              }
-       //            } else {
-       //              ident = scanner.getCurrentIdentifierSource();
-       //              current.add(new PHPVarDeclaration(current, variableName,
-       //              // chIndx - ident.length
-       //                  scanner.getCurrentTokenStartPosition()));
-       //            }
-       //          }
-       //        } else if (token == TokenNamefunction) {
-       //          getNextToken();
-       //          if (token == TokenNameAND) {
-       //            getNextToken();
-       //          }
-       //          if (token == TokenNameIdentifier
-       //              && store.getBoolean(PHPeclipsePlugin.PHP_OUTLINE_FUNC)) {
-       //            ident = scanner.getCurrentIdentifierSource();
-       //            outlineInfo.addVariable(new String(ident));
-       //            temp = new PHPFunctionDeclaration(current, new String(ident),
-       //            // chIndx - ident.length
-       //                scanner.getCurrentTokenStartPosition());
-       //            current.add(temp);
-       //            getNextToken();
-       //            parseDeclarations(outlineInfo, temp, true);
-       //          }
-       //        } else if (token == TokenNameclass) {
-       //          getNextToken();
-       //          if (token == TokenNameIdentifier
-       //              && store.getBoolean(PHPeclipsePlugin.PHP_OUTLINE_CLASS)) {
-       //            ident = scanner.getCurrentIdentifierSource();
-       //            outlineInfo.addVariable(new String(ident));
-       //            temp = new PHPClassDeclaration(current, new String(ident),
-       //            // chIndx - ident.len
-       //                scanner.getCurrentTokenStartPosition());
-       //            current.add(temp);
-       //            // stack.push(temp);
-       //            getNextToken();
-       //            //skip tokens for classname, extends and others until
-       //            // we have the opening '{'
-       //            while (token != TokenNameLBRACE && token != TokenNameEOF
-       //                && token != TokenNameERROR) {
-       //              getNextToken();
-       //            }
-       //            parseDeclarations(outlineInfo, temp, true);
-       //            // stack.pop();
-       //          }
-       //        } else if ((token == TokenNameLBRACE)
-       //            || (token == TokenNameDOLLAR_LBRACE)) {
-       //          getNextToken();
-       //          counter++;
-       //        } else if (token == TokenNameRBRACE) {
-       //          getNextToken();
-       //          --counter;
-       //          if (counter == 0 && goBack) {
-       //            return;
-       //          }
-       //        } else if (token == TokenNamerequire || token == TokenNamerequire_once
-       //            || token == TokenNameinclude || token == TokenNameinclude_once) {
-       //          ident = scanner.getCurrentTokenSource();
-       //          getNextToken();
-       //          int startPosition = scanner.getCurrentTokenStartPosition();
-       //          expr();
-       //          char[] expr = scanner.getCurrentTokenSource(startPosition);
-       //          outlineInfo.addVariable(new String(ident));
-       //          current.add(new PHPReqIncDeclaration(current, new String(ident),
-       //          // chIndx - ident.length,
-       //              startPosition, new String(expr)));
-       //          getNextToken();
-       //        } else {
-       //          getNextToken();
-       //        }
-       //      }
-       //    } catch (SyntaxError sytaxErr) {
-       //      // try {
-       //      // // setMarker(sytaxErr.getMessage(), sytaxErr.getLine(), ERROR);
-       //      // setMarker(sytaxErr.getMessage(),
-       //      // scanner.getCurrentTokenStartPosition(),
-       //      // scanner.getCurrentTokenEndPosition(), ERROR);
-       //      // } catch (CoreException e) {
-       //      // }
-       //    }
-       //  }
-       private void statementList() {
+
+       /**
+        *
+        * @return A block object which contains all statements from within the current block
+        */
+       private Block statementList() {
+               boolean    branchStatement = false;
+               int        blockStart      = scanner.getCurrentTokenStartPosition();
+               ArrayList  blockStatements = new ArrayList();
+               Statement  statement;
+
                do {
-                       statement(TokenNameEOF);
-                       if ((token == TokenNameRBRACE) || (token == TokenNamecase)
-                                       || (token == TokenNamedefault) || (token == TokenNameelse)
-                                       || (token == TokenNameelseif) || (token == TokenNameendif)
-                                       || (token == TokenNameendfor)
-                                       || (token == TokenNameendforeach)
-                                       || (token == TokenNameendwhile)
-                                       || (token == TokenNameendswitch) || (token == TokenNameEOF)
-                                       || (token == TokenNameERROR)) {
-                               return;
+                       try {
+                               statement = statement();
+
+                               if (statement != null) {
+                                   blockStatements.add(statement);
+                               }
+
+                               if (token == TokenName.EOF) {
+                                       return null;
+                               }
+
+                               if (branchStatement && statement != null) {
+                                       // reportSyntaxError("Unreachable code", statement.sourceStart, statement.sourceEnd);
+                                       if (!(statement instanceof BreakStatement)) {
+                                               /*
+                                                * Don't give an error for break statement following return statement.
+                                                * Technically it's unreachable code, but in switch-case it's recommended to avoid
+                                                * accidental fall-through later when editing the code
+                                                */
+                                               problemReporter.unreachableCode (new String (scanner.getCurrentIdentifierSource ()),
+                                                                                        statement.sourceStart,
+                                                                                                                statement.sourceEnd,
+                                                                                        referenceContext,
+                                                                                        compilationUnit.compilationResult);
+                                       }
+                               }
+
+                               switch (token) {
+                                       case RBRACE:
+                                       case CASE:
+                                       case DEFAULT:
+                                       case ELSE:
+                                       case ELSEIF:
+                                       case ENDIF:
+                                       case ENDFOR:
+                                       case ENDFOREACH:
+                                       case ENDWHILE:
+                                       case ENDSWITCH:
+                                       case ENDDECLARE:
+                                       case EOF:
+                                       case ERROR:
+                                               return createBlock (blockStart, blockStatements);          // Create and return a block object (contains all the statements from the current read block)
+                               }
+
+                               branchStatement = checkUnreachableStatements(statement);
                        }
+                       catch (SyntaxError sytaxErr1) {
+                               // If an error occurred, try to find keywords
+                               // to parse the rest of the string
+                               boolean tokenize = scanner.tokenizeStrings;
+
+                               if (!tokenize) {
+                                       scanner.tokenizeStrings = true;
+                               }
+
+                               try {
+                                       boolean bBreakLoop = false;
+
+                                       while (token != TokenName.EOF) {                               // As long as we are not at the end of file
+                                               switch (token) {                                           // If a block close?
+                                                       case RBRACE:
+                                                       case CASE:
+                                                       case DEFAULT:
+                                                       case ELSE:
+                                                       case ELSEIF:
+                                                       case ENDIF:
+                                                       case ENDFOR:
+                                                       case ENDFOREACH:
+                                                       case ENDWHILE:
+                                                       case ENDSWITCH:
+                                                       case ENDDECLARE:
+                                                       case EOF:
+                                                       case ERROR:
+                                                               return createBlock (blockStart, blockStatements);  // Create and return a block object (contains all the statements from the current read block)
+                                               }
+
+                                               switch (token) {
+                                                       case IF:
+                                                       case SWITCH:
+                                                       case FOR:
+                                                       case WHILE:
+                                                       case DO:
+                                                       case FOREACH:
+                                                       case CONTINUE:
+                                                       case BREAK:
+                                                       case RETURN:
+                                                       case EXIT:
+                                                       case ECHO:
+                                                       case NAMESPACE:
+                                                       case ECHO_INVISIBLE:
+                                                       case GLOBAL:
+                                                       case STATIC:
+                                                       case UNSET:
+                                                       case FUNCTION:
+                                                       case DECLARE:
+                                                       case TRY:
+                                                       case CATCH:
+                                                       case THROW:
+                                                       case FINAL:
+                                                       case ABSTRACT:
+                                                       case CLASS:
+                                                       case INTERFACE:
+                                                               bBreakLoop = true;
+                                                               break;
+                                               }
+
+                                               if (bBreakLoop) {
+                                                       break;
+                                               }
+
+                                               // System.out.println(scanner.toStringAction(token));
+                                               getNextToken();
+                                               // System.out.println(scanner.toStringAction(token));
+                                       }
+
+                                       if (token == TokenName.EOF) {
+                                               throw sytaxErr1;
+                                       }
+                               } finally {
+                                       scanner.tokenizeStrings = tokenize;
+                               }
+                       } // catch
                } while (true);
        }
+
+       /**
+        * @param statement
+        * @return
+        */
+       private boolean checkUnreachableStatements(Statement statement) {
+               if (statement instanceof ReturnStatement   ||
+                       statement instanceof ContinueStatement ||
+                       statement instanceof BreakStatement) {
+                       return true;
+               } else if (statement instanceof IfStatement
+                               && ((IfStatement) statement).checkUnreachable) {
+                       return true;
+               }
+               return false;
+       }
+
+       /**
+        * @param blockStart
+        * @param blockStatements
+        * @return
+        */
+       private Block createBlock (int blockStart, ArrayList blockStatements) {
+               int    blockEnd = scanner.getCurrentTokenEndPosition ();
+               Block  b        = Block.EmptyWith (blockStart, blockEnd);
+
+               b.statements = new Statement[blockStatements.size()];
+               blockStatements.toArray (b.statements);
+
+               return b;
+       }
+
        private void functionBody(MethodDeclaration methodDecl) {
                // '{' [statement-list] '}'
-               if (token == TokenNameLBRACE) {
+               if (token == TokenName.LBRACE) {
                        getNextToken();
                } else {
+                       methodDecl.sourceEnd = scanner.getCurrentTokenStartPosition() - 1;
                        throwSyntaxError("'{' expected in compound-statement.");
                }
-               if (token != TokenNameRBRACE) {
+
+               if (token != TokenName.RBRACE) {
                        statementList();
                }
-               if (token == TokenNameRBRACE) {
-                       methodDecl.declarationSourceEnd = scanner
-                                       .getCurrentTokenEndPosition();
+
+               if (token == TokenName.RBRACE) {
+                       methodDecl.sourceEnd = scanner.getCurrentTokenEndPosition();
                        getNextToken();
                } else {
+                       methodDecl.sourceEnd = scanner.getCurrentTokenStartPosition() - 1;
                        throwSyntaxError("'}' expected in compound-statement.");
                }
        }
-       private void statement(int previousToken) {
-               //   if (token > TokenNameKEYWORD && token != TokenNamelist && token !=
-               // TokenNamenew) {
-               //  char[] ident = scanner.getCurrentIdentifierSource();
-               //  String keyword = new String(ident);
-               //    if (token == TokenNameAT) {
-               //      getNextToken();
-               //      if (token != TokenNamerequire && token != TokenNamerequire_once
-               //          && token != TokenNameinclude && token != TokenNameinclude_once
-               //          && token != TokenNameIdentifier && token != TokenNameVariable
-               //          && token != TokenNameStringInterpolated) {
-               //        throwSyntaxError("identifier expected after '@'.");
-               //      }
-               //    }
-               //    if (token == TokenNameinclude || token == TokenNameinclude_once) {
-               //      getNextToken();
-               //      if (token == TokenNameLPAREN) {
-               //        expr();
-               //        if (token == TokenNameSEMICOLON) {
-               //          getNextToken();
-               //        } else {
-               //          if (previousToken != TokenNameAT && token != TokenNameStopPHP) {
-               //            throwSyntaxError("';' expected after 'include' or 'include_once'.");
-               //          }
-               //          // getNextToken();
-               //        }
-               //      } else {
-               //        concatenationExpression();
-               //      }
-               //      return;
-               //    } else if (token == TokenNamerequire || token ==
-               // TokenNamerequire_once)
-               // {
-               //      getNextToken();
-               //      //constant();
-               //      if (token == TokenNameLPAREN) {
-               //        expr();
-               //        if (token == TokenNameSEMICOLON) {
-               //          getNextToken();
-               //        } else {
-               //          if (previousToken != TokenNameAT && token != TokenNameStopPHP) {
-               //            throwSyntaxError("';' expected after 'require' or 'require_once'.");
-               //          }
-               //          // getNextToken();
-               //        }
-               //      } else {
-               //        concatenationExpression();
-               //      }
-               //      return;
-               //    } else
-               if (token == TokenNameif) {
-                       getNextToken();
-                       if (token == TokenNameLPAREN) {
-                               getNextToken();
-                       } else {
-                               throwSyntaxError("'(' expected after 'if' keyword.");
-                       }
-                       expr();
-                       if (token == TokenNameRPAREN) {
-                               getNextToken();
-                       } else {
-                               throwSyntaxError("')' expected after 'if' condition.");
-                       }
-                       ifStatement();
-                       return;
-               } else if (token == TokenNameswitch) {
-                       getNextToken();
-                       if (token == TokenNameLPAREN) {
-                               getNextToken();
-                       } else {
-                               throwSyntaxError("'(' expected after 'switch' keyword.");
-                       }
-                       expr();
-                       if (token == TokenNameRPAREN) {
-                               getNextToken();
-                       } else {
-                               throwSyntaxError("')' expected after 'switch' condition.");
-                       }
-                       switchStatement();
-                       return;
-               } else if (token == TokenNamefor) {
-                       getNextToken();
-                       if (token == TokenNameLPAREN) {
+
+       /**
+        * Try to create an statement reading from the current token position
+        *
+        * @return Returns a found statement or empty statement
+        */
+       private Statement statement() {
+               Statement   statement = null;
+               Expression  expression;
+               int         sourceStart = scanner.getCurrentTokenStartPosition();
+               int         sourceEnd;
+
+               switch (token) {
+                       case IF:
+                               // T_IF '(' expr ')' statement elseif_list else_single
+                               // T_IF '(' expr ')' ':' inner_statement_list new_elseif_list
+                               // new_else_single T_ENDIF ';'
                                getNextToken();
-                       } else {
-                               throwSyntaxError("'(' expected after 'for' keyword.");
-                       }
-                       if (token == TokenNameSEMICOLON) {
+                               if (token == TokenName.LPAREN) {
+                                       getNextToken();
+                               } else {
+                                       throwSyntaxError("'(' expected after 'if' keyword.");
+                               }
+
+                               expression = expr();
+
+                               if (token == TokenName.RPAREN) {
+                                       getNextToken();
+                               } else {
+                                       throwSyntaxError("')' expected after 'if' condition.");
+                               }
+                               // create basic IfStatement
+                               IfStatement ifStatement = new IfStatement(expression, null, null, sourceStart, -1);
+
+                               if (token == TokenName.COLON) {
+                                       getNextToken();
+                                       ifStatementColon(ifStatement);
+                               } else {
+                                       ifStatement(ifStatement);
+                               }
+                               return ifStatement;
+
+                       case SWITCH:
                                getNextToken();
-                       } else {
-                               expressionList();
-                               if (token == TokenNameSEMICOLON) {
+                               if (token == TokenName.LPAREN) {
                                        getNextToken();
                                } else {
-                                       throwSyntaxError("';' expected after 'for'.");
+                                       throwSyntaxError("'(' expected after 'switch' keyword.");
                                }
-                       }
-                       if (token == TokenNameSEMICOLON) {
+                               expr();
+                               if (token == TokenName.RPAREN) {
+                                       getNextToken();
+                               } else {
+                                       throwSyntaxError("')' expected after 'switch' condition.");
+                               }
+                               switchStatement();
+                               return statement;
+
+                       case FOR:
                                getNextToken();
-                       } else {
-                               expressionList();
-                               if (token == TokenNameSEMICOLON) {
+                               if (token == TokenName.LPAREN) {
                                        getNextToken();
                                } else {
-                                       throwSyntaxError("';' expected after 'for'.");
+                                       throwSyntaxError("'(' expected after 'for' keyword.");
                                }
-                       }
-                       if (token == TokenNameRPAREN) {
+                               if (token == TokenName.SEMICOLON) {
+                                       getNextToken();
+                               } else {
+                                       expressionList();
+                                       if (token == TokenName.SEMICOLON) {
+                                               getNextToken();
+                                       } else {
+                                               throwSyntaxError("';' expected after 'for'.");
+                                       }
+                               }
+                               if (token == TokenName.SEMICOLON) {
+                                       getNextToken();
+                               } else {
+                                       expressionList();
+                                       if (token == TokenName.SEMICOLON) {
+                                               getNextToken();
+                                       } else {
+                                               throwSyntaxError("';' expected after 'for'.");
+                                       }
+                               }
+                               if (token == TokenName.RPAREN) {
+                                       getNextToken();
+                               } else {
+                                       expressionList();
+                                       if (token == TokenName.RPAREN) {
+                                               getNextToken();
+                                       } else {
+                                               throwSyntaxError("')' expected after 'for'.");
+                                       }
+                               }
+                               forStatement();
+                               return statement;
+
+                       case WHILE:
                                getNextToken();
-                       } else {
-                               expressionList();
-                               if (token == TokenNameRPAREN) {
+                               if (token == TokenName.LPAREN) {
                                        getNextToken();
                                } else {
-                                       throwSyntaxError("')' expected after 'for'.");
+                                       throwSyntaxError("'(' expected after 'while' keyword.");
                                }
-                       }
-                       forStatement();
-                       return;
-               } else if (token == TokenNamewhile) {
-                       getNextToken();
-                       if (token == TokenNameLPAREN) {
+                               expr();
+                               if (token == TokenName.RPAREN) {
+                                       getNextToken();
+                               } else {
+                                       throwSyntaxError("')' expected after 'while' condition.");
+                               }
+                               whileStatement();
+                               return statement;
+
+                       case DO:
                                getNextToken();
-                       } else {
-                               throwSyntaxError("'(' expected after 'while' keyword.");
-                       }
-                       expr();
-                       if (token == TokenNameRPAREN) {
+                               if (token == TokenName.LBRACE) {
+                                       getNextToken();
+                                       if (token != TokenName.RBRACE) {
+                                               statementList();
+                                       }
+                                       if (token == TokenName.RBRACE) {
+                                               getNextToken();
+                                       } else {
+                                               throwSyntaxError("'}' expected after 'do' keyword.");
+                                       }
+                               } else {
+                                       statement();
+                               }
+                               if (token == TokenName.WHILE) {
+                                       getNextToken();
+                                       if (token == TokenName.LPAREN) {
+                                               getNextToken();
+                                       } else {
+                                               throwSyntaxError("'(' expected after 'while' keyword.");
+                                       }
+                                       expr();
+                                       if (token == TokenName.RPAREN) {
+                                               getNextToken();
+                                       } else {
+                                               throwSyntaxError("')' expected after 'while' condition.");
+                                       }
+                               } else {
+                                       throwSyntaxError("'while' expected after 'do' keyword.");
+                               }
+                               if (token == TokenName.SEMICOLON) {
+                                       getNextToken();
+                               } else {
+                                       if (token != TokenName.INLINE_HTML) {
+                                               throwSyntaxError("';' expected after do-while statement.");
+                                       }
+                                       getNextToken();
+                               }
+                               return statement;
+
+                       case FOREACH:
                                getNextToken();
-                       } else {
-                               throwSyntaxError("')' expected after 'while' condition.");
-                       }
-                       whileStatement();
-                       return;
-               } else if (token == TokenNamedo) {
-                       getNextToken();
-                       if (token == TokenNameLBRACE) {
+                               if (token == TokenName.LPAREN) {
+                                       getNextToken();
+                               } else {
+                                       throwSyntaxError("'(' expected after 'foreach' keyword.");
+                               }
+                               expr();
+                               if (token == TokenName.AS) {
+                                       getNextToken();
+                               } else {
+                                       throwSyntaxError("'as' expected after 'foreach' exxpression.");
+                               }
+                               // variable();
+                               foreach_variable();
+                               foreach_optional_arg();
+                               if (token == TokenName.EQUAL_GREATER) {
+                                       getNextToken();
+                                       variable(false, false);
+                               }
+                               if (token == TokenName.RPAREN) {
+                                       getNextToken();
+                               } else {
+                                       throwSyntaxError("')' expected after 'foreach' expression.");
+                               }
+                               foreachStatement();
+                               return statement;
+
+                       case BREAK:
+                               expression = null;
                                getNextToken();
-                               if (token != TokenNameRBRACE) {
-                                       statementList();
+                               if (token != TokenName.SEMICOLON) {
+                                       expression = expr();
                                }
-                               if (token == TokenNameRBRACE) {
+                               if (token == TokenName.SEMICOLON) {
+                                       sourceEnd = scanner.getCurrentTokenEndPosition();
                                        getNextToken();
                                } else {
-                                       throwSyntaxError("'}' expected after 'do' keyword.");
+                                       if (token != TokenName.INLINE_HTML) {
+                                               throwSyntaxError("';' expected after 'break'.");
+                                       }
+                                       sourceEnd = scanner.getCurrentTokenEndPosition();
+                                       getNextToken();
                                }
-                       } else {
-                               statement(TokenNameEOF);
-                       }
-                       if (token == TokenNamewhile) {
+                               return new BreakStatement(null, sourceStart, sourceEnd);
+
+                       case CONTINUE:
+                               expression = null;
                                getNextToken();
-                               if (token == TokenNameLPAREN) {
+                               if (token != TokenName.SEMICOLON) {
+                                       expression = expr();
+                               }
+                               if (token == TokenName.SEMICOLON) {
+                                       sourceEnd = scanner.getCurrentTokenEndPosition();
                                        getNextToken();
                                } else {
-                                       throwSyntaxError("'(' expected after 'while' keyword.");
+                                       if (token != TokenName.INLINE_HTML) {
+                                               throwSyntaxError("';' expected after 'continue'.");
+                                       }
+                                       sourceEnd = scanner.getCurrentTokenEndPosition();
+                                       getNextToken();
                                }
-                               expr();
-                               if (token == TokenNameRPAREN) {
+                               return new ContinueStatement(null, sourceStart, sourceEnd);
+
+                       case RETURN:
+                               expression = null;
+                               getNextToken();
+/*
+                               if (token == TokenName.VARIABLE) {
+                                       getNextToken ();
+
+                                       if (token == TokenName.PAAMAYIM_NEKUDOTAYIM) {
+                                               getNextToken ();
+
+                                               if (token != TokenName.IDENTIFIER) {
+                                                       throwSyntaxError("identifier expected after '::'.");
+                                               }
+                                               else {
+                                                       getNextToken ();
+                                               }
+                                       }
+                               }
+*/
+                               if (token != TokenName.SEMICOLON) {
+                                       expression = expr();
+                               }
+
+                               if (token == TokenName.SEMICOLON) {
+                                       sourceEnd = scanner.getCurrentTokenEndPosition();
+                                       getNextToken();
+                               }
+                               else {
+                                       if (token != TokenName.INLINE_HTML) {
+                                               throwSyntaxError("';' expected after 'return'.");
+                                       }
+
+                                       sourceEnd = scanner.getCurrentTokenEndPosition();
+                                       getNextToken();
+                               }
+                               return new ReturnStatement(expression, sourceStart, sourceEnd);
+
+                       case ECHO:
+                               getNextToken();                                 // Read the token after 'echo'
+                               expressionList();                               // Read everything after 'echo'
+                               if (token == TokenName.SEMICOLON) {
                                        getNextToken();
                                } else {
-                                       throwSyntaxError("')' expected after 'while' condition.");
+                                       if (token != TokenName.INLINE_HTML) {
+                                               throwSyntaxError("';' expected after 'echo' statement.");
+                                       }
+                                       getNextToken();
                                }
-                       } else {
-                               throwSyntaxError("'while' expected after 'do' keyword.");
-                       }
-                       if (token == TokenNameSEMICOLON) {
+                               return statement;   // return null statement
+
+                       case ECHO_INVISIBLE:
+                               // 0-length token directly after PHP short tag &lt;?=
                                getNextToken();
-                       } else {
-                               if (token != TokenNameINLINE_HTML) {
-                                       throwSyntaxError("';' expected after do-while statement.");
+                               expressionList();
+                               if (token == TokenName.SEMICOLON) {
+                                       getNextToken();
+                                       // if (token != TokenName.INLINE_HTML) {
+                                       // // TODO should this become a configurable warning?
+                                       // reportSyntaxError("Probably '?>' expected after PHP short tag
+                                       // expression (only the first expression will be echoed).");
+                                       // }
+                               } else {
+                                       if (token != TokenName.INLINE_HTML) {
+                                               throwSyntaxError("';' expected after PHP short tag '<?=' expression.");
+                                       }
+                                       getNextToken();
                                }
+                               return statement;
+
+                       case INLINE_HTML:
                                getNextToken();
-                       }
-                       return;
-               } else if (token == TokenNameforeach) {
-                       getNextToken();
-                       if (token == TokenNameLPAREN) {
+                               return statement;
+
+                       case GLOBAL:
                                getNextToken();
-                       } else {
-                               throwSyntaxError("'(' expected after 'foreach' keyword.");
-                       }
-                       expr();
-                       if (token == TokenNameas) {
+                               global_var_list();
+                               if (token == TokenName.SEMICOLON) {
+                                       getNextToken();
+                               } else {
+                                       if (token != TokenName.INLINE_HTML) {
+                                               throwSyntaxError("';' expected after 'global' statement.");
+                                       }
+                                       getNextToken();
+                               }
+                               return statement;
+
+                       case STATIC:
                                getNextToken();
-                       } else {
-                               throwSyntaxError("'as' expected after 'foreach' exxpression.");
-                       }
-                       //      variable();
-                       foreach_variable();
-                       foreach_optional_arg();
-                       if (token == TokenNameEQUAL_GREATER) {
+                               static_var_list();
+                               if (token == TokenName.SEMICOLON) {
+                                       getNextToken();
+                               }
+                               else if (token == TokenName.PAAMAYIM_NEKUDOTAYIM) {
+                                       getNextToken ();
+
+                                       if (token != TokenName.IDENTIFIER) {
+                                               throwSyntaxError("identifier expected after '::'.");
+                                       }
+                               }
+                               else {
+                                       if (token != TokenName.INLINE_HTML) {
+                                               throwSyntaxError("';' expected after 'static' statement.");
+                                       }
+                                       getNextToken();
+                               }
+                               return statement;
+
+                       case UNSET:
                                getNextToken();
-                               variable();
-                       }
-                       if (token == TokenNameRPAREN) {
+                               if (token == TokenName.LPAREN) {
+                                       getNextToken();
+                               } else {
+                                       throwSyntaxError("'(' expected after 'unset' statement.");
+                               }
+                               unset_variables();
+                               if (token == TokenName.RPAREN) {
+                                       getNextToken();
+                               } else {
+                                       throwSyntaxError("')' expected after 'unset' statement.");
+                               }
+                               if (token == TokenName.SEMICOLON) {
+                                       getNextToken();
+                               } else {
+                                       if (token != TokenName.INLINE_HTML) {
+                                               throwSyntaxError("';' expected after 'unset' statement.");
+                                       }
+                                       getNextToken();
+                               }
+                               return statement;
+
+            case NAMESPACE:
+                getNextToken ();
+                namespacePath ();
+
+                if (token == TokenName.SEMICOLON) {             // After the namespace identifier there is a ';'
+                    getNextToken();
+                }
+                else if (token == TokenName.LBRACE) {           // or a '{'
+                    getNextToken();                             // set to next token
+
+                    if (token != TokenName.RBRACE) {            // if next token is not a '}'
+                        statementList();                        // read the entire block
+                    }
+
+                    if (token == TokenName.RBRACE) {            // If the end is a '}'
+                        getNextToken();                         // go for the next token
+                    }
+                    else {                                      // Not a '}' as expected
+                        throwSyntaxError("'}' expected after 'do' keyword.");
+                    }
+                }
+                else {
+                    if (token != TokenName.INLINE_HTML) {
+                        throwSyntaxError("';' expected after 'namespace' statement.");
+                    }
+                    getNextToken();
+                }
+                return statement;
+
+            case GOTO:
+                getNextToken ();                                // This should get the label
+
+                if (token == TokenName.IDENTIFIER) {
+                    getNextToken ();
+                }
+                else {
+                    throwSyntaxError("expected a label after goto");
+                }
+
+                if (token == TokenName.SEMICOLON) {             // After the 'goto' label name there is a ';'
+                    getNextToken ();
+                }
+                else {
+                    throwSyntaxError("expected a ';' after goto label");
+                }
+                return statement;
+
+                       case FUNCTION:
+                               MethodDeclaration methodDecl = new MethodDeclaration (this.compilationUnit.compilationResult);
+                               methodDecl.declarationSourceStart = scanner.getCurrentTokenStartPosition();
+                               methodDecl.modifiers = AccDefault;
+                               methodDecl.type = MethodDeclaration.FUNCTION_DEFINITION;
+                               try {
+                                       getNextToken();
+                                       functionDefinition(methodDecl);
+                               } finally {
+                                       sourceEnd = methodDecl.sourceEnd;
+                                       if (sourceEnd <= 0 || methodDecl.declarationSourceStart > sourceEnd) {
+                                               sourceEnd = methodDecl.declarationSourceStart + 1;
+                                       }
+                                       methodDecl.declarationSourceEnd = sourceEnd;
+                                       methodDecl.sourceEnd = sourceEnd;
+                               }
+                               return statement;
+
+                       case DECLARE:
+                               // T_DECLARE '(' declare_list ')' declare_statement
                                getNextToken();
-                       } else {
-                               throwSyntaxError("')' expected after 'foreach' expression.");
-                       }
-                       foreachStatement();
-                       return;
-               } else if (token == TokenNamecontinue || token == TokenNamebreak
-                               || token == TokenNamereturn) {
-                       getNextToken();
-                       if (token != TokenNameSEMICOLON) {
-                               expr();
-                       }
-                       if (token == TokenNameSEMICOLON) {
+                               if (token != TokenName.LPAREN) {
+                                       throwSyntaxError("'(' expected in 'declare' statement.");
+                               }
                                getNextToken();
-                       } else {
-                               if (token != TokenNameINLINE_HTML) {
-                                       throwSyntaxError("';' expected after 'continue', 'break' or 'return'.");
+                               declare_list();
+                               if (token != TokenName.RPAREN) {
+                                       throwSyntaxError("')' expected in 'declare' statement.");
                                }
                                getNextToken();
-                       }
-                       return;
-               } else if (token == TokenNameecho) {
-                       getNextToken();
-                       expressionList();
-                       if (token == TokenNameSEMICOLON) {
+                               declare_statement();
+                               return statement;
+
+                       case TRY:
                                getNextToken();
-                       } else {
-                               if (token != TokenNameINLINE_HTML) {
-                                       throwSyntaxError("';' expected after 'echo' statement.");
+                               if (token != TokenName.LBRACE) {
+                                       throwSyntaxError("'{' expected in 'try' statement.");
                                }
+
                                getNextToken();
-                       }
-                       return;
-               } else if (token == TokenNameINLINE_HTML) {
-                       getNextToken();
-                       return;
-                       //    } else if (token == TokenNameprint) {
-                       //      getNextToken();
-                       //      expression();
-                       //      if (token == TokenNameSEMICOLON) {
-                       //        getNextToken();
-                       //      } else {
-                       //        if (token != TokenNameStopPHP) {
-                       //          throwSyntaxError("';' expected after 'print' statement.");
-                       //        }
-                       //        getNextToken();
-                       //      }
-                       //      return;
-               } else if (token == TokenNameglobal) {
-                       getNextToken();
-                       global_var_list();
-                       if (token == TokenNameSEMICOLON) {
+
+                               if (token != TokenName.RBRACE) {                // Process the statement only if there is (possibly) a statement
+                                       statementList ();
+
+                                       if (token != TokenName.RBRACE) {
+                                               throwSyntaxError("'}' expected in 'try' statement.");
+                                       }
+                               }
+
                                getNextToken();
-                       } else {
-                               if (token != TokenNameINLINE_HTML) {
-                                       throwSyntaxError("';' expected after 'global' statement.");
+                               return statement;
+
+                       case CATCH:
+                               getNextToken();
+                               if (token != TokenName.LPAREN) {
+                                       throwSyntaxError("'(' expected in 'catch' statement.");
                                }
                                getNextToken();
-                       }
-                       return;
-               } else if (token == TokenNamestatic) {
-                       getNextToken();
-                       static_var_list();
-                       if (token == TokenNameSEMICOLON) {
+                               fully_qualified_class_name();
+                               if (token != TokenName.VARIABLE) {
+                                       throwSyntaxError("Variable expected in 'catch' statement.");
+                               }
+                               addVariableSet();
                                getNextToken();
-                       } else {
-                               if (token != TokenNameINLINE_HTML) {
-                                       throwSyntaxError("';' expected after 'static' statement.");
+                               if (token != TokenName.RPAREN) {
+                                       throwSyntaxError("')' expected in 'catch' statement.");
                                }
                                getNextToken();
-                       }
-                       return;
-               } else if (token == TokenNameunset) {
-                       getNextToken();
-                       if (token == TokenNameLPAREN) {
+                               if (token != TokenName.LBRACE) {
+                                       throwSyntaxError("'{' expected in 'catch' statement.");
+                               }
                                getNextToken();
-                       } else {
-                               throwSyntaxError("'(' expected after 'unset' statement.");
-                       }
-                       unset_variables();
-                       if (token == TokenNameRPAREN) {
+                               if (token != TokenName.RBRACE) {
+                                       statementList();
+                                       if (token != TokenName.RBRACE) {
+                                               throwSyntaxError("'}' expected in 'catch' statement.");
+                                       }
+                               }
                                getNextToken();
-                       } else {
-                               throwSyntaxError("')' expected after 'unset' statement.");
-                       }
-                       if (token == TokenNameSEMICOLON) {
+                               additional_catches();
+                               return statement;
+
+                       case THROW:
                                getNextToken();
-                       } else {
-                               if (token != TokenNameINLINE_HTML) {
-                                       throwSyntaxError("';' expected after 'unset' statement.");
+                               expr();
+                               if (token == TokenName.SEMICOLON) {
+                                       getNextToken();
+                               } else {
+                                       throwSyntaxError("';' expected after 'throw' exxpression.");
                                }
+                               return statement;
+
+                       case FINAL:
+                       case ABSTRACT:
+                       case CLASS:
+                       case INTERFACE:
+                               try {
+                                       TypeDeclaration typeDecl = new TypeDeclaration (this.compilationUnit.compilationResult);
+                                       typeDecl.declarationSourceStart = scanner.getCurrentTokenStartPosition();
+                                       typeDecl.declarationSourceEnd = scanner.getCurrentTokenEndPosition();
+                                       typeDecl.name = new char[] { ' ' };
+                                       // default super class
+                                       typeDecl.superclass = new SingleTypeReference(TypeConstants.OBJECT, 0);
+                                       compilationUnit.types.add(typeDecl);
+                                       pushOnAstStack(typeDecl);
+                                       unticked_class_declaration_statement(typeDecl);
+                               } finally {
+                                       // reduce stack:
+                                       astPtr--;
+                                       astLengthPtr--;
+                               }
+                               return statement;
+
+                       case LBRACE:
                                getNextToken();
-                       }
-                       return;
-               } else if (token == TokenNamefunction) {
-                       MethodDeclaration methodDecl = new MethodDeclaration(
-                                       this.compilationUnit.compilationResult);
-                       methodDecl.declarationSourceStart = scanner
-                                       .getCurrentTokenStartPosition();
-                       getNextToken();
-                       functionDefinition(methodDecl);
-                       return;
-               } else if (token == TokenNametry) {
-                       getNextToken();
-                       if (token != TokenNameLBRACE) {
-                               throwSyntaxError("'{' expected in 'try' statement.");
-                       }
+                               if (token != TokenName.RBRACE) {
+                                       statement = statementList();
+                               }
+                               if (token == TokenName.RBRACE) {
+                                       getNextToken();
+                                       return statement;
+                               } else {
+                                       throwSyntaxError("'}' expected.");
+                               }
+                               break;
+
+                       default:
+                               if (token != TokenName.SEMICOLON) {
+                                       expr();
+                               }
+
+                               if (token == TokenName.SEMICOLON) {
+                                       getNextToken();
+                                       return statement;
+                               }
+                               else if (token == TokenName.COLON) {            // Colon after Label identifier
+                    getNextToken();
+                    return statement;
+                               }
+                               else {
+                                       if (token == TokenName.RBRACE) {
+                                               reportSyntaxError ("';' expected after expression (Found token: "
+                                                               + scanner.toStringAction(token) + ")");
+                                       }
+                                       else {
+                                               if (token == TokenName.PAAMAYIM_NEKUDOTAYIM) {
+                                                       getNextToken ();
+
+                                                       if (token != TokenName.IDENTIFIER) {
+                                                               throwSyntaxError("identifier expected after '::'.");
+                                                       }
+                                                       else {
+                                                               getNextToken ();
+                                                       }
+                                               }
+                                               else if (token != TokenName.INLINE_HTML && token != TokenName.EOF) {
+                                                       throwSyntaxError ("';' expected after expression (Found token: "
+                                                                       + scanner.toStringAction(token) + ")");
+                                               }
+                                               getNextToken();
+                                       }
+                               }
+                               break;
+               }
+               // may be null
+               return statement;
+       }
+
+       private void declare_statement() {
+               // statement
+               // | ':' inner_statement_list T_ENDDECLARE ';'
+               // ;
+               if (token == TokenName.COLON) {
                        getNextToken();
+                       // TODO: implement inner_statement_list();
                        statementList();
-                       if (token != TokenNameRBRACE) {
-                               throwSyntaxError("'}' expected in 'try' statement.");
+                       if (token != TokenName.ENDDECLARE) {
+                               throwSyntaxError("'enddeclare' expected in 'declare' statement.");
                        }
                        getNextToken();
-                       return;
-               } else if (token == TokenNamecatch) {
-                       getNextToken();
-                       if (token != TokenNameLPAREN) {
-                               throwSyntaxError("'(' expected in 'catch' statement.");
+                       if (token != TokenName.SEMICOLON) {
+                               throwSyntaxError("';' expected after 'enddeclare' keyword.");
                        }
                        getNextToken();
-                       fully_qualified_class_name();
-                       if (token != TokenNameVariable) {
-                               throwSyntaxError("Variable expected in 'catch' statement.");
-                       }
-                       getNextToken();
-                       if (token != TokenNameRPAREN) {
-                               throwSyntaxError("')' expected in 'catch' statement.");
-                       }
-                       getNextToken();
-                       if (token != TokenNameLBRACE) {
-                               throwSyntaxError("'{' expected in 'catch' statement.");
+               } else {
+                       statement();
+               }
+       }
+
+       private void declare_list() {
+               // T_STRING '=' static_scalar
+               // | declare_list ',' T_STRING '=' static_scalar
+               while (true) {
+                       if (token != TokenName.IDENTIFIER) {
+                               throwSyntaxError("Identifier expected in 'declare' list.");
                        }
                        getNextToken();
-                       if (token != TokenNameRBRACE) {
-                               statementList();
-                               if (token != TokenNameRBRACE) {
-                                       throwSyntaxError("'}' expected in 'catch' statement.");
-                               }
+                       if (token != TokenName.EQUAL) {
+                               throwSyntaxError("'=' expected in 'declare' list.");
                        }
                        getNextToken();
-                       additional_catches();
-                       return;
-               } else if (token == TokenNamethrow) {
-                       getNextToken();
-                       expr();
-                       if (token == TokenNameSEMICOLON) {
-                               getNextToken();
-                       } else {
-                               throwSyntaxError("';' expected after 'throw' exxpression.");
-                       }
-                       return;
-               } else if (token == TokenNamefinal || token == TokenNameabstract
-                               || token == TokenNameclass || token == TokenNameinterface) {
-                       TypeDeclaration typeDecl = new TypeDeclaration(
-                                       this.compilationUnit.compilationResult);
-                       typeDecl.declarationSourceStart = scanner
-                                       .getCurrentTokenStartPosition();
-                       // default super class
-                       typeDecl.superclass = new SingleTypeReference(TypeConstants.OBJECT,
-                                       0);
-                       compilationUnit.types.add(typeDecl);
-                       try {
-                               pushOnAstStack(typeDecl);
-                               unticked_class_declaration_statement(typeDecl);
-                               //        classBody(typeDecl);
-                       } finally {
-                               astPtr--;
-                               astLengthPtr--;
+                       static_scalar();
+                       if (token != TokenName.COMMA) {
+                               break;
                        }
-                       return;
-                       //      } else {
-                       //        throwSyntaxError("Unexpected keyword '" + keyword + "'");
-               } else if (token == TokenNameLBRACE) {
                        getNextToken();
-                       if (token != TokenNameRBRACE) {
-                               statementList();
-                       }
-                       if (token == TokenNameRBRACE) {
-                               getNextToken();
-                               return;
-                       } else {
-                               throwSyntaxError("'}' expected.");
-                       }
-               } else {
-                       if (token != TokenNameSEMICOLON) {
-                               expr();
-                       }
-                       if (token == TokenNameSEMICOLON) {
-                               getNextToken();
-                               return;
-                       } else {
-                               if (token != TokenNameINLINE_HTML && token != TokenNameEOF) {
-                                       throwSyntaxError("';' expected after expression (Found token: "
-                                                       + scanner.toStringAction(token) + ")");
-                               }
-                               getNextToken();
-                       }
                }
        }
+
        private void additional_catches() {
-               while (token == TokenNamecatch) {
+               while (token == TokenName.CATCH) {
                        getNextToken();
-                       if (token != TokenNameLPAREN) {
+                       if (token != TokenName.LPAREN) {
                                throwSyntaxError("'(' expected in 'catch' statement.");
                        }
                        getNextToken();
                        fully_qualified_class_name();
-                       if (token != TokenNameVariable) {
+                       if (token != TokenName.VARIABLE) {
                                throwSyntaxError("Variable expected in 'catch' statement.");
                        }
+                       addVariableSet();
                        getNextToken();
-                       if (token != TokenNameRPAREN) {
+                       if (token != TokenName.RPAREN) {
                                throwSyntaxError("')' expected in 'catch' statement.");
                        }
                        getNextToken();
-                       if (token != TokenNameLBRACE) {
+                       if (token != TokenName.LBRACE) {
                                throwSyntaxError("'{' expected in 'catch' statement.");
                        }
                        getNextToken();
-                       statementList();
-                       if (token != TokenNameRBRACE) {
+                       if (token != TokenName.RBRACE) {
+                               statementList();
+                       }
+                       if (token != TokenName.RBRACE) {
                                throwSyntaxError("'}' expected in 'catch' statement.");
                        }
                        getNextToken();
                }
        }
+
        private void foreach_variable() {
-               //      w_variable
-               //| '&' w_variable
-               if (token == TokenNameAND) {
+               // w_variable
+               // | '&' w_variable
+               if (token == TokenName.OP_AND) {
                        getNextToken();
                }
-               w_variable();
+               w_variable(true);
        }
+
        private void foreach_optional_arg() {
-               //      /* empty */
-               //| T_DOUBLE_ARROW foreach_variable
-               if (token == TokenNameEQUAL_GREATER) {
+               // /* empty */
+               // | T_DOUBLE_ARROW foreach_variable
+               if (token == TokenName.EQUAL_GREATER) {
                        getNextToken();
                        foreach_variable();
                }
        }
+
        private void global_var_list() {
-               //  global_var_list:
-               //      global_var_list ',' global_var
-               //| global_var
+               // global_var_list:
+               // global_var_list ',' global_var
+               // | global_var
+               HashSet set = peekVariableSet();
                while (true) {
-                       global_var();
-                       if (token != TokenNameCOMMA) {
+                       global_var(set);
+                       if (token != TokenName.COMMA) {
                                break;
                        }
                        getNextToken();
                }
        }
-       private void global_var() {
-               //global_var:
-               //      T_VARIABLE
-               //| '$' r_variable
-               //| '$' '{' expr '}'
-               if (token == TokenNameVariable) {
+
+       private void global_var(HashSet set) {
+               // global_var:
+               // T_VARIABLE
+               // | '$' r_variable
+               // | '$' '{' expr '}'
+               if (token == TokenName.VARIABLE) {
+                       if (fMethodVariables != null) {
+                               VariableInfo info = new VariableInfo(scanner
+                                               .getCurrentTokenStartPosition(),
+                                               VariableInfo.LEVEL_GLOBAL_VAR);
+                               fMethodVariables.put(new String(scanner
+                                               .getCurrentIdentifierSource()), info);
+                       }
+                       addVariableSet(set);
                        getNextToken();
-               } else if (token == TokenNameDOLLAR) {
+               } else if (token == TokenName.DOLLAR) {
                        getNextToken();
-                       if (token == TokenNameLPAREN) {
+                       if (token == TokenName.LBRACE) {
                                getNextToken();
                                expr();
-                               if (token != TokenNameLPAREN) {
-                                       throwSyntaxError("')' expected in global variable.");
+                               if (token != TokenName.RBRACE) {
+                                       throwSyntaxError("'}' expected in global variable.");
                                }
                                getNextToken();
                        } else {
@@ -1050,20 +1337,30 @@ public class Parser //extends PHPParserSuperclass
                        }
                }
        }
+
        private void static_var_list() {
-               //static_var_list:
-               //      static_var_list ',' T_VARIABLE
-               //| static_var_list ',' T_VARIABLE '=' static_scalar
-               //| T_VARIABLE
-               //| T_VARIABLE '=' static_scalar
+               // static_var_list:
+               // static_var_list ',' T_VARIABLE
+               // | static_var_list ',' T_VARIABLE '=' static_scalar
+               // | T_VARIABLE
+               // | T_VARIABLE '=' static_scalar,
+               HashSet set = peekVariableSet();
                while (true) {
-                       if (token == TokenNameVariable) {
+                       if (token == TokenName.VARIABLE) {
+                               if (fMethodVariables != null) {
+                                       VariableInfo info = new VariableInfo(scanner
+                                                       .getCurrentTokenStartPosition(),
+                                                       VariableInfo.LEVEL_STATIC_VAR);
+                                       fMethodVariables.put(new String(scanner
+                                                       .getCurrentIdentifierSource()), info);
+                               }
+                               addVariableSet(set);
                                getNextToken();
-                               if (token == TokenNameEQUAL) {
+                               if (token == TokenName.EQUAL) {
                                        getNextToken();
                                        static_scalar();
                                }
-                               if (token != TokenNameCOMMA) {
+                               if (token != TokenName.COMMA) {
                                        break;
                                }
                                getNextToken();
@@ -1072,105 +1369,115 @@ public class Parser //extends PHPParserSuperclass
                        }
                }
        }
+
        private void unset_variables() {
-               //    unset_variables:
-               //              unset_variable
-               //      | unset_variables ',' unset_variable
-               //    unset_variable:
-               //              variable
+               // unset_variables:
+               // unset_variable
+               // | unset_variables ',' unset_variable
+               // unset_variable:
+               // variable
                while (true) {
-                       variable();
-                       if (token != TokenNameCOMMA) {
+                       variable(false, false);
+                       if (token != TokenName.COMMA) {
                                break;
                        }
                        getNextToken();
                }
        }
+
        private final void initializeModifiers() {
                this.modifiers = 0;
                this.modifiersSourceStart = -1;
        }
+
        private final void checkAndSetModifiers(int flag) {
                this.modifiers |= flag;
                if (this.modifiersSourceStart < 0)
                        this.modifiersSourceStart = this.scanner.startPosition;
        }
+
        private void unticked_class_declaration_statement(TypeDeclaration typeDecl) {
                initializeModifiers();
-               if (token == TokenNameinterface) {
-                       //      interface_entry T_STRING
-                       //              interface_extends_list
-                       //              '{' class_statement_list '}'
+               if (token == TokenName.INTERFACE) {
+                       // interface_entry T_STRING
+                       // interface_extends_list
+                       // '{' class_statement_list '}'
                        checkAndSetModifiers(AccInterface);
                        getNextToken();
                        typeDecl.modifiers = this.modifiers;
-                       if (token == TokenNameIdentifier || token > TokenNameKEYWORD) {
-                               typeDecl.sourceStart = scanner.getCurrentTokenStartPosition();
-                               typeDecl.sourceEnd = scanner.getCurrentTokenEndPosition();
+                       typeDecl.sourceStart = scanner.getCurrentTokenStartPosition();
+                       typeDecl.sourceEnd = scanner.getCurrentTokenEndPosition();
+                       if (token == TokenName.IDENTIFIER || token.compareTo (TokenName.KEYWORD) > 0) {
                                typeDecl.name = scanner.getCurrentIdentifierSource();
-                               if (token > TokenNameKEYWORD) {
-                                       throwSyntaxError(
-                                                       "Don't use a keyword for interface declaration ["
-                                                                       + scanner.toStringAction(token) + "].",
-                                                       typeDecl.sourceStart, typeDecl.sourceEnd);
+                               if (token.compareTo (TokenName.KEYWORD) > 0) {
+                                       problemReporter.phpKeywordWarning(new String[] { scanner
+                                                       .toStringAction(token) }, scanner
+                                                       .getCurrentTokenStartPosition(), scanner
+                                                       .getCurrentTokenEndPosition(), referenceContext,
+                                                       compilationUnit.compilationResult);
+                                       // throwSyntaxError("Don't use a keyword for interface
+                                       // declaration ["
+                                       // + scanner.toStringAction(token) + "].",
+                                       // typeDecl.sourceStart, typeDecl.sourceEnd);
                                }
                                getNextToken();
-                               interface_extends_list();
+                               interface_extends_list(typeDecl);
                        } else {
-                               typeDecl.sourceStart = scanner.getCurrentTokenStartPosition();
-                               typeDecl.sourceEnd = scanner.getCurrentTokenEndPosition();
-                               typeDecl.name = new char[]{' '};
+                               typeDecl.name = new char[] { ' ' };
                                throwSyntaxError(
                                                "Interface name expected after keyword 'interface'.",
                                                typeDecl.sourceStart, typeDecl.sourceEnd);
                                return;
                        }
                } else {
-                       //      class_entry_type T_STRING extends_from
-                       //              implements_list
-                       //              '{' class_statement_list'}'
+                       // class_entry_type T_STRING extends_from
+                       // implements_list
+                       // '{' class_statement_list'}'
                        class_entry_type();
                        typeDecl.modifiers = this.modifiers;
-                       //identifier
-                       //identifier 'extends' identifier
-                       if (token == TokenNameIdentifier || token > TokenNameKEYWORD) {
-                               typeDecl.sourceStart = scanner.getCurrentTokenStartPosition();
-                               typeDecl.sourceEnd = scanner.getCurrentTokenEndPosition();
+                       typeDecl.sourceStart = scanner.getCurrentTokenStartPosition();
+                       typeDecl.sourceEnd = scanner.getCurrentTokenEndPosition();
+                       // identifier
+                       // identifier 'extends' identifier
+                       if (token == TokenName.IDENTIFIER || token.compareTo (TokenName.KEYWORD) > 0) {
                                typeDecl.name = scanner.getCurrentIdentifierSource();
-                               if (token > TokenNameKEYWORD) {
-                                       throwSyntaxError(
-                                                       "Don't use a keyword for class declaration ["
-                                                                       + scanner.toStringAction(token) + "].",
-                                                       typeDecl.sourceStart, typeDecl.sourceEnd);
-                               }
-                               getNextToken();
-                               //    extends_from:
-                               //              /* empty */
-                               //      | T_EXTENDS fully_qualified_class_name
-                               if (token == TokenNameextends) {
-                                       interface_extends_list();
-                                       //          getNextToken();
-                                       //          if (token != TokenNameIdentifier) {
-                                       //            throwSyntaxError("Class name expected after keyword
+                               if (token.compareTo (TokenName.KEYWORD) > 0) {
+                                       problemReporter.phpKeywordWarning(new String[] { scanner
+                                                       .toStringAction(token) }, scanner
+                                                       .getCurrentTokenStartPosition(), scanner
+                                                       .getCurrentTokenEndPosition(), referenceContext,
+                                                       compilationUnit.compilationResult);
+                                       // throwSyntaxError("Don't use a keyword for class
+                                       // declaration [" +
+                                       // scanner.toStringAction(token) + "].",
+                                       // typeDecl.sourceStart, typeDecl.sourceEnd);
+                               }
+                               getNextToken();
+                               // extends_from:
+                               // /* empty */
+                               // | T_EXTENDS fully_qualified_class_name
+                               if (token == TokenName.EXTENDS) {
+                                       class_extends_list(typeDecl);
+                                       // getNextToken();
+                                       // if (token != TokenName.IDENTIFIER) {
+                                       // throwSyntaxError("Class name expected after keyword
                                        // 'extends'.",
-                                       //                scanner.getCurrentTokenStartPosition(), scanner
-                                       //                    .getCurrentTokenEndPosition());
-                                       //          }
+                                       // scanner.getCurrentTokenStartPosition(), scanner
+                                       // .getCurrentTokenEndPosition());
+                                       // }
                                }
-                               implements_list();
+                               implements_list(typeDecl);
                        } else {
-                               typeDecl.sourceStart = scanner.getCurrentTokenStartPosition();
-                               typeDecl.sourceEnd = scanner.getCurrentTokenEndPosition();
-                               typeDecl.name = new char[]{' '};
+                               typeDecl.name = new char[] { ' ' };
                                throwSyntaxError("Class name expected after keyword 'class'.",
                                                typeDecl.sourceStart, typeDecl.sourceEnd);
                                return;
                        }
                }
-               //  '{' class_statement_list '}'
-               if (token == TokenNameLBRACE) {
+               // '{' class_statement_list '}'
+               if (token == TokenName.LBRACE) {
                        getNextToken();
-                       if (token != TokenNameRBRACE) {
+                       if (token != TokenName.RBRACE) {
                                ArrayList list = new ArrayList();
                                class_statement_list(list);
                                typeDecl.fields = new FieldDeclaration[list.size()];
@@ -1178,7 +1485,7 @@ public class Parser //extends PHPParserSuperclass
                                        typeDecl.fields[i] = (FieldDeclaration) list.get(i);
                                }
                        }
-                       if (token == TokenNameRBRACE) {
+                       if (token == TokenName.RBRACE) {
                                typeDecl.declarationSourceEnd = scanner
                                                .getCurrentTokenEndPosition();
                                getNextToken();
@@ -1189,23 +1496,24 @@ public class Parser //extends PHPParserSuperclass
                        throwSyntaxError("'{' expected at start of class body.");
                }
        }
+
        private void class_entry_type() {
-               //      T_CLASS
-               //      | T_ABSTRACT T_CLASS
-               //      | T_FINAL T_CLASS
-               if (token == TokenNameclass) {
+               // T_CLASS
+               // | T_ABSTRACT T_CLASS
+               // | T_FINAL T_CLASS
+               if (token == TokenName.CLASS) {
                        getNextToken();
-               } else if (token == TokenNameabstract) {
+               } else if (token == TokenName.ABSTRACT) {
                        checkAndSetModifiers(AccAbstract);
                        getNextToken();
-                       if (token != TokenNameclass) {
+                       if (token != TokenName.CLASS) {
                                throwSyntaxError("Keyword 'class' expected after keyword 'abstract'.");
                        }
                        getNextToken();
-               } else if (token == TokenNamefinal) {
+               } else if (token == TokenName.FINAL) {
                        checkAndSetModifiers(AccFinal);
                        getNextToken();
-                       if (token != TokenNameclass) {
+                       if (token != TokenName.CLASS) {
                                throwSyntaxError("Keyword 'class' expected after keyword 'final'.");
                        }
                        getNextToken();
@@ -1213,74 +1521,179 @@ public class Parser //extends PHPParserSuperclass
                        throwSyntaxError("Keyword 'class' 'final' or 'abstract' expected");
                }
        }
-       private void interface_extends_list() {
-               //      /* empty */
-               //      | T_EXTENDS interface_list
-               if (token == TokenNameextends) {
+
+       // private void class_extends(TypeDeclaration typeDecl) {
+       // // /* empty */
+       // // | T_EXTENDS interface_list
+       // if (token == TokenName.EXTENDS) {
+       // getNextToken();
+       //
+       // if (token == TokenName.IDENTIFIER) {
+       // getNextToken();
+       // } else {
+       // throwSyntaxError("Class name expected after keyword 'extends'.");
+       // }
+       // }
+       // }
+
+       private void interface_extends_list(TypeDeclaration typeDecl) {
+               // /* empty */
+               // | T_EXTENDS interface_list
+               if (token == TokenName.EXTENDS) {
+                       getNextToken();
+                       interface_list(typeDecl);
+               }
+       }
+
+       private void class_extends_list(TypeDeclaration typeDecl) {
+               // /* empty */
+               // | T_EXTENDS interface_list
+               if (token == TokenName.EXTENDS) {
                        getNextToken();
-                       interface_list();
+                       class_list(typeDecl);
                }
        }
-       private void implements_list() {
-               //      /* empty */
-               //      | T_IMPLEMENTS interface_list
-               if (token == TokenNameimplements) {
+
+       private void implements_list(TypeDeclaration typeDecl) {
+               // /* empty */
+               // | T_IMPLEMENTS interface_list
+               if (token == TokenName.IMPLEMENTS) {
                        getNextToken();
-                       interface_list();
+                       interface_list(typeDecl);
                }
        }
-       private void interface_list() {
-               //  interface_list:
-               //      fully_qualified_class_name
-               //| interface_list ',' fully_qualified_class_name
+
+       private void class_list(TypeDeclaration typeDecl) {
+               // class_list:
+               // fully_qualified_class_name
+               do {
+                       if (token == TokenName.IDENTIFIER) {
+                               //char[] ident = scanner.getCurrentIdentifierSource();
+                               // TODO make this code working better:
+                               // SingleTypeReference ref =
+                               // ParserUtil.getTypeReference(scanner,
+                               // includesList, ident);
+                               // if (ref != null) {
+                               // typeDecl.superclass = ref;
+                               // }
+                               getNextToken();
+                       } else {
+                               throwSyntaxError("Classname expected after keyword 'extends'.");
+                       }
+                       if (token == TokenName.COMMA) {
+                               reportSyntaxError("No multiple inheritance allowed. Expected token 'implements' or '{'.");
+                               getNextToken();
+                               continue;
+                       } else {
+                               break;
+                       }
+               } while (true);
+       }
+
+       private void interface_list(TypeDeclaration typeDecl) {
+               // interface_list:
+               // fully_qualified_class_name
+               // | interface_list ',' fully_qualified_class_name
                do {
-                       if (token == TokenNameIdentifier) {
+                       if (token == TokenName.IDENTIFIER) {
                                getNextToken();
                        } else {
-                               throwSyntaxError("Interface name expected after keyword 'implements'.");
+                               throwSyntaxError("Interfacename expected after keyword 'implements'.");
                        }
-                       if (token != TokenNameCOMMA) {
+                       if (token != TokenName.COMMA) {
                                return;
                        }
                        getNextToken();
                } while (true);
        }
-       //  private void classBody(TypeDeclaration typeDecl) {
-       //    //'{' [class-element-list] '}'
-       //    if (token == TokenNameLBRACE) {
-       //      getNextToken();
-       //      if (token != TokenNameRBRACE) {
-       //        class_statement_list();
-       //      }
-       //      if (token == TokenNameRBRACE) {
-       //        typeDecl.declarationSourceEnd = scanner.getCurrentTokenEndPosition();
-       //        getNextToken();
-       //      } else {
-       //        throwSyntaxError("'}' expected at end of class body.");
-       //      }
-       //    } else {
-       //      throwSyntaxError("'{' expected at start of class body.");
-       //    }
-       //  }
+
+       // private void classBody(TypeDeclaration typeDecl) {
+       // //'{' [class-element-list] '}'
+       // if (token == TokenName.LBRACE) {
+       // getNextToken();
+       // if (token != TokenName.RBRACE) {
+       // class_statement_list();
+       // }
+       // if (token == TokenName.RBRACE) {
+       // typeDecl.declarationSourceEnd = scanner.getCurrentTokenEndPosition();
+       // getNextToken();
+       // } else {
+       // throwSyntaxError("'}' expected at end of class body.");
+       // }
+       // } else {
+       // throwSyntaxError("'{' expected at start of class body.");
+       // }
+       // }
        private void class_statement_list(ArrayList list) {
                do {
-                       class_statement(list);
-               } while (token == TokenNamepublic || token == TokenNameprotected
-                               || token == TokenNameprivate || token == TokenNamestatic
-                               || token == TokenNameabstract || token == TokenNamefinal
-                               || token == TokenNamefunction || token == TokenNamevar
-                               || token == TokenNameconst);
+                       try {
+                               class_statement(list);
+                               if (token == TokenName.PUBLIC       ||
+                                   token == TokenName.PROTECTED        ||
+                                       token == TokenName.PRIVATE      ||
+                                       token == TokenName.STATIC       ||
+                                       token == TokenName.ABSTRACT     ||
+                                       token == TokenName.FINAL        ||
+                                       token == TokenName.FUNCTION     ||
+                                       token == TokenName.VAR          ||
+                                       token == TokenName.CONST) {
+                                       continue;
+                               }
+
+                               if (token == TokenName.RBRACE) {
+                                       break;
+                               }
+
+                               throwSyntaxError("'}' at end of class statement.");
+                       }
+                       catch (SyntaxError sytaxErr1) {
+                               boolean tokenize = scanner.tokenizeStrings;
+
+                               if (!tokenize) {
+                                       scanner.tokenizeStrings = true;
+                               }
+                               try {
+                                       // if an error occured,
+                                       // try to find keywords
+                                       // to parse the rest of the string
+                                       while (token != TokenName.EOF) {
+                                               if (token == TokenName.PUBLIC       ||
+                                                       token == TokenName.PROTECTED    ||
+                                                       token == TokenName.PRIVATE      ||
+                                                       token == TokenName.STATIC       ||
+                                                       token == TokenName.ABSTRACT     ||
+                                                       token == TokenName.FINAL        ||
+                                                       token == TokenName.FUNCTION     ||
+                                                       token == TokenName.VAR          ||
+                                                       token == TokenName.CONST) {
+                                                       break;
+                                               }
+                                               // System.out.println(scanner.toStringAction(token));
+                                               getNextToken();
+                                       }
+                                       if (token == TokenName.EOF) {
+                                               throw sytaxErr1;
+                                       }
+                               } finally {
+                                       scanner.tokenizeStrings = tokenize;
+                               }
+                       }
+               } while (true);
        }
+
+       /**
+        *
+        */
        private void class_statement(ArrayList list) {
-               //    class_statement:
-               //              variable_modifiers class_variable_declaration ';'
-               //      | class_constant_declaration ';'
-               //      | method_modifiers T_FUNCTION is_reference T_STRING
-               //    '(' parameter_list ')' method_body
+               // class_statement:
+               // variable_modifiers class_variable_declaration ';'
+               // | class_constant_declaration ';'
+               // | method_modifiers T_FUNCTION is_reference T_STRING
+               // '(' parameter_list ')' method_body
                initializeModifiers();
                int declarationSourceStart = scanner.getCurrentTokenStartPosition();
-               ;
-               if (token == TokenNamevar) {
+
+               if (token == TokenName.VAR) {
                        checkAndSetModifiers(AccPublic);
                        problemReporter.phpVarDeprecatedWarning(scanner
                                        .getCurrentTokenStartPosition(), scanner
@@ -1288,15 +1701,16 @@ public class Parser //extends PHPParserSuperclass
                                        compilationUnit.compilationResult);
                        getNextToken();
                        class_variable_declaration(declarationSourceStart, list);
-               } else if (token == TokenNameconst) {
-                       class_constant_declaration();
-                       if (token != TokenNameSEMICOLON) {
+               } else if (token == TokenName.CONST) {
+                       checkAndSetModifiers(AccFinal | AccPublic);
+                       class_constant_declaration(declarationSourceStart, list);
+                       if (token != TokenName.SEMICOLON) {
                                throwSyntaxError("';' expected after class const declaration.");
                        }
                        getNextToken();
                } else {
                        boolean hasModifiers = member_modifiers();
-                       if (token == TokenNamefunction) {
+                       if (token == TokenName.FUNCTION) {
                                if (!hasModifiers) {
                                        checkAndSetModifiers(AccPublic);
                                }
@@ -1305,8 +1719,19 @@ public class Parser //extends PHPParserSuperclass
                                methodDecl.declarationSourceStart = scanner
                                                .getCurrentTokenStartPosition();
                                methodDecl.modifiers = this.modifiers;
-                               getNextToken();
-                               functionDefinition(methodDecl);
+                               methodDecl.type = MethodDeclaration.METHOD_DEFINITION;
+                               try {
+                                       getNextToken();
+                                       functionDefinition(methodDecl);
+                               } finally {
+                                       int sourceEnd = methodDecl.sourceEnd;
+                                       if (sourceEnd <= 0
+                                                       || methodDecl.declarationSourceStart > sourceEnd) {
+                                               sourceEnd = methodDecl.declarationSourceStart + 1;
+                                       }
+                                       methodDecl.declarationSourceEnd = sourceEnd;
+                                       methodDecl.sourceEnd = sourceEnd;
+                               }
                        } else {
                                if (!hasModifiers) {
                                        throwSyntaxError("'public' 'private' or 'protected' modifier expected for field declarations.");
@@ -1314,104 +1739,105 @@ public class Parser //extends PHPParserSuperclass
                                class_variable_declaration(declarationSourceStart, list);
                        }
                }
-               //    if (token == TokenNamefunction) {
-               //      MethodDeclaration methodDecl = new MethodDeclaration(
-               //          this.compilationUnit.compilationResult);
-               //      methodDecl.declarationSourceStart = scanner
-               //          .getCurrentTokenStartPosition();
-               //      getNextToken();
-               //      functionDefinition(methodDecl);
-               //    } else if (token == TokenNamevar) {
-               //      getNextToken();
-               //      classProperty();
-               //    } else {
-               //      throwSyntaxError("'function' or 'var' expected.");
-               //    }
-       }
-       private void class_constant_declaration() {
-               //      class_constant_declaration ',' T_STRING '=' static_scalar
-               //      | T_CONST T_STRING '=' static_scalar
-               if (token != TokenNameconst) {
+       }
+
+       private void class_constant_declaration(int declarationSourceStart,
+                       ArrayList list) {
+               // class_constant_declaration ',' T_STRING '=' static_scalar
+               // | T_CONST T_STRING '=' static_scalar
+               if (token != TokenName.CONST) {
                        throwSyntaxError("'const' keyword expected in class declaration.");
                } else {
                        getNextToken();
                }
                while (true) {
-                       if (token != TokenNameIdentifier) {
+                       if (token != TokenName.IDENTIFIER) {
                                throwSyntaxError("Identifier expected in class const declaration.");
                        }
+                       FieldDeclaration fieldDeclaration = new FieldDeclaration(scanner
+                                       .getCurrentIdentifierSource(), scanner
+                                       .getCurrentTokenStartPosition(), scanner
+                                       .getCurrentTokenEndPosition());
+                       fieldDeclaration.modifiers = this.modifiers;
+                       fieldDeclaration.declarationSourceStart = declarationSourceStart;
+                       fieldDeclaration.declarationSourceEnd = scanner
+                                       .getCurrentTokenEndPosition();
+                       fieldDeclaration.modifiersSourceStart = declarationSourceStart;
+                       // fieldDeclaration.type
+                       list.add(fieldDeclaration);
                        getNextToken();
-                       if (token != TokenNameEQUAL) {
+                       if (token != TokenName.EQUAL) {
                                throwSyntaxError("'=' expected in class const declaration.");
                        }
                        getNextToken();
                        static_scalar();
-                       if (token != TokenNameCOMMA) {
+                       if (token != TokenName.COMMA) {
                                break; // while(true)-loop
                        }
                        getNextToken();
                }
        }
-       //  private void variable_modifiers() {
-       //    // variable_modifiers:
-       //    // non_empty_member_modifiers
-       //    //| T_VAR
-       //    initializeModifiers();
-       //    if (token == TokenNamevar) {
-       //      checkAndSetModifiers(AccPublic);
-       //      reportSyntaxError(
-       //          "Keyword 'var' is deprecated. Please use 'public' 'private' or
+
+       // private void variable_modifiers() {
+       // // variable_modifiers:
+       // // non_empty_member_modifiers
+       // //| T_VAR
+       // initializeModifiers();
+       // if (token == TokenName.var) {
+       // checkAndSetModifiers(AccPublic);
+       // reportSyntaxError(
+       // "Keyword 'var' is deprecated. Please use 'public' 'private' or
        // 'protected'
        // modifier for field declarations.",
-       //          scanner.getCurrentTokenStartPosition(), scanner
-       //              .getCurrentTokenEndPosition());
-       //      getNextToken();
-       //    } else {
-       //      if (!member_modifiers()) {
-       //        throwSyntaxError("'public' 'private' or 'protected' modifier expected for
+       // scanner.getCurrentTokenStartPosition(), scanner
+       // .getCurrentTokenEndPosition());
+       // getNextToken();
+       // } else {
+       // if (!member_modifiers()) {
+       // throwSyntaxError("'public' 'private' or 'protected' modifier expected for
        // field declarations.");
-       //      }
-       //    }
-       //  }
-       //  private void method_modifiers() {
-       //    //method_modifiers:
-       //    // /* empty */
-       //    //| non_empty_member_modifiers
-       //    initializeModifiers();
-       //    if (!member_modifiers()) {
-       //      checkAndSetModifiers(AccPublic);
-       //    }
-       //  }
+       // }
+       // }
+       // }
+       // private void method_modifiers() {
+       // //method_modifiers:
+       // // /* empty */
+       // //| non_empty_member_modifiers
+       // initializeModifiers();
+       // if (!member_modifiers()) {
+       // checkAndSetModifiers(AccPublic);
+       // }
+       // }
        private boolean member_modifiers() {
-               //      T_PUBLIC
-               //| T_PROTECTED
-               //| T_PRIVATE
-               //| T_STATIC
-               //| T_ABSTRACT
-               //| T_FINAL
+               // T_PUBLIC
+               // | T_PROTECTED
+               // | T_PRIVATE
+               // | T_STATIC
+               // | T_ABSTRACT
+               // | T_FINAL
                boolean foundToken = false;
                while (true) {
-                       if (token == TokenNamepublic) {
+                       if (token == TokenName.PUBLIC) {
                                checkAndSetModifiers(AccPublic);
                                getNextToken();
                                foundToken = true;
-                       } else if (token == TokenNameprotected) {
+                       } else if (token == TokenName.PROTECTED) {
                                checkAndSetModifiers(AccProtected);
                                getNextToken();
                                foundToken = true;
-                       } else if (token == TokenNameprivate) {
+                       } else if (token == TokenName.PRIVATE) {
                                checkAndSetModifiers(AccPrivate);
                                getNextToken();
                                foundToken = true;
-                       } else if (token == TokenNamestatic) {
+                       } else if (token == TokenName.STATIC) {
                                checkAndSetModifiers(AccStatic);
                                getNextToken();
                                foundToken = true;
-                       } else if (token == TokenNameabstract) {
+                       } else if (token == TokenName.ABSTRACT) {
                                checkAndSetModifiers(AccAbstract);
                                getNextToken();
                                foundToken = true;
-                       } else if (token == TokenNamefinal) {
+                       } else if (token == TokenName.FINAL) {
                                checkAndSetModifiers(AccFinal);
                                getNextToken();
                                foundToken = true;
@@ -1421,57 +1847,72 @@ public class Parser //extends PHPParserSuperclass
                }
                return foundToken;
        }
+
        private void class_variable_declaration(int declarationSourceStart,
                        ArrayList list) {
-               //    class_variable_declaration:
-               //              class_variable_declaration ',' T_VARIABLE
-               //      | class_variable_declaration ',' T_VARIABLE '=' static_scalar
-               //      | T_VARIABLE
-               //      | T_VARIABLE '=' static_scalar
+               // class_variable_declaration:
+               // class_variable_declaration ',' T_VARIABLE
+               // | class_variable_declaration ',' T_VARIABLE '=' static_scalar
+               // | T_VARIABLE
+               // | T_VARIABLE '=' static_scalar
+               char[] classVariable;
                do {
-                       if (token == TokenNameVariable) {
+                       if (token == TokenName.VARIABLE) {
+                               classVariable = scanner.getCurrentIdentifierSource();
+                               // indexManager.addIdentifierInformation('v', classVariable,
+                               // buf, -1,
+                               // -1);
                                FieldDeclaration fieldDeclaration = new FieldDeclaration(
-                                               scanner.getCurrentIdentifierSource(), scanner
-                                                               .getCurrentTokenStartPosition(), scanner
-                                                               .getCurrentTokenEndPosition());
+                                               classVariable, scanner.getCurrentTokenStartPosition(),
+                                               scanner.getCurrentTokenEndPosition());
                                fieldDeclaration.modifiers = this.modifiers;
                                fieldDeclaration.declarationSourceStart = declarationSourceStart;
-                               fieldDeclaration.declarationSourceEnd = scanner.getCurrentTokenEndPosition();
+                               fieldDeclaration.declarationSourceEnd = scanner
+                                               .getCurrentTokenEndPosition();
                                fieldDeclaration.modifiersSourceStart = declarationSourceStart;
-                               //        fieldDeclaration.type
                                list.add(fieldDeclaration);
+                               if (fTypeVariables != null) {
+                                       VariableInfo info = new VariableInfo(scanner
+                                                       .getCurrentTokenStartPosition(),
+                                                       VariableInfo.LEVEL_CLASS_UNIT);
+                                       fTypeVariables.put(new String(scanner
+                                                       .getCurrentIdentifierSource()), info);
+                               }
                                getNextToken();
-                               if (token == TokenNameEQUAL) {
+                               if (token == TokenName.EQUAL) {
                                        getNextToken();
                                        static_scalar();
                                }
                        } else {
-                               //        if (token == TokenNamethis) {
-                               //          throwSyntaxError("'$this' not allowed after keyword 'public'
+                               // if (token == TokenName.THIS) {
+                               // throwSyntaxError("'$this' not allowed after keyword 'public'
                                // 'protected' 'private' 'var'.");
-                               //        }
+                               // }
                                throwSyntaxError("Variable expected after keyword 'public' 'protected' 'private' 'var'.");
                        }
-                       if (token != TokenNameCOMMA) {
+                       if (token != TokenName.COMMA) {
                                break;
                        }
                        getNextToken();
                } while (true);
-               if (token != TokenNameSEMICOLON) {
+               if (token != TokenName.SEMICOLON) {
                        throwSyntaxError("';' expected after field declaration.");
                }
                getNextToken();
        }
+
        private void functionDefinition(MethodDeclaration methodDecl) {
                boolean isAbstract = false;
                if (astPtr == 0) {
-                       compilationUnit.types.add(methodDecl);
+                       if (compilationUnit != null) {
+                               compilationUnit.types.add(methodDecl);
+                       }
                } else {
-                       AstNode node = astStack[astPtr];
+                       ASTNode node = astStack[astPtr];
                        if (node instanceof TypeDeclaration) {
                                TypeDeclaration typeDecl = ((TypeDeclaration) node);
                                if (typeDecl.methods == null) {
-                                       typeDecl.methods = new AbstractMethodDeclaration[]{methodDecl};
+                                       typeDecl.methods = new AbstractMethodDeclaration[] { methodDecl };
                                } else {
                                        AbstractMethodDeclaration[] newMethods;
                                        System
@@ -1479,8 +1920,8 @@ public class Parser //extends PHPParserSuperclass
                                                                        typeDecl.methods,
                                                                        0,
                                                                        newMethods = new AbstractMethodDeclaration[typeDecl.methods.length + 1],
-                                                                       1, typeDecl.methods.length);
-                                       newMethods[0] = methodDecl;
+                                                                       0, typeDecl.methods.length);
+                                       newMethods[typeDecl.methods.length] = methodDecl;
                                        typeDecl.methods = newMethods;
                                }
                                if ((typeDecl.modifiers & AccAbstract) == AccAbstract) {
@@ -1490,85 +1931,152 @@ public class Parser //extends PHPParserSuperclass
                                }
                        }
                }
-               functionDeclarator(methodDecl);
-               if (token == TokenNameSEMICOLON) {
-                       if (!isAbstract) {
-                               throwSyntaxError("Body declaration expected for method: "
-                                               + new String(methodDecl.selector));
+               try {
+                       pushFunctionVariableSet();
+                       functionDeclarator(methodDecl);
+                       if (token == TokenName.SEMICOLON) {
+                               if (!isAbstract) {
+                                       methodDecl.sourceEnd = scanner
+                                                       .getCurrentTokenStartPosition() - 1;
+                                       throwSyntaxError("Body declaration expected for method: "
+                                                       + new String(methodDecl.selector));
+                               }
+                               getNextToken();
+                               return;
+                       }
+                       functionBody(methodDecl);
+               } finally {
+                       if (!fStackUnassigned.isEmpty()) {
+                               fStackUnassigned.remove(fStackUnassigned.size() - 1);
                        }
-                       getNextToken();
-                       return;
                }
-               functionBody(methodDecl);
        }
+
        private void functionDeclarator(MethodDeclaration methodDecl) {
-               //identifier '(' [parameter-list] ')'
-               if (token == TokenNameAND) {
+               // identifier '(' [parameter-list] ')'
+               if (token == TokenName.OP_AND) {
                        getNextToken();
                }
-               if (token == TokenNameIdentifier) {
-                       methodDecl.sourceStart = scanner.getCurrentTokenStartPosition();
-                       methodDecl.sourceEnd = scanner.getCurrentTokenEndPosition();
-                       methodDecl.selector = scanner.getCurrentIdentifierSource();
-                       getNextToken();
-                       if (token == TokenNameLPAREN) {
+
+               methodDecl.sourceStart = scanner.getCurrentTokenStartPosition();
+               methodDecl.sourceEnd = scanner.getCurrentTokenEndPosition();
+
+               if (Scanner.isIdentifierOrKeyword (token) ||
+                   token == TokenName.LPAREN) {
+
+                   if (token == TokenName.LPAREN) {
+                       methodDecl.selector = scanner.getCurrentIdentifierSource();
+
+                if (token.compareTo (TokenName.KEYWORD) > 0) {
+                    problemReporter.phpKeywordWarning (new String[] {scanner.toStringAction(token) },
+                                                       scanner.getCurrentTokenStartPosition(),
+                                                       scanner.getCurrentTokenEndPosition(),
+                                                       referenceContext,
+                                                       compilationUnit.compilationResult);
+                }
+                   }
+                   else {
+                       methodDecl.selector = scanner.getCurrentIdentifierSource();
+
+                       if (token.compareTo (TokenName.KEYWORD) > 0) {
+                           problemReporter.phpKeywordWarning (new String[] {scanner.toStringAction(token) },
+                                                                              scanner.getCurrentTokenStartPosition(),
+                                                                              scanner.getCurrentTokenEndPosition(),
+                                                                              referenceContext,
+                                                                              compilationUnit.compilationResult);
+                       }
+
+                       getNextToken();
+                   }
+
+                       if (token == TokenName.LPAREN) {
                                getNextToken();
-                       } else {
+                       }
+                       else {
+                               methodDecl.sourceEnd = scanner.getCurrentTokenStartPosition() - 1;
                                throwSyntaxError("'(' expected in function declaration.");
                        }
-                       if (token != TokenNameRPAREN) {
-                               parameter_list();
+
+                       if (token != TokenName.RPAREN) {
+                               parameter_list(methodDecl);
                        }
-                       if (token != TokenNameRPAREN) {
+
+                       if (token != TokenName.RPAREN) {
+                               methodDecl.sourceEnd = scanner.getCurrentTokenStartPosition() - 1;
                                throwSyntaxError("')' expected in function declaration.");
-                       } else {
+                       }
+                       else {
                                methodDecl.bodyStart = scanner.getCurrentTokenEndPosition() + 1;
                                getNextToken();
                        }
-               } else {
-                       if (token > TokenNameKEYWORD) {
-                               throwSyntaxError("Don't use keyword for function declaration ["
-                                               + token + "].");
-                       }
+               }
+               else {
+                       methodDecl.selector = "<undefined>".toCharArray();
+                       methodDecl.sourceEnd = scanner.getCurrentTokenStartPosition() - 1;
                        throwSyntaxError("Function name expected after keyword 'function'.");
                }
        }
+
        //
-       private void parameter_list() {
-               //      non_empty_parameter_list
-               //      | /* empty */
-               non_empty_parameter_list(true);
-       }
-       private void non_empty_parameter_list(boolean empty_allowed) {
-               //      optional_class_type T_VARIABLE
-               //      | optional_class_type '&' T_VARIABLE
-               //      | optional_class_type '&' T_VARIABLE '=' static_scalar
-               //      | optional_class_type T_VARIABLE '=' static_scalar
-               //      | non_empty_parameter_list ',' optional_class_type T_VARIABLE
-               //      | non_empty_parameter_list ',' optional_class_type '&' T_VARIABLE
-               //      | non_empty_parameter_list ',' optional_class_type '&' T_VARIABLE '='
+       private void parameter_list(MethodDeclaration methodDecl) {
+               // non_empty_parameter_list
+               // | /* empty */
+               non_empty_parameter_list(methodDecl, true);
+       }
+
+       private void non_empty_parameter_list(MethodDeclaration methodDecl,
+                       boolean empty_allowed) {
+               // optional_class_type T_VARIABLE
+               // | optional_class_type '&' T_VARIABLE
+               // | optional_class_type '&' T_VARIABLE '=' static_scalar
+               // | optional_class_type T_VARIABLE '=' static_scalar
+               // | non_empty_parameter_list ',' optional_class_type T_VARIABLE
+               // | non_empty_parameter_list ',' optional_class_type '&' T_VARIABLE
+               // | non_empty_parameter_list ',' optional_class_type '&' T_VARIABLE '='
                // static_scalar
-               //      | non_empty_parameter_list ',' optional_class_type T_VARIABLE '='
+               // | non_empty_parameter_list ',' optional_class_type T_VARIABLE '='
                // static_scalar
-               if (token == TokenNameIdentifier || token == TokenNameVariable
-                               || token == TokenNameAND) {
+               char[] typeIdentifier = null;
+               if (token == TokenName.IDENTIFIER ||
+                   token == TokenName.ARRAY      ||
+                   token == TokenName.VARIABLE   ||
+                   token == TokenName.OP_AND) {
+                       HashSet set = peekVariableSet();
+
                        while (true) {
-                               if (token == TokenNameIdentifier) {
+                               if (token == TokenName.IDENTIFIER || token == TokenName.ARRAY) {// feature req. #1254275
+                                       typeIdentifier = scanner.getCurrentIdentifierSource();
                                        getNextToken();
                                }
-                               if (token == TokenNameAND) {
+                               if (token == TokenName.OP_AND) {
                                        getNextToken();
                                }
-                               if (token == TokenNameVariable) {
+                               if (token == TokenName.VARIABLE) {
+                                       if (fMethodVariables != null) {
+                                               VariableInfo info;
+                                               if (methodDecl.type == MethodDeclaration.FUNCTION_DEFINITION) {
+                                                       info = new VariableInfo(scanner
+                                                                       .getCurrentTokenStartPosition(),
+                                                                       VariableInfo.LEVEL_FUNCTION_DEFINITION);
+                                               } else {
+                                                       info = new VariableInfo(scanner
+                                                                       .getCurrentTokenStartPosition(),
+                                                                       VariableInfo.LEVEL_METHOD_DEFINITION);
+                                               }
+                                               info.typeIdentifier = typeIdentifier;
+                                               fMethodVariables.put(new String(scanner
+                                                               .getCurrentIdentifierSource()), info);
+                                       }
+                                       addVariableSet(set);
                                        getNextToken();
-                                       if (token == TokenNameEQUAL) {
+                                       if (token == TokenName.EQUAL) {
                                                getNextToken();
                                                static_scalar();
                                        }
                                } else {
                                        throwSyntaxError("Variable expected in parameter list.");
                                }
-                               if (token != TokenNameCOMMA) {
+                               if (token != TokenName.COMMA) {
                                        break;
                                }
                                getNextToken();
@@ -1579,851 +2087,1373 @@ public class Parser //extends PHPParserSuperclass
                        throwSyntaxError("Identifier expected in parameter list.");
                }
        }
-       private void optional_class_type() {
-               //      /* empty */
-               //| T_STRING
-       }
-       private void parameterDeclaration() {
-               //variable
-               //variable-reference
-               if (token == TokenNameAND) {
-                       getNextToken();
-                       if (isVariable()) {
-                               getNextToken();
-                       } else {
-                               throwSyntaxError("Variable expected after reference operator '&'.");
-                       }
-               }
-               //variable '=' constant
-               if (token == TokenNameVariable) {
-                       getNextToken();
-                       if (token == TokenNameEQUAL) {
-                               getNextToken();
-                               static_scalar();
-                       }
-                       return;
-               }
-               //    if (token == TokenNamethis) {
-               //      throwSyntaxError("Reserved word '$this' not allowed in parameter
-               // declaration.");
-               //    }
-       }
+
+//     private void optional_class_type() {
+//             // /* empty */
+//             // | T_STRING
+//     }
+
+       // private void parameterDeclaration() {
+       // //variable
+       // //variable-reference
+       // if (token == TokenName.AND) {
+       // getNextToken();
+       // if (isVariable()) {
+       // getNextToken();
+       // } else {
+       // throwSyntaxError("Variable expected after reference operator '&'.");
+       // }
+       // }
+       // //variable '=' constant
+       // if (token == TokenName.VARIABLE) {
+       // getNextToken();
+       // if (token == TokenName.EQUAL) {
+       // getNextToken();
+       // static_scalar();
+       // }
+       // return;
+       // }
+       // // if (token == TokenName.THIS) {
+       // // throwSyntaxError("Reserved word '$this' not allowed in parameter
+       // // declaration.");
+       // // }
+       // }
+
        private void labeledStatementList() {
-               if (token != TokenNamecase && token != TokenNamedefault) {
+               if (token != TokenName.CASE && token != TokenName.DEFAULT) {
                        throwSyntaxError("'case' or 'default' expected.");
                }
                do {
-                       if (token == TokenNamecase) {
+                       if (token == TokenName.CASE) {
                                getNextToken();
-                               expr(); //constant();
-                               if (token == TokenNameCOLON || token == TokenNameSEMICOLON) {
+                               expr_without_variable (true, null, true); // constant();
+                               if (token == TokenName.COLON || token == TokenName.SEMICOLON) {
                                        getNextToken();
-                                       if (token == TokenNamecase || token == TokenNamedefault) {
+                                       if (token == TokenName.RBRACE) {
+                                               // empty case; assumes that the '}' token belongs to the wrapping
+                                               // switch statement - #1371992
+                                               break;
+                                       }
+                                       if (token == TokenName.CASE || token == TokenName.DEFAULT) {
                                                // empty case statement ?
                                                continue;
                                        }
                                        statementList();
                                }
-                               //        else if (token == TokenNameSEMICOLON) {
-                               //          setMarker(
-                               //            "':' expected after 'case' keyword (Found token: " +
+                               // else if (token == TokenName.SEMICOLON) {
+                               // setMarker(
+                               // "':' expected after 'case' keyword (Found token: " +
                                // scanner.toStringAction(token) + ")",
-                               //            scanner.getCurrentTokenStartPosition(),
-                               //            scanner.getCurrentTokenEndPosition(),
-                               //            INFO);
-                               //          getNextToken();
-                               //          if (token == TokenNamecase) { // empty case statement ?
-                               //            continue;
-                               //          }
-                               //          statementList();
-                               //        }
+                               // scanner.getCurrentTokenStartPosition(),
+                               // scanner.getCurrentTokenEndPosition(),
+                               // INFO);
+                               // getNextToken();
+                               // if (token == TokenName.CASE) { // empty case statement ?
+                               // continue;
+                               // }
+                               // statementList();
+                               // }
                                else {
-                                       throwSyntaxError("':' character after 'case' constant expected (Found token: "
+                                       throwSyntaxError("':' character expected after 'case' constant (Found token: "
                                                        + scanner.toStringAction(token) + ")");
                                }
-                       } else { // TokenNamedefault
+                       } else { // TokenName.DEFAULT
                                getNextToken();
-                               if (token == TokenNameCOLON) {
+                               if (token == TokenName.COLON || token == TokenName.SEMICOLON) {
                                        getNextToken();
-                                       if (token == TokenNameRBRACE) {
-                                               // empty default case
+                                       if (token == TokenName.RBRACE) {
+                                               // empty default case; ; assumes that the '}' token belongs to the
+                                               // wrapping switch statement - #1371992
                                                break;
                                        }
-                                       statementList();
+                                       if (token != TokenName.CASE) {
+                                               statementList();
+                                       }
                                } else {
-                                       throwSyntaxError("':' character after 'default' expected.");
-                               }
-                       }
-               } while (token == TokenNamecase || token == TokenNamedefault);
-       }
-       //  public void labeledStatement() {
-       //    if (token == TokenNamecase) {
-       //      getNextToken();
-       //      constant();
-       //      if (token == TokenNameDDOT) {
-       //        getNextToken();
-       //        statement();
-       //      } else {
-       //        throwSyntaxError("':' character after 'case' constant expected.");
-       //      }
-       //      return;
-       //    } else if (token == TokenNamedefault) {
-       //      getNextToken();
-       //      if (token == TokenNameDDOT) {
-       //        getNextToken();
-       //        statement();
-       //      } else {
-       //        throwSyntaxError("':' character after 'default' expected.");
-       //      }
-       //      return;
-       //    }
-       //  }
-       //  public void expressionStatement() {
-       //  }
-       //  private void inclusionStatement() {
-       //  }
-       //  public void compoundStatement() {
-       //  }
-       //  public void selectionStatement() {
-       //  }
-       //
-       //  public void iterationStatement() {
-       //  }
-       //
-       //  public void jumpStatement() {
-       //  }
-       //
-       //  public void outputStatement() {
-       //  }
-       //
-       //  public void scopeStatement() {
-       //  }
-       //
-       //  public void flowStatement() {
-       //  }
-       //
-       //  public void definitionStatement() {
-       //  }
-       private void ifStatement() {
-               // ':' statement-list [elseif-list] [else-colon-statement] 'endif' ';'
-               if (token == TokenNameCOLON) {
-                       getNextToken();
-                       if (token != TokenNameendif) {
-                               statementList();
-                               switch (token) {
-                                       case TokenNameelse :
-                                               getNextToken();
-                                               if (token == TokenNameCOLON) {
-                                                       getNextToken();
-                                                       if (token != TokenNameendif) {
-                                                               statementList();
-                                                       }
-                                               } else {
-                                                       if (token == TokenNameif) { //'else if'
-                                                               getNextToken();
-                                                               elseifStatementList();
-                                                       } else {
-                                                               throwSyntaxError("':' expected after 'else'.");
-                                                       }
-                                               }
-                                               break;
-                                       case TokenNameelseif :
-                                               getNextToken();
-                                               elseifStatementList();
-                                               break;
+                                       throwSyntaxError("':' character expected after 'default'.");
                                }
                        }
-                       if (token != TokenNameendif) {
-                               throwSyntaxError("'endif' expected.");
+               } while (token == TokenName.CASE || token == TokenName.DEFAULT);
+       }
+
+       private void ifStatementColon(IfStatement iState) {
+               // T_IF '(' expr ')' ':' inner_statement_list new_elseif_list
+               // new_else_single T_ENDIF ';'
+               HashSet assignedVariableSet = null;
+               try {
+                       Block b = inner_statement_list();
+                       iState.thenStatement = b;
+                       checkUnreachable(iState, b);
+               } finally {
+                       assignedVariableSet = removeIfVariableSet();
+               }
+               if (token == TokenName.ELSEIF) {
+                       try {
+                               pushIfVariableSet();
+                               new_elseif_list(iState);
+                       } finally {
+                               HashSet set = removeIfVariableSet();
+                               if (assignedVariableSet != null && set != null) {
+                                       assignedVariableSet.addAll(set);
+                               }
                        }
-                       getNextToken();
-                       if (token != TokenNameSEMICOLON) {
-                               throwSyntaxError("';' expected after if-statement.");
+               }
+               try {
+                       pushIfVariableSet();
+                       new_else_single(iState);
+               } finally {
+                       HashSet set = removeIfVariableSet();
+                       if (assignedVariableSet != null) {
+                               HashSet topSet = peekVariableSet();
+                               if (topSet != null) {
+                                       if (set != null) {
+                                               topSet.addAll(set);
+                                       }
+                                       topSet.addAll(assignedVariableSet);
+                               }
                        }
-                       getNextToken();
+               }
+               if (token != TokenName.ENDIF) {
+                       throwSyntaxError("'endif' expected.");
+               }
+               getNextToken();
+               if (token != TokenName.SEMICOLON && token != TokenName.INLINE_HTML) {
+                       reportSyntaxError("';' expected after if-statement.");
+                       iState.sourceEnd = scanner.getCurrentTokenStartPosition();
                } else {
-                       // statement [else-statement]
-                       statement(TokenNameEOF);
-                       if (token == TokenNameelseif) {
-                               getNextToken();
-                               if (token == TokenNameLPAREN) {
-                                       getNextToken();
-                               } else {
-                                       throwSyntaxError("'(' expected after 'elseif' keyword.");
-                               }
-                               expr();
-                               if (token == TokenNameRPAREN) {
-                                       getNextToken();
-                               } else {
-                                       throwSyntaxError("')' expected after 'elseif' condition.");
+                       iState.sourceEnd = scanner.getCurrentTokenEndPosition();
+                       getNextToken();
+               }
+       }
+
+       private void ifStatement(IfStatement iState) {
+               // T_IF '(' expr ')' statement elseif_list else_single
+               HashSet assignedVariableSet = null;
+               try {
+                       pushIfVariableSet();
+                       Statement s = statement();
+                       iState.thenStatement = s;
+                       checkUnreachable(iState, s);
+               } finally {
+                       assignedVariableSet = removeIfVariableSet();
+               }
+
+               if (token == TokenName.ELSEIF) {
+                       try {
+                               pushIfVariableSet();
+                               elseif_list(iState);
+                       } finally {
+                               HashSet set = removeIfVariableSet();
+                               if (assignedVariableSet != null && set != null) {
+                                       assignedVariableSet.addAll(set);
                                }
-                               ifStatement();
-                       } else if (token == TokenNameelse) {
-                               getNextToken();
-                               statement(TokenNameEOF);
                        }
                }
-       }
-       private void elseifStatementList() {
-               do {
-                       elseifStatement();
-                       switch (token) {
-                               case TokenNameelse :
-                                       getNextToken();
-                                       if (token == TokenNameCOLON) {
-                                               getNextToken();
-                                               if (token != TokenNameendif) {
-                                                       statementList();
-                                               }
-                                               return;
-                                       } else {
-                                               if (token == TokenNameif) { //'else if'
-                                                       getNextToken();
-                                               } else {
-                                                       throwSyntaxError("':' expected after 'else'.");
-                                               }
+               try {
+                       pushIfVariableSet();
+                       else_single(iState);
+               } finally {
+                       HashSet set = removeIfVariableSet();
+                       if (assignedVariableSet != null) {
+                               HashSet topSet = peekVariableSet();
+                               if (topSet != null) {
+                                       if (set != null) {
+                                               topSet.addAll(set);
                                        }
-                                       break;
-                               case TokenNameelseif :
-                                       getNextToken();
-                                       break;
-                               default :
-                                       return;
+                                       topSet.addAll(assignedVariableSet);
+                               }
                        }
-               } while (true);
+               }
        }
-       private void elseifStatement() {
-               if (token == TokenNameLPAREN) {
+
+       private void elseif_list(IfStatement iState) {
+               // /* empty */
+               // | elseif_list T_ELSEIF '(' expr ')' statement
+               ArrayList conditionList = new ArrayList();
+               ArrayList statementList = new ArrayList();
+               Expression e;
+               Statement s;
+               while (token == TokenName.ELSEIF) {
                        getNextToken();
-                       expr();
-                       if (token != TokenNameRPAREN) {
-                               throwSyntaxError("')' expected in else-if-statement.");
+                       if (token == TokenName.LPAREN) {
+                               getNextToken();
+                       } else {
+                               throwSyntaxError("'(' expected after 'elseif' keyword.");
+                       }
+                       e = expr();
+                       conditionList.add(e);
+                       if (token == TokenName.RPAREN) {
+                               getNextToken();
+                       } else {
+                               throwSyntaxError("')' expected after 'elseif' condition.");
                        }
+                       s = statement();
+                       statementList.add(s);
+                       checkUnreachable(iState, s);
+               }
+               iState.elseifConditions = new Expression[conditionList.size()];
+               iState.elseifStatements = new Statement[statementList.size()];
+               conditionList.toArray(iState.elseifConditions);
+               statementList.toArray(iState.elseifStatements);
+       }
+
+       private void new_elseif_list(IfStatement iState) {
+               // /* empty */
+               // | new_elseif_list T_ELSEIF '(' expr ')' ':' inner_statement_list
+               ArrayList conditionList = new ArrayList();
+               ArrayList statementList = new ArrayList();
+               Expression e;
+               Block b;
+               while (token == TokenName.ELSEIF) {
                        getNextToken();
-                       if (token != TokenNameCOLON) {
-                               throwSyntaxError("':' expected in else-if-statement.");
+                       if (token == TokenName.LPAREN) {
+                               getNextToken();
+                       } else {
+                               throwSyntaxError("'(' expected after 'elseif' keyword.");
                        }
+                       e = expr();
+                       conditionList.add(e);
+                       if (token == TokenName.RPAREN) {
+                               getNextToken();
+                       } else {
+                               throwSyntaxError("')' expected after 'elseif' condition.");
+                       }
+                       if (token == TokenName.COLON) {
+                               getNextToken();
+                       } else {
+                               throwSyntaxError("':' expected after 'elseif' keyword.");
+                       }
+                       b = inner_statement_list();
+                       statementList.add(b);
+                       checkUnreachable(iState, b);
+               }
+               iState.elseifConditions = new Expression[conditionList.size()];
+               iState.elseifStatements = new Statement[statementList.size()];
+               conditionList.toArray(iState.elseifConditions);
+               statementList.toArray(iState.elseifStatements);
+       }
+
+       private void else_single(IfStatement iState) {
+               // /* empty */
+               // T_ELSE statement
+               if (token == TokenName.ELSE) {
                        getNextToken();
-                       if (token != TokenNameendif) {
-                               statementList();
+                       Statement s = statement();
+                       iState.elseStatement = s;
+                       checkUnreachable(iState, s);
+               } else {
+                       iState.checkUnreachable = false;
+               }
+               iState.sourceEnd = scanner.getCurrentTokenStartPosition();
+       }
+
+       private void new_else_single(IfStatement iState) {
+               // /* empty */
+               // | T_ELSE ':' inner_statement_list
+               if (token == TokenName.ELSE) {
+                       getNextToken();
+                       if (token == TokenName.COLON) {
+                               getNextToken();
+                       } else {
+                               throwSyntaxError("':' expected after 'else' keyword.");
+                       }
+                       Block b = inner_statement_list();
+                       iState.elseStatement = b;
+                       checkUnreachable(iState, b);
+               } else {
+                       iState.checkUnreachable = false;
+               }
+       }
+
+       private Block inner_statement_list() {
+               // inner_statement_list inner_statement
+               // /* empty */
+               return statementList();
+       }
+
+       /**
+        * @param iState
+        * @param b
+        */
+       private void checkUnreachable(IfStatement iState, Statement s) {
+               if (s instanceof Block) {
+                       Block b = (Block) s;
+                       if (b.statements == null || b.statements.length == 0) {
+                               iState.checkUnreachable = false;
+                       } else {
+                               int off = b.statements.length - 1;
+                               if (!(b.statements[off] instanceof ReturnStatement)
+                                               && !(b.statements[off] instanceof ContinueStatement)
+                                               && !(b.statements[off] instanceof BreakStatement)) {
+                                       if (!(b.statements[off] instanceof IfStatement)
+                                                       || !((IfStatement) b.statements[off]).checkUnreachable) {
+                                               iState.checkUnreachable = false;
+                                       }
+                               }
+                       }
+               } else {
+                       if (!(s instanceof ReturnStatement)
+                                       && !(s instanceof ContinueStatement)
+                                       && !(s instanceof BreakStatement)) {
+                               if (!(s instanceof IfStatement)
+                                               || !((IfStatement) s).checkUnreachable) {
+                                       iState.checkUnreachable = false;
+                               }
                        }
                }
        }
+
+       // private void elseifStatementList() {
+       // do {
+       // elseifStatement();
+       // switch (token) {
+       // case TokenName.else:
+       // getNextToken();
+       // if (token == TokenName.COLON) {
+       // getNextToken();
+       // if (token != TokenName.endif) {
+       // statementList();
+       // }
+       // return;
+       // } else {
+       // if (token == TokenName.if) { //'else if'
+       // getNextToken();
+       // } else {
+       // throwSyntaxError("':' expected after 'else'.");
+       // }
+       // }
+       // break;
+       // case TokenName.elseif:
+       // getNextToken();
+       // break;
+       // default:
+       // return;
+       // }
+       // } while (true);
+       // }
+
+       // private void elseifStatement() {
+       // if (token == TokenName.LPAREN) {
+       // getNextToken();
+       // expr();
+       // if (token != TokenName.RPAREN) {
+       // throwSyntaxError("')' expected in else-if-statement.");
+       // }
+       // getNextToken();
+       // if (token != TokenName.COLON) {
+       // throwSyntaxError("':' expected in else-if-statement.");
+       // }
+       // getNextToken();
+       // if (token != TokenName.endif) {
+       // statementList();
+       // }
+       // }
+       // }
+
        private void switchStatement() {
-               if (token == TokenNameCOLON) {
+               if (token == TokenName.COLON) {
                        // ':' [labeled-statement-list] 'endswitch' ';'
                        getNextToken();
                        labeledStatementList();
-                       if (token != TokenNameendswitch) {
+                       if (token != TokenName.ENDSWITCH) {
                                throwSyntaxError("'endswitch' expected.");
                        }
                        getNextToken();
-                       if (token != TokenNameSEMICOLON) {
+                       if (token != TokenName.SEMICOLON && token != TokenName.INLINE_HTML) {
                                throwSyntaxError("';' expected after switch-statement.");
                        }
                        getNextToken();
                } else {
                        // '{' [labeled-statement-list] '}'
-                       if (token != TokenNameLBRACE) {
+                       if (token != TokenName.LBRACE) {
                                throwSyntaxError("'{' expected in switch statement.");
                        }
                        getNextToken();
-                       if (token != TokenNameRBRACE) {
+                       if (token != TokenName.RBRACE) {
                                labeledStatementList();
                        }
-                       if (token != TokenNameRBRACE) {
+                       if (token != TokenName.RBRACE) {
                                throwSyntaxError("'}' expected in switch statement.");
                        }
                        getNextToken();
                }
        }
+
        private void forStatement() {
-               if (token == TokenNameCOLON) {
+               if (token == TokenName.COLON) {
                        getNextToken();
                        statementList();
-                       if (token != TokenNameendfor) {
+                       if (token != TokenName.ENDFOR) {
                                throwSyntaxError("'endfor' expected.");
                        }
                        getNextToken();
-                       if (token != TokenNameSEMICOLON) {
+                       if (token != TokenName.SEMICOLON && token != TokenName.INLINE_HTML) {
                                throwSyntaxError("';' expected after for-statement.");
                        }
                        getNextToken();
                } else {
-                       statement(TokenNameEOF);
+                       statement();
                }
        }
+
        private void whileStatement() {
                // ':' statement-list 'endwhile' ';'
-               if (token == TokenNameCOLON) {
+               if (token == TokenName.COLON) {
                        getNextToken();
                        statementList();
-                       if (token != TokenNameendwhile) {
+                       if (token != TokenName.ENDWHILE) {
                                throwSyntaxError("'endwhile' expected.");
                        }
                        getNextToken();
-                       if (token != TokenNameSEMICOLON) {
+                       if (token != TokenName.SEMICOLON && token != TokenName.INLINE_HTML) {
                                throwSyntaxError("';' expected after while-statement.");
                        }
                        getNextToken();
                } else {
-                       statement(TokenNameEOF);
+                       statement();
                }
        }
+
        private void foreachStatement() {
-               if (token == TokenNameCOLON) {
+               if (token == TokenName.COLON) {
                        getNextToken();
                        statementList();
-                       if (token != TokenNameendforeach) {
+                       if (token != TokenName.ENDFOREACH) {
                                throwSyntaxError("'endforeach' expected.");
                        }
                        getNextToken();
-                       if (token != TokenNameSEMICOLON) {
+                       if (token != TokenName.SEMICOLON && token != TokenName.INLINE_HTML) {
                                throwSyntaxError("';' expected after foreach-statement.");
                        }
                        getNextToken();
                } else {
-                       statement(TokenNameEOF);
-               }
-       }
-       //  private void exitStatus() {
-       //    if (token == TokenNameLPAREN) {
-       //      getNextToken();
-       //    } else {
-       //      throwSyntaxError("'(' expected in 'exit-status'.");
-       //    }
-       //    if (token != TokenNameRPAREN) {
-       //      expression();
-       //    }
-       //    if (token == TokenNameRPAREN) {
-       //      getNextToken();
-       //    } else {
-       //      throwSyntaxError("')' expected after 'exit-status'.");
-       //    }
-       //  }
+                       statement();
+               }
+       }
+
+       // private void exitStatus() {
+       // if (token == TokenName.LPAREN) {
+       // getNextToken();
+       // } else {
+       // throwSyntaxError("'(' expected in 'exit-status'.");
+       // }
+       // if (token != TokenName.RPAREN) {
+       // expression();
+       // }
+       // if (token == TokenName.RPAREN) {
+       // getNextToken();
+       // } else {
+       // throwSyntaxError("')' expected after 'exit-status'.");
+       // }
+       // }
+    /**
+     *
+     */
+    private void namespacePath () {
+       do {
+           expr_without_variable (true, null, false);
+
+           if (token == TokenName.BACKSLASH) {
+               getNextToken();
+           } else {
+               break;
+           }
+       } while (true);
+    }
+
+       /**
+        *
+        */
        private void expressionList() {
                do {
-                       expr();
-                       if (token == TokenNameCOMMA) {
-                               getNextToken();
+                       expr_without_variable (true, null, false);
+
+                       if (token == TokenName.COMMA) {         // If it's a list of (comma separated) expressions
+                               getNextToken();                     // read all in, untill no more found
                        } else {
                                break;
                        }
                } while (true);
        }
-       private void expr() {
-               //      r_variable
-               //      | expr_without_variable
-               //    if (token!=TokenNameEOF) {
-               if (Scanner.TRACE) {
-                       System.out.println("TRACE: expr()");
-               }
-               expr_without_variable(true);
-               //    }
-       }
-       private void expr_without_variable(boolean only_variable) {
-               //              internal_functions_in_yacc
-               //      | T_CLONE expr
-               //      | T_PRINT expr
-               //      | '(' expr ')'
-               //      | '@' expr
-               //      | '+' expr
-               //      | '-' expr
-               //      | '!' expr
-               //      | '~' expr
-               //      | T_INC rw_variable
-               //      | T_DEC rw_variable
-               //      | T_INT_CAST expr
-               //      | T_DOUBLE_CAST expr
-               //      | T_STRING_CAST expr
-               //      | T_ARRAY_CAST expr
-               //      | T_OBJECT_CAST expr
-               //      | T_BOOL_CAST expr
-               //      | T_UNSET_CAST expr
-               //      | T_EXIT exit_expr
-               //      | scalar
-               //      | T_ARRAY '(' array_pair_list ')'
-               //      | '`' encaps_list '`'
-               //      | T_LIST '(' assignment_list ')' '=' expr
-               //      | T_NEW class_name_reference ctor_arguments
-               //      | variable '=' expr
-               //      | variable '=' '&' variable
-               //      | variable '=' '&' T_NEW class_name_reference ctor_arguments
-               //      | variable T_PLUS_EQUAL expr
-               //      | variable T_MINUS_EQUAL expr
-               //      | variable T_MUL_EQUAL expr
-               //      | variable T_DIV_EQUAL expr
-               //      | variable T_CONCAT_EQUAL expr
-               //      | variable T_MOD_EQUAL expr
-               //      | variable T_AND_EQUAL expr
-               //      | variable T_OR_EQUAL expr
-               //      | variable T_XOR_EQUAL expr
-               //      | variable T_SL_EQUAL expr
-               //      | variable T_SR_EQUAL expr
-               //      | rw_variable T_INC
-               //      | rw_variable T_DEC
-               //      | expr T_BOOLEAN_OR expr
-               //      | expr T_BOOLEAN_AND expr
-               //      | expr T_LOGICAL_OR expr
-               //      | expr T_LOGICAL_AND expr
-               //      | expr T_LOGICAL_XOR expr
-               //      | expr '|' expr
-               //      | expr '&' expr
-               //      | expr '^' expr
-               //      | expr '.' expr
-               //      | expr '+' expr
-               //      | expr '-' expr
-               //      | expr '*' expr
-               //      | expr '/' expr
-               //      | expr '%' expr
-               //      | expr T_SL expr
-               //      | expr T_SR expr
-               //      | expr T_IS_IDENTICAL expr
-               //      | expr T_IS_NOT_IDENTICAL expr
-               //      | expr T_IS_EQUAL expr
-               //      | expr T_IS_NOT_EQUAL expr
-               //      | expr '<' expr
-               //      | expr T_IS_SMALLER_OR_EQUAL expr
-               //      | expr '>' expr
-               //      | expr T_IS_GREATER_OR_EQUAL expr
-               //      | expr T_INSTANCEOF class_name_reference
-               //      | expr '?' expr ':' expr
-               if (Scanner.TRACE) {
-                       System.out.println("TRACE: expr_without_variable() PART 1");
-               }
-               switch (token) {
-                       case TokenNameisset :
-                       case TokenNameempty :
-                       case TokenNameeval :
-                       case TokenNameinclude :
-                       case TokenNameinclude_once :
-                       case TokenNamerequire :
-                       case TokenNamerequire_once :
-                               internal_functions_in_yacc();
-                               break;
-                       //      | '(' expr ')'
-                       case TokenNameLPAREN :
-                               getNextToken();
-                               expr();
-                               if (token == TokenNameRPAREN) {
+
+       private Expression expr() {
+               return expr_without_variable(true, null, false);
+       }
+
+       /**
+        *
+        * @param only_variable
+        * @param initHandler
+        */
+       private Expression expr_without_variable (boolean only_variable,
+                                                 UninitializedVariableHandler initHandler,
+                                                 boolean bColonAllowed) {
+               int exprSourceStart    = scanner.getCurrentTokenStartPosition();
+               int exprSourceEnd      = scanner.getCurrentTokenEndPosition();
+               Expression expression  = new Expression();
+
+               expression.sourceStart = exprSourceStart;
+               expression.sourceEnd   = exprSourceEnd;                     // default, may be overwritten
+
+               try {
+                       // internal_functions_in_yacc
+                       // | T_CLONE expr
+                       // | T_PRINT expr
+                       // | '(' expr ')'
+                       // | '@' expr
+                       // | '+' expr
+                       // | '-' expr
+                       // | '!' expr
+                       // | '~' expr
+                       // | T_INC rw_variable
+                       // | T_DEC rw_variable
+                       // | T_INT_CAST expr
+                       // | T_DOUBLE_CAST expr
+                       // | T_STRING_CAST expr
+                       // | T_ARRAY_CAST expr
+                       // | T_OBJECT_CAST expr
+                       // | T_BOOL_CAST expr
+                       // | T_UNSET_CAST expr
+                       // | T_EXIT exit_expr
+                       // | scalar
+                       // | T_ARRAY '(' array_pair_list ')'
+                       // | '`' encaps_list '`'
+                       // | T_LIST '(' assignment_list ')' '=' expr
+                       // | T_NEW class_name_reference ctor_arguments
+                       // | variable '=' expr
+                       // | variable '=' '&' variable
+                       // | variable '=' '&' T_NEW class_name_reference ctor_arguments
+                       // | variable T_PLUS_EQUAL expr
+                       // | variable T_MINUS_EQUAL expr
+                       // | variable T_MUL_EQUAL expr
+                       // | variable T_DIV_EQUAL expr
+                       // | variable T_CONCAT_EQUAL expr
+                       // | variable T_MOD_EQUAL expr
+                       // | variable T_AND_EQUAL expr
+                       // | variable T_OR_EQUAL expr
+                       // | variable T_XOR_EQUAL expr
+                       // | variable T_SL_EQUAL expr
+                       // | variable T_SR_EQUAL expr
+                       // | rw_variable T_INC
+                       // | rw_variable T_DEC
+                       // | expr T_BOOLEAN_OR expr
+                       // | expr T_BOOLEAN_AND expr
+                       // | expr T_LOGICAL_OR expr
+                       // | expr T_LOGICAL_AND expr
+                       // | expr T_LOGICAL_XOR expr
+                       // | expr '|' expr
+                       // | expr '&' expr
+                       // | expr '^' expr
+                       // | expr '.' expr
+                       // | expr '+' expr
+                       // | expr '-' expr
+                       // | expr '*' expr
+                       // | expr '/' expr
+                       // | expr '%' expr
+                       // | expr T_SL expr
+                       // | expr T_SR expr
+                       // | expr T_IS_IDENTICAL expr
+                       // | expr T_IS_NOT_IDENTICAL expr
+                       // | expr T_IS_EQUAL expr
+                       // | expr T_IS_NOT_EQUAL expr
+                       // | expr '<' expr
+                       // | expr T_IS_SMALLER_OR_EQUAL expr
+                       // | expr '>' expr
+                       // | expr T_IS_GREATER_OR_EQUAL expr
+                       // | expr T_INSTANCEOF class_name_reference
+                       // | expr '?' expr ':' expr
+                       if (Scanner.TRACE) {
+                               System.out.println("TRACE: expr_without_variable() PART 1");
+                       }
+
+                       switch (token) {
+                               case ISSET:
+                                       // T_ISSET '(' isset_variables ')'
                                        getNextToken();
-                               } else {
-                                       throwSyntaxError("')' expected in expression.");
-                               }
-                               break;
-                       //    | T_CLONE expr
-                       //    | T_PRINT expr
-                       //    | '@' expr
-                       //    | '+' expr
-                       //    | '-' expr
-                       //    | '!' expr
-                       //    | '~' expr
-                       //    | T_INT_CAST expr
-                       //      | T_DOUBLE_CAST expr
-                       //      | T_STRING_CAST expr
-                       //      | T_ARRAY_CAST expr
-                       //      | T_OBJECT_CAST expr
-                       //      | T_BOOL_CAST expr
-                       //      | T_UNSET_CAST expr
-                       case TokenNameclone :
-                       case TokenNameprint :
-                       case TokenNameAT :
-                       case TokenNamePLUS :
-                       case TokenNameMINUS :
-                       case TokenNameNOT :
-                       case TokenNameTWIDDLE :
-                       case TokenNameintCAST :
-                       case TokenNamedoubleCAST :
-                       case TokenNamestringCAST :
-                       case TokenNamearrayCAST :
-                       case TokenNameobjectCAST :
-                       case TokenNameboolCAST :
-                       case TokenNameunsetCAST :
-                               getNextToken();
-                               expr();
-                               break;
-                       case TokenNameexit :
-                               getNextToken();
-                               exit_expr();
-                               break;
-                       //  scalar:
-                       //      T_STRING
-                       //| T_STRING_VARNAME
-                       //| class_constant
-                       //| T_START_HEREDOC encaps_list T_END_HEREDOC
-                       //      | '`' encaps_list '`'
-                       //  | common_scalar
-                       //      | '`' encaps_list '`'
-                       case TokenNameEncapsedString0 :
-                               scanner.encapsedStringStack.push(new Character('`'));
-                               getNextToken();
-                               try {
-                                       if (token == TokenNameEncapsedString0) {
-                                       } else {
-                                               encaps_list();
-                                               if (token != TokenNameEncapsedString0) {
-                                                       throwSyntaxError("\'`\' expected at end of string"
-                                                                       + "(Found token: "
-                                                                       + scanner.toStringAction(token) + " )");
-                                               }
+                                       if (token != TokenName.LPAREN) {
+                                               throwSyntaxError("'(' expected after keyword 'isset'");
                                        }
-                               } finally {
-                                       scanner.encapsedStringStack.pop();
                                        getNextToken();
-                               }
-                               break;
-                       //      | '\'' encaps_list '\''
-                       case TokenNameEncapsedString1 :
-                               scanner.encapsedStringStack.push(new Character('\''));
-                               getNextToken();
-                               try {
-                                       if (token == TokenNameEncapsedString1) {
-                                       } else {
-                                               encaps_list();
-                                               if (token != TokenNameEncapsedString1) {
-                                                       throwSyntaxError("\'\'\' expected at end of string"
-                                                                       + "(Found token: "
-                                                                       + scanner.toStringAction(token) + " )");
-                                               }
+                                       isset_variables();
+                                       if (token != TokenName.RPAREN) {
+                                               throwSyntaxError("')' expected after keyword 'isset'");
                                        }
-                               } finally {
-                                       scanner.encapsedStringStack.pop();
                                        getNextToken();
-                               }
-                               break;
-                       //| '"' encaps_list '"'
-                       case TokenNameEncapsedString2 :
-                               scanner.encapsedStringStack.push(new Character('"'));
-                               getNextToken();
-                               try {
-                                       if (token == TokenNameEncapsedString2) {
-                                       } else {
-                                               encaps_list();
-                                               if (token != TokenNameEncapsedString2) {
-                                                       throwSyntaxError("'\"' expected at end of string"
-                                                                       + "(Found token: "
-                                                                       + scanner.toStringAction(token) + " )");
-                                               }
+                                       break;
+                               case EMPTY:
+                                       getNextToken();
+                                       if (token != TokenName.LPAREN) {
+                                               throwSyntaxError("'(' expected after keyword 'empty'");
                                        }
-                               } finally {
-                                       scanner.encapsedStringStack.pop();
                                        getNextToken();
-                               }
-                               break;
-                       case TokenNameIntegerLiteral :
-                       case TokenNameDoubleLiteral :
-                       case TokenNameStringLiteral :
-                       case TokenNameStringConstant :
-                       case TokenNameStringInterpolated :
-                       case TokenNameFILE :
-                       case TokenNameLINE :
-                       case TokenNameCLASS_C :
-                       case TokenNameMETHOD_C :
-                       case TokenNameFUNC_C :
-                               common_scalar();
-                               break;
-                       case TokenNameHEREDOC :
-                               getNextToken();
-                               break;
-                       case TokenNamearray :
-                               //    T_ARRAY '(' array_pair_list ')'
-                               getNextToken();
-                               if (token == TokenNameLPAREN) {
+                                       variable(true, false);
+                                       if (token != TokenName.RPAREN) {
+                                               throwSyntaxError("')' expected after keyword 'empty'");
+                                       }
+                                       getNextToken();
+                                       break;
+                               case EVAL:
+                               case INCLUDE:
+                               case INCLUDE_ONCE:
+                               case REQUIRE:
+                               case REQUIRE_ONCE:
+                                       internal_functions_in_yacc();
+                                       break;
+
+                               // | '(' expr ')'
+                               case LPAREN:
                                        getNextToken();
-                                       if (token == TokenNameRPAREN) {
+                                       expr();
+                                       if (token == TokenName.RPAREN) {
                                                getNextToken();
-                                               break;
-                                       }
-                                       array_pair_list();
-                                       if (token != TokenNameRPAREN) {
-                                               throwSyntaxError("')' expected after keyword 'array'"
-                                                               + "(Found token: "
-                                                               + scanner.toStringAction(token) + ")");
+                                       } else {
+                                               throwSyntaxError("')' expected in expression.");
                                        }
+                                       break;
+                               // | T_CLONE expr
+                               // | T_PRINT expr
+                               // | '@' expr
+                               // | '+' expr
+                               // | '-' expr
+                               // | '!' expr
+                               // | '~' expr
+                               // | T_INT_CAST expr
+                               // | T_DOUBLE_CAST expr
+                               // | T_STRING_CAST expr
+                               // | T_ARRAY_CAST expr
+                               // | T_OBJECT_CAST expr
+                               // | T_BOOL_CAST expr
+                               // | T_UNSET_CAST expr
+                               case OP_AT:
+                               case CLONE:
+                               case PRINT:
+                               case PLUS:
+                               case MINUS:
+                               case NOT:
+                               case TWIDDLE:
+                               case INTCAST:
+                               case DOUBLECAST:
+                               case STRINGCAST:
+                               case ARRAYCAST:
+                               case OBJECTCAST:
+                               case BOOLCAST:
+                               case UNSETCAST:
+                    getNextToken();
+                    expr_without_variable (only_variable, initHandler, bColonAllowed);
+                    break;
+                               case EXIT:
                                        getNextToken();
-                               } else {
-                                       throwSyntaxError("'(' expected after keyword 'array'"
-                                                       + "(Found token: " + scanner.toStringAction(token)
-                                                       + ")");
-                               }
-                               break;
-                       case TokenNamelist :
-                               //    | T_LIST '(' assignment_list ')' '=' expr
-                               getNextToken();
-                               if (token == TokenNameLPAREN) {
+                                       exit_expr();
+                                       break;
+                               // scalar:
+                               // T_STRING
+                               // | T_STRING_VARNAME
+                               // | class_constant
+                               // | T_START_HEREDOC encaps_list T_END_HEREDOC
+                               // | '`' encaps_list '`'
+                               // | common_scalar
+                               // | '`' encaps_list '`'
+                               // case TokenName.EncapsedString0:
+                               // scanner.encapsedStringStack.push(new Character('`'));
+                               // getNextToken();
+                               // try {
+                               // if (token == TokenName.EncapsedString0) {
+                               // } else {
+                               // encaps_list();
+                               // if (token != TokenName.EncapsedString0) {
+                               // throwSyntaxError("\'`\' expected at end of string" + "(Found
+                               // token: " +
+                               // scanner.toStringAction(token) + " )");
+                               // }
+                               // }
+                               // } finally {
+                               // scanner.encapsedStringStack.pop();
+                               // getNextToken();
+                               // }
+                               // break;
+                               // // | '\'' encaps_list '\''
+                               // case TokenName.EncapsedString1:
+                               // scanner.encapsedStringStack.push(new Character('\''));
+                               // getNextToken();
+                               // try {
+                               // exprSourceStart = scanner.getCurrentTokenStartPosition();
+                               // if (token == TokenName.EncapsedString1) {
+                               // expression = new
+                               // StringLiteralSQ(scanner.getCurrentStringLiteralSource(exprSourceStart),
+                               // exprSourceStart, scanner
+                               // .getCurrentTokenEndPosition());
+                               // } else {
+                               // encaps_list();
+                               // if (token != TokenName.EncapsedString1) {
+                               // throwSyntaxError("\'\'\' expected at end of string" + "(Found
+                               // token: "
+                               // + scanner.toStringAction(token) + " )");
+                               // } else {
+                               // expression = new
+                               // StringLiteralSQ(scanner.getCurrentStringLiteralSource(exprSourceStart),
+                               // exprSourceStart, scanner
+                               // .getCurrentTokenEndPosition());
+                               // }
+                               // }
+                               // } finally {
+                               // scanner.encapsedStringStack.pop();
+                               // getNextToken();
+                               // }
+                               // break;
+                               // //| '"' encaps_list '"'
+                               // case TokenName.EncapsedString2:
+                               // scanner.encapsedStringStack.push(new Character('"'));
+                               // getNextToken();
+                               // try {
+                               // exprSourceStart = scanner.getCurrentTokenStartPosition();
+                               // if (token == TokenName.EncapsedString2) {
+                               // expression = new
+                               // StringLiteralDQ(scanner.getCurrentStringLiteralSource(exprSourceStart),
+                               // exprSourceStart, scanner
+                               // .getCurrentTokenEndPosition());
+                               // } else {
+                               // encaps_list();
+                               // if (token != TokenName.EncapsedString2) {
+                               // throwSyntaxError("'\"' expected at end of string" + "(Found
+                               // token: " +
+                               // scanner.toStringAction(token) + " )");
+                               // } else {
+                               // expression = new
+                               // StringLiteralDQ(scanner.getCurrentStringLiteralSource(exprSourceStart),
+                               // exprSourceStart, scanner
+                               // .getCurrentTokenEndPosition());
+                               // }
+                               // }
+                               // } finally {
+                               // scanner.encapsedStringStack.pop();
+                               // getNextToken();
+                               // }
+                               // break;
+                               case STRINGDOUBLEQUOTE:
+                                       expression = new StringLiteralDQ (scanner.getCurrentStringLiteralSource(),
+                                                                         scanner.getCurrentTokenStartPosition(),
+                                                                                                         scanner.getCurrentTokenEndPosition());
+                                       common_scalar();
+                                       break;
+                               case STRINGSINGLEQUOTE:
+                                       expression = new StringLiteralSQ (scanner.getCurrentStringLiteralSource(),
+                                                                         scanner.getCurrentTokenStartPosition(),
+                                                                                                         scanner.getCurrentTokenEndPosition());
+                                       common_scalar();
+                                       break;
+                               case INTEGERLITERAL:
+                               case DOUBLELITERAL:
+                               case STRINGINTERPOLATED:
+                               case FILE:
+                               case LINE:
+                               case CLASS_C:
+                               case METHOD_C:
+                               case FUNC_C:
+                                       common_scalar();
+                                       break;
+                               case HEREDOC:
                                        getNextToken();
-                                       assignment_list();
-                                       if (token != TokenNameRPAREN) {
-                                               throwSyntaxError("')' expected after 'list' keyword.");
-                                       }
+                                       break;
+                               case ARRAY:
+                                       // T_ARRAY '(' array_pair_list ')'
                                        getNextToken();
-                                       if (token != TokenNameEQUAL) {
-                                               throwSyntaxError("'=' expected after 'list' keyword.");
+                                       if (token == TokenName.LPAREN) {
+                                               getNextToken();
+                                               if (token == TokenName.RPAREN) {
+                                                       getNextToken();
+                                                       break;
+                                               }
+                                               array_pair_list();
+                                               if (token != TokenName.RPAREN) {
+                                                       throwSyntaxError("')' or ',' expected after keyword 'array'"
+                                                                       + "(Found token: "
+                                                                       + scanner.toStringAction(token) + ")");
+                                               }
+                                               getNextToken();
+                                       } else {
+                                               throwSyntaxError("'(' expected after keyword 'array'"
+                                                               + "(Found token: " + scanner.toStringAction(token)
+                                                               + ")");
                                        }
+                                       break;
+                               case LIST:
+                                       // | T_LIST '(' assignment_list ')' '=' expr
                                        getNextToken();
-                                       expr();
-                               } else {
-                                       throwSyntaxError("'(' expected after 'list' keyword.");
-                               }
-                               break;
-                       case TokenNamenew :
-                               //      | T_NEW class_name_reference ctor_arguments
-                               getNextToken();
-                               class_name_reference();
-                               ctor_arguments();
-                               break;
-                       //      | T_INC rw_variable
-                       //      | T_DEC rw_variable
-                       case TokenNamePLUS_PLUS :
-                       case TokenNameMINUS_MINUS :
-                               getNextToken();
-                               rw_variable();
-                               break;
-                       //      | variable '=' expr
-                       //      | variable '=' '&' variable
-                       //      | variable '=' '&' T_NEW class_name_reference ctor_arguments
-                       //      | variable T_PLUS_EQUAL expr
-                       //      | variable T_MINUS_EQUAL expr
-                       //      | variable T_MUL_EQUAL expr
-                       //      | variable T_DIV_EQUAL expr
-                       //      | variable T_CONCAT_EQUAL expr
-                       //      | variable T_MOD_EQUAL expr
-                       //      | variable T_AND_EQUAL expr
-                       //      | variable T_OR_EQUAL expr
-                       //      | variable T_XOR_EQUAL expr
-                       //      | variable T_SL_EQUAL expr
-                       //      | variable T_SR_EQUAL expr
-                       //      | rw_variable T_INC
-                       //      | rw_variable T_DEC
-                       case TokenNameIdentifier :
-                       case TokenNameVariable :
-                       case TokenNameDOLLAR :
-                               variable();
-                               switch (token) {
-                                       case TokenNameEQUAL :
+                                       if (token == TokenName.LPAREN) {
+                                               getNextToken();
+                                               assignment_list();
+                                               if (token != TokenName.RPAREN) {
+                                                       throwSyntaxError("')' expected after 'list' keyword.");
+                                               }
+                                               getNextToken();
+                                               if (token != TokenName.EQUAL) {
+                                                       throwSyntaxError("'=' expected after 'list' keyword.");
+                                               }
                                                getNextToken();
-                                               if (token == TokenNameAND) {
+                                               expr();
+                                       } else {
+                                               throwSyntaxError("'(' expected after 'list' keyword.");
+                                       }
+                                       break;
+                               case NEW:
+                                       // | T_NEW class_name_reference ctor_arguments
+                                       getNextToken();
+                                       Expression typeRef = class_name_reference();
+                                       ctor_arguments();
+                                       if (typeRef != null) {
+                                               expression = typeRef;
+                                       }
+                                       break;
+                               // | T_INC rw_variable
+                               // | T_DEC rw_variable
+                               case PLUS_PLUS:
+                               case MINUS_MINUS:
+                                       getNextToken();
+                                       rw_variable();
+                                       break;
+                               // | variable '=' expr
+                               // | variable '=' '&' variable
+                               // | variable '=' '&' T_NEW class_name_reference ctor_arguments
+                               // | variable T_PLUS_EQUAL expr
+                               // | variable T_MINUS_EQUAL expr
+                               // | variable T_MUL_EQUAL expr
+                               // | variable T_DIV_EQUAL expr
+                               // | variable T_CONCAT_EQUAL expr
+                               // | variable T_MOD_EQUAL expr
+                               // | variable T_AND_EQUAL expr
+                               // | variable T_OR_EQUAL expr
+                               // | variable T_XOR_EQUAL expr
+                               // | variable T_SL_EQUAL expr
+                               // | variable T_SR_EQUAL expr
+                               // | rw_variable T_INC
+                               // | rw_variable T_DEC
+                               case IDENTIFIER:
+                               case VARIABLE:
+                               case DOLLAR:
+                                       Expression lhs = null;
+                                       boolean rememberedVar = false;
+
+                                       if (token == TokenName.IDENTIFIER) {
+                                               lhs = identifier(true, true, bColonAllowed);
+
+                                               if (lhs != null) {
+                                                       expression = lhs;
+                                               }
+                                       }
+                                       else {
+                                               lhs = variable (true, true);
+
+                                               if (lhs != null) {
+                                                       expression = lhs;
+                                               }
+
+                                               if (lhs != null                                              &&
+                                                   lhs instanceof FieldReference        &&
+                                                       token != TokenName.EQUAL             &&
+                                                       token != TokenName.PLUS_EQUAL        &&
+                                                       token != TokenName.MINUS_EQUAL       &&
+                                                       token != TokenName.MULTIPLY_EQUAL    &&
+                                                       token != TokenName.DIVIDE_EQUAL      &&
+                                                       token != TokenName.DOT_EQUAL         &&
+                                                       token != TokenName.REMAINDER_EQUAL   &&
+                                                       token != TokenName.AND_EQUAL         &&
+                                                       token != TokenName.OR_EQUAL          &&
+                                                       token != TokenName.XOR_EQUAL         &&
+                                                       token != TokenName.RIGHT_SHIFT_EQUAL &&
+                                                       token != TokenName.LEFT_SHIFT_EQUAL) {
+
+                                                       FieldReference ref = (FieldReference) lhs;
+
+                                                       if (!containsVariableSet(ref.token)) {
+                                                               if (null == initHandler || initHandler.reportError()) {
+                                                                       problemReporter.uninitializedLocalVariable(
+                                                                                       new String(ref.token), ref.sourceStart,
+                                                                                       ref.sourceEnd, referenceContext,
+                                                                                       compilationUnit.compilationResult);
+                                                               }
+                                                               addVariableSet(ref.token);
+                                                       }
+                                               }
+                                       }
+
+                                       switch (token) {
+                                               case EQUAL:
+                                                       if (lhs != null && lhs instanceof FieldReference) {
+                                                               addVariableSet(((FieldReference) lhs).token);
+                                                       }
                                                        getNextToken();
-                                                       if (token == TokenNamenew) {
-                                                               // | variable '=' '&' T_NEW class_name_reference
-                                                               // ctor_arguments
+                                                       if (token == TokenName.OP_AND) {
                                                                getNextToken();
-                                                               class_name_reference();
-                                                               ctor_arguments();
+                                                               if (token == TokenName.NEW) {
+                                                                       // | variable '=' '&' T_NEW class_name_reference
+                                                                       // ctor_arguments
+                                                                       getNextToken();
+                                                                       SingleTypeReference classRef = class_name_reference();
+                                                                       ctor_arguments();
+                                                                       if (classRef != null) {
+                                                                               if (lhs != null
+                                                                                               && lhs instanceof FieldReference) {
+                                                                                       // example:
+                                                                                       // $var = & new Object();
+                                                                                       if (fMethodVariables != null) {
+                                                                                               VariableInfo lhsInfo = new VariableInfo(
+                                                                                                               ((FieldReference) lhs).sourceStart);
+                                                                                               lhsInfo.reference = classRef;
+                                                                                               lhsInfo.typeIdentifier = classRef.token;
+                                                                                               fMethodVariables.put(new String(
+                                                                                                               ((FieldReference) lhs).token),
+                                                                                                               lhsInfo);
+                                                                                               rememberedVar = true;
+                                                                                       }
+                                                                               }
+                                                                       }
+                                                               } else {
+                                                                       Expression rhs = variable(false, false);
+                                                                       if (rhs != null && rhs instanceof FieldReference
+                                                                                       && lhs != null
+                                                                                       && lhs instanceof FieldReference) {
+                                                                               // example:
+                                                                               // $var = &$ref;
+                                                                               if (fMethodVariables != null) {
+                                                                                       VariableInfo rhsInfo = (VariableInfo) fMethodVariables
+                                                                                                       .get(((FieldReference) rhs).token);
+                                                                                       if (rhsInfo != null
+                                                                                                       && rhsInfo.reference != null) {
+                                                                                               VariableInfo lhsInfo = new VariableInfo(
+                                                                                                               ((FieldReference) lhs).sourceStart);
+                                                                                               lhsInfo.reference = rhsInfo.reference;
+                                                                                               lhsInfo.typeIdentifier = rhsInfo.typeIdentifier;
+                                                                                               fMethodVariables.put(new String(
+                                                                                                               ((FieldReference) lhs).token),
+                                                                                                               lhsInfo);
+                                                                                               rememberedVar = true;
+                                                                                       }
+                                                                               }
+                                                                       }
+                                                               }
                                                        } else {
-                                                               variable();
+                                                               Expression rhs = expr_without_variable (only_variable, initHandler, bColonAllowed);
+
+                                                               if (lhs != null && lhs instanceof FieldReference) {
+                                                                       if (rhs != null && rhs instanceof FieldReference) {
+                                                                               // example:
+                                                                               // $var = $ref;
+                                                                               if (fMethodVariables != null) {
+                                                                                       VariableInfo rhsInfo = (VariableInfo) fMethodVariables
+                                                                                                       .get(((FieldReference) rhs).token);
+                                                                                       if (rhsInfo != null
+                                                                                                       && rhsInfo.reference != null) {
+                                                                                               VariableInfo lhsInfo = new VariableInfo(
+                                                                                                               ((FieldReference) lhs).sourceStart);
+                                                                                               lhsInfo.reference = rhsInfo.reference;
+                                                                                               lhsInfo.typeIdentifier = rhsInfo.typeIdentifier;
+                                                                                               fMethodVariables.put(new String(
+                                                                                                               ((FieldReference) lhs).token),
+                                                                                                               lhsInfo);
+                                                                                               rememberedVar = true;
+                                                                                       }
+                                                                               }
+                                                                       } else if (rhs != null
+                                                                                       && rhs instanceof SingleTypeReference) {
+                                                                               // example:
+                                                                               // $var = new Object();
+                                                                               if (fMethodVariables != null) {
+                                                                                       VariableInfo lhsInfo = new VariableInfo(
+                                                                                                       ((FieldReference) lhs).sourceStart);
+                                                                                       lhsInfo.reference = (SingleTypeReference) rhs;
+                                                                                       lhsInfo.typeIdentifier = ((SingleTypeReference) rhs).token;
+                                                                                       fMethodVariables.put(new String(
+                                                                                                       ((FieldReference) lhs).token),
+                                                                                                       lhsInfo);
+                                                                                       rememberedVar = true;
+                                                                               }
+                                                                       }
+                                                               }
                                                        }
+                                                       if (rememberedVar == false && lhs != null
+                                                                       && lhs instanceof FieldReference) {
+                                                               if (fMethodVariables != null) {
+                                                                       VariableInfo lhsInfo = new VariableInfo (((FieldReference) lhs).sourceStart);
+                                                                       fMethodVariables.put (new String (((FieldReference) lhs).token), lhsInfo);
+                                                               }
+                                                       }
+                                                       break;
+
+                                               case TERNARY_SHORT:
+                                               case PLUS_EQUAL:
+                                               case MINUS_EQUAL:
+                                               case MULTIPLY_EQUAL:
+                                               case DIVIDE_EQUAL:
+                                               case DOT_EQUAL:
+                                               case REMAINDER_EQUAL:
+                                               case AND_EQUAL:
+                                               case OR_EQUAL:
+                                               case XOR_EQUAL:
+                                               case RIGHT_SHIFT_EQUAL:
+                                               case LEFT_SHIFT_EQUAL:
+                                                       if (lhs != null && lhs instanceof FieldReference) {
+                                                               addVariableSet(((FieldReference) lhs).token);
+                                                       }
+                                                       getNextToken();
+                                                       expr_without_variable (only_variable, initHandler, bColonAllowed);
+                                                       break;
+                                               case PLUS_PLUS:
+                                               case MINUS_MINUS:
+                                                       getNextToken();
+                                                       break;
+                                               default:
+                                                       if (!only_variable) {
+                                                               throwSyntaxError("Variable expression not allowed (found token '"
+                                                                               + scanner.toStringAction(token) + "').");
+                                                       }
+                                                       if (lhs != null) {
+                                                               expression = lhs;
+                                                       }
+                                       } // case DOLLAR, VARIABLE, IDENTIFIER: switch token
+                                       break;
+
+                               case FUNCTION:
+                                       MethodDeclaration methodDecl = new MethodDeclaration (this.compilationUnit.compilationResult);
+                                       methodDecl.declarationSourceStart = scanner.getCurrentTokenStartPosition();
+                                       methodDecl.modifiers = AccDefault;
+                                       methodDecl.type = MethodDeclaration.FUNCTION_DEFINITION;
+                                       try {
+                                               getNextToken();
+                                               functionDefinition(methodDecl);
+                                       } finally {
+                                               int sourceEnd = methodDecl.sourceEnd;
+                                               if (sourceEnd <= 0 || methodDecl.declarationSourceStart > sourceEnd) {
+                                                       sourceEnd = methodDecl.declarationSourceStart + 1;
+                                               }
+                                               methodDecl.declarationSourceEnd = sourceEnd;
+                                               methodDecl.sourceEnd = sourceEnd;
+                                       }
+                                       break;
+
+                               case STATIC:
+                                       getNextToken ();
+                                       if (token == TokenName.PAAMAYIM_NEKUDOTAYIM) {
+                                               getNextToken ();
+                                               expr_without_variable (only_variable, initHandler, bColonAllowed);
+                                       }
+                                       else {
+                                               throwSyntaxError("Error in expression (Expected '::' after 'static').");
+                                       }
+                                       break;
+                                                                               
+                               default:
+                                       if (token != TokenName.INLINE_HTML) {
+                                               if (token.compareTo (TokenName.KEYWORD) > 0) {
+                                                       getNextToken();
+                                                       break;
                                                } else {
-                                                       expr();
+                                                       // System.out.println(scanner.getCurrentTokenStartPosition());
+                                                       // System.out.println(scanner.getCurrentTokenEndPosition());
+
+                                                       throwSyntaxError("Error in expression (found token '"
+                                                                       + scanner.toStringAction(token) + "').");
                                                }
+                                       }
+                                       return expression;
+                       } // switch token
+
+                       if (Scanner.TRACE) {
+                               System.out.println("TRACE: expr_without_variable() PART 2");
+                       }
+
+                       // | expr T_BOOLEAN_OR expr
+                       // | expr T_BOOLEAN_AND expr
+                       // | expr T_LOGICAL_OR expr
+                       // | expr T_LOGICAL_AND expr
+                       // | expr T_LOGICAL_XOR expr
+                       // | expr '|' expr
+                       // | expr '&' expr
+                       // | expr '^' expr
+                       // | expr '.' expr
+                       // | expr '+' expr
+                       // | expr '-' expr
+                       // | expr '*' expr
+                       // | expr '/' expr
+                       // | expr '%' expr
+                       // | expr T_SL expr
+                       // | expr T_SR expr
+                       // | expr T_IS_IDENTICAL expr
+                       // | expr T_IS_NOT_IDENTICAL expr
+                       // | expr T_IS_EQUAL expr
+                       // | expr T_IS_NOT_EQUAL expr
+                       // | expr '<' expr
+                       // | expr T_IS_SMALLER_OR_EQUAL expr
+                       // | expr '>' expr
+                       // | expr T_IS_GREATER_OR_EQUAL expr
+                       while (true) {
+                               switch (token) {
+                                       case OR_OR:
+                                               getNextToken();
+                                               expression = new OR_OR_Expression(expression, expr_without_variable (only_variable, initHandler, bColonAllowed), OperatorIds.OR_OR);
                                                break;
-                                       case TokenNamePLUS_EQUAL :
-                                       case TokenNameMINUS_EQUAL :
-                                       case TokenNameMULTIPLY_EQUAL :
-                                       case TokenNameDIVIDE_EQUAL :
-                                       case TokenNameDOT_EQUAL :
-                                       case TokenNameREMAINDER_EQUAL :
-                                       case TokenNameAND_EQUAL :
-                                       case TokenNameOR_EQUAL :
-                                       case TokenNameXOR_EQUAL :
-                                       case TokenNameRIGHT_SHIFT_EQUAL :
-                                       case TokenNameLEFT_SHIFT_EQUAL :
+                                       case AND_AND:
                                                getNextToken();
-                                               expr();
+                                               expression = new AND_AND_Expression(expression, expr_without_variable (only_variable, initHandler, bColonAllowed), OperatorIds.AND_AND);
                                                break;
-                                       case TokenNamePLUS_PLUS :
-                                       case TokenNameMINUS_MINUS :
+                                       case EQUAL_EQUAL:
                                                getNextToken();
+                                               expression = new EqualExpression(expression, expr_without_variable (only_variable, initHandler, bColonAllowed), OperatorIds.EQUAL_EQUAL);
                                                break;
-                                       default :
-                                               if (!only_variable) {
-                                                       throwSyntaxError("Variable expression not allowed (found token '"
-                                                                       + scanner.toStringAction(token) + "').");
+                                       case OP_AND:
+                           getNextToken();
+                           expression = new BinaryExpression(expression, expr_without_variable (only_variable, initHandler, bColonAllowed), OperatorIds.AND);
+                           break;
+                                       case OP_OR:
+                           getNextToken();
+                           expression = new BinaryExpression(expression, expr_without_variable (only_variable, initHandler, bColonAllowed), OperatorIds.OR);
+                           break;
+                                       case OP_XOR:
+                           getNextToken();
+                           expression = new BinaryExpression(expression, expr_without_variable (only_variable, initHandler, bColonAllowed), OperatorIds.XOR);
+                           break;
+                                       case OP_AND_OLD:
+                           getNextToken();
+                           expression = new BinaryExpression(expression, expr_without_variable (only_variable, initHandler, bColonAllowed), OperatorIds.AND);
+                           break;
+                       case OP_OR_OLD:
+                           getNextToken();
+                           expression = new BinaryExpression(expression, expr_without_variable (only_variable, initHandler, bColonAllowed), OperatorIds.OR);
+                           break;
+                                       case OP_XOR_OLD:
+                           getNextToken();
+                           expression = new BinaryExpression(expression, expr_without_variable (only_variable, initHandler, bColonAllowed), OperatorIds.XOR);
+                           break;
+                                       case DOT:
+                           getNextToken();
+                           expression = new BinaryExpression(expression, expr_without_variable (only_variable, initHandler, bColonAllowed), OperatorIds.TWIDDLE);
+                           break;
+                                       case PLUS:
+                           getNextToken();
+                           expression = new BinaryExpression(expression, expr_without_variable (only_variable, initHandler, bColonAllowed), OperatorIds.PLUS);
+                           break;
+                                       case MINUS:
+                           getNextToken();
+                           expression = new BinaryExpression(expression, expr_without_variable (only_variable, initHandler, bColonAllowed), OperatorIds.MINUS);
+                           break;
+                                       case MULTIPLY:
+                           getNextToken();
+                           expression = new BinaryExpression(expression, expr_without_variable (only_variable, initHandler, bColonAllowed), OperatorIds.MULTIPLY);
+                           break;
+                                       case DIVIDE:
+                           getNextToken();
+                           expression = new BinaryExpression(expression, expr_without_variable (only_variable, initHandler, bColonAllowed), OperatorIds.DIVIDE);
+                           break;
+                                       case REMAINDER:
+                           getNextToken();
+                           expression = new BinaryExpression(expression, expr_without_variable (only_variable, initHandler, bColonAllowed), OperatorIds.REMAINDER);
+                           break;
+                                       case LEFT_SHIFT:
+                           getNextToken();
+                           expression = new BinaryExpression(expression, expr_without_variable (only_variable, initHandler, bColonAllowed), OperatorIds.LEFT_SHIFT);
+                           break;
+                                       case RIGHT_SHIFT:
+                           getNextToken();
+                           expression = new BinaryExpression(expression, expr_without_variable (only_variable, initHandler, bColonAllowed), OperatorIds.RIGHT_SHIFT);
+                           break;
+                                       case EQUAL_EQUAL_EQUAL:
+                           getNextToken();
+                           expression = new BinaryExpression(expression, expr_without_variable (only_variable, initHandler, bColonAllowed), OperatorIds.EQUAL_EQUAL);
+                           break;
+                                       case NOT_EQUAL_EQUAL:
+                           getNextToken();
+                           expression = new BinaryExpression(expression, expr_without_variable (only_variable, initHandler, bColonAllowed), OperatorIds.NOT_EQUAL);
+                           break;
+                                       case NOT_EQUAL:
+                           getNextToken();
+                           expression = new BinaryExpression(expression, expr_without_variable (only_variable, initHandler, bColonAllowed), OperatorIds.NOT_EQUAL);
+                           break;
+                                       case LESS:
+                           getNextToken();
+                           expression = new BinaryExpression(expression, expr_without_variable (only_variable, initHandler, bColonAllowed), OperatorIds.LESS);
+                           break;
+                                       case LESS_EQUAL:
+                           getNextToken();
+                           expression = new BinaryExpression(expression, expr_without_variable (only_variable, initHandler, bColonAllowed), OperatorIds.LESS_EQUAL);
+                           break;
+                                       case GREATER:
+                           getNextToken();
+                           expression = new BinaryExpression(expression, expr_without_variable (only_variable, initHandler, bColonAllowed), OperatorIds.GREATER);
+                           break;
+                                       case GREATER_EQUAL:
+                                               getNextToken();
+                                               expression = new BinaryExpression(expression, expr_without_variable (only_variable, initHandler, bColonAllowed), OperatorIds.GREATER_EQUAL);
+                                               break;
+                                       // | expr T_INSTANCEOF class_name_reference
+                                       // | expr '?' expr ':' expr
+                                       case INSTANCEOF:
+                                               getNextToken();
+                                               TypeReference classRef = class_name_reference();
+
+                                               if (classRef != null) {
+                                                       expression = new InstanceOfExpression (expression, classRef, OperatorIds.INSTANCEOF);
+                                                       expression.sourceStart = exprSourceStart;
+                                                       expression.sourceEnd = scanner.getCurrentTokenEndPosition();
                                                }
-                               }
-                               break;
-                       default :
-                               if (token != TokenNameINLINE_HTML) {
-                                       if (token > TokenNameKEYWORD) {
+                                               break;
+
+                                       case TERNARY_SHORT:
                                                getNextToken();
+                                               expression = new EqualExpression(expression, expr_without_variable (only_variable, initHandler, bColonAllowed), OperatorIds.TERNARY_SHORT);
                                                break;
-                                       } else {
-                                               throwSyntaxError("Error in expression (found token '"
-                                                               + scanner.toStringAction(token) + "').");
-                                       }
-                               }
-                               return;
-               }
-               if (Scanner.TRACE) {
-                       System.out.println("TRACE: expr_without_variable() PART 2");
-               }
-               //      | expr T_BOOLEAN_OR expr
-               //      | expr T_BOOLEAN_AND expr
-               //      | expr T_LOGICAL_OR expr
-               //      | expr T_LOGICAL_AND expr
-               //      | expr T_LOGICAL_XOR expr
-               //      | expr '|' expr
-               //      | expr '&' expr
-               //      | expr '^' expr
-               //      | expr '.' expr
-               //      | expr '+' expr
-               //      | expr '-' expr
-               //      | expr '*' expr
-               //      | expr '/' expr
-               //      | expr '%' expr
-               //      | expr T_SL expr
-               //      | expr T_SR expr
-               //      | expr T_IS_IDENTICAL expr
-               //      | expr T_IS_NOT_IDENTICAL expr
-               //      | expr T_IS_EQUAL expr
-               //      | expr T_IS_NOT_EQUAL expr
-               //      | expr '<' expr
-               //      | expr T_IS_SMALLER_OR_EQUAL expr
-               //      | expr '>' expr
-               //      | expr T_IS_GREATER_OR_EQUAL expr
-               while (true) {
-                       switch (token) {
-                               case TokenNameOR_OR :
-                               case TokenNameAND_AND :
-                               case TokenNameand :
-                               case TokenNameor :
-                               case TokenNamexor :
-                               case TokenNameAND :
-                               case TokenNameOR :
-                               case TokenNameXOR :
-                               case TokenNameDOT :
-                               case TokenNamePLUS :
-                               case TokenNameMINUS :
-                               case TokenNameMULTIPLY :
-                               case TokenNameDIVIDE :
-                               case TokenNameREMAINDER :
-                               case TokenNameLEFT_SHIFT :
-                               case TokenNameRIGHT_SHIFT :
-                               case TokenNameEQUAL_EQUAL_EQUAL :
-                               case TokenNameNOT_EQUAL_EQUAL :
-                               case TokenNameEQUAL_EQUAL :
-                               case TokenNameNOT_EQUAL :
-                               case TokenNameLESS :
-                               case TokenNameLESS_EQUAL :
-                               case TokenNameGREATER :
-                               case TokenNameGREATER_EQUAL :
-                                       getNextToken();
-                                       expr();
-                                       break;
-                               //  | expr T_INSTANCEOF class_name_reference
-                               //      | expr '?' expr ':' expr
-                               case TokenNameinstanceof :
-                                       getNextToken();
-                                       class_name_reference();
-                                       break;
-                               case TokenNameQUESTION :
-                                       getNextToken();
-                                       expr();
-                                       if (token == TokenNameCOLON) {
+
+                                       case QUESTION:
                                                getNextToken();
-                                               expr();
-                                       }
-                                       break;
-                               default :
-                                       return;
+                                               Expression valueIfTrue = expr_without_variable (true, null, true);
+                                               if (token != TokenName.COLON) {
+                                                       throwSyntaxError("':' expected in conditional expression.");
+                                               }
+                                               getNextToken();
+                                               Expression valueIfFalse = expr();
+
+                                               expression = new ConditionalExpression (expression, valueIfTrue, valueIfFalse);
+                                               break;
+                                       default:
+                                               return expression;
+                               } // switch
+                       } // while (true)
+               } catch (SyntaxError e) {
+                       // try to find next token after expression with errors:
+                       if (token == TokenName.SEMICOLON) {
+                               getNextToken();
+                               return expression;
+                       }
+
+                       if (token == TokenName.RBRACE ||
+                           token == TokenName.RPAREN ||
+                               token == TokenName.RBRACKET) {
+                               getNextToken();
+                               return expression;
                        }
+                       throw e;
                }
        }
-       private void class_name_reference() {
-               //  class_name_reference:
-               //      T_STRING
-               //| dynamic_class_name_reference
+
+       /**
+        *
+        */
+       private SingleTypeReference class_name_reference() {
+               // class_name_reference:
+               // T_STRING
+               // | dynamic_class_name_reference
+               SingleTypeReference ref = null;
                if (Scanner.TRACE) {
                        System.out.println("TRACE: class_name_reference()");
                }
-               if (token == TokenNameIdentifier) {
+               if (token == TokenName.IDENTIFIER) {
+                       ref = new SingleTypeReference(scanner.getCurrentIdentifierSource(),
+                                       scanner.getCurrentTokenStartPosition());
+                       int pos = scanner.currentPosition;
                        getNextToken();
+                       if (token == TokenName.PAAMAYIM_NEKUDOTAYIM) {
+                               // Not terminated by T_STRING, reduce to dynamic_class_name_reference
+                               scanner.currentPosition = pos;
+                               token = TokenName.IDENTIFIER;
+                               ref = null;
+                               dynamic_class_name_reference();
+                       }
                } else {
+                       ref = null;
                        dynamic_class_name_reference();
                }
+               return ref;
        }
+
        private void dynamic_class_name_reference() {
-               //dynamic_class_name_reference:
-               //      base_variable T_OBJECT_OPERATOR object_property
+               // dynamic_class_name_reference:
+               // base_variable T_OBJECT_OPERATOR object_property
                // dynamic_class_name_variable_properties
-               //| base_variable
+               // | base_variable
                if (Scanner.TRACE) {
                        System.out.println("TRACE: dynamic_class_name_reference()");
                }
-               base_variable();
-               if (token == TokenNameMINUS_GREATER) {
+               base_variable(true);
+               if (token == TokenName.MINUS_GREATER) {
                        getNextToken();
                        object_property();
                        dynamic_class_name_variable_properties();
                }
        }
+
        private void dynamic_class_name_variable_properties() {
-               //  dynamic_class_name_variable_properties:
-               //              dynamic_class_name_variable_properties
+               // dynamic_class_name_variable_properties:
+               // dynamic_class_name_variable_properties
                // dynamic_class_name_variable_property
-               //      | /* empty */
+               // | /* empty */
                if (Scanner.TRACE) {
                        System.out
                                        .println("TRACE: dynamic_class_name_variable_properties()");
                }
-               while (token == TokenNameMINUS_GREATER) {
+               while (token == TokenName.MINUS_GREATER) {
                        dynamic_class_name_variable_property();
                }
        }
+
        private void dynamic_class_name_variable_property() {
-               //  dynamic_class_name_variable_property:
-               //      T_OBJECT_OPERATOR object_property
+               // dynamic_class_name_variable_property:
+               // T_OBJECT_OPERATOR object_property
                if (Scanner.TRACE) {
                        System.out.println("TRACE: dynamic_class_name_variable_property()");
                }
-               if (token == TokenNameMINUS_GREATER) {
+               if (token == TokenName.MINUS_GREATER) {
                        getNextToken();
                        object_property();
                }
        }
+
        private void ctor_arguments() {
-               //  ctor_arguments:
-               //      /* empty */
-               //| '(' function_call_parameter_list ')'
-               if (token == TokenNameLPAREN) {
+               // ctor_arguments:
+               // /* empty */
+               // | '(' function_call_parameter_list ')'
+               if (token == TokenName.LPAREN) {
                        getNextToken();
-                       if (token == TokenNameRPAREN) {
+                       if (token == TokenName.RPAREN) {
                                getNextToken();
                                return;
                        }
                        non_empty_function_call_parameter_list();
-                       if (token != TokenNameRPAREN) {
+                       if (token != TokenName.RPAREN) {
                                throwSyntaxError("')' expected in ctor_arguments.");
                        }
                        getNextToken();
                }
        }
+
        private void assignment_list() {
-               //  assignment_list:
-               //      assignment_list ',' assignment_list_element
-               //| assignment_list_element
+               // assignment_list:
+               // assignment_list ',' assignment_list_element
+               // | assignment_list_element
                while (true) {
                        assignment_list_element();
-                       if (token != TokenNameCOMMA) {
+                       if (token != TokenName.COMMA) {
                                break;
                        }
                        getNextToken();
                }
        }
+
        private void assignment_list_element() {
-               //assignment_list_element:
-               //      variable
-               //| T_LIST '(' assignment_list ')'
-               //| /* empty */
-               if (token == TokenNameVariable || token == TokenNameDOLLAR) {
-                       variable();
+               // assignment_list_element:
+               // variable
+               // | T_LIST '(' assignment_list ')'
+               // | /* empty */
+               if (token == TokenName.VARIABLE) {
+                       variable(true, false);
+               } else if (token == TokenName.DOLLAR) {
+                       variable(false, false);
+               } else if (token == TokenName.IDENTIFIER) {
+                       identifier(true, true, false);
                } else {
-                       if (token == TokenNamelist) {
+                       if (token == TokenName.LIST) {
                                getNextToken();
-                               if (token == TokenNameLPAREN) {
+                               if (token == TokenName.LPAREN) {
                                        getNextToken();
                                        assignment_list();
-                                       if (token != TokenNameRPAREN) {
+                                       if (token != TokenName.RPAREN) {
                                                throwSyntaxError("')' expected after 'list' keyword.");
                                        }
                                        getNextToken();
@@ -2433,247 +3463,329 @@ public class Parser //extends PHPParserSuperclass
                        }
                }
        }
+
        private void array_pair_list() {
-               //  array_pair_list:
-               //      /* empty */
-               //| non_empty_array_pair_list possible_comma
+               // array_pair_list:
+               // /* empty */
+               // | non_empty_array_pair_list possible_comma
                non_empty_array_pair_list();
-               if (token == TokenNameCOMMA) {
+               if (token == TokenName.COMMA) {
                        getNextToken();
                }
        }
+
        private void non_empty_array_pair_list() {
-               //non_empty_array_pair_list:
-               //      non_empty_array_pair_list ',' expr T_DOUBLE_ARROW expr
-               //| non_empty_array_pair_list ',' expr
-               //| expr T_DOUBLE_ARROW expr
-               //| expr
-               //| non_empty_array_pair_list ',' expr T_DOUBLE_ARROW '&' w_variable
-               //| non_empty_array_pair_list ',' '&' w_variable
-               //| expr T_DOUBLE_ARROW '&' w_variable
-               //| '&' w_variable
+               // non_empty_array_pair_list:
+               // non_empty_array_pair_list ',' expr T_DOUBLE_ARROW expr
+               // | non_empty_array_pair_list ',' expr
+               // | expr T_DOUBLE_ARROW expr
+               // | expr
+               // | non_empty_array_pair_list ',' expr T_DOUBLE_ARROW '&' w_variable
+               // | non_empty_array_pair_list ',' '&' w_variable
+               // | expr T_DOUBLE_ARROW '&' w_variable
+               // | '&' w_variable
                while (true) {
-                       if (token == TokenNameAND) {
+                       if (token == TokenName.OP_AND) {
                                getNextToken();
-                               variable();
+                               variable(true, false);
                        } else {
                                expr();
-                               if (token == TokenNameAND) {
+                               if (token == TokenName.OP_AND) {
                                        getNextToken();
-                                       variable();
-                               } else if (token == TokenNameEQUAL_GREATER) {
+                                       variable(true, false);
+                               } else if (token == TokenName.EQUAL_GREATER) {
                                        getNextToken();
-                                       if (token == TokenNameAND) {
+                                       if (token == TokenName.OP_AND) {
                                                getNextToken();
-                                               variable();
+                                               variable(true, false);
                                        } else {
                                                expr();
                                        }
                                }
                        }
-                       if (token != TokenNameCOMMA) {
+                       if (token != TokenName.COMMA) {
                                return;
                        }
                        getNextToken();
-                       if (token == TokenNameRPAREN) {
+                       if (token == TokenName.RPAREN) {
                                return;
                        }
                }
        }
-       //  private void variableList() {
-       //    do {
-       //      variable();
-       //      if (token == TokenNameCOMMA) {
-       //        getNextToken();
-       //      } else {
-       //        break;
-       //      }
-       //    } while (true);
-       //  }
-       private void variable_without_objects() {
-               //  variable_without_objects:
-               //              reference_variable
-               //      | simple_indirect_reference reference_variable
+
+       // private void variableList() {
+       // do {
+       // variable();
+       // if (token == TokenName.COMMA) {
+       // getNextToken();
+       // } else {
+       // break;
+       // }
+       // } while (true);
+       // }
+       private Expression variable_without_objects(boolean lefthandside,
+                       boolean ignoreVar) {
+               // variable_without_objects:
+               // reference_variable
+               // | simple_indirect_reference reference_variable
                if (Scanner.TRACE) {
                        System.out.println("TRACE: variable_without_objects()");
                }
-               while (token == TokenNameDOLLAR) {
+               while (token == TokenName.DOLLAR) {
                        getNextToken();
                }
-               reference_variable();
+               return reference_variable(lefthandside, ignoreVar);
        }
-       private void function_call() {
-               //  function_call:
-               //      T_STRING '(' function_call_parameter_list ')'
-               //| class_constant '(' function_call_parameter_list ')'
-               //| static_member '(' function_call_parameter_list ')'
-               //| variable_without_objects '(' function_call_parameter_list ')'
+
+       private Expression function_call(boolean lefthandside, boolean ignoreVar) {
+               // function_call:
+               // T_STRING '(' function_call_parameter_list ')'
+               // | class_constant '(' function_call_parameter_list ')'
+               // | static_member '(' function_call_parameter_list ')'
+               // | variable_without_objects '(' function_call_parameter_list ')'
+               char[] defineName = null;
+               char[] ident = null;
+               int startPos = 0;
+               int endPos = 0;
+               Expression ref = null;
                if (Scanner.TRACE) {
                        System.out.println("TRACE: function_call()");
                }
-               if (token == TokenNameIdentifier) {
+               if (token == TokenName.IDENTIFIER) {
+                       ident = scanner.getCurrentIdentifierSource();
+                       defineName = ident;
+                       startPos = scanner.getCurrentTokenStartPosition();
+                       endPos = scanner.getCurrentTokenEndPosition();
                        getNextToken();
                        switch (token) {
-                               case TokenNamePAAMAYIM_NEKUDOTAYIM :
-                                       // static member:
+                       case PAAMAYIM_NEKUDOTAYIM:
+                               // static member:
+                               defineName = null;
+                               getNextToken();
+                               if (token == TokenName.IDENTIFIER) {
+                                       // class _constant
                                        getNextToken();
-                                       if (token == TokenNameIdentifier) {
-                                               // class _constant
-                                               getNextToken();
-                                       } else {
-                                               //        static member:
-                                               variable_without_objects();
-                                       }
-                                       break;
+                               } else {
+                                       // static member:
+                                       variable_without_objects(true, false);
+                               }
+                               break;
                        }
                } else {
-                       variable_without_objects();
+                       ref = variable_without_objects(lefthandside, ignoreVar);
                }
-               if (token != TokenNameLPAREN) {
-                       // TODO is this ok ?
-                       return;
-                       //      throwSyntaxError("'(' expected in function call.");
-               }
-               getNextToken();
-               if (token == TokenNameRPAREN) {
+               if (token != TokenName.LPAREN) {
+                       if (defineName != null) {
+                               // does this identifier contain only uppercase characters?
+                               if (defineName.length == 3) {
+                                       if (defineName[0] == 'd' &&
+                                           defineName[1] == 'i' &&
+                                               defineName[2] == 'e') {
+                                               defineName = null;
+                                       }
+                               } else if (defineName.length == 4) {
+                                       if (defineName[0] == 't' &&
+                                           defineName[1] == 'r' &&
+                                               defineName[2] == 'u' &&
+                                               defineName[3] == 'e') {
+                                               defineName = null;
+                                       } else if (defineName[0] == 'n' &&
+                                                  defineName[1] == 'u' &&
+                                                          defineName[2] == 'l' &&
+                                                          defineName[3] == 'l') {
+                                               defineName = null;
+                                       }
+                               } else if (defineName.length == 5) {
+                                       if (defineName[0] == 'f' &&
+                                           defineName[1] == 'a' &&
+                                               defineName[2] == 'l' &&
+                                               defineName[3] == 's' &&
+                                               defineName[4] == 'e') {
+                                               defineName = null;
+                                       }
+                               }
+                               if (defineName != null) {
+                                       for (int i = 0; i < defineName.length; i++) {
+                                               if (Character.isLowerCase(defineName[i])) {
+                                                       problemReporter.phpUppercaseIdentifierWarning(
+                                                                       startPos, endPos, referenceContext,
+                                                                       compilationUnit.compilationResult);
+                                                       break;
+                                               }
+                                       }
+                               }
+                       }
+               } else {
+                       getNextToken();
+                       if (token == TokenName.RPAREN) {
+                               getNextToken();
+                               return ref;
+                       }
+
+                       non_empty_function_call_parameter_list();
+
+                       if (token != TokenName.RPAREN) {
+                               String functionName;
+
+                               if (ident == null) {
+                                       functionName = new String(" ");
+                               } else {
+                                       functionName = new String(ident);
+                               }
+
+                               throwSyntaxError("')' expected in function call (" + functionName + ").");
+                       }
                        getNextToken();
-                       return;
-               }
-               non_empty_function_call_parameter_list();
-               if (token != TokenNameRPAREN) {
-                       throwSyntaxError("')' expected in function call.");
                }
-               getNextToken();
+               return ref;
        }
-       //  private void function_call_parameter_list() {
-       //    function_call_parameter_list:
-       //              non_empty_function_call_parameter_list { $$ = $1; }
-       //      | /* empty */
-       //  }
+
        private void non_empty_function_call_parameter_list() {
-               //non_empty_function_call_parameter_list:
-               //              expr_without_variable
-               //      | variable
-               //      | '&' w_variable
-               //      | non_empty_function_call_parameter_list ',' expr_without_variable
-               //      | non_empty_function_call_parameter_list ',' variable
-               //      | non_empty_function_call_parameter_list ',' '&' w_variable
+               this.non_empty_function_call_parameter_list(null);
+       }
+
+       // private void function_call_parameter_list() {
+       // function_call_parameter_list:
+       // non_empty_function_call_parameter_list { $$ = $1; }
+       // | /* empty */
+       // }
+       private void non_empty_function_call_parameter_list(String functionName) {
+               // non_empty_function_call_parameter_list:
+               // expr_without_variable
+               // | variable
+               // | '&' w_variable
+               // | non_empty_function_call_parameter_list ',' expr_without_variable
+               // | non_empty_function_call_parameter_list ',' variable
+               // | non_empty_function_call_parameter_list ',' '&' w_variable
                if (Scanner.TRACE) {
                        System.out
                                        .println("TRACE: non_empty_function_call_parameter_list()");
                }
+               UninitializedVariableHandler initHandler = new UninitializedVariableHandler();
+               initHandler.setFunctionName(functionName);
                while (true) {
-                       if (token == TokenNameAND) {
+                       initHandler.incrementArgumentCount();
+                       if (token == TokenName.OP_AND) {
                                getNextToken();
-                               w_variable();
+                               w_variable(true);
                        } else {
-                               //        if (token == TokenNameIdentifier || token ==
-                               // TokenNameVariable
-                               //            || token == TokenNameDOLLAR) {
-                               //          variable();
-                               //        } else {
-                               expr_without_variable(true);
-                               //        }
-                       }
-                       if (token != TokenNameCOMMA) {
+                               // if (token == TokenName.Identifier || token ==
+                               // TokenName.Variable
+                               // || token == TokenName.DOLLAR) {
+                               // variable();
+                               // } else {
+                               expr_without_variable(true, initHandler, false);
+                               // }
+                       }
+                       if (token != TokenName.COMMA) {
                                break;
                        }
                        getNextToken();
                }
        }
+
        private void fully_qualified_class_name() {
-               if (token == TokenNameIdentifier) {
+               if (token == TokenName.IDENTIFIER) {
                        getNextToken();
                } else {
                        throwSyntaxError("Class name expected.");
                }
        }
+
        private void static_member() {
-               //  static_member:
-               //      fully_qualified_class_name T_PAAMAYIM_NEKUDOTAYIM
+               // static_member:
+               // fully_qualified_class_name T_PAAMAYIM_NEKUDOTAYIM
                // variable_without_objects
                if (Scanner.TRACE) {
                        System.out.println("TRACE: static_member()");
                }
                fully_qualified_class_name();
-               if (token != TokenNamePAAMAYIM_NEKUDOTAYIM) {
+               if (token != TokenName.PAAMAYIM_NEKUDOTAYIM) {
                        throwSyntaxError("'::' expected after class name (static_member).");
                }
                getNextToken();
-               variable_without_objects();
+               variable_without_objects(false, false);
        }
-       private void base_variable_with_function_calls() {
-               //  base_variable_with_function_calls:
-               //      base_variable
-               //| function_call
-               boolean functionCall = false;
+
+       /**
+        * base_variable_with_function_calls:
+        * base_variable | function_call
+        *
+        * @param lefthandside
+        * @param ignoreVar
+        * @return
+        */
+       private Expression base_variable_with_function_calls (boolean lefthandside, boolean ignoreVar) {
                if (Scanner.TRACE) {
                        System.out.println("TRACE: base_variable_with_function_calls()");
                }
-               //    if (token == TokenNameIdentifier) {
-               //      functionCall = true;
-               //    } else if (token == TokenNameVariable) {
-               //      int tempToken = token;
-               //      int tempPosition = scanner.currentPosition;
-               //      getNextToken();
-               //      if (token == TokenNameLPAREN) {
-               //        functionCall = true;
-               //      }
-               //      token = tempToken;
-               //      scanner.currentPosition = tempPosition;
-               //      scanner.phpMode = true;
-               //    }
-               //    if (functionCall) {
-               function_call();
-               //    } else {
-               //      base_variable();
-               //    }
-       }
-       private void base_variable() {
-               //  base_variable:
-               //              reference_variable
-               //      | simple_indirect_reference reference_variable
-               //      | static_member
+
+               return function_call(lefthandside, ignoreVar);
+       }
+
+       /**
+        * base_variable:
+        * reference_variable
+        * | simple_indirect_reference reference_variable
+        * | static_member
+        *
+        * @param lefthandside
+        * @return
+        */
+       private Expression base_variable (boolean lefthandside) {
+               Expression ref = null;
+
                if (Scanner.TRACE) {
-                       System.out.println("TRACE: base_variable()");
+                       System.out.println ("TRACE: base_variable()");
                }
-               if (token == TokenNameIdentifier) {
-                       static_member();
-               } else {
-                       while (token == TokenNameDOLLAR) {
-                               getNextToken();
+
+               if (token == TokenName.IDENTIFIER) {
+                       static_member ();
+               }
+               else {
+                       while (token == TokenName.DOLLAR) {
+                               getNextToken ();
                        }
-                       reference_variable();
+
+                       reference_variable (lefthandside, false);
                }
+
+               return ref;
        }
-       //  private void simple_indirect_reference() {
-       //    // simple_indirect_reference:
-       //    // '$'
-       //    //| simple_indirect_reference '$'
-       //  }
-       private void reference_variable() {
-               //  reference_variable:
-               //              reference_variable '[' dim_offset ']'
-               //      | reference_variable '{' expr '}'
-               //      | compound_variable
+
+       // private void simple_indirect_reference() {
+       // // simple_indirect_reference:
+       // // '$'
+       // //| simple_indirect_reference '$'
+       // }
+       private Expression reference_variable (boolean lefthandside, boolean ignoreVar) {
+               // reference_variable:
+               // reference_variable '[' dim_offset ']'
+               // | reference_variable '{' expr '}'
+               // | compound_variable
+               Expression ref = null;
                if (Scanner.TRACE) {
                        System.out.println("TRACE: reference_variable()");
                }
-               compound_variable();
+               ref = compound_variable(lefthandside, ignoreVar);
                while (true) {
-                       if (token == TokenNameLBRACE) {
+                       if (token == TokenName.LBRACE) {
+                               ref = null;
                                getNextToken();
                                expr();
-                               if (token != TokenNameRBRACE) {
+                               if (token != TokenName.RBRACE) {
                                        throwSyntaxError("'}' expected in reference variable.");
                                }
                                getNextToken();
-                       } else if (token == TokenNameLBRACKET) {
+                       } else if (token == TokenName.LBRACKET) {
+                               // To remove "ref = null;" here, is probably better than the
+                               // patch
+                               // commented in #1368081 - axelcl
                                getNextToken();
-                               if (token != TokenNameRBRACKET) {
+                               if (token != TokenName.RBRACKET) {
                                        expr();
-                                       //        dim_offset();
-                                       if (token != TokenNameRBRACKET) {
+                                       // dim_offset();
+                                       if (token != TokenName.RBRACKET) {
                                                throwSyntaxError("']' expected in reference variable.");
                                        }
                                }
@@ -2682,846 +3794,1140 @@ public class Parser //extends PHPParserSuperclass
                                break;
                        }
                }
+               return ref;
        }
-       private void compound_variable() {
-               //  compound_variable:
-               //              T_VARIABLE
-               //      | '$' '{' expr '}'
+
+       private Expression compound_variable (boolean lefthandside, boolean ignoreVar) {
+               // compound_variable:
+               // T_VARIABLE
+               // | '$' '{' expr '}'
                if (Scanner.TRACE) {
                        System.out.println("TRACE: compound_variable()");
                }
-               if (token == TokenNameVariable) {
+
+               if (token == TokenName.VARIABLE) {
+                       if (!lefthandside) {
+                               if (!containsVariableSet()) {
+                                       // reportSyntaxError("The local variable " + new
+                                       // String(scanner.getCurrentIdentifierSource())
+                                       // + " may not have been initialized");
+                                       problemReporter.uninitializedLocalVariable (
+                                                       new String (scanner.getCurrentIdentifierSource()),
+                                                                   scanner.getCurrentTokenStartPosition(),
+                                                                   scanner.getCurrentTokenEndPosition(),
+                                                                   referenceContext,
+                                                                   compilationUnit.compilationResult);
+                               }
+                       } else {
+                               if (!ignoreVar) {
+                                       addVariableSet();
+                               }
+                       }
+
+                       FieldReference ref = new FieldReference (scanner.getCurrentIdentifierSource(),
+                                                                                                        scanner.getCurrentTokenStartPosition());
                        getNextToken();
-               } else {
+                       return ref;
+               }
+               else {
                        // because of simple_indirect_reference
-                       while (token == TokenNameDOLLAR) {
+                       while (token == TokenName.DOLLAR) {
                                getNextToken();
                        }
-                       if (token != TokenNameLBRACE) {
-                               throwSyntaxError("'{' expected after compound variable token '$'.");
+
+                       if (token != TokenName.LBRACE) {
+                               reportSyntaxError("'{' expected after compound variable token '$'.");
+                               return null;
                        }
+
                        getNextToken();
                        expr();
-                       if (token != TokenNameRBRACE) {
+
+                       if (token != TokenName.RBRACE) {
                                throwSyntaxError("'}' expected after compound variable token '$'.");
                        }
+
                        getNextToken();
                }
-       }
-       //  private void dim_offset() {
-       //    // dim_offset:
-       //    // /* empty */
-       //    // | expr
-       //    expr();
-       //  }
+
+               return null;
+       } // private void dim_offset() { // // dim_offset: // // /* empty */
+
+       // // | expr
+       // expr();
+       // }
        private void object_property() {
-               //  object_property:
-               //      object_dim_list
-               //| variable_without_objects
+               // object_property:
+               // object_dim_list
+               // | variable_without_objects
                if (Scanner.TRACE) {
                        System.out.println("TRACE: object_property()");
                }
-               if (token == TokenNameVariable || token == TokenNameDOLLAR) {
-                       variable_without_objects();
-               } else {
+
+               if ((token == TokenName.VARIABLE) ||
+                       (token == TokenName.DOLLAR)) {
+                       variable_without_objects (false, false);
+               }
+               else {
                        object_dim_list();
                }
        }
+
        private void object_dim_list() {
-               //object_dim_list:
-               //      object_dim_list '[' dim_offset ']'
-               //| object_dim_list '{' expr '}'
-               //| variable_name
+               // object_dim_list:
+               // object_dim_list '[' dim_offset ']'
+               // | object_dim_list '{' expr '}'
+               // | variable_name
                if (Scanner.TRACE) {
                        System.out.println("TRACE: object_dim_list()");
                }
+
                variable_name();
+
                while (true) {
-                       if (token == TokenNameLBRACE) {
+                       if (token == TokenName.LBRACE) {
                                getNextToken();
                                expr();
-                               if (token != TokenNameRBRACE) {
+
+                               if (token != TokenName.RBRACE) {
                                        throwSyntaxError("'}' expected in object_dim_list.");
                                }
+
                                getNextToken();
-                       } else if (token == TokenNameLBRACKET) {
+                       }
+                       else if (token == TokenName.LBRACKET) {
                                getNextToken();
-                               if (token == TokenNameRBRACKET) {
+
+                               if (token == TokenName.RBRACKET) {
                                        getNextToken();
                                        continue;
                                }
+
                                expr();
-                               if (token != TokenNameRBRACKET) {
+
+                               if (token != TokenName.RBRACKET) {
                                        throwSyntaxError("']' expected in object_dim_list.");
                                }
+
                                getNextToken();
-                       } else {
+                       }
+                       else {
                                break;
                        }
                }
        }
+
        private void variable_name() {
-               //variable_name:
-               //      T_STRING
-               //| '{' expr '}'
+               // variable_name:
+               // T_STRING
+               // | '{' expr '}'
                if (Scanner.TRACE) {
                        System.out.println("TRACE: variable_name()");
                }
-               if (token == TokenNameIdentifier || token > TokenNameKEYWORD) {
-                       if (token > TokenNameKEYWORD) {
+
+               if ((token == TokenName.IDENTIFIER) ||
+                        (token.compareTo (TokenName.KEYWORD) > 0)) {
+                       if (token.compareTo (TokenName.KEYWORD) > 0) {
                                // TODO show a warning "Keyword used as variable" ?
                        }
+
                        getNextToken();
-               } else {
-                       if (token != TokenNameLBRACE) {
+               }
+               else if ((token == TokenName.OP_AND_OLD) ||                     // If the found token is e.g $var->and
+                                (token == TokenName.OP_OR_OLD)  ||                     // or is $var->or
+                                (token == TokenName.OP_XOR_OLD)) {                     // or is $var->xor
+                       getNextToken ();                                                                // get the next token. Maybe we should issue an warning?
+               }
+               else {
+                       if (token != TokenName.LBRACE) {
                                throwSyntaxError("'{' expected in variable name.");
                        }
+
                        getNextToken();
                        expr();
-                       if (token != TokenNameRBRACE) {
+
+                       if (token != TokenName.RBRACE) {
                                throwSyntaxError("'}' expected in variable name.");
                        }
+
                        getNextToken();
                }
        }
+
        private void r_variable() {
-               variable();
+               variable(false, false);
        }
-       private void w_variable() {
-               variable();
+
+       private void w_variable(boolean lefthandside) {
+               variable(lefthandside, false);
        }
+
        private void rw_variable() {
-               variable();
+               variable(false, false);
        }
-       private void variable() {
-               //    variable:
-               //              base_variable_with_function_calls T_OBJECT_OPERATOR
-               //                      object_property method_or_not variable_properties
-               //      | base_variable_with_function_calls
-               base_variable_with_function_calls();
-               if (token == TokenNameMINUS_GREATER) {
+
+       /**
+        *
+        * variable:
+        * base_variable_with_function_calls T_OBJECT_OPERATOR
+        * object_property method_or_not variable_properties
+        * | base_variable_with_function_calls
+        *
+        * @param lefthandside
+        * @param ignoreVar
+        * @return
+        */
+       private Expression variable (boolean lefthandside, boolean ignoreVar) {
+               Expression ref = base_variable_with_function_calls (lefthandside, ignoreVar);
+
+               if ((token == TokenName.MINUS_GREATER) ||
+                   (token == TokenName.PAAMAYIM_NEKUDOTAYIM))  {
+/* I don't know why ref was set to null, but if it is null, the variable will neither be added to the set of variable,
+ * nor would it be checked for beeing unitialized. So I don't set it to null!
+ */
+//                     ref = null;
                        getNextToken();
                        object_property();
                        method_or_not();
                        variable_properties();
                }
-               //    if (token == TokenNameDOLLAR_LBRACE) {
-               //      getNextToken();
-               //      expr();
-               //      ;
-               //      if (token != TokenNameRBRACE) {
-               //        throwSyntaxError("'}' expected after indirect variable token '${'.");
-               //      }
-               //      getNextToken();
-               //    } else {
-               //      if (token == TokenNameVariable) {
-               //        getNextToken();
-               //        if (token == TokenNameLBRACKET) {
-               //          getNextToken();
-               //          expr();
-               //          if (token != TokenNameRBRACKET) {
-               //            throwSyntaxError("']' expected in variable-list.");
-               //          }
-               //          getNextToken();
-               //        } else if (token == TokenNameEQUAL) {
-               //          getNextToken();
-               //          static_scalar();
-               //        }
-               //      } else {
-               //        throwSyntaxError("$-variable expected in variable-list.");
-               //      }
-               //    }
+
+               return ref;
        }
+
        private void variable_properties() {
-               //  variable_properties:
-               //              variable_properties variable_property
-               //      | /* empty */
-               while (token == TokenNameMINUS_GREATER) {
+               // variable_properties:
+               // variable_properties variable_property
+               // | /* empty */
+               while (token == TokenName.MINUS_GREATER) {
                        variable_property();
                }
        }
+
        private void variable_property() {
-               //  variable_property:
-               //              T_OBJECT_OPERATOR object_property method_or_not
+               // variable_property:
+               // T_OBJECT_OPERATOR object_property method_or_not
                if (Scanner.TRACE) {
                        System.out.println("TRACE: variable_property()");
                }
-               if (token == TokenNameMINUS_GREATER) {
+
+               if (token == TokenName.MINUS_GREATER) {
                        getNextToken();
                        object_property();
                        method_or_not();
-               } else {
+               }
+               else {
                        throwSyntaxError("'->' expected in variable_property.");
                }
        }
+
+       /**
+        *
+        * variable:
+        * base_variable_with_function_calls T_OBJECT_OPERATOR
+        * object_property method_or_not variable_properties
+        * | base_variable_with_function_calls
+        *
+        * Expression ref = function_call(lefthandside, ignoreVar);
+        *
+        * function_call:
+        * T_STRING '(' function_call_parameter_list ')'
+        * | class_constant '(' function_call_parameter_list ')'
+        * | static_member '(' function_call_parameter_list ')'
+        * | variable_without_objects '(' function_call_parameter_list ')'
+        *
+        * @param lefthandside
+        * @param ignoreVar
+        *
+        * @return
+        */
+       private Expression identifier (boolean lefthandside, boolean ignoreVar, boolean bColonAllowed) {
+               char[] defineName = null;
+               char[] ident      = null;
+               int startPos      = 0;
+               int endPos        = 0;
+               Expression ref    = null;
+
+               if (Scanner.TRACE) {
+                       System.out.println("TRACE: function_call()");
+               }
+
+               if (token == TokenName.IDENTIFIER) {
+                       ident      = scanner.getCurrentIdentifierSource();
+                       defineName = ident;
+                       startPos   = scanner.getCurrentTokenStartPosition();
+                       endPos     = scanner.getCurrentTokenEndPosition();
+
+                       getNextToken();              // Get the token after the identifier
+
+                       switch (token) {
+                               case EQUAL:
+                               case PLUS_EQUAL:
+                               case MINUS_EQUAL:
+                               case MULTIPLY_EQUAL:
+                               case DIVIDE_EQUAL:
+                               case DOT_EQUAL:
+                               case REMAINDER_EQUAL:
+                               case AND_EQUAL:
+                               case OR_EQUAL:
+                               case XOR_EQUAL:
+                               case RIGHT_SHIFT_EQUAL:
+                               case LEFT_SHIFT_EQUAL:
+                                       String error = "Assignment operator '"
+                                                       + scanner.toStringAction(token)
+                                                       + "' not allowed after identifier '"
+                                                       + new String(ident)
+                                                       + "' (use 'define(...)' to define constants).";
+                                       reportSyntaxError(error);
+                                       break;
+                       }
+
+                       if (token == TokenName.COLON) {                    // If it's a ':', the identifier is a label
+                           return ref;
+                       }
+
+                       do {
+                           if (token == TokenName.PAAMAYIM_NEKUDOTAYIM) { // '::'
+                               defineName = null;
+
+                               getNextToken ();                           // Read the identifier
+
+                               if (token == TokenName.IDENTIFIER) {       // class _constant
+                                   getNextToken ();
+                               }
+                               else {                                     // static member:
+                                   variable_without_objects (true, false);
+                               }
+                               break;
+                           }
+                           else if (token == TokenName.BACKSLASH) {       // '\' namespace path separator
+                       getNextToken ();
+
+                       if (token == TokenName.IDENTIFIER) {       // If it's an identifier
+                           getNextToken ();                       // go for the next token
+                       }
+                       else {                                     // It's not an identifiere, something wrong
+                                               throwSyntaxError ("an identifier expected after '\\' ");
+                       }
+                           }
+                           else {
+                       break;
+                           }
+               } while (true);
+               }
+               else {                                                 // Token is not an identifier
+                       ref = variable_without_objects(lefthandside, ignoreVar);
+               }
+
+               if (token == TokenName.LPAREN) {                       // If token is '('
+            getNextToken();
+
+            if (token == TokenName.RPAREN) {                   // If token is ')'
+                getNextToken();
+                ref = null;
+            }
+                       else {
+                String functionName;
+
+                if (ident == null) {
+                    functionName = new String(" ");
+                } else {
+                    functionName = new String(ident);
+                }
+
+                non_empty_function_call_parameter_list(functionName); // Get the parameter list for the given function name
+
+                if (token != TokenName.RPAREN) {                      // If token is not a ')', throw error
+                    throwSyntaxError ("')' expected in function call (" + functionName + ").");
+                }
+
+                getNextToken();                                 // Get the token after ')'
+            }
+               }
+               else {                                                  // It's not an '('
+                       if (defineName != null) {                                       // does this identifier contain only uppercase characters?
+                               if (defineName.length == 3) {                   // If it's a 'die'
+                                       if (defineName[0] == 'd' &&
+                                           defineName[1] == 'i' &&
+                                           defineName[2] == 'e') {
+                                               defineName = null;
+                                       }
+                               }
+                               else if (defineName.length == 4) {              // If it's a 'true'
+                                       if (defineName[0] == 't' &&
+                                           defineName[1] == 'r' &&
+                                           defineName[2] == 'u' &&
+                                           defineName[3] == 'e') {
+                                               defineName = null;
+                                       }
+                                       else if (defineName[0] == 'n' &&            // If it's a 'null'
+                                                defineName[1] == 'u' &&
+                                                defineName[2] == 'l' &&
+                                                defineName[3] == 'l') {
+                                               defineName = null;
+                                       }
+                               }
+                               else if (defineName.length == 5) {              // If it's a 'false'
+                                       if (defineName[0] == 'f' &&
+                                           defineName[1] == 'a' &&
+                                           defineName[2] == 'l' &&
+                                           defineName[3] == 's' &&
+                                           defineName[4] == 'e') {
+                                               defineName = null;
+                                       }
+                               }
+
+                               if (defineName != null) {
+                                   for (int i = 0; i < defineName.length; i++) {
+                                       if (Character.isLowerCase (defineName[i])) {
+                                           problemReporter.phpUppercaseIdentifierWarning (startPos, endPos, referenceContext,
+                                                                                          compilationUnit.compilationResult);
+                                           break;
+                                       }
+                                   }
+                               }
+                       }
+                       // TODO is this ok ?
+                       // return ref;
+                       // throwSyntaxError("'(' expected in function call.");
+               }
+
+               if (token == TokenName.MINUS_GREATER) {
+                       ref = null;
+                       getNextToken();
+                       object_property();
+                       method_or_not();
+                       variable_properties();
+               }
+
+               // A colon is only allowed here if it is an expression read after a '?'
+
+               if ((token == TokenName.COLON) &&
+                   (!bColonAllowed)) {
+                   throwSyntaxError ("No ':' allowed");
+               }
+
+               return ref;
+       }
+
        private void method_or_not() {
-               //  method_or_not:
-               //              '(' function_call_parameter_list ')'
-               //      | /* empty */
+               // method_or_not:
+               // '(' function_call_parameter_list ')'
+               // | /* empty */
                if (Scanner.TRACE) {
                        System.out.println("TRACE: method_or_not()");
                }
-               if (token == TokenNameLPAREN) {
+               if (token == TokenName.LPAREN) {
                        getNextToken();
-                       if (token == TokenNameRPAREN) {
+                       if (token == TokenName.RPAREN) {
                                getNextToken();
                                return;
                        }
                        non_empty_function_call_parameter_list();
-                       if (token != TokenNameRPAREN) {
+                       if (token != TokenName.RPAREN) {
                                throwSyntaxError("')' expected in method_or_not.");
                        }
                        getNextToken();
                }
        }
+
        private void exit_expr() {
-               //      /* empty */
-               //      | '(' ')'
-               //      | '(' expr ')'
-               if (token != TokenNameLPAREN) {
+               // /* empty */
+               // | '(' ')'
+               // | '(' expr ')'
+               if (token != TokenName.LPAREN) {
                        return;
                }
                getNextToken();
-               if (token == TokenNameRPAREN) {
+               if (token == TokenName.RPAREN) {
                        getNextToken();
                        return;
                }
                expr();
-               if (token != TokenNameRPAREN) {
+               if (token != TokenName.RPAREN) {
                        throwSyntaxError("')' expected after keyword 'exit'");
                }
                getNextToken();
        }
-       private void encaps_list() {
-               //              encaps_list encaps_var
-               //      | encaps_list T_STRING
-               //      | encaps_list T_NUM_STRING
-               //      | encaps_list T_ENCAPSED_AND_WHITESPACE
-               //      | encaps_list T_CHARACTER
-               //      | encaps_list T_BAD_CHARACTER
-               //      | encaps_list '['
-               //      | encaps_list ']'
-               //      | encaps_list '{'
-               //      | encaps_list '}'
-               //      | encaps_list T_OBJECT_OPERATOR
-               //      | /* empty */
-               while (true) {
-                       switch (token) {
-                               case TokenNameSTRING :
-                                       getNextToken();
-                                       break;
-                               case TokenNameLBRACE :
-                                       //          scanner.encapsedStringStack.pop();
-                                       getNextToken();
-                                       break;
-                               case TokenNameRBRACE :
-                                       //          scanner.encapsedStringStack.pop();
-                                       getNextToken();
-                                       break;
-                               case TokenNameLBRACKET :
-                                       //          scanner.encapsedStringStack.pop();
-                                       getNextToken();
-                                       break;
-                               case TokenNameRBRACKET :
-                                       //          scanner.encapsedStringStack.pop();
-                                       getNextToken();
-                                       break;
-                               case TokenNameMINUS_GREATER :
-                                       //          scanner.encapsedStringStack.pop();
-                                       getNextToken();
-                                       break;
-                               case TokenNameVariable :
-                               case TokenNameDOLLAR_LBRACE :
-                               case TokenNameCURLY_OPEN :
-                                       encaps_var();
-                                       break;
-                               //        case TokenNameDOLLAR :
-                               //          getNextToken();
-                               //          if (token == TokenNameLBRACE) {
-                               //            token = TokenNameDOLLAR_LBRACE;
-                               //            encaps_var();
-                               //          }
-                               //          break;
-                               default :
-                                       char encapsedChar = ((Character) scanner.encapsedStringStack
-                                                       .peek()).charValue();
-                                       if (encapsedChar == '$') {
-                                               scanner.encapsedStringStack.pop();
-                                               encapsedChar = ((Character) scanner.encapsedStringStack
-                                                               .peek()).charValue();
-                                               switch (encapsedChar) {
-                                                       case '`' :
-                                                               if (token == TokenNameEncapsedString0) {
-                                                                       return;
-                                                               }
-                                                               token = TokenNameSTRING;
-                                                               continue;
-                                                       case '\'' :
-                                                               if (token == TokenNameEncapsedString1) {
-                                                                       return;
-                                                               }
-                                                               token = TokenNameSTRING;
-                                                               continue;
-                                                       case '"' :
-                                                               if (token == TokenNameEncapsedString2) {
-                                                                       return;
-                                                               }
-                                                               token = TokenNameSTRING;
-                                                               continue;
-                                               }
-                                       }
-                                       return;
+
+       // private void encaps_list() {
+       // // encaps_list encaps_var
+       // // | encaps_list T_STRING
+       // // | encaps_list T_NUM_STRING
+       // // | encaps_list T_ENCAPSED_AND_WHITESPACE
+       // // | encaps_list T_CHARACTER
+       // // | encaps_list T_BAD_CHARACTER
+       // // | encaps_list '['
+       // // | encaps_list ']'
+       // // | encaps_list '{'
+       // // | encaps_list '}'
+       // // | encaps_list T_OBJECT_OPERATOR
+       // // | /* empty */
+       // while (true) {
+       // switch (token) {
+       // case TokenName.STRING:
+       // getNextToken();
+       // break;
+       // case TokenName.LBRACE:
+       // // scanner.encapsedStringStack.pop();
+       // getNextToken();
+       // break;
+       // case TokenName.RBRACE:
+       // // scanner.encapsedStringStack.pop();
+       // getNextToken();
+       // break;
+       // case TokenName.LBRACKET:
+       // // scanner.encapsedStringStack.pop();
+       // getNextToken();
+       // break;
+       // case TokenName.RBRACKET:
+       // // scanner.encapsedStringStack.pop();
+       // getNextToken();
+       // break;
+       // case TokenName.MINUS_GREATER:
+       // // scanner.encapsedStringStack.pop();
+       // getNextToken();
+       // break;
+       // case TokenName.Variable:
+       // case TokenName.DOLLAR_LBRACE:
+       // case TokenName.LBRACE_DOLLAR:
+       // encaps_var();
+       // break;
+       // default:
+       // char encapsedChar = ((Character)
+       // scanner.encapsedStringStack.peek()).charValue();
+       // if (encapsedChar == '$') {
+       // scanner.encapsedStringStack.pop();
+       // encapsedChar = ((Character)
+       // scanner.encapsedStringStack.peek()).charValue();
+       // switch (encapsedChar) {
+       // case '`':
+       // if (token == TokenName.EncapsedString0) {
+       // return;
+       // }
+       // token = TokenName.STRING;
+       // continue;
+       // case '\'':
+       // if (token == TokenName.EncapsedString1) {
+       // return;
+       // }
+       // token = TokenName.STRING;
+       // continue;
+       // case '"':
+       // if (token == TokenName.EncapsedString2) {
+       // return;
+       // }
+       // token = TokenName.STRING;
+       // continue;
+       // }
+       // }
+       // return;
+       // }
+       // }
+       // }
+
+       // private void encaps_var() {
+       // // T_VARIABLE
+       // // | T_VARIABLE '[' encaps_var_offset ']'
+       // // | T_VARIABLE T_OBJECT_OPERATOR T_STRING
+       // // | T_DOLLAR_OPEN_CURLY_BRACES expr '}'
+       // // | T_DOLLAR_OPEN_CURLY_BRACES T_STRING_VARNAME '[' expr ']' '}'
+       // // | T_CURLY_OPEN variable '}'
+       // switch (token) {
+       // case TokenName.Variable:
+       // getNextToken();
+       // if (token == TokenName.LBRACKET) {
+       // getNextToken();
+       // expr(); //encaps_var_offset();
+       // if (token != TokenName.RBRACKET) {
+       // throwSyntaxError("']' expected after variable.");
+       // }
+       // // scanner.encapsedStringStack.pop();
+       // getNextToken();
+       // // }
+       // } else if (token == TokenName.MINUS_GREATER) {
+       // getNextToken();
+       // if (token != TokenName.Identifier) {
+       // throwSyntaxError("Identifier expected after '->'.");
+       // }
+       // // scanner.encapsedStringStack.pop();
+       // getNextToken();
+       // }
+       // // else {
+       // // // scanner.encapsedStringStack.pop();
+       // // int tempToken = TokenName.STRING;
+       // // if (!scanner.encapsedStringStack.isEmpty()
+       // // && (token == TokenName.EncapsedString0
+       // // || token == TokenName.EncapsedString1
+       // // || token == TokenName.EncapsedString2 || token ==
+       // // TokenName.ERROR)) {
+       // // char encapsedChar = ((Character)
+       // // scanner.encapsedStringStack.peek())
+       // // .charValue();
+       // // switch (token) {
+       // // case TokenName.EncapsedString0 :
+       // // if (encapsedChar == '`') {
+       // // tempToken = TokenName.EncapsedString0;
+       // // }
+       // // break;
+       // // case TokenName.EncapsedString1 :
+       // // if (encapsedChar == '\'') {
+       // // tempToken = TokenName.EncapsedString1;
+       // // }
+       // // break;
+       // // case TokenName.EncapsedString2 :
+       // // if (encapsedChar == '"') {
+       // // tempToken = TokenName.EncapsedString2;
+       // // }
+       // // break;
+       // // case TokenName.ERROR :
+       // // if (scanner.source[scanner.currentPosition - 1] == '\\') {
+       // // scanner.currentPosition--;
+       // // getNextToken();
+       // // }
+       // // break;
+       // // }
+       // // }
+       // // token = tempToken;
+       // // }
+       // break;
+       // case TokenName.DOLLAR_LBRACE:
+       // getNextToken();
+       // if (token == TokenName.DOLLAR_LBRACE) {
+       // encaps_var();
+       // } else if (token == TokenName.Identifier) {
+       // getNextToken();
+       // if (token == TokenName.LBRACKET) {
+       // getNextToken();
+       // // if (token == TokenName.RBRACKET) {
+       // // getNextToken();
+       // // } else {
+       // expr();
+       // if (token != TokenName.RBRACKET) {
+       // throwSyntaxError("']' expected after '${'.");
+       // }
+       // getNextToken();
+       // // }
+       // }
+       // } else {
+       // expr();
+       // }
+       // if (token != TokenName.RBRACE) {
+       // throwSyntaxError("'}' expected.");
+       // }
+       // getNextToken();
+       // break;
+       // case TokenName.LBRACE_DOLLAR:
+       // getNextToken();
+       // if (token == TokenName.LBRACE_DOLLAR) {
+       // encaps_var();
+       // } else if (token == TokenName.Identifier || token > TokenName.KEYWORD) {
+       // getNextToken();
+       // if (token == TokenName.LBRACKET) {
+       // getNextToken();
+       // // if (token == TokenName.RBRACKET) {
+       // // getNextToken();
+       // // } else {
+       // expr();
+       // if (token != TokenName.RBRACKET) {
+       // throwSyntaxError("']' expected.");
+       // }
+       // getNextToken();
+       // // }
+       // } else if (token == TokenName.MINUS_GREATER) {
+       // getNextToken();
+       // if (token != TokenName.Identifier && token != TokenName.Variable) {
+       // throwSyntaxError("String or Variable token expected.");
+       // }
+       // getNextToken();
+       // if (token == TokenName.LBRACKET) {
+       // getNextToken();
+       // // if (token == TokenName.RBRACKET) {
+       // // getNextToken();
+       // // } else {
+       // expr();
+       // if (token != TokenName.RBRACKET) {
+       // throwSyntaxError("']' expected after '${'.");
+       // }
+       // getNextToken();
+       // // }
+       // }
+       // }
+       // // if (token != TokenName.RBRACE) {
+       // // throwSyntaxError("'}' expected after '{$'.");
+       // // }
+       // // // scanner.encapsedStringStack.pop();
+       // // getNextToken();
+       // } else {
+       // expr();
+       // if (token != TokenName.RBRACE) {
+       // throwSyntaxError("'}' expected.");
+       // }
+       // // scanner.encapsedStringStack.pop();
+       // getNextToken();
+       // }
+       // break;
+       // }
+       // }
+
+       // private void encaps_var_offset() {
+       // // T_STRING
+       // // | T_NUM_STRING
+       // // | T_VARIABLE
+       // switch (token) {
+       // case TokenName.STRING:
+       // getNextToken();
+       // break;
+       // case TokenName.IntegerLiteral:
+       // getNextToken();
+       // break;
+       // case TokenName.Variable:
+       // getNextToken();
+       // break;
+       // case TokenName.Identifier:
+       // getNextToken();
+       // break;
+       // default:
+       // throwSyntaxError("Variable or String token expected.");
+       // break;
+       // }
+       // }
+
+       /**
+        *
+        */
+       private void internal_functions_in_yacc() {
+               // int start = 0;
+               switch (token) {
+               // case TokenName.isset:
+               // // T_ISSET '(' isset_variables ')'
+               // getNextToken();
+               // if (token != TokenName.LPAREN) {
+               // throwSyntaxError("'(' expected after keyword 'isset'");
+               // }
+               // getNextToken();
+               // isset_variables();
+               // if (token != TokenName.RPAREN) {
+               // throwSyntaxError("')' expected after keyword 'isset'");
+               // }
+               // getNextToken();
+               // break;
+               // case TokenName.empty:
+               // // T_EMPTY '(' variable ')'
+               // getNextToken();
+               // if (token != TokenName.LPAREN) {
+               // throwSyntaxError("'(' expected after keyword 'empty'");
+               // }
+               // getNextToken();
+               // variable(false);
+               // if (token != TokenName.RPAREN) {
+               // throwSyntaxError("')' expected after keyword 'empty'");
+               // }
+               // getNextToken();
+               // break;
+               case INCLUDE:
+                       // T_INCLUDE expr
+                       checkFileName(token);
+                       break;
+               case INCLUDE_ONCE:
+                       // T_INCLUDE_ONCE expr
+                       checkFileName(token);
+                       break;
+               case EVAL:
+                       // T_EVAL '(' expr ')'
+                       getNextToken();
+                       if (token != TokenName.LPAREN) {
+                               throwSyntaxError("'(' expected after keyword 'eval'");
+                       }
+                       getNextToken();
+                       expr();
+                       if (token != TokenName.RPAREN) {
+                               throwSyntaxError("')' expected after keyword 'eval'");
                        }
+                       getNextToken();
+                       break;
+               case REQUIRE:
+                       // T_REQUIRE expr
+                       checkFileName(token);
+                       break;
+               case REQUIRE_ONCE:
+                       // T_REQUIRE_ONCE expr
+                       checkFileName(token);
+                       break;
                }
        }
-       private void encaps_var() {
-               //              T_VARIABLE
-               //      | T_VARIABLE '[' encaps_var_offset ']'
-               //      | T_VARIABLE T_OBJECT_OPERATOR T_STRING
-               //      | T_DOLLAR_OPEN_CURLY_BRACES expr '}'
-               //      | T_DOLLAR_OPEN_CURLY_BRACES T_STRING_VARNAME '[' expr ']' '}'
-               //      | T_CURLY_OPEN variable '}'
-               switch (token) {
-                       case TokenNameVariable :
-                               getNextToken();
-                               if (token == TokenNameLBRACKET) {
-                                       getNextToken();
-                                       //          if (token == TokenNameRBRACKET) {
-                                       //            getNextToken();
-                                       //          } else {
-                                       expr(); //encaps_var_offset();
-                                       if (token != TokenNameRBRACKET) {
-                                               throwSyntaxError("']' expected after variable.");
-                                       }
-                                       //          scanner.encapsedStringStack.pop();
-                                       getNextToken();
-                                       //          }
-                               } else if (token == TokenNameMINUS_GREATER) {
-                                       getNextToken();
-                                       if (token != TokenNameIdentifier) {
-                                               throwSyntaxError("Identifier expected after '->'.");
-                                       }
-                                       //          scanner.encapsedStringStack.pop();
-                                       getNextToken();
-                               }
-                               //        else {
-                               //          // scanner.encapsedStringStack.pop();
-                               //          int tempToken = TokenNameSTRING;
-                               //          if (!scanner.encapsedStringStack.isEmpty()
-                               //              && (token == TokenNameEncapsedString0
-                               //                  || token == TokenNameEncapsedString1
-                               //                  || token == TokenNameEncapsedString2 || token ==
-                               // TokenNameERROR)) {
-                               //            char encapsedChar = ((Character)
-                               // scanner.encapsedStringStack.peek())
-                               //                .charValue();
-                               //            switch (token) {
-                               //              case TokenNameEncapsedString0 :
-                               //                if (encapsedChar == '`') {
-                               //                  tempToken = TokenNameEncapsedString0;
-                               //                }
-                               //                break;
-                               //              case TokenNameEncapsedString1 :
-                               //                if (encapsedChar == '\'') {
-                               //                  tempToken = TokenNameEncapsedString1;
-                               //                }
-                               //                break;
-                               //              case TokenNameEncapsedString2 :
-                               //                if (encapsedChar == '"') {
-                               //                  tempToken = TokenNameEncapsedString2;
-                               //                }
-                               //                break;
-                               //              case TokenNameERROR :
-                               //                if (scanner.source[scanner.currentPosition - 1] == '\\') {
-                               //                  scanner.currentPosition--;
-                               //                  getNextToken();
-                               //                }
-                               //                break;
-                               //            }
-                               //          }
-                               //          token = tempToken;
-                               //        }
-                               break;
-                       case TokenNameDOLLAR_LBRACE :
-                               getNextToken();
-                               if (token == TokenNameIdentifier) {
-                                       getNextToken();
-                                       if (token == TokenNameLBRACKET) {
-                                               getNextToken();
-                                               //            if (token == TokenNameRBRACKET) {
-                                               //              getNextToken();
-                                               //            } else {
-                                               expr();
-                                               if (token != TokenNameRBRACKET) {
-                                                       throwSyntaxError("']' expected after '${'.");
-                                               }
-                                               getNextToken();
-                                               //            }
-                                       }
-                                       if (token != TokenNameRBRACE) {
-                                               throwSyntaxError("'}' expected after '${'.");
-                                       }
-                                       //          scanner.encapsedStringStack.pop();
-                                       getNextToken();
-                               } else {
-                                       expr();
-                                       if (token != TokenNameRBRACE) {
-                                               throwSyntaxError("'}' expected.");
-                                       }
-                                       //          scanner.encapsedStringStack.pop();
-                                       getNextToken();
-                               }
-                               break;
-                       case TokenNameCURLY_OPEN :
-                               getNextToken();
-                               if (token == TokenNameIdentifier || token > TokenNameKEYWORD) {
-                                       getNextToken();
-                                       if (token == TokenNameLBRACKET) {
-                                               getNextToken();
-                                               //            if (token == TokenNameRBRACKET) {
-                                               //              getNextToken();
-                                               //            } else {
-                                               expr();
-                                               if (token != TokenNameRBRACKET) {
-                                                       throwSyntaxError("']' expected after '{$'.");
-                                               }
-                                               getNextToken();
-                                               //            }
-                                       } else if (token == TokenNameMINUS_GREATER) {
-                                               getNextToken();
-                                               if (token != TokenNameIdentifier) {
-                                                       throwSyntaxError("String token expected.");
-                                               }
-                                               getNextToken();
-                                       }
-                                       //          if (token != TokenNameRBRACE) {
-                                       //            throwSyntaxError("'}' expected after '{$'.");
-                                       //          }
-                                       //          // scanner.encapsedStringStack.pop();
-                                       //          getNextToken();
-                               } else {
-                                       expr();
-                                       if (token != TokenNameRBRACE) {
-                                               throwSyntaxError("'}' expected.");
-                                       }
-                                       //          scanner.encapsedStringStack.pop();
-                                       getNextToken();
-                               }
-                               break;
+
+       /**
+        * Parse and check the include file name
+        *
+        * @param includeToken
+        */
+       private void checkFileName(TokenName includeToken) {
+               // <include-token> expr
+               int start = scanner.getCurrentTokenStartPosition();
+               boolean hasLPAREN = false;
+               getNextToken();
+               if (token == TokenName.LPAREN) {
+                       hasLPAREN = true;
+                       getNextToken();
                }
-       }
-       private void encaps_var_offset() {
-               //              T_STRING
-               //      | T_NUM_STRING
-               //      | T_VARIABLE
-               switch (token) {
-                       case TokenNameSTRING :
-                               getNextToken();
-                               break;
-                       case TokenNameIntegerLiteral :
-                               getNextToken();
-                               break;
-                       case TokenNameVariable :
-                               getNextToken();
-                               break;
-                       case TokenNameIdentifier :
+               Expression expression = expr();
+               if (hasLPAREN) {
+                       if (token == TokenName.RPAREN) {
                                getNextToken();
-                               break;
-                       default :
-                               throwSyntaxError("Variable or String token expected.");
-                               break;
+                       } else {
+                               throwSyntaxError("')' expected for keyword '"
+                                               + scanner.toStringAction(includeToken) + "'");
+                       }
                }
-       }
-       private void internal_functions_in_yacc() {
-               switch (token) {
-                       case TokenNameisset :
-                               //      T_ISSET '(' isset_variables ')'
-                               getNextToken();
-                               if (token != TokenNameLPAREN) {
-                                       throwSyntaxError("'(' expected after keyword 'isset'");
-                               }
-                               getNextToken();
-                               isset_variables();
-                               if (token != TokenNameRPAREN) {
-                                       throwSyntaxError("')' expected after keyword 'isset'");
-                               }
-                               getNextToken();
-                               break;
-                       case TokenNameempty :
-                               //      T_EMPTY '(' variable ')'
-                               getNextToken();
-                               if (token != TokenNameLPAREN) {
-                                       throwSyntaxError("'(' expected after keyword 'empty'");
-                               }
-                               getNextToken();
-                               variable();
-                               if (token != TokenNameRPAREN) {
-                                       throwSyntaxError("')' expected after keyword 'empty'");
-                               }
-                               getNextToken();
-                               break;
-                       case TokenNameinclude :
-                               //T_INCLUDE expr
-                               getNextToken();
-                               expr();
-                               //        ImportReference impt = new ImportReference(tokens, positions,
-                               // false, AccDefault);
-                               //        impt.declarationSourceEnd = impt.sourceEnd;
-                               //        impt.declarationEnd = impt.declarationSourceEnd;
-                               //      //endPosition is just before the ;
-                               //      impt.declarationSourceStart = this.intStack[this.intPtr--];
-                               break;
-                       case TokenNameinclude_once :
-                               //      T_INCLUDE_ONCE expr
-                               getNextToken();
-                               expr();
-                               break;
-                       case TokenNameeval :
-                               //      T_EVAL '(' expr ')'
-                               getNextToken();
-                               if (token != TokenNameLPAREN) {
-                                       throwSyntaxError("'(' expected after keyword 'eval'");
+               char[] currTokenSource = scanner.getCurrentTokenSource(start);
+               IFile file = null;
+               if (scanner.compilationUnit != null) {
+                       IResource resource = scanner.compilationUnit.getResource();
+                       if (resource != null && resource instanceof IFile) {
+                               file = (IFile) resource;
+                       }
+               }
+               char[][] tokens;
+               tokens = new char[1][];
+               tokens[0] = currTokenSource;
+
+               ImportReference impt = new ImportReference(tokens, currTokenSource,
+                               start, scanner.getCurrentTokenEndPosition(), false);
+               impt.declarationSourceEnd = impt.sourceEnd;
+               impt.declarationEnd = impt.declarationSourceEnd;
+               // endPosition is just before the ;
+               impt.declarationSourceStart = start;
+               includesList.add(impt);
+
+               if (expression instanceof StringLiteral) {
+                       StringLiteral literal = (StringLiteral) expression;
+                       char[] includeName = literal.source();
+                       if (includeName.length == 0) {
+                               reportSyntaxError("Empty filename after keyword '"
+                                               + scanner.toStringAction(includeToken) + "'",
+                                               literal.sourceStart, literal.sourceStart + 1);
+                       }
+                       String includeNameString = new String(includeName);
+                       if (literal instanceof StringLiteralDQ) {
+                               if (includeNameString.indexOf('$') >= 0) {
+                                       // assuming that the filename contains a variable => no
+                                       // filename check
+                                       return;
                                }
-                               getNextToken();
-                               expr();
-                               if (token != TokenNameRPAREN) {
-                                       throwSyntaxError("')' expected after keyword 'eval'");
+                       }
+                       if (includeNameString.startsWith("http://")) {
+                               // assuming external include location
+                               return;
+                       }
+                       if (file != null) {
+                               // check the filename:
+                               // System.out.println(new
+                               // String(compilationUnit.getFileName())+" - "+
+                               // expression.toStringExpression());
+                               IProject project = file.getProject();
+                               if (project != null) {
+                                       IPath path = PHPFileUtil.determineFilePath(
+                                                       includeNameString, file, project);
+
+                                       if (path == null) {
+                                               // SyntaxError: "File: << >> doesn't exist in project."
+                                               String[] args = { expression.toStringExpression(),
+                                                               project.getFullPath().toString() };
+                                               problemReporter.phpIncludeNotExistWarning(args,
+                                                               literal.sourceStart, literal.sourceEnd,
+                                                               referenceContext,
+                                                               compilationUnit.compilationResult);
+                                       } else {
+                                               try {
+                                                       String filePath = path.toString();
+                                                       String ext = file.getRawLocation()
+                                                                       .getFileExtension();
+                                                       int fileExtensionLength = ext == null ? 0 : ext
+                                                                       .length() + 1;
+
+                                                       IFile f = PHPFileUtil.createFile(path, project);
+
+                                                       impt.tokens = CharOperation.splitOn('/', filePath
+                                                                       .toCharArray(), 0, filePath.length()
+                                                                       - fileExtensionLength);
+                                                       impt.setFile(f);
+                                               } catch (Exception e) {
+                                                       // the file is outside of the workspace
+                                               }
+                                       }
                                }
-                               getNextToken();
-                               break;
-                       case TokenNamerequire :
-                               //T_REQUIRE expr
-                               getNextToken();
-                               expr();
-                               break;
-                       case TokenNamerequire_once :
-                               //      T_REQUIRE_ONCE expr
-                               getNextToken();
-                               expr();
-                               break;
+                       }
                }
        }
+
        private void isset_variables() {
-               //      variable
-               //      | isset_variables ','
-               if (token == TokenNameRPAREN) {
+               // variable
+               // | isset_variables ','
+               if (token == TokenName.RPAREN) {
                        throwSyntaxError("Variable expected after keyword 'isset'");
                }
                while (true) {
-                       variable();
-                       if (token == TokenNameCOMMA) {
+                       variable(true, false);
+                       if (token == TokenName.COMMA) {
                                getNextToken();
                        } else {
                                break;
                        }
                }
        }
+
        private boolean common_scalar() {
-               //  common_scalar:
-               //      T_LNUMBER
-               //      | T_DNUMBER
-               //      | T_CONSTANT_ENCAPSED_STRING
-               //      | T_LINE
-               //      | T_FILE
-               //      | T_CLASS_C
-               //      | T_METHOD_C
-               //      | T_FUNC_C
+               // common_scalar:
+               // T_LNUMBER
+               // | T_DNUMBER
+               // | T_CONSTANT_ENCAPSED_STRING
+               // | T_LINE
+               // | T_FILE
+               // | T_CLASS_C
+               // | T_METHOD_C
+               // | T_FUNC_C
                switch (token) {
-                       case TokenNameIntegerLiteral :
-                               getNextToken();
-                               return true;
-                       case TokenNameDoubleLiteral :
-                               getNextToken();
-                               return true;
-                       case TokenNameStringLiteral :
-                               getNextToken();
-                               return true;
-                       case TokenNameStringConstant :
-                               getNextToken();
-                               return true;
-                       case TokenNameStringInterpolated :
-                               getNextToken();
-                               return true;
-                       case TokenNameFILE :
-                               getNextToken();
-                               return true;
-                       case TokenNameLINE :
-                               getNextToken();
-                               return true;
-                       case TokenNameCLASS_C :
-                               getNextToken();
-                               return true;
-                       case TokenNameMETHOD_C :
-                               getNextToken();
-                               return true;
-                       case TokenNameFUNC_C :
-                               getNextToken();
-                               return true;
+               case INTEGERLITERAL:
+                       getNextToken();
+                       return true;
+               case DOUBLELITERAL:
+                       getNextToken();
+                       return true;
+               case STRINGDOUBLEQUOTE:
+                       getNextToken();
+                       return true;
+               case STRINGSINGLEQUOTE:
+                       getNextToken();
+                       return true;
+               case STRINGINTERPOLATED:
+                       getNextToken();
+                       return true;
+               case FILE:
+                       getNextToken();
+                       return true;
+               case LINE:
+                       getNextToken();
+                       return true;
+               case CLASS_C:
+                       getNextToken();
+                       return true;
+               case METHOD_C:
+                       getNextToken();
+                       return true;
+               case FUNC_C:
+                       getNextToken();
+                       return true;
                }
                return false;
        }
-       private void scalar() {
-               //  scalar:
-               //      T_STRING
-               //| T_STRING_VARNAME
-               //| class_constant
-               //| common_scalar
-               //| '"' encaps_list '"'
-               //| '\'' encaps_list '\''
-               //| T_START_HEREDOC encaps_list T_END_HEREDOC
-               throwSyntaxError("Not yet implemented (scalar).");
-       }
+
+//     private void scalar() {
+//             // scalar:
+//             // T_STRING
+//             // | T_STRING_VARNAME
+//             // | class_constant
+//             // | common_scalar
+//             // | '"' encaps_list '"'
+//             // | '\'' encaps_list '\''
+//             // | T_START_HEREDOC encaps_list T_END_HEREDOC
+//             throwSyntaxError("Not yet implemented (scalar).");
+//     }
+
        private void static_scalar() {
-               //    static_scalar: /* compile-time evaluated scalars */
-               //              common_scalar
-               //      | T_STRING
-               //      | '+' static_scalar
-               //      | '-' static_scalar
-               //      | T_ARRAY '(' static_array_pair_list ')'
-               //      | static_class_constant
+               // static_scalar: /* compile-time evaluated scalars */
+               // common_scalar
+               // | T_STRING
+               // | '+' static_scalar
+               // | '-' static_scalar
+               // | T_ARRAY '(' static_array_pair_list ')'
+               // | static_class_constant
                if (common_scalar()) {
                        return;
                }
                switch (token) {
-                       case TokenNameIdentifier :
+               case IDENTIFIER:
+                       getNextToken();
+                       // static_class_constant:
+                       // T_STRING T_PAAMAYIM_NEKUDOTAYIM T_STRING
+                       if (token == TokenName.PAAMAYIM_NEKUDOTAYIM) {
                                getNextToken();
-                               //        static_class_constant:
-                               //              T_STRING T_PAAMAYIM_NEKUDOTAYIM T_STRING
-                               if (token == TokenNamePAAMAYIM_NEKUDOTAYIM) {
-                                       getNextToken();
-                                       if (token == TokenNameIdentifier) {
-                                               getNextToken();
-                                       } else {
-                                               throwSyntaxError("Identifier expected after '::' operator.");
-                                       }
-                               }
-                               break;
-                       case TokenNameEncapsedString0 :
-                               try {
-                                       scanner.currentCharacter = scanner.source[scanner.currentPosition++];
-                                       while (scanner.currentCharacter != '`') {
-                                               if (scanner.currentCharacter == '\\') {
-                                                       scanner.currentPosition++;
-                                               }
-                                               scanner.currentCharacter = scanner.source[scanner.currentPosition++];
-                                       }
+                               if (token == TokenName.IDENTIFIER) {
                                        getNextToken();
-                               } catch (IndexOutOfBoundsException e) {
-                                       throwSyntaxError("'`' expected at end of static string.");
+                               } else {
+                                       throwSyntaxError("Identifier expected after '::' operator.");
                                }
-                               break;
-                       case TokenNameEncapsedString1 :
-                               try {
-                                       scanner.currentCharacter = scanner.source[scanner.currentPosition++];
-                                       while (scanner.currentCharacter != '\'') {
-                                               if (scanner.currentCharacter == '\\') {
-                                                       scanner.currentPosition++;
-                                               }
-                                               scanner.currentCharacter = scanner.source[scanner.currentPosition++];
+                       }
+                       break;
+               case ENCAPSEDSTRING0:
+                       try {
+                               scanner.currentCharacter = scanner.source[scanner.currentPosition++];
+                               while (scanner.currentCharacter != '`') {
+                                       if (scanner.currentCharacter == '\\') {
+                                               scanner.currentPosition++;
                                        }
-                                       getNextToken();
-                               } catch (IndexOutOfBoundsException e) {
-                                       throwSyntaxError("'\'' expected at end of static string.");
-                               }
-                               break;
-                       case TokenNameEncapsedString2 :
-                               try {
                                        scanner.currentCharacter = scanner.source[scanner.currentPosition++];
-                                       while (scanner.currentCharacter != '"') {
-                                               if (scanner.currentCharacter == '\\') {
-                                                       scanner.currentPosition++;
-                                               }
-                                               scanner.currentCharacter = scanner.source[scanner.currentPosition++];
-                                       }
-                                       getNextToken();
-                               } catch (IndexOutOfBoundsException e) {
-                                       throwSyntaxError("'\"' expected at end of static string.");
                                }
-                               break;
-                       case TokenNamePLUS :
                                getNextToken();
-                               static_scalar();
-                               break;
-                       case TokenNameMINUS :
-                               getNextToken();
-                               static_scalar();
-                               break;
-                       case TokenNamearray :
-                               getNextToken();
-                               if (token != TokenNameLPAREN) {
-                                       throwSyntaxError("'(' expected after keyword 'array'");
-                               }
-                               getNextToken();
-                               if (token == TokenNameRPAREN) {
-                                       getNextToken();
-                                       break;
-                               }
-                               non_empty_static_array_pair_list();
-                               if (token != TokenNameRPAREN) {
-                                       throwSyntaxError("')' expected after keyword 'array'");
-                               }
+                       } catch (IndexOutOfBoundsException e) {
+                               throwSyntaxError("'`' expected at end of static string.");
+                       }
+                       break;
+               // case TokenName.EncapsedString1:
+               // try {
+               // scanner.currentCharacter = scanner.source[scanner.currentPosition++];
+               // while (scanner.currentCharacter != '\'') {
+               // if (scanner.currentCharacter == '\\') {
+               // scanner.currentPosition++;
+               // }
+               // scanner.currentCharacter = scanner.source[scanner.currentPosition++];
+               // }
+               // getNextToken();
+               // } catch (IndexOutOfBoundsException e) {
+               // throwSyntaxError("'\'' expected at end of static string.");
+               // }
+               // break;
+               // case TokenName.EncapsedString2:
+               // try {
+               // scanner.currentCharacter = scanner.source[scanner.currentPosition++];
+               // while (scanner.currentCharacter != '"') {
+               // if (scanner.currentCharacter == '\\') {
+               // scanner.currentPosition++;
+               // }
+               // scanner.currentCharacter = scanner.source[scanner.currentPosition++];
+               // }
+               // getNextToken();
+               // } catch (IndexOutOfBoundsException e) {
+               // throwSyntaxError("'\"' expected at end of static string.");
+               // }
+               // break;
+               case STRINGSINGLEQUOTE:
+                       getNextToken();
+                       break;
+               case STRINGDOUBLEQUOTE:
+                       getNextToken();
+                       break;
+               case PLUS:
+                       getNextToken();
+                       static_scalar();
+                       break;
+               case MINUS:
+                       getNextToken();
+                       static_scalar();
+                       break;
+               case ARRAY:
+                       getNextToken();
+                       if (token != TokenName.LPAREN) {
+                               throwSyntaxError("'(' expected after keyword 'array'");
+                       }
+                       getNextToken();
+                       if (token == TokenName.RPAREN) {
                                getNextToken();
                                break;
-                       //      case TokenNamenull :
-                       //        getNextToken();
-                       //        break;
-                       //      case TokenNamefalse :
-                       //        getNextToken();
-                       //        break;
-                       //      case TokenNametrue :
-                       //        getNextToken();
-                       //        break;
-                       default :
-                               throwSyntaxError("Static scalar/constant expected.");
+                       }
+                       non_empty_static_array_pair_list();
+                       if (token != TokenName.RPAREN) {
+                               throwSyntaxError("')' or ',' expected after keyword 'array'");
+                       }
+                       getNextToken();
+                       break;
+               // case TokenName.null :
+               // getNextToken();
+               // break;
+               // case TokenName.false :
+               // getNextToken();
+               // break;
+               // case TokenName.true :
+               // getNextToken();
+               // break;
+               default:
+                       throwSyntaxError("Static scalar/constant expected.");
                }
        }
+
        private void non_empty_static_array_pair_list() {
-               //  non_empty_static_array_pair_list:
-               //      non_empty_static_array_pair_list ',' static_scalar T_DOUBLE_ARROW
+               // non_empty_static_array_pair_list:
+               // non_empty_static_array_pair_list ',' static_scalar T_DOUBLE_ARROW
                // static_scalar
-               //| non_empty_static_array_pair_list ',' static_scalar
-               //| static_scalar T_DOUBLE_ARROW static_scalar
-               //| static_scalar
+               // | non_empty_static_array_pair_list ',' static_scalar
+               // | static_scalar T_DOUBLE_ARROW static_scalar
+               // | static_scalar
                while (true) {
                        static_scalar();
-                       if (token == TokenNameEQUAL_GREATER) {
+                       if (token == TokenName.EQUAL_GREATER) {
                                getNextToken();
                                static_scalar();
                        }
-                       if (token != TokenNameCOMMA) {
+                       if (token != TokenName.COMMA) {
                                break;
                        }
                        getNextToken();
-                       if (token == TokenNameRPAREN) {
+                       if (token == TokenName.RPAREN) {
                                break;
                        }
                }
        }
-       public void reportSyntaxError() { //int act, int currentKind, int
-               // stateStackTop) {
-               /* remember current scanner position */
-               int startPos = scanner.startPosition;
-               int currentPos = scanner.currentPosition;
-               //              String[] expectings;
-               //              String tokenName = name[symbol_index[currentKind]];
-               //fetch all "accurate" possible terminals that could recover the error
-               //              int start, end = start = asi(stack[stateStackTop]);
-               //              while (asr[end] != 0)
-               //                      end++;
-               //              int length = end - start;
-               //              expectings = new String[length];
-               //              if (length != 0) {
-               //                      char[] indexes = new char[length];
-               //                      System.arraycopy(asr, start, indexes, 0, length);
-               //                      for (int i = 0; i < length; i++) {
-               //                              expectings[i] = name[symbol_index[indexes[i]]];
-               //                      }
-               //              }
-               //if the pb is an EOF, try to tell the user that they are some
-               //              if (tokenName.equals(UNEXPECTED_EOF)) {
-               //                      if (!this.checkAndReportBracketAnomalies(problemReporter())) {
-               //                              char[] tokenSource;
-               //                              try {
-               //                                      tokenSource = this.scanner.getCurrentTokenSource();
-               //                              } catch (Exception e) {
-               //                                      tokenSource = new char[] {};
-               //                              }
-               //                              problemReporter().parseError(
-               //                                      this.scanner.startPosition,
-               //                                      this.scanner.currentPosition - 1,
-               //                                      tokenSource,
-               //                                      tokenName,
-               //                                      expectings);
-               //                      }
-               //              } else { //the next test is HEAVILY grammar DEPENDENT.
-               //                      if ((length == 14)
-               //                              && (expectings[0] == "=") //$NON-NLS-1$
-               //                              && (expectings[1] == "*=") //$NON-NLS-1$
-               //                              && (expressionPtr > -1)) {
-               //                                      switch(currentKind) {
-               //                                              case TokenNameSEMICOLON:
-               //                                              case TokenNamePLUS:
-               //                                              case TokenNameMINUS:
-               //                                              case TokenNameDIVIDE:
-               //                                              case TokenNameREMAINDER:
-               //                                              case TokenNameMULTIPLY:
-               //                                              case TokenNameLEFT_SHIFT:
-               //                                              case TokenNameRIGHT_SHIFT:
-               //// case TokenNameUNSIGNED_RIGHT_SHIFT:
-               //                                              case TokenNameLESS:
-               //                                              case TokenNameGREATER:
-               //                                              case TokenNameLESS_EQUAL:
-               //                                              case TokenNameGREATER_EQUAL:
-               //                                              case TokenNameEQUAL_EQUAL:
-               //                                              case TokenNameNOT_EQUAL:
-               //                                              case TokenNameXOR:
-               //                                              case TokenNameAND:
-               //                                              case TokenNameOR:
-               //                                              case TokenNameOR_OR:
-               //                                              case TokenNameAND_AND:
-               //                                                      // the ; is not the expected token ==> it ends a statement when an
-               // expression is not ended
-               //                                                      problemReporter().invalidExpressionAsStatement(expressionStack[expressionPtr]);
-               //                                                      break;
-               //                                              case TokenNameRBRACE :
-               //                                                      problemReporter().missingSemiColon(expressionStack[expressionPtr]);
-               //                                                      break;
-               //                                              default:
-               //                                                      char[] tokenSource;
-               //                                                      try {
-               //                                                              tokenSource = this.scanner.getCurrentTokenSource();
-               //                                                      } catch (Exception e) {
-               //                                                              tokenSource = new char[] {};
-               //                                                      }
-               //                                                      problemReporter().parseError(
-               //                                                              this.scanner.startPosition,
-               //                                                              this.scanner.currentPosition - 1,
-               //                                                              tokenSource,
-               //                                                              tokenName,
-               //                                                              expectings);
-               //                                                      this.checkAndReportBracketAnomalies(problemReporter());
-               //                                      }
-               //                      } else {
-               char[] tokenSource;
-               try {
-                       tokenSource = this.scanner.getCurrentTokenSource();
-               } catch (Exception e) {
-                       tokenSource = new char[]{};
-               }
-               //                              problemReporter().parseError(
-               //                                      this.scanner.startPosition,
-               //                                      this.scanner.currentPosition - 1,
-               //                                      tokenSource,
-               //                                      tokenName,
-               //                                      expectings);
-               this.checkAndReportBracketAnomalies(problemReporter());
-               //                      }
-               //              }
-               /* reset scanner where it was */
-               scanner.startPosition = startPos;
-               scanner.currentPosition = currentPos;
-       }
+
+       // public void reportSyntaxError() { //int act, int currentKind, int
+       // // stateStackTop) {
+       // /* remember current scanner position */
+       // int startPos = scanner.startPosition;
+       // int currentPos = scanner.currentPosition;
+       //
+       // this.checkAndReportBracketAnomalies(problemReporter());
+       // /* reset scanner where it was */
+       // scanner.startPosition = startPos;
+       // scanner.currentPosition = currentPos;
+       // }
+
        public static final int RoundBracket = 0;
+
        public static final int SquareBracket = 1;
+
        public static final int CurlyBracket = 2;
+
        public static final int BracketKinds = 3;
-       protected int[] nestedMethod; //the ptr is nestedType
+
+       protected int[] nestedMethod; // the ptr is nestedType
+
        protected int nestedType, dimensions;
-       //ast stack
+
+       // variable set stack
+       final static int VariableStackIncrement = 10;
+
+       HashMap fTypeVariables = null;
+
+       HashMap fMethodVariables = null;
+
+       ArrayList fStackUnassigned = new ArrayList();
+
+       // ast stack
        final static int AstStackIncrement = 100;
+
        protected int astPtr;
-       protected AstNode[] astStack = new AstNode[AstStackIncrement];
+
+       protected ASTNode[] astStack = new ASTNode[AstStackIncrement];
+
        protected int astLengthPtr;
+
        protected int[] astLengthStack;
-       AstNode[] noAstNodes = new AstNode[AstStackIncrement];
+
+       ASTNode[] noAstNodes = new ASTNode[AstStackIncrement];
+
        public CompilationUnitDeclaration compilationUnit; /*
-                                                                                                           * the result from
-                                                                                                           * parse()
-                                                                                                           */
+                                                                                                                * the result from
+                                                                                                                * parse()
+                                                                                                                */
+
        protected ReferenceContext referenceContext;
+
        protected ProblemReporter problemReporter;
+
        protected CompilerOptions options;
-       //  protected CompilationResult compilationResult;
+
+       private ArrayList includesList;
+
+       // protected CompilationResult compilationResult;
        /**
         * Returns this parser's problem reporter initialized with its reference
         * context. Also it is assumed that a problem is going to be reported, so
@@ -3535,533 +4941,486 @@ public class Parser //extends PHPParserSuperclass
                problemReporter.referenceContext = referenceContext;
                return problemReporter;
        }
+
        /*
         * Reconsider the entire source looking for inconsistencies in {} () []
         */
-       public boolean checkAndReportBracketAnomalies(
-                       ProblemReporter problemReporter) {
-               scanner.wasAcr = false;
-               boolean anomaliesDetected = false;
-               try {
-                       char[] source = scanner.source;
-                       int[] leftCount = {0, 0, 0};
-                       int[] rightCount = {0, 0, 0};
-                       int[] depths = {0, 0, 0};
-                       int[][] leftPositions = new int[][]{new int[10], new int[10],
-                                       new int[10]};
-                       int[][] leftDepths = new int[][]{new int[10], new int[10],
-                                       new int[10]};
-                       int[][] rightPositions = new int[][]{new int[10], new int[10],
-                                       new int[10]};
-                       int[][] rightDepths = new int[][]{new int[10], new int[10],
-                                       new int[10]};
-                       scanner.currentPosition = scanner.initialPosition; //starting
-                       // point
-                       // (first-zero-based
-                       // char)
-                       while (scanner.currentPosition < scanner.eofPosition) { //loop for
-                               // jumping
-                               // over
-                               // comments
-                               try {
-                                       // ---------Consume white space and handles
-                                       // startPosition---------
-                                       boolean isWhiteSpace;
-                                       do {
-                                               scanner.startPosition = scanner.currentPosition;
-                                               //                                              if (((scanner.currentCharacter =
-                                               // source[scanner.currentPosition++]) == '\\') &&
-                                               // (source[scanner.currentPosition] == 'u')) {
-                                               //                                                      isWhiteSpace = scanner.jumpOverUnicodeWhiteSpace();
-                                               //                                              } else {
-                                               if (scanner.recordLineSeparator
-                                                               && ((scanner.currentCharacter == '\r') || (scanner.currentCharacter == '\n'))) {
-                                                       if (scanner.lineEnds[scanner.linePtr] < scanner.startPosition) {
-                                                               // only record line positions we have not
-                                                               // recorded yet
-                                                               scanner.pushLineSeparator();
-                                                       }
-                                               }
-                                               isWhiteSpace = CharOperation
-                                                               .isWhitespace(scanner.currentCharacter);
-                                               //                                              }
-                                       } while (isWhiteSpace
-                                                       && (scanner.currentPosition < scanner.eofPosition));
-                                       // -------consume token until } is found---------
-                                       switch (scanner.currentCharacter) {
-                                               case '{' : {
-                                                       int index = leftCount[CurlyBracket]++;
-                                                       if (index == leftPositions[CurlyBracket].length) {
-                                                               System
-                                                                               .arraycopy(
-                                                                                               leftPositions[CurlyBracket],
-                                                                                               0,
-                                                                                               (leftPositions[CurlyBracket] = new int[index * 2]),
-                                                                                               0, index);
-                                                               System
-                                                                               .arraycopy(
-                                                                                               leftDepths[CurlyBracket],
-                                                                                               0,
-                                                                                               (leftDepths[CurlyBracket] = new int[index * 2]),
-                                                                                               0, index);
-                                                       }
-                                                       leftPositions[CurlyBracket][index] = scanner.startPosition;
-                                                       leftDepths[CurlyBracket][index] = depths[CurlyBracket]++;
-                                               }
-                                                       break;
-                                               case '}' : {
-                                                       int index = rightCount[CurlyBracket]++;
-                                                       if (index == rightPositions[CurlyBracket].length) {
-                                                               System
-                                                                               .arraycopy(
-                                                                                               rightPositions[CurlyBracket],
-                                                                                               0,
-                                                                                               (rightPositions[CurlyBracket] = new int[index * 2]),
-                                                                                               0, index);
-                                                               System
-                                                                               .arraycopy(
-                                                                                               rightDepths[CurlyBracket],
-                                                                                               0,
-                                                                                               (rightDepths[CurlyBracket] = new int[index * 2]),
-                                                                                               0, index);
-                                                       }
-                                                       rightPositions[CurlyBracket][index] = scanner.startPosition;
-                                                       rightDepths[CurlyBracket][index] = --depths[CurlyBracket];
-                                               }
-                                                       break;
-                                               case '(' : {
-                                                       int index = leftCount[RoundBracket]++;
-                                                       if (index == leftPositions[RoundBracket].length) {
-                                                               System
-                                                                               .arraycopy(
-                                                                                               leftPositions[RoundBracket],
-                                                                                               0,
-                                                                                               (leftPositions[RoundBracket] = new int[index * 2]),
-                                                                                               0, index);
-                                                               System
-                                                                               .arraycopy(
-                                                                                               leftDepths[RoundBracket],
-                                                                                               0,
-                                                                                               (leftDepths[RoundBracket] = new int[index * 2]),
-                                                                                               0, index);
-                                                       }
-                                                       leftPositions[RoundBracket][index] = scanner.startPosition;
-                                                       leftDepths[RoundBracket][index] = depths[RoundBracket]++;
-                                               }
-                                                       break;
-                                               case ')' : {
-                                                       int index = rightCount[RoundBracket]++;
-                                                       if (index == rightPositions[RoundBracket].length) {
-                                                               System
-                                                                               .arraycopy(
-                                                                                               rightPositions[RoundBracket],
-                                                                                               0,
-                                                                                               (rightPositions[RoundBracket] = new int[index * 2]),
-                                                                                               0, index);
-                                                               System
-                                                                               .arraycopy(
-                                                                                               rightDepths[RoundBracket],
-                                                                                               0,
-                                                                                               (rightDepths[RoundBracket] = new int[index * 2]),
-                                                                                               0, index);
-                                                       }
-                                                       rightPositions[RoundBracket][index] = scanner.startPosition;
-                                                       rightDepths[RoundBracket][index] = --depths[RoundBracket];
-                                               }
-                                                       break;
-                                               case '[' : {
-                                                       int index = leftCount[SquareBracket]++;
-                                                       if (index == leftPositions[SquareBracket].length) {
-                                                               System
-                                                                               .arraycopy(
-                                                                                               leftPositions[SquareBracket],
-                                                                                               0,
-                                                                                               (leftPositions[SquareBracket] = new int[index * 2]),
-                                                                                               0, index);
-                                                               System
-                                                                               .arraycopy(
-                                                                                               leftDepths[SquareBracket],
-                                                                                               0,
-                                                                                               (leftDepths[SquareBracket] = new int[index * 2]),
-                                                                                               0, index);
-                                                       }
-                                                       leftPositions[SquareBracket][index] = scanner.startPosition;
-                                                       leftDepths[SquareBracket][index] = depths[SquareBracket]++;
-                                               }
-                                                       break;
-                                               case ']' : {
-                                                       int index = rightCount[SquareBracket]++;
-                                                       if (index == rightPositions[SquareBracket].length) {
-                                                               System
-                                                                               .arraycopy(
-                                                                                               rightPositions[SquareBracket],
-                                                                                               0,
-                                                                                               (rightPositions[SquareBracket] = new int[index * 2]),
-                                                                                               0, index);
-                                                               System
-                                                                               .arraycopy(
-                                                                                               rightDepths[SquareBracket],
-                                                                                               0,
-                                                                                               (rightDepths[SquareBracket] = new int[index * 2]),
-                                                                                               0, index);
-                                                       }
-                                                       rightPositions[SquareBracket][index] = scanner.startPosition;
-                                                       rightDepths[SquareBracket][index] = --depths[SquareBracket];
-                                               }
-                                                       break;
-                                               case '\'' : {
-                                                       if (scanner.getNextChar('\\')) {
-                                                               scanner.scanEscapeCharacter();
-                                                       } else { // consume next character
-                                                               scanner.unicodeAsBackSlash = false;
-                                                               //                                                                      if (((scanner.currentCharacter =
-                                                               // source[scanner.currentPosition++]) ==
-                                                               // '\\') &&
-                                                               // (source[scanner.currentPosition] ==
-                                                               // 'u')) {
-                                                               //                                                                              scanner.getNextUnicodeChar();
-                                                               //                                                                      } else {
-                                                               if (scanner.withoutUnicodePtr != 0) {
-                                                                       scanner.withoutUnicodeBuffer[++scanner.withoutUnicodePtr] = scanner.currentCharacter;
-                                                               }
-                                                               //                                                                      }
-                                                       }
-                                                       scanner.getNextChar('\'');
-                                                       break;
-                                               }
-                                               case '"' :
-                                                       // consume next character
-                                                       scanner.unicodeAsBackSlash = false;
-                                                       //                                                      if (((scanner.currentCharacter =
-                                                       // source[scanner.currentPosition++]) == '\\') &&
-                                                       // (source[scanner.currentPosition] == 'u')) {
-                                                       //                                                              scanner.getNextUnicodeChar();
-                                                       //                                                      } else {
-                                                       if (scanner.withoutUnicodePtr != 0) {
-                                                               scanner.withoutUnicodeBuffer[++scanner.withoutUnicodePtr] = scanner.currentCharacter;
-                                                       }
-                                                       //                                                      }
-                                                       while (scanner.currentCharacter != '"') {
-                                                               if (scanner.currentCharacter == '\r') {
-                                                                       if (source[scanner.currentPosition] == '\n')
-                                                                               scanner.currentPosition++;
-                                                                       break; // the string cannot go further that
-                                                                       // the line
-                                                               }
-                                                               if (scanner.currentCharacter == '\n') {
-                                                                       break; // the string cannot go further that
-                                                                       // the line
-                                                               }
-                                                               if (scanner.currentCharacter == '\\') {
-                                                                       scanner.scanEscapeCharacter();
-                                                               }
-                                                               // consume next character
-                                                               scanner.unicodeAsBackSlash = false;
-                                                               //                                                              if (((scanner.currentCharacter =
-                                                               // source[scanner.currentPosition++]) == '\\')
-                                                               // && (source[scanner.currentPosition] == 'u'))
-                                                               // {
-                                                               //                                                                      scanner.getNextUnicodeChar();
-                                                               //                                                              } else {
-                                                               if (scanner.withoutUnicodePtr != 0) {
-                                                                       scanner.withoutUnicodeBuffer[++scanner.withoutUnicodePtr] = scanner.currentCharacter;
-                                                               }
-                                                               //                                                              }
-                                                       }
-                                                       break;
-                                               case '/' : {
-                                                       int test;
-                                                       if ((test = scanner.getNextChar('/', '*')) == 0) { //line
-                                                               // comment
-                                                               //get the next char
-                                                               if (((scanner.currentCharacter = source[scanner.currentPosition++]) == '\\')
-                                                                               && (source[scanner.currentPosition] == 'u')) {
-                                                                       //-------------unicode traitement
-                                                                       // ------------
-                                                                       int c1 = 0, c2 = 0, c3 = 0, c4 = 0;
-                                                                       scanner.currentPosition++;
-                                                                       while (source[scanner.currentPosition] == 'u') {
-                                                                               scanner.currentPosition++;
-                                                                       }
-                                                                       if ((c1 = Character
-                                                                                       .getNumericValue(source[scanner.currentPosition++])) > 15
-                                                                                       || c1 < 0
-                                                                                       || (c2 = Character
-                                                                                                       .getNumericValue(source[scanner.currentPosition++])) > 15
-                                                                                       || c2 < 0
-                                                                                       || (c3 = Character
-                                                                                                       .getNumericValue(source[scanner.currentPosition++])) > 15
-                                                                                       || c3 < 0
-                                                                                       || (c4 = Character
-                                                                                                       .getNumericValue(source[scanner.currentPosition++])) > 15
-                                                                                       || c4 < 0) { //error don't
-                                                                               // care of the
-                                                                               // value
-                                                                               scanner.currentCharacter = 'A';
-                                                                       } //something different from \n and \r
-                                                                       else {
-                                                                               scanner.currentCharacter = (char) (((c1 * 16 + c2) * 16 + c3) * 16 + c4);
-                                                                       }
-                                                               }
-                                                               while (scanner.currentCharacter != '\r'
-                                                                               && scanner.currentCharacter != '\n') {
-                                                                       //get the next char
-                                                                       scanner.startPosition = scanner.currentPosition;
-                                                                       if (((scanner.currentCharacter = source[scanner.currentPosition++]) == '\\')
-                                                                                       && (source[scanner.currentPosition] == 'u')) {
-                                                                               //-------------unicode traitement
-                                                                               // ------------
-                                                                               int c1 = 0, c2 = 0, c3 = 0, c4 = 0;
-                                                                               scanner.currentPosition++;
-                                                                               while (source[scanner.currentPosition] == 'u') {
-                                                                                       scanner.currentPosition++;
-                                                                               }
-                                                                               if ((c1 = Character
-                                                                                               .getNumericValue(source[scanner.currentPosition++])) > 15
-                                                                                               || c1 < 0
-                                                                                               || (c2 = Character
-                                                                                                               .getNumericValue(source[scanner.currentPosition++])) > 15
-                                                                                               || c2 < 0
-                                                                                               || (c3 = Character
-                                                                                                               .getNumericValue(source[scanner.currentPosition++])) > 15
-                                                                                               || c3 < 0
-                                                                                               || (c4 = Character
-                                                                                                               .getNumericValue(source[scanner.currentPosition++])) > 15
-                                                                                               || c4 < 0) { //error don't
-                                                                                       // care of the
-                                                                                       // value
-                                                                                       scanner.currentCharacter = 'A';
-                                                                               } //something different from \n
-                                                                               // and \r
-                                                                               else {
-                                                                                       scanner.currentCharacter = (char) (((c1 * 16 + c2) * 16 + c3) * 16 + c4);
-                                                                               }
-                                                                       }
-                                                               }
-                                                               if (scanner.recordLineSeparator
-                                                                               && ((scanner.currentCharacter == '\r') || (scanner.currentCharacter == '\n'))) {
-                                                                       if (scanner.lineEnds[scanner.linePtr] < scanner.startPosition) {
-                                                                               // only record line positions we
-                                                                               // have not recorded yet
-                                                                               scanner.pushLineSeparator();
-                                                                               if (this.scanner.taskTags != null) {
-                                                                                       this.scanner
-                                                                                                       .checkTaskTag(
-                                                                                                                       this.scanner
-                                                                                                                                       .getCurrentTokenStartPosition(),
-                                                                                                                       this.scanner
-                                                                                                                                       .getCurrentTokenEndPosition());
-                                                                               }
-                                                                       }
-                                                               }
-                                                               break;
-                                                       }
-                                                       if (test > 0) { //traditional and annotation
-                                                               // comment
-                                                               boolean star = false;
-                                                               // consume next character
-                                                               scanner.unicodeAsBackSlash = false;
-                                                               //                                                                      if (((scanner.currentCharacter =
-                                                               // source[scanner.currentPosition++]) ==
-                                                               // '\\') &&
-                                                               // (source[scanner.currentPosition] ==
-                                                               // 'u')) {
-                                                               //                                                                              scanner.getNextUnicodeChar();
-                                                               //                                                                      } else {
-                                                               if (scanner.withoutUnicodePtr != 0) {
-                                                                       scanner.withoutUnicodeBuffer[++scanner.withoutUnicodePtr] = scanner.currentCharacter;
-                                                               }
-                                                               //                                                                      }
-                                                               if (scanner.currentCharacter == '*') {
-                                                                       star = true;
-                                                               }
-                                                               //get the next char
-                                                               if (((scanner.currentCharacter = source[scanner.currentPosition++]) == '\\')
-                                                                               && (source[scanner.currentPosition] == 'u')) {
-                                                                       //-------------unicode traitement
-                                                                       // ------------
-                                                                       int c1 = 0, c2 = 0, c3 = 0, c4 = 0;
-                                                                       scanner.currentPosition++;
-                                                                       while (source[scanner.currentPosition] == 'u') {
-                                                                               scanner.currentPosition++;
-                                                                       }
-                                                                       if ((c1 = Character
-                                                                                       .getNumericValue(source[scanner.currentPosition++])) > 15
-                                                                                       || c1 < 0
-                                                                                       || (c2 = Character
-                                                                                                       .getNumericValue(source[scanner.currentPosition++])) > 15
-                                                                                       || c2 < 0
-                                                                                       || (c3 = Character
-                                                                                                       .getNumericValue(source[scanner.currentPosition++])) > 15
-                                                                                       || c3 < 0
-                                                                                       || (c4 = Character
-                                                                                                       .getNumericValue(source[scanner.currentPosition++])) > 15
-                                                                                       || c4 < 0) { //error don't
-                                                                               // care of the
-                                                                               // value
-                                                                               scanner.currentCharacter = 'A';
-                                                                       } //something different from * and /
-                                                                       else {
-                                                                               scanner.currentCharacter = (char) (((c1 * 16 + c2) * 16 + c3) * 16 + c4);
-                                                                       }
-                                                               }
-                                                               //loop until end of comment */
-                                                               while ((scanner.currentCharacter != '/')
-                                                                               || (!star)) {
-                                                                       star = scanner.currentCharacter == '*';
-                                                                       //get next char
-                                                                       if (((scanner.currentCharacter = source[scanner.currentPosition++]) == '\\')
-                                                                                       && (source[scanner.currentPosition] == 'u')) {
-                                                                               //-------------unicode traitement
-                                                                               // ------------
-                                                                               int c1 = 0, c2 = 0, c3 = 0, c4 = 0;
-                                                                               scanner.currentPosition++;
-                                                                               while (source[scanner.currentPosition] == 'u') {
-                                                                                       scanner.currentPosition++;
-                                                                               }
-                                                                               if ((c1 = Character
-                                                                                               .getNumericValue(source[scanner.currentPosition++])) > 15
-                                                                                               || c1 < 0
-                                                                                               || (c2 = Character
-                                                                                                               .getNumericValue(source[scanner.currentPosition++])) > 15
-                                                                                               || c2 < 0
-                                                                                               || (c3 = Character
-                                                                                                               .getNumericValue(source[scanner.currentPosition++])) > 15
-                                                                                               || c3 < 0
-                                                                                               || (c4 = Character
-                                                                                                               .getNumericValue(source[scanner.currentPosition++])) > 15
-                                                                                               || c4 < 0) { //error don't
-                                                                                       // care of the
-                                                                                       // value
-                                                                                       scanner.currentCharacter = 'A';
-                                                                               } //something different from * and
-                                                                               // /
-                                                                               else {
-                                                                                       scanner.currentCharacter = (char) (((c1 * 16 + c2) * 16 + c3) * 16 + c4);
-                                                                               }
-                                                                       }
-                                                               }
-                                                               if (this.scanner.taskTags != null) {
-                                                                       this.scanner
-                                                                                       .checkTaskTag(
-                                                                                                       this.scanner
-                                                                                                                       .getCurrentTokenStartPosition(),
-                                                                                                       this.scanner
-                                                                                                                       .getCurrentTokenEndPosition());
-                                                               }
-                                                               break;
-                                                       }
-                                                       break;
-                                               }
-                                               default :
-                                                       if (Scanner
-                                                                       .isPHPIdentifierStart(scanner.currentCharacter)) {
-                                                               scanner.scanIdentifierOrKeyword(false);
-                                                               break;
-                                                       }
-                                                       if (Character.isDigit(scanner.currentCharacter)) {
-                                                               scanner.scanNumber(false);
-                                                               break;
-                                                       }
-                                       }
-                                       //-----------------end switch while
-                                       // try--------------------
-                               } catch (IndexOutOfBoundsException e) {
-                                       break; // read until EOF
-                               } catch (InvalidInputException e) {
-                                       return false; // no clue
-                               }
-                       }
-                       if (scanner.recordLineSeparator) {
-                               //                              compilationUnit.compilationResult.lineSeparatorPositions =
-                               // scanner.getLineEnds();
-                       }
-                       // check placement anomalies against other kinds of brackets
-                       for (int kind = 0; kind < BracketKinds; kind++) {
-                               for (int leftIndex = leftCount[kind] - 1; leftIndex >= 0; leftIndex--) {
-                                       int start = leftPositions[kind][leftIndex]; // deepest
-                                       // first
-                                       // find matching closing bracket
-                                       int depth = leftDepths[kind][leftIndex];
-                                       int end = -1;
-                                       for (int i = 0; i < rightCount[kind]; i++) {
-                                               int pos = rightPositions[kind][i];
-                                               // want matching bracket further in source with same
-                                               // depth
-                                               if ((pos > start) && (depth == rightDepths[kind][i])) {
-                                                       end = pos;
-                                                       break;
-                                               }
-                                       }
-                                       if (end < 0) { // did not find a good closing match
-                                               problemReporter.unmatchedBracket(start,
-                                                               referenceContext,
-                                                               compilationUnit.compilationResult);
-                                               return true;
-                                       }
-                                       // check if even number of opening/closing other brackets
-                                       // in between this pair of brackets
-                                       int balance = 0;
-                                       for (int otherKind = 0; (balance == 0)
-                                                       && (otherKind < BracketKinds); otherKind++) {
-                                               for (int i = 0; i < leftCount[otherKind]; i++) {
-                                                       int pos = leftPositions[otherKind][i];
-                                                       if ((pos > start) && (pos < end))
-                                                               balance++;
-                                               }
-                                               for (int i = 0; i < rightCount[otherKind]; i++) {
-                                                       int pos = rightPositions[otherKind][i];
-                                                       if ((pos > start) && (pos < end))
-                                                               balance--;
-                                               }
-                                               if (balance != 0) {
-                                                       problemReporter.unmatchedBracket(start,
-                                                                       referenceContext,
-                                                                       compilationUnit.compilationResult); //bracket
-                                                       // anomaly
-                                                       return true;
-                                               }
-                                       }
-                               }
-                               // too many opening brackets ?
-                               for (int i = rightCount[kind]; i < leftCount[kind]; i++) {
-                                       anomaliesDetected = true;
-                                       problemReporter
-                                                       .unmatchedBracket(
-                                                                       leftPositions[kind][leftCount[kind] - i - 1],
-                                                                       referenceContext,
-                                                                       compilationUnit.compilationResult);
-                               }
-                               // too many closing brackets ?
-                               for (int i = leftCount[kind]; i < rightCount[kind]; i++) {
-                                       anomaliesDetected = true;
-                                       problemReporter
-                                                       .unmatchedBracket(rightPositions[kind][i],
-                                                                       referenceContext,
-                                                                       compilationUnit.compilationResult);
-                               }
-                               if (anomaliesDetected)
-                                       return true;
-                       }
-                       return anomaliesDetected;
-               } catch (ArrayStoreException e) { // jdk1.2.2 jit bug
-                       return anomaliesDetected;
-               } catch (NullPointerException e) { // jdk1.2.2 jit bug
-                       return anomaliesDetected;
-               }
-       }
-       protected void pushOnAstLengthStack(int pos) {
-               try {
-                       astLengthStack[++astLengthPtr] = pos;
-               } catch (IndexOutOfBoundsException e) {
-                       int oldStackLength = astLengthStack.length;
-                       int[] oldPos = astLengthStack;
-                       astLengthStack = new int[oldStackLength + StackIncrement];
-                       System.arraycopy(oldPos, 0, astLengthStack, 0, oldStackLength);
-                       astLengthStack[astLengthPtr] = pos;
-               }
-       }
-       protected void pushOnAstStack(AstNode node) {
+       // public boolean checkAndReportBracketAnomalies(ProblemReporter
+       // problemReporter) {
+       // scanner.wasAcr = false;
+       // boolean anomaliesDetected = false;
+       // try {
+       // char[] source = scanner.source;
+       // int[] leftCount = { 0, 0, 0 };
+       // int[] rightCount = { 0, 0, 0 };
+       // int[] depths = { 0, 0, 0 };
+       // int[][] leftPositions = new int[][] { new int[10], new int[10], new
+       // int[10]
+       // };
+       // int[][] leftDepths = new int[][] { new int[10], new int[10], new int[10]
+       // };
+       // int[][] rightPositions = new int[][] { new int[10], new int[10], new
+       // int[10] };
+       // int[][] rightDepths = new int[][] { new int[10], new int[10], new int[10]
+       // };
+       // scanner.currentPosition = scanner.initialPosition; //starting
+       // // point
+       // // (first-zero-based
+       // // char)
+       // while (scanner.currentPosition < scanner.eofPosition) { //loop for
+       // // jumping
+       // // over
+       // // comments
+       // try {
+       // // ---------Consume white space and handles
+       // // startPosition---------
+       // boolean isWhiteSpace;
+       // do {
+       // scanner.startPosition = scanner.currentPosition;
+       // // if (((scanner.currentCharacter =
+       // // source[scanner.currentPosition++]) == '\\') &&
+       // // (source[scanner.currentPosition] == 'u')) {
+       // // isWhiteSpace = scanner.jumpOverUnicodeWhiteSpace();
+       // // } else {
+       // if (scanner.recordLineSeparator && ((scanner.currentCharacter == '\r') ||
+       // (scanner.currentCharacter == '\n'))) {
+       // if (scanner.lineEnds[scanner.linePtr] < scanner.startPosition) {
+       // // only record line positions we have not
+       // // recorded yet
+       // scanner.pushLineSeparator();
+       // }
+       // }
+       // isWhiteSpace = CharOperation.isWhitespace(scanner.currentCharacter);
+       // // }
+       // } while (isWhiteSpace && (scanner.currentPosition <
+       // scanner.eofPosition));
+       // // -------consume token until } is found---------
+       // switch (scanner.currentCharacter) {
+       // case '{': {
+       // int index = leftCount[CurlyBracket]++;
+       // if (index == leftPositions[CurlyBracket].length) {
+       // System.arraycopy(leftPositions[CurlyBracket], 0,
+       // (leftPositions[CurlyBracket] = new int[index * 2]), 0, index);
+       // System.arraycopy(leftDepths[CurlyBracket], 0, (leftDepths[CurlyBracket] =
+       // new int[index * 2]), 0, index);
+       // }
+       // leftPositions[CurlyBracket][index] = scanner.startPosition;
+       // leftDepths[CurlyBracket][index] = depths[CurlyBracket]++;
+       // }
+       // break;
+       // case '}': {
+       // int index = rightCount[CurlyBracket]++;
+       // if (index == rightPositions[CurlyBracket].length) {
+       // System.arraycopy(rightPositions[CurlyBracket], 0,
+       // (rightPositions[CurlyBracket] = new int[index * 2]), 0, index);
+       // System.arraycopy(rightDepths[CurlyBracket], 0, (rightDepths[CurlyBracket]
+       // =
+       // new int[index * 2]), 0, index);
+       // }
+       // rightPositions[CurlyBracket][index] = scanner.startPosition;
+       // rightDepths[CurlyBracket][index] = --depths[CurlyBracket];
+       // }
+       // break;
+       // case '(': {
+       // int index = leftCount[RoundBracket]++;
+       // if (index == leftPositions[RoundBracket].length) {
+       // System.arraycopy(leftPositions[RoundBracket], 0,
+       // (leftPositions[RoundBracket] = new int[index * 2]), 0, index);
+       // System.arraycopy(leftDepths[RoundBracket], 0, (leftDepths[RoundBracket] =
+       // new int[index * 2]), 0, index);
+       // }
+       // leftPositions[RoundBracket][index] = scanner.startPosition;
+       // leftDepths[RoundBracket][index] = depths[RoundBracket]++;
+       // }
+       // break;
+       // case ')': {
+       // int index = rightCount[RoundBracket]++;
+       // if (index == rightPositions[RoundBracket].length) {
+       // System.arraycopy(rightPositions[RoundBracket], 0,
+       // (rightPositions[RoundBracket] = new int[index * 2]), 0, index);
+       // System.arraycopy(rightDepths[RoundBracket], 0, (rightDepths[RoundBracket]
+       // =
+       // new int[index * 2]), 0, index);
+       // }
+       // rightPositions[RoundBracket][index] = scanner.startPosition;
+       // rightDepths[RoundBracket][index] = --depths[RoundBracket];
+       // }
+       // break;
+       // case '[': {
+       // int index = leftCount[SquareBracket]++;
+       // if (index == leftPositions[SquareBracket].length) {
+       // System.arraycopy(leftPositions[SquareBracket], 0,
+       // (leftPositions[SquareBracket] = new int[index * 2]), 0, index);
+       // System.arraycopy(leftDepths[SquareBracket], 0, (leftDepths[SquareBracket]
+       // =
+       // new int[index * 2]), 0, index);
+       // }
+       // leftPositions[SquareBracket][index] = scanner.startPosition;
+       // leftDepths[SquareBracket][index] = depths[SquareBracket]++;
+       // }
+       // break;
+       // case ']': {
+       // int index = rightCount[SquareBracket]++;
+       // if (index == rightPositions[SquareBracket].length) {
+       // System.arraycopy(rightPositions[SquareBracket], 0,
+       // (rightPositions[SquareBracket] = new int[index * 2]), 0, index);
+       // System.arraycopy(rightDepths[SquareBracket], 0,
+       // (rightDepths[SquareBracket]
+       // = new int[index * 2]), 0, index);
+       // }
+       // rightPositions[SquareBracket][index] = scanner.startPosition;
+       // rightDepths[SquareBracket][index] = --depths[SquareBracket];
+       // }
+       // break;
+       // case '\'': {
+       // if (scanner.getNextChar('\\')) {
+       // scanner.scanEscapeCharacter();
+       // } else { // consume next character
+       // scanner.unicodeAsBackSlash = false;
+       // // if (((scanner.currentCharacter =
+       // // source[scanner.currentPosition++]) ==
+       // // '\\') &&
+       // // (source[scanner.currentPosition] ==
+       // // 'u')) {
+       // // scanner.getNextUnicodeChar();
+       // // } else {
+       // if (scanner.withoutUnicodePtr != 0) {
+       // scanner.withoutUnicodeBuffer[++scanner.withoutUnicodePtr] =
+       // scanner.currentCharacter;
+       // }
+       // // }
+       // }
+       // scanner.getNextChar('\'');
+       // break;
+       // }
+       // case '"':
+       // // consume next character
+       // scanner.unicodeAsBackSlash = false;
+       // // if (((scanner.currentCharacter =
+       // // source[scanner.currentPosition++]) == '\\') &&
+       // // (source[scanner.currentPosition] == 'u')) {
+       // // scanner.getNextUnicodeChar();
+       // // } else {
+       // if (scanner.withoutUnicodePtr != 0) {
+       // scanner.withoutUnicodeBuffer[++scanner.withoutUnicodePtr] =
+       // scanner.currentCharacter;
+       // }
+       // // }
+       // while (scanner.currentCharacter != '"') {
+       // if (scanner.currentCharacter == '\r') {
+       // if (source[scanner.currentPosition] == '\n')
+       // scanner.currentPosition++;
+       // break; // the string cannot go further that
+       // // the line
+       // }
+       // if (scanner.currentCharacter == '\n') {
+       // break; // the string cannot go further that
+       // // the line
+       // }
+       // if (scanner.currentCharacter == '\\') {
+       // scanner.scanEscapeCharacter();
+       // }
+       // // consume next character
+       // scanner.unicodeAsBackSlash = false;
+       // // if (((scanner.currentCharacter =
+       // // source[scanner.currentPosition++]) == '\\')
+       // // && (source[scanner.currentPosition] == 'u'))
+       // // {
+       // // scanner.getNextUnicodeChar();
+       // // } else {
+       // if (scanner.withoutUnicodePtr != 0) {
+       // scanner.withoutUnicodeBuffer[++scanner.withoutUnicodePtr] =
+       // scanner.currentCharacter;
+       // }
+       // // }
+       // }
+       // break;
+       // case '/': {
+       // int test;
+       // if ((test = scanner.getNextChar('/', '*')) == 0) { //line
+       // // comment
+       // //get the next char
+       // if (((scanner.currentCharacter = source[scanner.currentPosition++]) ==
+       // '\\')
+       // && (source[scanner.currentPosition] == 'u')) {
+       // //-------------unicode traitement
+       // // ------------
+       // int c1 = 0, c2 = 0, c3 = 0, c4 = 0;
+       // scanner.currentPosition++;
+       // while (source[scanner.currentPosition] == 'u') {
+       // scanner.currentPosition++;
+       // }
+       // if ((c1 = Character.getNumericValue(source[scanner.currentPosition++])) >
+       // 15 || c1 < 0
+       // || (c2 = Character.getNumericValue(source[scanner.currentPosition++])) >
+       // 15
+       // || c2 < 0
+       // || (c3 = Character.getNumericValue(source[scanner.currentPosition++])) >
+       // 15
+       // || c3 < 0
+       // || (c4 = Character.getNumericValue(source[scanner.currentPosition++])) >
+       // 15
+       // || c4 < 0) { //error
+       // // don't
+       // // care of the
+       // // value
+       // scanner.currentCharacter = 'A';
+       // } //something different from \n and \r
+       // else {
+       // scanner.currentCharacter = (char) (((c1 * 16 + c2) * 16 + c3) * 16 + c4);
+       // }
+       // }
+       // while (scanner.currentCharacter != '\r' && scanner.currentCharacter !=
+       // '\n') {
+       // //get the next char
+       // scanner.startPosition = scanner.currentPosition;
+       // if (((scanner.currentCharacter = source[scanner.currentPosition++]) ==
+       // '\\')
+       // && (source[scanner.currentPosition] == 'u')) {
+       // //-------------unicode traitement
+       // // ------------
+       // int c1 = 0, c2 = 0, c3 = 0, c4 = 0;
+       // scanner.currentPosition++;
+       // while (source[scanner.currentPosition] == 'u') {
+       // scanner.currentPosition++;
+       // }
+       // if ((c1 = Character.getNumericValue(source[scanner.currentPosition++])) >
+       // 15 || c1 < 0
+       // || (c2 = Character.getNumericValue(source[scanner.currentPosition++])) >
+       // 15
+       // || c2 < 0
+       // || (c3 = Character.getNumericValue(source[scanner.currentPosition++])) >
+       // 15
+       // || c3 < 0
+       // || (c4 = Character.getNumericValue(source[scanner.currentPosition++])) >
+       // 15
+       // || c4 < 0) { //error
+       // // don't
+       // // care of the
+       // // value
+       // scanner.currentCharacter = 'A';
+       // } //something different from \n
+       // // and \r
+       // else {
+       // scanner.currentCharacter = (char) (((c1 * 16 + c2) * 16 + c3) * 16 + c4);
+       // }
+       // }
+       // }
+       // if (scanner.recordLineSeparator && ((scanner.currentCharacter == '\r') ||
+       // (scanner.currentCharacter == '\n'))) {
+       // if (scanner.lineEnds[scanner.linePtr] < scanner.startPosition) {
+       // // only record line positions we
+       // // have not recorded yet
+       // scanner.pushLineSeparator();
+       // if (this.scanner.taskTags != null) {
+       // this.scanner.checkTaskTag(this.scanner.getCurrentTokenStartPosition(),
+       // this.scanner
+       // .getCurrentTokenEndPosition());
+       // }
+       // }
+       // }
+       // break;
+       // }
+       // if (test > 0) { //traditional and annotation
+       // // comment
+       // boolean star = false;
+       // // consume next character
+       // scanner.unicodeAsBackSlash = false;
+       // // if (((scanner.currentCharacter =
+       // // source[scanner.currentPosition++]) ==
+       // // '\\') &&
+       // // (source[scanner.currentPosition] ==
+       // // 'u')) {
+       // // scanner.getNextUnicodeChar();
+       // // } else {
+       // if (scanner.withoutUnicodePtr != 0) {
+       // scanner.withoutUnicodeBuffer[++scanner.withoutUnicodePtr] =
+       // scanner.currentCharacter;
+       // }
+       // // }
+       // if (scanner.currentCharacter == '*') {
+       // star = true;
+       // }
+       // //get the next char
+       // if (((scanner.currentCharacter = source[scanner.currentPosition++]) ==
+       // '\\')
+       // && (source[scanner.currentPosition] == 'u')) {
+       // //-------------unicode traitement
+       // // ------------
+       // int c1 = 0, c2 = 0, c3 = 0, c4 = 0;
+       // scanner.currentPosition++;
+       // while (source[scanner.currentPosition] == 'u') {
+       // scanner.currentPosition++;
+       // }
+       // if ((c1 = Character.getNumericValue(source[scanner.currentPosition++])) >
+       // 15 || c1 < 0
+       // || (c2 = Character.getNumericValue(source[scanner.currentPosition++])) >
+       // 15
+       // || c2 < 0
+       // || (c3 = Character.getNumericValue(source[scanner.currentPosition++])) >
+       // 15
+       // || c3 < 0
+       // || (c4 = Character.getNumericValue(source[scanner.currentPosition++])) >
+       // 15
+       // || c4 < 0) { //error
+       // // don't
+       // // care of the
+       // // value
+       // scanner.currentCharacter = 'A';
+       // } //something different from * and /
+       // else {
+       // scanner.currentCharacter = (char) (((c1 * 16 + c2) * 16 + c3) * 16 + c4);
+       // }
+       // }
+       // //loop until end of comment */
+       // while ((scanner.currentCharacter != '/') || (!star)) {
+       // star = scanner.currentCharacter == '*';
+       // //get next char
+       // if (((scanner.currentCharacter = source[scanner.currentPosition++]) ==
+       // '\\')
+       // && (source[scanner.currentPosition] == 'u')) {
+       // //-------------unicode traitement
+       // // ------------
+       // int c1 = 0, c2 = 0, c3 = 0, c4 = 0;
+       // scanner.currentPosition++;
+       // while (source[scanner.currentPosition] == 'u') {
+       // scanner.currentPosition++;
+       // }
+       // if ((c1 = Character.getNumericValue(source[scanner.currentPosition++])) >
+       // 15 || c1 < 0
+       // || (c2 = Character.getNumericValue(source[scanner.currentPosition++])) >
+       // 15
+       // || c2 < 0
+       // || (c3 = Character.getNumericValue(source[scanner.currentPosition++])) >
+       // 15
+       // || c3 < 0
+       // || (c4 = Character.getNumericValue(source[scanner.currentPosition++])) >
+       // 15
+       // || c4 < 0) { //error
+       // // don't
+       // // care of the
+       // // value
+       // scanner.currentCharacter = 'A';
+       // } //something different from * and
+       // // /
+       // else {
+       // scanner.currentCharacter = (char) (((c1 * 16 + c2) * 16 + c3) * 16 + c4);
+       // }
+       // }
+       // }
+       // if (this.scanner.taskTags != null) {
+       // this.scanner.checkTaskTag(this.scanner.getCurrentTokenStartPosition(),
+       // this.scanner.getCurrentTokenEndPosition());
+       // }
+       // break;
+       // }
+       // break;
+       // }
+       // default:
+       // if (Scanner.isPHPIdentifierStart(scanner.currentCharacter)) {
+       // scanner.scanIdentifierOrKeyword(false);
+       // break;
+       // }
+       // if (Character.isDigit(scanner.currentCharacter)) {
+       // scanner.scanNumber(false);
+       // break;
+       // }
+       // }
+       // //-----------------end switch while
+       // // try--------------------
+       // } catch (IndexOutOfBoundsException e) {
+       // break; // read until EOF
+       // } catch (InvalidInputException e) {
+       // return false; // no clue
+       // }
+       // }
+       // if (scanner.recordLineSeparator) {
+       // compilationUnit.compilationResult.lineSeparatorPositions =
+       // scanner.getLineEnds();
+       // }
+       // // check placement anomalies against other kinds of brackets
+       // for (int kind = 0; kind < BracketKinds; kind++) {
+       // for (int leftIndex = leftCount[kind] - 1; leftIndex >= 0; leftIndex--) {
+       // int start = leftPositions[kind][leftIndex]; // deepest
+       // // first
+       // // find matching closing bracket
+       // int depth = leftDepths[kind][leftIndex];
+       // int end = -1;
+       // for (int i = 0; i < rightCount[kind]; i++) {
+       // int pos = rightPositions[kind][i];
+       // // want matching bracket further in source with same
+       // // depth
+       // if ((pos > start) && (depth == rightDepths[kind][i])) {
+       // end = pos;
+       // break;
+       // }
+       // }
+       // if (end < 0) { // did not find a good closing match
+       // problemReporter.unmatchedBracket(start, referenceContext,
+       // compilationUnit.compilationResult);
+       // return true;
+       // }
+       // // check if even number of opening/closing other brackets
+       // // in between this pair of brackets
+       // int balance = 0;
+       // for (int otherKind = 0; (balance == 0) && (otherKind < BracketKinds);
+       // otherKind++) {
+       // for (int i = 0; i < leftCount[otherKind]; i++) {
+       // int pos = leftPositions[otherKind][i];
+       // if ((pos > start) && (pos < end))
+       // balance++;
+       // }
+       // for (int i = 0; i < rightCount[otherKind]; i++) {
+       // int pos = rightPositions[otherKind][i];
+       // if ((pos > start) && (pos < end))
+       // balance--;
+       // }
+       // if (balance != 0) {
+       // problemReporter.unmatchedBracket(start, referenceContext,
+       // compilationUnit.compilationResult); //bracket
+       // // anomaly
+       // return true;
+       // }
+       // }
+       // }
+       // // too many opening brackets ?
+       // for (int i = rightCount[kind]; i < leftCount[kind]; i++) {
+       // anomaliesDetected = true;
+       // problemReporter.unmatchedBracket(leftPositions[kind][leftCount[kind] - i
+       // -
+       // 1], referenceContext,
+       // compilationUnit.compilationResult);
+       // }
+       // // too many closing brackets ?
+       // for (int i = leftCount[kind]; i < rightCount[kind]; i++) {
+       // anomaliesDetected = true;
+       // problemReporter.unmatchedBracket(rightPositions[kind][i],
+       // referenceContext,
+       // compilationUnit.compilationResult);
+       // }
+       // if (anomaliesDetected)
+       // return true;
+       // }
+       // return anomaliesDetected;
+       // } catch (ArrayStoreException e) { // jdk1.2.2 jit bug
+       // return anomaliesDetected;
+       // } catch (NullPointerException e) { // jdk1.2.2 jit bug
+       // return anomaliesDetected;
+       // }
+       // }
+//     protected void pushOnAstLengthStack(int pos) {
+//             try {
+//                     astLengthStack[++astLengthPtr] = pos;
+//             } catch (IndexOutOfBoundsException e) {
+//                     int oldStackLength = astLengthStack.length;
+//                     int[] oldPos = astLengthStack;
+//                     astLengthStack = new int[oldStackLength + StackIncrement];
+//                     System.arraycopy(oldPos, 0, astLengthStack, 0, oldStackLength);
+//                     astLengthStack[astLengthPtr] = pos;
+//             }
+//     }
+
+       protected void pushOnAstStack(ASTNode node) {
                /*
                 * add a new obj on top of the ast stack
                 */
@@ -4069,8 +5428,8 @@ public class Parser //extends PHPParserSuperclass
                        astStack[++astPtr] = node;
                } catch (IndexOutOfBoundsException e) {
                        int oldStackLength = astStack.length;
-                       AstNode[] oldStack = astStack;
-                       astStack = new AstNode[oldStackLength + AstStackIncrement];
+                       ASTNode[] oldStack = astStack;
+                       astStack = new ASTNode[oldStackLength + AstStackIncrement];
                        System.arraycopy(oldStack, 0, astStack, 0, oldStackLength);
                        astPtr = oldStackLength;
                        astStack[astPtr] = node;
@@ -4089,7 +5448,145 @@ public class Parser //extends PHPParserSuperclass
        protected void resetModifiers() {
                this.modifiers = AccDefault;
                this.modifiersSourceStart = -1; // <-- see comment into
-                                                                               // modifiersFlag(int)
+               // modifiersFlag(int)
                this.scanner.commentPtr = -1;
        }
-}
\ No newline at end of file
+
+       protected void consumePackageDeclarationName(IFile file) {
+               // create a package name similar to java package names
+               // incastrix
+               //String projectPath = ProjectPrefUtil.getDocumentRoot(file.getProject())
+               //              .toString();
+                //String filePath = file.getFullPath().toString();
+
+                String ext = file.getFileExtension();
+                int fileExtensionLength = ext == null ? 0 : ext.length() + 1;
+                ImportReference impt;
+                char[][] tokens;
+
+               /*if (filePath.startsWith(projectPath)) {
+                       tokens = CharOperation.splitOn('/', filePath.toCharArray(),
+                                       projectPath.length() + 1, filePath.length()
+                                                       - fileExtensionLength);
+               } else {*/
+                       String name = file.getName();
+                       tokens = new char[1][];
+                       tokens[0] = name.substring(0, name.length() - fileExtensionLength)
+                                       .toCharArray();
+               //}
+
+               this.compilationUnit.currentPackage = impt = new ImportReference(
+                               tokens, new char[0], 0, 0, true);
+
+               impt.declarationSourceStart = 0;
+               impt.declarationSourceEnd = 0;
+               impt.declarationEnd = 0;
+               // endPosition is just before the ;
+
+       }
+
+       public final static String[] GLOBALS = { "$this", "$_COOKIE", "$_ENV",
+                       "$_FILES", "$_GET", "$GLOBALS", "$_POST", "$_REQUEST", "$_SESSION",
+                       "$_SERVER" };
+
+       /**
+        *
+        */
+       private void pushFunctionVariableSet() {
+               HashSet set = new HashSet();
+               if (fStackUnassigned.isEmpty()) {
+                       for (int i = 0; i < GLOBALS.length; i++) {
+                               set.add(GLOBALS[i]);
+                       }
+               }
+               fStackUnassigned.add(set);
+       }
+
+       private void pushIfVariableSet() {
+               if (!fStackUnassigned.isEmpty()) {
+                       HashSet set = new HashSet();
+                       fStackUnassigned.add(set);
+               }
+       }
+
+       private HashSet removeIfVariableSet() {
+               if (!fStackUnassigned.isEmpty()) {
+                       return (HashSet) fStackUnassigned
+                                       .remove(fStackUnassigned.size() - 1);
+               }
+               return null;
+       }
+
+       /**
+        * Returns the <i>set of assigned variables </i> returns null if no Set is
+        * defined at the current scanner position
+        */
+       private HashSet peekVariableSet() {
+               if (!fStackUnassigned.isEmpty()) {
+                       return (HashSet) fStackUnassigned.get(fStackUnassigned.size() - 1);
+               }
+               return null;
+       }
+
+       /**
+        * add the current identifier source to the <i>set of assigned variables
+        * </i>
+        *
+        * @param set
+        */
+       private void addVariableSet(HashSet set) {
+               if (set != null) {
+                       set.add(new String(scanner.getCurrentTokenSource()));
+               }
+       }
+
+       /**
+        * add the current identifier source to the <i>set of assigned variables
+        * </i>
+        *
+        */
+       private void addVariableSet() {
+               HashSet set = peekVariableSet();
+               if (set != null) {
+                       set.add(new String(scanner.getCurrentTokenSource()));
+               }
+       }
+
+       /**
+        * add the current identifier source to the <i>set of assigned variables
+        * </i>
+        *
+        */
+       private void addVariableSet(char[] token) {
+               HashSet set = peekVariableSet();
+               if (set != null) {
+                       set.add(new String(token));
+               }
+       }
+
+       /**
+        * check if the current identifier source is in the <i>set of assigned
+        * variables </i> Returns true, if no set is defined for the current scanner
+        * position
+        *
+        */
+       private boolean containsVariableSet() {
+               return containsVariableSet(scanner.getCurrentTokenSource());
+       }
+
+       private boolean containsVariableSet(char[] token) {
+
+               if (!fStackUnassigned.isEmpty()) {
+                       HashSet set;
+                       String str = new String(token);
+                       for (int i = 0; i < fStackUnassigned.size(); i++) {
+                               set = (HashSet) fStackUnassigned.get(i);
+                               if (set.contains(str)) {
+                                       return true;
+                               }
+                       }
+                       return false;
+               }
+               return true;
+       }
+}