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 4e23483..cef140f 100644 (file)
@@ -14,6 +14,7 @@ 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;
@@ -65,7 +66,7 @@ public class Parser implements ITerminalSymbols, CompilerModifiers,
 
        // protected int[] stack = new int[StackIncrement];
 
-       public int firstToken; // handle for multiple parsing goals
+       public TokenName firstToken; // handle for multiple parsing goals
 
        public int lastAct; // handle for multiple parsing goals
 
@@ -80,7 +81,7 @@ public class Parser implements ITerminalSymbols, CompilerModifiers,
         */
        public Scanner scanner;
 
-       int token;
+       TokenName token;
 
        protected int modifiers;
 
@@ -89,43 +90,43 @@ public class Parser implements ITerminalSymbols, CompilerModifiers,
        protected Parser(ProblemReporter problemReporter) {
                this.problemReporter = problemReporter;
                this.options = problemReporter.options;
-               this.token = TokenNameEOF;
+               this.token = TokenName.EOF;
                this.initializeScanner();
        }
 
-       public void setFileToParse(IFile fileToParse) {
-               this.token = TokenNameEOF;
-               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.includesList = 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(
@@ -146,7 +147,7 @@ public class Parser implements ITerminalSymbols, CompilerModifiers,
        /**
         * This method will throw the SyntaxError. It will add the good lines and
         * columns to the Error
-        * 
+        *
         * @param error
         *            the error message
         * @throws SyntaxError
@@ -170,7 +171,7 @@ public class Parser implements ITerminalSymbols, CompilerModifiers,
        /**
         * This method will throw the SyntaxError. It will add the good lines and
         * columns to the Error
-        * 
+        *
         * @param error
         *            the error message
         * @throws SyntaxError
@@ -214,21 +215,20 @@ public class Parser implements ITerminalSymbols, CompilerModifiers,
        // }
 
        /**
-        * 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) {
@@ -242,7 +242,7 @@ public class Parser implements ITerminalSymbols, CompilerModifiers,
 
        public void init(String s) {
                // this.str = s;
-               this.token = TokenNameEOF;
+               this.token = TokenName.EOF;
                this.includesList = new ArrayList();
                // this.chIndx = 0;
                // this.rowCount = 1;
@@ -266,7 +266,7 @@ public class Parser implements ITerminalSymbols, CompilerModifiers,
                this.includesList = new ArrayList();
                // this.indexManager = indexManager;
                // this.str = "";
-               this.token = TokenNameEOF;
+               this.token = TokenName.EOF;
                // this.chIndx = 0;
                // this.rowCount = 1;
                // this.columnCount = 0;
@@ -298,6 +298,8 @@ public class Parser implements ITerminalSymbols, CompilerModifiers,
        /**
         * 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) {
@@ -307,36 +309,50 @@ public class Parser implements ITerminalSymbols, CompilerModifiers,
                                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.");
+
+                               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;
                                        }
-                                       throwSyntaxError("End-of-file not reached.");
                                }
                                break;
                        } catch (SyntaxError syntaxError) {
@@ -365,7 +381,7 @@ public class Parser implements ITerminalSymbols, CompilerModifiers,
        protected void parseFunction(HashMap variables) {
                getNextToken();
                boolean hasModifiers = member_modifiers();
-               if (token == TokenNamefunction) {
+               if (token == TokenName.FUNCTION) {
                        if (!hasModifiers) {
                                checkAndSetModifiers(AccPublic);
                        }
@@ -436,111 +452,139 @@ public class Parser implements ITerminalSymbols, CompilerModifiers,
                return compilationUnit;
        }
 
+       /**
+        *
+        * @return A block object which contains all statements from within the current block
+        */
        private Block statementList() {
-               boolean branchStatement = false;
-               Statement statement;
-               int blockStart = scanner.getCurrentTokenStartPosition();
-               ArrayList blockStatements = new ArrayList();
+               boolean    branchStatement = false;
+               int        blockStart      = scanner.getCurrentTokenStartPosition();
+               ArrayList  blockStatements = new ArrayList();
+               Statement  statement;
+
                do {
                        try {
                                statement = statement();
-                               blockStatements.add(statement);
-                               if (token == TokenNameEOF) {
+
+                               if (statement != null) {
+                                   blockStatements.add(statement);
+                               }
+
+                               if (token == TokenName.EOF) {
                                        return null;
                                }
+
                                if (branchStatement && statement != null) {
-                                       // reportSyntaxError("Unreachable code",
-                                       // statement.sourceStart,
-                                       // statement.sourceEnd);
+                                       // 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
+                                                * 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);
+                                               problemReporter.unreachableCode (new String (scanner.getCurrentIdentifierSource ()),
+                                                                                        statement.sourceStart,
+                                                                                                                statement.sourceEnd,
+                                                                                        referenceContext,
+                                                                                        compilationUnit.compilationResult);
                                        }
                                }
-                               if ((token == TokenNameRBRACE) || (token == TokenNamecase)
-                                               || (token == TokenNamedefault)
-                                               || (token == TokenNameelse)
-                                               || (token == TokenNameelseif)
-                                               || (token == TokenNameendif)
-                                               || (token == TokenNameendfor)
-                                               || (token == TokenNameendforeach)
-                                               || (token == TokenNameendwhile)
-                                               || (token == TokenNameendswitch)
-                                               || (token == TokenNameenddeclare)
-                                               || (token == TokenNameEOF) || (token == TokenNameERROR)) {
-                                       return createBlock(blockStart, blockStatements);
+
+                               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 occured,
-                               // try to find keywords
+                       }
+                       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 {
-                                       while (token != TokenNameEOF) {
-                                               if ((token == TokenNameRBRACE)
-                                                               || (token == TokenNamecase)
-                                                               || (token == TokenNamedefault)
-                                                               || (token == TokenNameelse)
-                                                               || (token == TokenNameelseif)
-                                                               || (token == TokenNameendif)
-                                                               || (token == TokenNameendfor)
-                                                               || (token == TokenNameendforeach)
-                                                               || (token == TokenNameendwhile)
-                                                               || (token == TokenNameendswitch)
-                                                               || (token == TokenNameenddeclare)
-                                                               || (token == TokenNameEOF)
-                                                               || (token == TokenNameERROR)) {
-                                                       return createBlock(blockStart, blockStatements);
+                                       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)
                                                }
-                                               if (token == TokenNameif || token == TokenNameswitch
-                                                               || token == TokenNamefor
-                                                               || token == TokenNamewhile
-                                                               || token == TokenNamedo
-                                                               || token == TokenNameforeach
-                                                               || token == TokenNamecontinue
-                                                               || token == TokenNamebreak
-                                                               || token == TokenNamereturn
-                                                               || token == TokenNameexit
-                                                               || token == TokenNameecho
-                                                               || token == TokenNameECHO_INVISIBLE
-                                                               || token == TokenNameglobal
-                                                               || token == TokenNamestatic
-                                                               || token == TokenNameunset
-                                                               || token == TokenNamefunction
-                                                               || token == TokenNamedeclare
-                                                               || token == TokenNametry
-                                                               || token == TokenNamecatch
-                                                               || token == TokenNamethrow
-                                                               || token == TokenNamefinal
-                                                               || token == TokenNameabstract
-                                                               || token == TokenNameclass
-                                                               || token == TokenNameinterface) {
+
+                                               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 == TokenNameEOF) {
+
+                                       if (token == TokenName.EOF) {
                                                throw sytaxErr1;
                                        }
                                } finally {
                                        scanner.tokenizeStrings = tokenize;
                                }
-                       }
+                       } // catch
                } while (true);
        }
 
@@ -549,9 +593,9 @@ public class Parser implements ITerminalSymbols, CompilerModifiers,
         * @return
         */
        private boolean checkUnreachableStatements(Statement statement) {
-               if (statement instanceof ReturnStatement
-                               || statement instanceof ContinueStatement
-                               || statement instanceof BreakStatement) {
+               if (statement instanceof ReturnStatement   ||
+                       statement instanceof ContinueStatement ||
+                       statement instanceof BreakStatement) {
                        return true;
                } else if (statement instanceof IfStatement
                                && ((IfStatement) statement).checkUnreachable) {
@@ -565,26 +609,30 @@ public class Parser implements ITerminalSymbols, CompilerModifiers,
         * @param blockStatements
         * @return
         */
-       private Block createBlock(int blockStart, ArrayList blockStatements) {
-               int blockEnd = scanner.getCurrentTokenEndPosition();
-               Block b = Block.EmptyWith(blockStart, blockEnd);
+       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);
+               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) {
+
+               if (token == TokenName.RBRACE) {
                        methodDecl.sourceEnd = scanner.getCurrentTokenEndPosition();
                        getNextToken();
                } else {
@@ -593,441 +641,564 @@ public class Parser implements ITerminalSymbols, CompilerModifiers,
                }
        }
 
+       /**
+        * 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;
-               if (token == TokenNameif) {
-                       // T_IF '(' expr ')' statement elseif_list else_single
-                       // T_IF '(' expr ')' ':' inner_statement_list new_elseif_list
-                       // new_else_single T_ENDIF ';'
-                       getNextToken();
-                       if (token == TokenNameLPAREN) {
-                               getNextToken();
-                       } else {
-                               throwSyntaxError("'(' expected after 'if' keyword.");
-                       }
-                       expression = expr();
-                       if (token == TokenNameRPAREN) {
-                               getNextToken();
-                       } else {
-                               throwSyntaxError("')' expected after 'if' condition.");
-                       }
-                       // create basic IfStatement
-                       IfStatement ifStatement = new IfStatement(expression, null, null,
-                                       sourceStart, -1);
-                       if (token == TokenNameCOLON) {
-                               getNextToken();
-                               ifStatementColon(ifStatement);
-                       } else {
-                               ifStatement(ifStatement);
-                       }
-                       return ifStatement;
-               } 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 statement;
-               } else if (token == TokenNamefor) {
-                       getNextToken();
-                       if (token == TokenNameLPAREN) {
-                               getNextToken();
-                       } else {
-                               throwSyntaxError("'(' expected after 'for' keyword.");
-                       }
-                       if (token == TokenNameSEMICOLON) {
+               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 {
-                               expressionList();
-                               if (token == TokenNameSEMICOLON) {
+                               if (token == TokenName.LPAREN) {
                                        getNextToken();
                                } else {
-                                       throwSyntaxError("';' expected after 'for'.");
+                                       throwSyntaxError("'(' expected after 'if' keyword.");
                                }
-                       }
-                       if (token == TokenNameSEMICOLON) {
-                               getNextToken();
-                       } else {
-                               expressionList();
-                               if (token == TokenNameSEMICOLON) {
+
+                               expression = expr();
+
+                               if (token == TokenName.RPAREN) {
                                        getNextToken();
                                } else {
-                                       throwSyntaxError("';' expected after 'for'.");
+                                       throwSyntaxError("')' expected after 'if' condition.");
                                }
-                       }
-                       if (token == TokenNameRPAREN) {
-                               getNextToken();
-                       } else {
-                               expressionList();
-                               if (token == TokenNameRPAREN) {
+                               // create basic IfStatement
+                               IfStatement ifStatement = new IfStatement(expression, null, null, sourceStart, -1);
+
+                               if (token == TokenName.COLON) {
                                        getNextToken();
+                                       ifStatementColon(ifStatement);
                                } else {
-                                       throwSyntaxError("')' expected after 'for'.");
+                                       ifStatement(ifStatement);
                                }
-                       }
-                       forStatement();
-                       return statement;
-               } else if (token == TokenNamewhile) {
-                       getNextToken();
-                       if (token == TokenNameLPAREN) {
-                               getNextToken();
-                       } else {
-                               throwSyntaxError("'(' expected after 'while' keyword.");
-                       }
-                       expr();
-                       if (token == TokenNameRPAREN) {
+                               return ifStatement;
+
+                       case SWITCH:
                                getNextToken();
-                       } else {
-                               throwSyntaxError("')' expected after 'while' condition.");
-                       }
-                       whileStatement();
-                       return statement;
-               } else if (token == TokenNamedo) {
-                       getNextToken();
-                       if (token == TokenNameLBRACE) {
+                               if (token == TokenName.LPAREN) {
+                                       getNextToken();
+                               } else {
+                                       throwSyntaxError("'(' expected after 'switch' keyword.");
+                               }
+                               expr();
+                               if (token == TokenName.RPAREN) {
+                                       getNextToken();
+                               } else {
+                                       throwSyntaxError("')' expected after 'switch' condition.");
+                               }
+                               switchStatement();
+                               return statement;
+
+                       case FOR:
                                getNextToken();
-                               if (token != TokenNameRBRACE) {
-                                       statementList();
+                               if (token == TokenName.LPAREN) {
+                                       getNextToken();
+                               } else {
+                                       throwSyntaxError("'(' expected after 'for' keyword.");
                                }
-                               if (token == TokenNameRBRACE) {
+                               if (token == TokenName.SEMICOLON) {
                                        getNextToken();
                                } else {
-                                       throwSyntaxError("'}' expected after 'do' keyword.");
+                                       expressionList();
+                                       if (token == TokenName.SEMICOLON) {
+                                               getNextToken();
+                                       } else {
+                                               throwSyntaxError("';' expected after 'for'.");
+                                       }
                                }
-                       } else {
-                               statement();
-                       }
-                       if (token == TokenNamewhile) {
+                               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();
-                               if (token == TokenNameLPAREN) {
+                               if (token == TokenName.LPAREN) {
                                        getNextToken();
                                } else {
                                        throwSyntaxError("'(' expected after 'while' keyword.");
                                }
                                expr();
-                               if (token == TokenNameRPAREN) {
+                               if (token == TokenName.RPAREN) {
                                        getNextToken();
                                } else {
                                        throwSyntaxError("')' expected after 'while' condition.");
                                }
-                       } else {
-                               throwSyntaxError("'while' expected after 'do' keyword.");
-                       }
-                       if (token == TokenNameSEMICOLON) {
+                               whileStatement();
+                               return statement;
+
+                       case DO:
                                getNextToken();
-                       } else {
-                               if (token != TokenNameINLINE_HTML) {
-                                       throwSyntaxError("';' expected after do-while statement.");
+                               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();
-                       }
-                       return statement;
-               } else if (token == TokenNameforeach) {
-                       getNextToken();
-                       if (token == TokenNameLPAREN) {
-                               getNextToken();
-                       } else {
-                               throwSyntaxError("'(' expected after 'foreach' keyword.");
-                       }
-                       expr();
-                       if (token == TokenNameas) {
+                               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();
-                       } else {
-                               throwSyntaxError("'as' expected after 'foreach' exxpression.");
-                       }
-                       // variable();
-                       foreach_variable();
-                       foreach_optional_arg();
-                       if (token == TokenNameEQUAL_GREATER) {
+                               if (token != TokenName.SEMICOLON) {
+                                       expression = expr();
+                               }
+                               if (token == TokenName.SEMICOLON) {
+                                       sourceEnd = scanner.getCurrentTokenEndPosition();
+                                       getNextToken();
+                               } else {
+                                       if (token != TokenName.INLINE_HTML) {
+                                               throwSyntaxError("';' expected after 'break'.");
+                                       }
+                                       sourceEnd = scanner.getCurrentTokenEndPosition();
+                                       getNextToken();
+                               }
+                               return new BreakStatement(null, sourceStart, sourceEnd);
+
+                       case CONTINUE:
+                               expression = null;
                                getNextToken();
-                               variable(false, false);
-                       }
-                       if (token == TokenNameRPAREN) {
+                               if (token != TokenName.SEMICOLON) {
+                                       expression = expr();
+                               }
+                               if (token == TokenName.SEMICOLON) {
+                                       sourceEnd = scanner.getCurrentTokenEndPosition();
+                                       getNextToken();
+                               } else {
+                                       if (token != TokenName.INLINE_HTML) {
+                                               throwSyntaxError("';' expected after 'continue'.");
+                                       }
+                                       sourceEnd = scanner.getCurrentTokenEndPosition();
+                                       getNextToken();
+                               }
+                               return new ContinueStatement(null, sourceStart, sourceEnd);
+
+                       case RETURN:
+                               expression = null;
                                getNextToken();
-                       } else {
-                               throwSyntaxError("')' expected after 'foreach' expression.");
-                       }
-                       foreachStatement();
-                       return statement;
-               } else if (token == TokenNamebreak) {
-                       expression = null;
-                       getNextToken();
-                       if (token != TokenNameSEMICOLON) {
-                               expression = expr();
-                       }
-                       if (token == TokenNameSEMICOLON) {
-                               sourceEnd = scanner.getCurrentTokenEndPosition();
+/*
+                               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 {
+                                       if (token != TokenName.INLINE_HTML) {
+                                               throwSyntaxError("';' expected after 'echo' statement.");
+                                       }
+                                       getNextToken();
+                               }
+                               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 'break'.");
+                               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();
                                }
-                               sourceEnd = scanner.getCurrentTokenEndPosition();
+                               return statement;
+
+                       case INLINE_HTML:
                                getNextToken();
-                       }
-                       return new BreakStatement(null, sourceStart, sourceEnd);
-               } else if (token == TokenNamecontinue) {
-                       expression = null;
-                       getNextToken();
-                       if (token != TokenNameSEMICOLON) {
-                               expression = expr();
-                       }
-                       if (token == TokenNameSEMICOLON) {
-                               sourceEnd = scanner.getCurrentTokenEndPosition();
+                               return statement;
+
+                       case GLOBAL:
                                getNextToken();
-                       } else {
-                               if (token != TokenNameINLINE_HTML) {
-                                       throwSyntaxError("';' expected after 'continue'.");
+                               global_var_list();
+                               if (token == TokenName.SEMICOLON) {
+                                       getNextToken();
+                               } else {
+                                       if (token != TokenName.INLINE_HTML) {
+                                               throwSyntaxError("';' expected after 'global' statement.");
+                                       }
+                                       getNextToken();
                                }
-                               sourceEnd = scanner.getCurrentTokenEndPosition();
+                               return statement;
+
+                       case STATIC:
                                getNextToken();
-                       }
-                       return new ContinueStatement(null, sourceStart, sourceEnd);
-               } else if (token == TokenNamereturn) {
-                       expression = null;
-                       getNextToken();
-                       if (token != TokenNameSEMICOLON) {
-                               expression = expr();
-                       }
-                       if (token == TokenNameSEMICOLON) {
-                               sourceEnd = scanner.getCurrentTokenEndPosition();
+                               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();
-                       } else {
-                               if (token != TokenNameINLINE_HTML) {
-                                       throwSyntaxError("';' expected after 'return'.");
+                               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();
                                }
-                               sourceEnd = scanner.getCurrentTokenEndPosition();
+                               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();
-                       }
-                       return new ReturnStatement(expression, sourceStart, sourceEnd);
-               } else if (token == TokenNameecho) {
-                       getNextToken();
-                       expressionList();
-                       if (token == TokenNameSEMICOLON) {
+                               if (token != TokenName.LPAREN) {
+                                       throwSyntaxError("'(' expected in 'declare' statement.");
+                               }
                                getNextToken();
-                       } else {
-                               if (token != TokenNameINLINE_HTML) {
-                                       throwSyntaxError("';' expected after 'echo' statement.");
+                               declare_list();
+                               if (token != TokenName.RPAREN) {
+                                       throwSyntaxError("')' expected in 'declare' statement.");
                                }
                                getNextToken();
-                       }
-                       return statement;
-               } else if (token == TokenNameECHO_INVISIBLE) {
-                       // 0-length token directly after PHP short tag &lt;?=
-                       getNextToken();
-                       expressionList();
-                       if (token == TokenNameSEMICOLON) {
+                               declare_statement();
+                               return statement;
+
+                       case TRY:
                                getNextToken();
-                               // if (token != TokenNameINLINE_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 != TokenNameINLINE_HTML) {
-                                       throwSyntaxError("';' expected after PHP short tag '<?=' expression.");
+                               if (token != TokenName.LBRACE) {
+                                       throwSyntaxError("'{' expected in 'try' statement.");
                                }
+
                                getNextToken();
-                       }
-                       return statement;
-               } else if (token == TokenNameINLINE_HTML) {
-                       getNextToken();
-                       return statement;
-               } else if (token == TokenNameglobal) {
-                       getNextToken();
-                       global_var_list();
-                       if (token == TokenNameSEMICOLON) {
-                               getNextToken();
-                       } else {
-                               if (token != TokenNameINLINE_HTML) {
-                                       throwSyntaxError("';' expected after 'global' statement.");
+
+                               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();
-                       }
-                       return statement;
-               } else if (token == TokenNamestatic) {
-                       getNextToken();
-                       static_var_list();
-                       if (token == TokenNameSEMICOLON) {
+                               return statement;
+
+                       case CATCH:
                                getNextToken();
-                       } else {
-                               if (token != TokenNameINLINE_HTML) {
-                                       throwSyntaxError("';' expected after 'static' statement.");
+                               if (token != TokenName.LPAREN) {
+                                       throwSyntaxError("'(' expected in 'catch' statement.");
                                }
                                getNextToken();
-                       }
-                       return statement;
-               } else if (token == TokenNameunset) {
-                       getNextToken();
-                       if (token == TokenNameLPAREN) {
+                               fully_qualified_class_name();
+                               if (token != TokenName.VARIABLE) {
+                                       throwSyntaxError("Variable expected in 'catch' statement.");
+                               }
+                               addVariableSet();
                                getNextToken();
-                       } else {
-                               throwSyntaxError("'(' expected after 'unset' statement.");
-                       }
-                       unset_variables();
-                       if (token == TokenNameRPAREN) {
+                               if (token != TokenName.RPAREN) {
+                                       throwSyntaxError("')' expected in 'catch' statement.");
+                               }
                                getNextToken();
-                       } else {
-                               throwSyntaxError("')' expected after 'unset' statement.");
-                       }
-                       if (token == TokenNameSEMICOLON) {
+                               if (token != TokenName.LBRACE) {
+                                       throwSyntaxError("'{' expected in 'catch' statement.");
+                               }
                                getNextToken();
-                       } else {
-                               if (token != TokenNameINLINE_HTML) {
-                                       throwSyntaxError("';' expected after 'unset' statement.");
+                               if (token != TokenName.RBRACE) {
+                                       statementList();
+                                       if (token != TokenName.RBRACE) {
+                                               throwSyntaxError("'}' expected in 'catch' statement.");
+                                       }
                                }
                                getNextToken();
-                       }
-                       return statement;
-               } else if (token == TokenNamefunction) {
-                       MethodDeclaration methodDecl = new MethodDeclaration(
-                                       this.compilationUnit.compilationResult);
-                       methodDecl.declarationSourceStart = scanner
-                                       .getCurrentTokenStartPosition();
-                       methodDecl.modifiers = AccDefault;
-                       methodDecl.type = MethodDeclaration.FUNCTION_DEFINITION;
-                       try {
+                               additional_catches();
+                               return statement;
+
+                       case THROW:
                                getNextToken();
-                               functionDefinition(methodDecl);
-                       } finally {
-                               sourceEnd = methodDecl.sourceEnd;
-                               if (sourceEnd <= 0
-                                               || methodDecl.declarationSourceStart > sourceEnd) {
-                                       sourceEnd = methodDecl.declarationSourceStart + 1;
+                               expr();
+                               if (token == TokenName.SEMICOLON) {
+                                       getNextToken();
+                               } else {
+                                       throwSyntaxError("';' expected after 'throw' exxpression.");
                                }
-                               methodDecl.declarationSourceEnd = sourceEnd;
-                               methodDecl.sourceEnd = sourceEnd;
-                       }
-                       return statement;
-               } else if (token == TokenNamedeclare) {
-                       // T_DECLARE '(' declare_list ')' declare_statement
-                       getNextToken();
-                       if (token != TokenNameLPAREN) {
-                               throwSyntaxError("'(' expected in 'declare' statement.");
-                       }
-                       getNextToken();
-                       declare_list();
-                       if (token != TokenNameRPAREN) {
-                               throwSyntaxError("')' expected in 'declare' statement.");
-                       }
-                       getNextToken();
-                       declare_statement();
-                       return statement;
-               } else if (token == TokenNametry) {
-                       getNextToken();
-                       if (token != TokenNameLBRACE) {
-                               throwSyntaxError("'{' expected in 'try' statement.");
-                       }
-                       getNextToken();
-                       statementList();
-                       if (token != TokenNameRBRACE) {
-                               throwSyntaxError("'}' expected in 'try' statement.");
-                       }
-                       getNextToken();
-                       return statement;
-               } else if (token == TokenNamecatch) {
-                       getNextToken();
-                       if (token != TokenNameLPAREN) {
-                               throwSyntaxError("'(' expected in 'catch' statement.");
-                       }
-                       getNextToken();
-                       fully_qualified_class_name();
-                       if (token != TokenNameVariable) {
-                               throwSyntaxError("Variable expected in 'catch' statement.");
-                       }
-                       addVariableSet();
-                       getNextToken();
-                       if (token != TokenNameRPAREN) {
-                               throwSyntaxError("')' expected in 'catch' statement.");
-                       }
-                       getNextToken();
-                       if (token != TokenNameLBRACE) {
-                               throwSyntaxError("'{' expected in 'catch' statement.");
-                       }
-                       getNextToken();
-                       if (token != TokenNameRBRACE) {
-                               statementList();
-                               if (token != TokenNameRBRACE) {
-                                       throwSyntaxError("'}' expected in 'catch' statement.");
+                               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--;
                                }
-                       }
-                       getNextToken();
-                       additional_catches();
-                       return statement;
-               } else if (token == TokenNamethrow) {
-                       getNextToken();
-                       expr();
-                       if (token == TokenNameSEMICOLON) {
-                               getNextToken();
-                       } else {
-                               throwSyntaxError("';' expected after 'throw' exxpression.");
-                       }
-                       return statement;
-               } else if (token == TokenNamefinal || token == TokenNameabstract
-                               || token == TokenNameclass || token == TokenNameinterface) {
-                       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;
-                       // } else {
-                       // throwSyntaxError("Unexpected keyword '" + keyword + "'");
-               } else if (token == TokenNameLBRACE) {
-                       getNextToken();
-                       if (token != TokenNameRBRACE) {
-                               statement = statementList();
-                       }
-                       if (token == TokenNameRBRACE) {
-                               getNextToken();
                                return statement;
-                       } else {
-                               throwSyntaxError("'}' expected.");
-                       }
-               } else {
-                       if (token != TokenNameSEMICOLON) {
-                               expr();
-                       }
-                       if (token == TokenNameSEMICOLON) {
+
+                       case LBRACE:
                                getNextToken();
-                               return statement;
-                       } else {
-                               if (token == TokenNameRBRACE) {
-                                       reportSyntaxError("';' expected after expression (Found token: "
-                                                       + scanner.toStringAction(token) + ")");
+                               if (token != TokenName.RBRACE) {
+                                       statement = statementList();
+                               }
+                               if (token == TokenName.RBRACE) {
+                                       getNextToken();
+                                       return statement;
                                } else {
-                                       if (token != TokenNameINLINE_HTML && token != TokenNameEOF) {
-                                               throwSyntaxError("';' expected after expression (Found token: "
+                                       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) + ")");
                                        }
-                                       getNextToken();
+                                       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;
@@ -1037,15 +1208,15 @@ public class Parser implements ITerminalSymbols, CompilerModifiers,
                // statement
                // | ':' inner_statement_list T_ENDDECLARE ';'
                // ;
-               if (token == TokenNameCOLON) {
+               if (token == TokenName.COLON) {
                        getNextToken();
                        // TODO: implement inner_statement_list();
                        statementList();
-                       if (token != TokenNameenddeclare) {
+                       if (token != TokenName.ENDDECLARE) {
                                throwSyntaxError("'enddeclare' expected in 'declare' statement.");
                        }
                        getNextToken();
-                       if (token != TokenNameSEMICOLON) {
+                       if (token != TokenName.SEMICOLON) {
                                throwSyntaxError("';' expected after 'enddeclare' keyword.");
                        }
                        getNextToken();
@@ -1058,16 +1229,16 @@ public class Parser implements ITerminalSymbols, CompilerModifiers,
                // T_STRING '=' static_scalar
                // | declare_list ',' T_STRING '=' static_scalar
                while (true) {
-                       if (token != TokenNameIdentifier) {
+                       if (token != TokenName.IDENTIFIER) {
                                throwSyntaxError("Identifier expected in 'declare' list.");
                        }
                        getNextToken();
-                       if (token != TokenNameEQUAL) {
+                       if (token != TokenName.EQUAL) {
                                throwSyntaxError("'=' expected in 'declare' list.");
                        }
                        getNextToken();
                        static_scalar();
-                       if (token != TokenNameCOMMA) {
+                       if (token != TokenName.COMMA) {
                                break;
                        }
                        getNextToken();
@@ -1075,30 +1246,30 @@ public class Parser implements ITerminalSymbols, CompilerModifiers,
        }
 
        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();
-                       if (token != TokenNameRBRACE) {
+                       if (token != TokenName.RBRACE) {
                                statementList();
                        }
-                       if (token != TokenNameRBRACE) {
+                       if (token != TokenName.RBRACE) {
                                throwSyntaxError("'}' expected in 'catch' statement.");
                        }
                        getNextToken();
@@ -1108,7 +1279,7 @@ public class Parser implements ITerminalSymbols, CompilerModifiers,
        private void foreach_variable() {
                // w_variable
                // | '&' w_variable
-               if (token == TokenNameAND) {
+               if (token == TokenName.OP_AND) {
                        getNextToken();
                }
                w_variable(true);
@@ -1117,7 +1288,7 @@ public class Parser implements ITerminalSymbols, CompilerModifiers,
        private void foreach_optional_arg() {
                // /* empty */
                // | T_DOUBLE_ARROW foreach_variable
-               if (token == TokenNameEQUAL_GREATER) {
+               if (token == TokenName.EQUAL_GREATER) {
                        getNextToken();
                        foreach_variable();
                }
@@ -1130,7 +1301,7 @@ public class Parser implements ITerminalSymbols, CompilerModifiers,
                HashSet set = peekVariableSet();
                while (true) {
                        global_var(set);
-                       if (token != TokenNameCOMMA) {
+                       if (token != TokenName.COMMA) {
                                break;
                        }
                        getNextToken();
@@ -1142,7 +1313,7 @@ public class Parser implements ITerminalSymbols, CompilerModifiers,
                // T_VARIABLE
                // | '$' r_variable
                // | '$' '{' expr '}'
-               if (token == TokenNameVariable) {
+               if (token == TokenName.VARIABLE) {
                        if (fMethodVariables != null) {
                                VariableInfo info = new VariableInfo(scanner
                                                .getCurrentTokenStartPosition(),
@@ -1152,12 +1323,12 @@ public class Parser implements ITerminalSymbols, CompilerModifiers,
                        }
                        addVariableSet(set);
                        getNextToken();
-               } else if (token == TokenNameDOLLAR) {
+               } else if (token == TokenName.DOLLAR) {
                        getNextToken();
-                       if (token == TokenNameLBRACE) {
+                       if (token == TokenName.LBRACE) {
                                getNextToken();
                                expr();
-                               if (token != TokenNameRBRACE) {
+                               if (token != TokenName.RBRACE) {
                                        throwSyntaxError("'}' expected in global variable.");
                                }
                                getNextToken();
@@ -1175,7 +1346,7 @@ public class Parser implements ITerminalSymbols, CompilerModifiers,
                // | 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(),
@@ -1185,11 +1356,11 @@ public class Parser implements ITerminalSymbols, CompilerModifiers,
                                }
                                addVariableSet(set);
                                getNextToken();
-                               if (token == TokenNameEQUAL) {
+                               if (token == TokenName.EQUAL) {
                                        getNextToken();
                                        static_scalar();
                                }
-                               if (token != TokenNameCOMMA) {
+                               if (token != TokenName.COMMA) {
                                        break;
                                }
                                getNextToken();
@@ -1207,7 +1378,7 @@ public class Parser implements ITerminalSymbols, CompilerModifiers,
                // variable
                while (true) {
                        variable(false, false);
-                       if (token != TokenNameCOMMA) {
+                       if (token != TokenName.COMMA) {
                                break;
                        }
                        getNextToken();
@@ -1227,7 +1398,7 @@ public class Parser implements ITerminalSymbols, CompilerModifiers,
 
        private void unticked_class_declaration_statement(TypeDeclaration typeDecl) {
                initializeModifiers();
-               if (token == TokenNameinterface) {
+               if (token == TokenName.INTERFACE) {
                        // interface_entry T_STRING
                        // interface_extends_list
                        // '{' class_statement_list '}'
@@ -1236,9 +1407,9 @@ public class Parser implements ITerminalSymbols, CompilerModifiers,
                        typeDecl.modifiers = this.modifiers;
                        typeDecl.sourceStart = scanner.getCurrentTokenStartPosition();
                        typeDecl.sourceEnd = scanner.getCurrentTokenEndPosition();
-                       if (token == TokenNameIdentifier || token > TokenNameKEYWORD) {
+                       if (token == TokenName.IDENTIFIER || token.compareTo (TokenName.KEYWORD) > 0) {
                                typeDecl.name = scanner.getCurrentIdentifierSource();
-                               if (token > TokenNameKEYWORD) {
+                               if (token.compareTo (TokenName.KEYWORD) > 0) {
                                        problemReporter.phpKeywordWarning(new String[] { scanner
                                                        .toStringAction(token) }, scanner
                                                        .getCurrentTokenStartPosition(), scanner
@@ -1268,9 +1439,9 @@ public class Parser implements ITerminalSymbols, CompilerModifiers,
                        typeDecl.sourceEnd = scanner.getCurrentTokenEndPosition();
                        // identifier
                        // identifier 'extends' identifier
-                       if (token == TokenNameIdentifier || token > TokenNameKEYWORD) {
+                       if (token == TokenName.IDENTIFIER || token.compareTo (TokenName.KEYWORD) > 0) {
                                typeDecl.name = scanner.getCurrentIdentifierSource();
-                               if (token > TokenNameKEYWORD) {
+                               if (token.compareTo (TokenName.KEYWORD) > 0) {
                                        problemReporter.phpKeywordWarning(new String[] { scanner
                                                        .toStringAction(token) }, scanner
                                                        .getCurrentTokenStartPosition(), scanner
@@ -1285,10 +1456,10 @@ public class Parser implements ITerminalSymbols, CompilerModifiers,
                                // extends_from:
                                // /* empty */
                                // | T_EXTENDS fully_qualified_class_name
-                               if (token == TokenNameextends) {
+                               if (token == TokenName.EXTENDS) {
                                        class_extends_list(typeDecl);
                                        // getNextToken();
-                                       // if (token != TokenNameIdentifier) {
+                                       // if (token != TokenName.IDENTIFIER) {
                                        // throwSyntaxError("Class name expected after keyword
                                        // 'extends'.",
                                        // scanner.getCurrentTokenStartPosition(), scanner
@@ -1304,9 +1475,9 @@ public class Parser implements ITerminalSymbols, CompilerModifiers,
                        }
                }
                // '{' class_statement_list '}'
-               if (token == TokenNameLBRACE) {
+               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()];
@@ -1314,7 +1485,7 @@ public class Parser implements ITerminalSymbols, CompilerModifiers,
                                        typeDecl.fields[i] = (FieldDeclaration) list.get(i);
                                }
                        }
-                       if (token == TokenNameRBRACE) {
+                       if (token == TokenName.RBRACE) {
                                typeDecl.declarationSourceEnd = scanner
                                                .getCurrentTokenEndPosition();
                                getNextToken();
@@ -1330,19 +1501,19 @@ public class Parser implements ITerminalSymbols, CompilerModifiers,
                // T_CLASS
                // | T_ABSTRACT T_CLASS
                // | T_FINAL T_CLASS
-               if (token == TokenNameclass) {
+               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();
@@ -1354,10 +1525,10 @@ public class Parser implements ITerminalSymbols, CompilerModifiers,
        // private void class_extends(TypeDeclaration typeDecl) {
        // // /* empty */
        // // | T_EXTENDS interface_list
-       // if (token == TokenNameextends) {
+       // if (token == TokenName.EXTENDS) {
        // getNextToken();
        //
-       // if (token == TokenNameIdentifier) {
+       // if (token == TokenName.IDENTIFIER) {
        // getNextToken();
        // } else {
        // throwSyntaxError("Class name expected after keyword 'extends'.");
@@ -1368,7 +1539,7 @@ public class Parser implements ITerminalSymbols, CompilerModifiers,
        private void interface_extends_list(TypeDeclaration typeDecl) {
                // /* empty */
                // | T_EXTENDS interface_list
-               if (token == TokenNameextends) {
+               if (token == TokenName.EXTENDS) {
                        getNextToken();
                        interface_list(typeDecl);
                }
@@ -1377,7 +1548,7 @@ public class Parser implements ITerminalSymbols, CompilerModifiers,
        private void class_extends_list(TypeDeclaration typeDecl) {
                // /* empty */
                // | T_EXTENDS interface_list
-               if (token == TokenNameextends) {
+               if (token == TokenName.EXTENDS) {
                        getNextToken();
                        class_list(typeDecl);
                }
@@ -1386,7 +1557,7 @@ public class Parser implements ITerminalSymbols, CompilerModifiers,
        private void implements_list(TypeDeclaration typeDecl) {
                // /* empty */
                // | T_IMPLEMENTS interface_list
-               if (token == TokenNameimplements) {
+               if (token == TokenName.IMPLEMENTS) {
                        getNextToken();
                        interface_list(typeDecl);
                }
@@ -1396,8 +1567,8 @@ public class Parser implements ITerminalSymbols, CompilerModifiers,
                // class_list:
                // fully_qualified_class_name
                do {
-                       if (token == TokenNameIdentifier) {
-                               char[] ident = scanner.getCurrentIdentifierSource();
+                       if (token == TokenName.IDENTIFIER) {
+                               //char[] ident = scanner.getCurrentIdentifierSource();
                                // TODO make this code working better:
                                // SingleTypeReference ref =
                                // ParserUtil.getTypeReference(scanner,
@@ -1409,7 +1580,7 @@ public class Parser implements ITerminalSymbols, CompilerModifiers,
                        } else {
                                throwSyntaxError("Classname expected after keyword 'extends'.");
                        }
-                       if (token == TokenNameCOMMA) {
+                       if (token == TokenName.COMMA) {
                                reportSyntaxError("No multiple inheritance allowed. Expected token 'implements' or '{'.");
                                getNextToken();
                                continue;
@@ -1424,12 +1595,12 @@ public class Parser implements ITerminalSymbols, CompilerModifiers,
                // fully_qualified_class_name
                // | interface_list ',' fully_qualified_class_name
                do {
-                       if (token == TokenNameIdentifier) {
+                       if (token == TokenName.IDENTIFIER) {
                                getNextToken();
                        } else {
                                throwSyntaxError("Interfacename expected after keyword 'implements'.");
                        }
-                       if (token != TokenNameCOMMA) {
+                       if (token != TokenName.COMMA) {
                                return;
                        }
                        getNextToken();
@@ -1438,12 +1609,12 @@ public class Parser implements ITerminalSymbols, CompilerModifiers,
 
        // private void classBody(TypeDeclaration typeDecl) {
        // //'{' [class-element-list] '}'
-       // if (token == TokenNameLBRACE) {
+       // if (token == TokenName.LBRACE) {
        // getNextToken();
-       // if (token != TokenNameRBRACE) {
+       // if (token != TokenName.RBRACE) {
        // class_statement_list();
        // }
-       // if (token == TokenNameRBRACE) {
+       // if (token == TokenName.RBRACE) {
        // typeDecl.declarationSourceEnd = scanner.getCurrentTokenEndPosition();
        // getNextToken();
        // } else {
@@ -1457,21 +1628,27 @@ public class Parser implements ITerminalSymbols, CompilerModifiers,
                do {
                        try {
                                class_statement(list);
-                               if (token == TokenNamepublic || token == TokenNameprotected
-                                               || token == TokenNameprivate
-                                               || token == TokenNamestatic
-                                               || token == TokenNameabstract
-                                               || token == TokenNamefinal
-                                               || token == TokenNamefunction || token == TokenNamevar
-                                               || token == TokenNameconst) {
+                               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 == TokenNameRBRACE) {
+
+                               if (token == TokenName.RBRACE) {
                                        break;
                                }
+
                                throwSyntaxError("'}' at end of class statement.");
-                       } catch (SyntaxError sytaxErr1) {
+                       }
+                       catch (SyntaxError sytaxErr1) {
                                boolean tokenize = scanner.tokenizeStrings;
+
                                if (!tokenize) {
                                        scanner.tokenizeStrings = true;
                                }
@@ -1479,22 +1656,22 @@ public class Parser implements ITerminalSymbols, CompilerModifiers,
                                        // if an error occured,
                                        // try to find keywords
                                        // to parse the rest of the string
-                                       while (token != TokenNameEOF) {
-                                               if (token == TokenNamepublic
-                                                               || token == TokenNameprotected
-                                                               || token == TokenNameprivate
-                                                               || token == TokenNamestatic
-                                                               || token == TokenNameabstract
-                                                               || token == TokenNamefinal
-                                                               || token == TokenNamefunction
-                                                               || token == TokenNamevar
-                                                               || token == TokenNameconst) {
+                                       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 == TokenNameEOF) {
+                                       if (token == TokenName.EOF) {
                                                throw sytaxErr1;
                                        }
                                } finally {
@@ -1504,6 +1681,9 @@ public class Parser implements ITerminalSymbols, CompilerModifiers,
                } while (true);
        }
 
+       /**
+        *
+        */
        private void class_statement(ArrayList list) {
                // class_statement:
                // variable_modifiers class_variable_declaration ';'
@@ -1513,7 +1693,7 @@ public class Parser implements ITerminalSymbols, CompilerModifiers,
                initializeModifiers();
                int declarationSourceStart = scanner.getCurrentTokenStartPosition();
 
-               if (token == TokenNamevar) {
+               if (token == TokenName.VAR) {
                        checkAndSetModifiers(AccPublic);
                        problemReporter.phpVarDeprecatedWarning(scanner
                                        .getCurrentTokenStartPosition(), scanner
@@ -1521,16 +1701,16 @@ public class Parser implements ITerminalSymbols, CompilerModifiers,
                                        compilationUnit.compilationResult);
                        getNextToken();
                        class_variable_declaration(declarationSourceStart, list);
-               } else if (token == TokenNameconst) {
+               } else if (token == TokenName.CONST) {
                        checkAndSetModifiers(AccFinal | AccPublic);
                        class_constant_declaration(declarationSourceStart, list);
-                       if (token != TokenNameSEMICOLON) {
+                       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);
                                }
@@ -1565,13 +1745,13 @@ public class Parser implements ITerminalSymbols, CompilerModifiers,
                        ArrayList list) {
                // class_constant_declaration ',' T_STRING '=' static_scalar
                // | T_CONST T_STRING '=' static_scalar
-               if (token != TokenNameconst) {
+               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
@@ -1586,12 +1766,12 @@ public class Parser implements ITerminalSymbols, CompilerModifiers,
                        // 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();
@@ -1603,7 +1783,7 @@ public class Parser implements ITerminalSymbols, CompilerModifiers,
        // // non_empty_member_modifiers
        // //| T_VAR
        // initializeModifiers();
-       // if (token == TokenNamevar) {
+       // if (token == TokenName.var) {
        // checkAndSetModifiers(AccPublic);
        // reportSyntaxError(
        // "Keyword 'var' is deprecated. Please use 'public' 'private' or
@@ -1637,27 +1817,27 @@ public class Parser implements ITerminalSymbols, CompilerModifiers,
                // | 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;
@@ -1677,7 +1857,7 @@ public class Parser implements ITerminalSymbols, CompilerModifiers,
                // | T_VARIABLE '=' static_scalar
                char[] classVariable;
                do {
-                       if (token == TokenNameVariable) {
+                       if (token == TokenName.VARIABLE) {
                                classVariable = scanner.getCurrentIdentifierSource();
                                // indexManager.addIdentifierInformation('v', classVariable,
                                // buf, -1,
@@ -1699,23 +1879,23 @@ public class Parser implements ITerminalSymbols, CompilerModifiers,
                                                        .getCurrentIdentifierSource()), info);
                                }
                                getNextToken();
-                               if (token == TokenNameEQUAL) {
+                               if (token == TokenName.EQUAL) {
                                        getNextToken();
                                        static_scalar();
                                }
                        } else {
-                               // if (token == TokenNamethis) {
+                               // 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();
@@ -1754,7 +1934,7 @@ public class Parser implements ITerminalSymbols, CompilerModifiers,
                try {
                        pushFunctionVariableSet();
                        functionDeclarator(methodDecl);
-                       if (token == TokenNameSEMICOLON) {
+                       if (token == TokenName.SEMICOLON) {
                                if (!isAbstract) {
                                        methodDecl.sourceEnd = scanner
                                                        .getCurrentTokenStartPosition() - 1;
@@ -1774,38 +1954,63 @@ public class Parser implements ITerminalSymbols, CompilerModifiers,
 
        private void functionDeclarator(MethodDeclaration methodDecl) {
                // identifier '(' [parameter-list] ')'
-               if (token == TokenNameAND) {
+               if (token == TokenName.OP_AND) {
                        getNextToken();
                }
+
                methodDecl.sourceStart = scanner.getCurrentTokenStartPosition();
                methodDecl.sourceEnd = scanner.getCurrentTokenEndPosition();
-               if (Scanner.isIdentifierOrKeyword(token)) {
-                       methodDecl.selector = scanner.getCurrentIdentifierSource();
-                       if (token > TokenNameKEYWORD) {
-                               problemReporter.phpKeywordWarning(new String[] { scanner
-                                               .toStringAction(token) }, scanner
-                                               .getCurrentTokenStartPosition(), scanner
-                                               .getCurrentTokenEndPosition(), referenceContext,
-                                               compilationUnit.compilationResult);
-                       }
-                       getNextToken();
-                       if (token == TokenNameLPAREN) {
+
+               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) {
+
+                       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 {
+               }
+               else {
                        methodDecl.selector = "<undefined>".toCharArray();
                        methodDecl.sourceEnd = scanner.getCurrentTokenStartPosition() - 1;
                        throwSyntaxError("Function name expected after keyword 'function'.");
@@ -1832,20 +2037,21 @@ public class Parser implements ITerminalSymbols, CompilerModifiers,
                // | non_empty_parameter_list ',' optional_class_type T_VARIABLE '='
                // static_scalar
                char[] typeIdentifier = null;
-               if (token == TokenNameIdentifier || token == TokenNamearray
-                               || token == TokenNameVariable || token == TokenNameAND) {
+               if (token == TokenName.IDENTIFIER ||
+                   token == TokenName.ARRAY      ||
+                   token == TokenName.VARIABLE   ||
+                   token == TokenName.OP_AND) {
                        HashSet set = peekVariableSet();
+
                        while (true) {
-                               if (token == TokenNameIdentifier || token == TokenNamearray) {// feature
-                                                                                                                                                               // req.
-                                                                                                                                                               // #1254275
+                               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) {
@@ -1863,14 +2069,14 @@ public class Parser implements ITerminalSymbols, CompilerModifiers,
                                        }
                                        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();
@@ -1890,7 +2096,7 @@ public class Parser implements ITerminalSymbols, CompilerModifiers,
        // private void parameterDeclaration() {
        // //variable
        // //variable-reference
-       // if (token == TokenNameAND) {
+       // if (token == TokenName.AND) {
        // getNextToken();
        // if (isVariable()) {
        // getNextToken();
@@ -1899,43 +2105,42 @@ public class Parser implements ITerminalSymbols, CompilerModifiers,
        // }
        // }
        // //variable '=' constant
-       // if (token == TokenNameVariable) {
+       // if (token == TokenName.VARIABLE) {
        // getNextToken();
-       // if (token == TokenNameEQUAL) {
+       // if (token == TokenName.EQUAL) {
        // getNextToken();
        // static_scalar();
        // }
        // return;
        // }
-       // // if (token == TokenNamethis) {
+       // // 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 == TokenNameRBRACE) {
-                                               // empty case; assumes that the '}' token belongs to the
-                                               // wrapping
+                                       if (token == TokenName.RBRACE) {
+                                               // empty case; assumes that the '}' token belongs to the wrapping
                                                // switch statement - #1371992
                                                break;
                                        }
-                                       if (token == TokenNamecase || token == TokenNamedefault) {
+                                       if (token == TokenName.CASE || token == TokenName.DEFAULT) {
                                                // empty case statement ?
                                                continue;
                                        }
                                        statementList();
                                }
-                               // else if (token == TokenNameSEMICOLON) {
+                               // else if (token == TokenName.SEMICOLON) {
                                // setMarker(
                                // "':' expected after 'case' keyword (Found token: " +
                                // scanner.toStringAction(token) + ")",
@@ -1943,7 +2148,7 @@ public class Parser implements ITerminalSymbols, CompilerModifiers,
                                // scanner.getCurrentTokenEndPosition(),
                                // INFO);
                                // getNextToken();
-                               // if (token == TokenNamecase) { // empty case statement ?
+                               // if (token == TokenName.CASE) { // empty case statement ?
                                // continue;
                                // }
                                // statementList();
@@ -1952,24 +2157,23 @@ public class Parser implements ITerminalSymbols, CompilerModifiers,
                                        throwSyntaxError("':' character expected after 'case' constant (Found token: "
                                                        + scanner.toStringAction(token) + ")");
                                }
-                       } else { // TokenNamedefault
+                       } else { // TokenName.DEFAULT
                                getNextToken();
-                               if (token == TokenNameCOLON || token == TokenNameSEMICOLON) {
+                               if (token == TokenName.COLON || token == TokenName.SEMICOLON) {
                                        getNextToken();
-                                       if (token == TokenNameRBRACE) {
-                                               // empty default case; ; assumes that the '}' token
-                                               // belongs to the
+                                       if (token == TokenName.RBRACE) {
+                                               // empty default case; ; assumes that the '}' token belongs to the
                                                // wrapping switch statement - #1371992
                                                break;
                                        }
-                                       if (token != TokenNamecase) {
+                                       if (token != TokenName.CASE) {
                                                statementList();
                                        }
                                } else {
                                        throwSyntaxError("':' character expected after 'default'.");
                                }
                        }
-               } while (token == TokenNamecase || token == TokenNamedefault);
+               } while (token == TokenName.CASE || token == TokenName.DEFAULT);
        }
 
        private void ifStatementColon(IfStatement iState) {
@@ -1983,7 +2187,7 @@ public class Parser implements ITerminalSymbols, CompilerModifiers,
                } finally {
                        assignedVariableSet = removeIfVariableSet();
                }
-               if (token == TokenNameelseif) {
+               if (token == TokenName.ELSEIF) {
                        try {
                                pushIfVariableSet();
                                new_elseif_list(iState);
@@ -2009,11 +2213,11 @@ public class Parser implements ITerminalSymbols, CompilerModifiers,
                                }
                        }
                }
-               if (token != TokenNameendif) {
+               if (token != TokenName.ENDIF) {
                        throwSyntaxError("'endif' expected.");
                }
                getNextToken();
-               if (token != TokenNameSEMICOLON && token != TokenNameINLINE_HTML) {
+               if (token != TokenName.SEMICOLON && token != TokenName.INLINE_HTML) {
                        reportSyntaxError("';' expected after if-statement.");
                        iState.sourceEnd = scanner.getCurrentTokenStartPosition();
                } else {
@@ -2034,7 +2238,7 @@ public class Parser implements ITerminalSymbols, CompilerModifiers,
                        assignedVariableSet = removeIfVariableSet();
                }
 
-               if (token == TokenNameelseif) {
+               if (token == TokenName.ELSEIF) {
                        try {
                                pushIfVariableSet();
                                elseif_list(iState);
@@ -2069,16 +2273,16 @@ public class Parser implements ITerminalSymbols, CompilerModifiers,
                ArrayList statementList = new ArrayList();
                Expression e;
                Statement s;
-               while (token == TokenNameelseif) {
+               while (token == TokenName.ELSEIF) {
                        getNextToken();
-                       if (token == TokenNameLPAREN) {
+                       if (token == TokenName.LPAREN) {
                                getNextToken();
                        } else {
                                throwSyntaxError("'(' expected after 'elseif' keyword.");
                        }
                        e = expr();
                        conditionList.add(e);
-                       if (token == TokenNameRPAREN) {
+                       if (token == TokenName.RPAREN) {
                                getNextToken();
                        } else {
                                throwSyntaxError("')' expected after 'elseif' condition.");
@@ -2100,21 +2304,21 @@ public class Parser implements ITerminalSymbols, CompilerModifiers,
                ArrayList statementList = new ArrayList();
                Expression e;
                Block b;
-               while (token == TokenNameelseif) {
+               while (token == TokenName.ELSEIF) {
                        getNextToken();
-                       if (token == TokenNameLPAREN) {
+                       if (token == TokenName.LPAREN) {
                                getNextToken();
                        } else {
                                throwSyntaxError("'(' expected after 'elseif' keyword.");
                        }
                        e = expr();
                        conditionList.add(e);
-                       if (token == TokenNameRPAREN) {
+                       if (token == TokenName.RPAREN) {
                                getNextToken();
                        } else {
                                throwSyntaxError("')' expected after 'elseif' condition.");
                        }
-                       if (token == TokenNameCOLON) {
+                       if (token == TokenName.COLON) {
                                getNextToken();
                        } else {
                                throwSyntaxError("':' expected after 'elseif' keyword.");
@@ -2132,7 +2336,7 @@ public class Parser implements ITerminalSymbols, CompilerModifiers,
        private void else_single(IfStatement iState) {
                // /* empty */
                // T_ELSE statement
-               if (token == TokenNameelse) {
+               if (token == TokenName.ELSE) {
                        getNextToken();
                        Statement s = statement();
                        iState.elseStatement = s;
@@ -2146,9 +2350,9 @@ public class Parser implements ITerminalSymbols, CompilerModifiers,
        private void new_else_single(IfStatement iState) {
                // /* empty */
                // | T_ELSE ':' inner_statement_list
-               if (token == TokenNameelse) {
+               if (token == TokenName.ELSE) {
                        getNextToken();
-                       if (token == TokenNameCOLON) {
+                       if (token == TokenName.COLON) {
                                getNextToken();
                        } else {
                                throwSyntaxError("':' expected after 'else' keyword.");
@@ -2203,23 +2407,23 @@ public class Parser implements ITerminalSymbols, CompilerModifiers,
        // do {
        // elseifStatement();
        // switch (token) {
-       // case TokenNameelse:
+       // case TokenName.else:
        // getNextToken();
-       // if (token == TokenNameCOLON) {
+       // if (token == TokenName.COLON) {
        // getNextToken();
-       // if (token != TokenNameendif) {
+       // if (token != TokenName.endif) {
        // statementList();
        // }
        // return;
        // } else {
-       // if (token == TokenNameif) { //'else if'
+       // if (token == TokenName.if) { //'else if'
        // getNextToken();
        // } else {
        // throwSyntaxError("':' expected after 'else'.");
        // }
        // }
        // break;
-       // case TokenNameelseif:
+       // case TokenName.elseif:
        // getNextToken();
        // break;
        // default:
@@ -2229,46 +2433,46 @@ public class Parser implements ITerminalSymbols, CompilerModifiers,
        // }
 
        // private void elseifStatement() {
-       // if (token == TokenNameLPAREN) {
+       // if (token == TokenName.LPAREN) {
        // getNextToken();
        // expr();
-       // if (token != TokenNameRPAREN) {
+       // if (token != TokenName.RPAREN) {
        // throwSyntaxError("')' expected in else-if-statement.");
        // }
        // getNextToken();
-       // if (token != TokenNameCOLON) {
+       // if (token != TokenName.COLON) {
        // throwSyntaxError("':' expected in else-if-statement.");
        // }
        // getNextToken();
-       // if (token != TokenNameendif) {
+       // 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 && token != TokenNameINLINE_HTML) {
+                       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();
@@ -2276,14 +2480,14 @@ public class Parser implements ITerminalSymbols, CompilerModifiers,
        }
 
        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 && token != TokenNameINLINE_HTML) {
+                       if (token != TokenName.SEMICOLON && token != TokenName.INLINE_HTML) {
                                throwSyntaxError("';' expected after for-statement.");
                        }
                        getNextToken();
@@ -2294,14 +2498,14 @@ public class Parser implements ITerminalSymbols, CompilerModifiers,
 
        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 && token != TokenNameINLINE_HTML) {
+                       if (token != TokenName.SEMICOLON && token != TokenName.INLINE_HTML) {
                                throwSyntaxError("';' expected after while-statement.");
                        }
                        getNextToken();
@@ -2311,14 +2515,14 @@ public class Parser implements ITerminalSymbols, CompilerModifiers,
        }
 
        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 && token != TokenNameINLINE_HTML) {
+                       if (token != TokenName.SEMICOLON && token != TokenName.INLINE_HTML) {
                                throwSyntaxError("';' expected after foreach-statement.");
                        }
                        getNextToken();
@@ -2328,25 +2532,44 @@ public class Parser implements ITerminalSymbols, CompilerModifiers,
        }
 
        // private void exitStatus() {
-       // if (token == TokenNameLPAREN) {
+       // if (token == TokenName.LPAREN) {
        // getNextToken();
        // } else {
        // throwSyntaxError("'(' expected in 'exit-status'.");
        // }
-       // if (token != TokenNameRPAREN) {
+       // if (token != TokenName.RPAREN) {
        // expression();
        // }
-       // if (token == TokenNameRPAREN) {
+       // 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;
                        }
@@ -2354,24 +2577,24 @@ public class Parser implements ITerminalSymbols, CompilerModifiers,
        }
 
        private Expression expr() {
-               // r_variable
-               // | expr_without_variable
-               // if (token!=TokenNameEOF) {
-               if (Scanner.TRACE) {
-                       System.out.println("TRACE: expr()");
-               }
-               return expr_without_variable(true, null);
-               // }
+               return expr_without_variable(true, null, false);
        }
 
-       private Expression expr_without_variable(boolean only_variable,
-                       UninitializedVariableHandler initHandler) {
-               int exprSourceStart = scanner.getCurrentTokenStartPosition();
-               int exprSourceEnd = scanner.getCurrentTokenEndPosition();
-               Expression expression = new Expression();
+       /**
+        *
+        * @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;
-               // default, may be overwritten
-               expression.sourceEnd = exprSourceEnd;
+               expression.sourceEnd   = exprSourceEnd;                     // default, may be overwritten
+
                try {
                        // internal_functions_in_yacc
                        // | T_CLONE expr
@@ -2442,461 +2665,502 @@ public class Parser implements ITerminalSymbols, CompilerModifiers,
                        if (Scanner.TRACE) {
                                System.out.println("TRACE: expr_without_variable() PART 1");
                        }
+
                        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:
-                               getNextToken();
-                               if (token != TokenNameLPAREN) {
-                                       throwSyntaxError("'(' expected after keyword 'empty'");
-                               }
-                               getNextToken();
-                               variable(true, false);
-                               if (token != TokenNameRPAREN) {
-                                       throwSyntaxError("')' expected after keyword 'empty'");
-                               }
-                               getNextToken();
-                               break;
-                       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) {
-                                       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) + " )");
-                       // }
-                       // }
-                       // } finally {
-                       // scanner.encapsedStringStack.pop();
-                       // getNextToken();
-                       // }
-                       // break;
-                       // // | '\'' encaps_list '\''
-                       // case TokenNameEncapsedString1:
-                       // scanner.encapsedStringStack.push(new Character('\''));
-                       // getNextToken();
-                       // try {
-                       // exprSourceStart = scanner.getCurrentTokenStartPosition();
-                       // if (token == TokenNameEncapsedString1) {
-                       // expression = new
-                       // StringLiteralSQ(scanner.getCurrentStringLiteralSource(exprSourceStart),
-                       // exprSourceStart, scanner
-                       // .getCurrentTokenEndPosition());
-                       // } else {
-                       // encaps_list();
-                       // if (token != TokenNameEncapsedString1) {
-                       // 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 TokenNameEncapsedString2:
-                       // scanner.encapsedStringStack.push(new Character('"'));
-                       // getNextToken();
-                       // try {
-                       // exprSourceStart = scanner.getCurrentTokenStartPosition();
-                       // if (token == TokenNameEncapsedString2) {
-                       // expression = new
-                       // StringLiteralDQ(scanner.getCurrentStringLiteralSource(exprSourceStart),
-                       // exprSourceStart, scanner
-                       // .getCurrentTokenEndPosition());
-                       // } else {
-                       // encaps_list();
-                       // if (token != TokenNameEncapsedString2) {
-                       // 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 TokenNameStringDoubleQuote:
-                               expression = new StringLiteralDQ(scanner
-                                               .getCurrentStringLiteralSource(), scanner
-                                               .getCurrentTokenStartPosition(), scanner
-                                               .getCurrentTokenEndPosition());
-                               common_scalar();
-                               break;
-                       case TokenNameStringSingleQuote:
-                               expression = new StringLiteralSQ(scanner
-                                               .getCurrentStringLiteralSource(), scanner
-                                               .getCurrentTokenStartPosition(), scanner
-                                               .getCurrentTokenEndPosition());
-                               common_scalar();
-                               break;
-                       case TokenNameIntegerLiteral:
-                       case TokenNameDoubleLiteral:
-                       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) {
+                               case ISSET:
+                                       // T_ISSET '(' isset_variables ')'
                                        getNextToken();
-                                       if (token == TokenNameRPAREN) {
-                                               getNextToken();
-                                               break;
+                                       if (token != TokenName.LPAREN) {
+                                               throwSyntaxError("'(' expected after keyword 'isset'");
                                        }
-                                       array_pair_list();
-                                       if (token != TokenNameRPAREN) {
-                                               throwSyntaxError("')' or ',' expected after keyword 'array'"
-                                                               + "(Found token: "
-                                                               + scanner.toStringAction(token) + ")");
+                                       getNextToken();
+                                       isset_variables();
+                                       if (token != TokenName.RPAREN) {
+                                               throwSyntaxError("')' expected after keyword 'isset'");
                                        }
                                        getNextToken();
-                               } else {
-                                       throwSyntaxError("'(' expected after keyword 'array'"
-                                                       + "(Found token: " + scanner.toStringAction(token)
-                                                       + ")");
-                               }
-                               break;
-                       case TokenNamelist:
-                               // | T_LIST '(' assignment_list ')' '=' expr
-                               getNextToken();
-                               if (token == TokenNameLPAREN) {
+                                       break;
+                               case EMPTY:
                                        getNextToken();
-                                       assignment_list();
-                                       if (token != TokenNameRPAREN) {
-                                               throwSyntaxError("')' expected after 'list' keyword.");
+                                       if (token != TokenName.LPAREN) {
+                                               throwSyntaxError("'(' expected after keyword 'empty'");
                                        }
                                        getNextToken();
-                                       if (token != TokenNameEQUAL) {
-                                               throwSyntaxError("'=' expected after 'list' keyword.");
+                                       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();
                                        expr();
-                               } else {
-                                       throwSyntaxError("'(' expected after 'list' keyword.");
-                               }
-                               break;
-                       case TokenNamenew:
-                               // | 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 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:
-                               Expression lhs = null;
-                               boolean rememberedVar = false;
-                               if (token == TokenNameIdentifier) {
-                                       lhs = identifier(true, true);
-                                       if (lhs != null) {
-                                               expression = lhs;
+                                       if (token == TokenName.RPAREN) {
+                                               getNextToken();
+                                       } else {
+                                               throwSyntaxError("')' expected in expression.");
                                        }
-                               } else {
-                                       lhs = variable(true, true);
-                                       if (lhs != null) {
-                                               expression = lhs;
+                                       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();
+                                       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();
+                                       break;
+                               case ARRAY:
+                                       // T_ARRAY '(' array_pair_list ')'
+                                       getNextToken();
+                                       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)
+                                                               + ")");
                                        }
-                                       if (lhs != null && lhs instanceof FieldReference
-                                                       && token != TokenNameEQUAL
-                                                       && token != TokenNamePLUS_EQUAL
-                                                       && token != TokenNameMINUS_EQUAL
-                                                       && token != TokenNameMULTIPLY_EQUAL
-                                                       && token != TokenNameDIVIDE_EQUAL
-                                                       && token != TokenNameDOT_EQUAL
-                                                       && token != TokenNameREMAINDER_EQUAL
-                                                       && token != TokenNameAND_EQUAL
-                                                       && token != TokenNameOR_EQUAL
-                                                       && token != TokenNameXOR_EQUAL
-                                                       && token != TokenNameRIGHT_SHIFT_EQUAL
-                                                       && token != TokenNameLEFT_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);
+                                       break;
+                               case LIST:
+                                       // | T_LIST '(' assignment_list ')' '=' expr
+                                       getNextToken();
+                                       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();
+                                               expr();
+                                       } else {
+                                               throwSyntaxError("'(' expected after 'list' keyword.");
                                        }
-                               }
-                               switch (token) {
-                               case TokenNameEQUAL:
-                                       if (lhs != null && lhs instanceof FieldReference) {
-                                               addVariableSet(((FieldReference) lhs).token);
+                                       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();
-                                       if (token == TokenNameAND) {
-                                               getNextToken();
-                                               if (token == TokenNamenew) {
-                                                       // | 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;
-                                                                       }
+                                       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);
                                                        }
-                                               } 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;
+                                               }
+                                       }
+
+                                       switch (token) {
+                                               case EQUAL:
+                                                       if (lhs != null && lhs instanceof FieldReference) {
+                                                               addVariableSet(((FieldReference) lhs).token);
+                                                       }
+                                                       getNextToken();
+                                                       if (token == TokenName.OP_AND) {
+                                                               getNextToken();
+                                                               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 {
-                                               Expression rhs = expr();
-                                               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 {
+                                                               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;
+                                                                               }
                                                                        }
                                                                }
-                                                       } else if (rhs != null
-                                                                       && rhs instanceof SingleTypeReference) {
-                                                               // example:
-                                                               // $var = new Object();
+                                                       }
+                                                       if (rememberedVar == false && lhs != null
+                                                                       && lhs instanceof FieldReference) {
                                                                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;
+                                                                       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;
                                                }
-                                       }
-                                       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);
-                                               }
+                                               methodDecl.declarationSourceEnd = sourceEnd;
+                                               methodDecl.sourceEnd = sourceEnd;
                                        }
                                        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:
-                                       if (lhs != null && lhs instanceof FieldReference) {
-                                               addVariableSet(((FieldReference) lhs).token);
+
+                               case STATIC:
+                                       getNextToken ();
+                                       if (token == TokenName.PAAMAYIM_NEKUDOTAYIM) {
+                                               getNextToken ();
+                                               expr_without_variable (only_variable, initHandler, bColonAllowed);
+                                       }
+                                       else {
+                                               throwSyntaxError("Error in expression (Expected '::' after 'static').");
                                        }
-                                       getNextToken();
-                                       expr();
-                                       break;
-                               case TokenNamePLUS_PLUS:
-                               case TokenNameMINUS_MINUS:
-                                       getNextToken();
                                        break;
+                                                                               
                                default:
-                                       if (!only_variable) {
-                                               throwSyntaxError("Variable expression not allowed (found token '"
-                                                               + scanner.toStringAction(token) + "').");
-                                       }
-                                       if (lhs != null) {
-                                               expression = lhs;
-                                       }
-                               }
-                               break;
-                       default:
-                               if (token != TokenNameINLINE_HTML) {
-                                       if (token > TokenNameKEYWORD) {
-                                               getNextToken();
-                                               break;
-                                       } else {
-                                               // System.out.println(scanner.getCurrentTokenStartPosition());
-                                               // System.out.println(scanner.getCurrentTokenEndPosition());
+                                       if (token != TokenName.INLINE_HTML) {
+                                               if (token.compareTo (TokenName.KEYWORD) > 0) {
+                                                       getNextToken();
+                                                       break;
+                                               } else {
+                                                       // System.out.println(scanner.getCurrentTokenStartPosition());
+                                                       // System.out.println(scanner.getCurrentTokenEndPosition());
 
-                                               throwSyntaxError("Error in expression (found token '"
-                                                               + scanner.toStringAction(token) + "').");
+                                                       throwSyntaxError("Error in expression (found token '"
+                                                                       + scanner.toStringAction(token) + "').");
+                                               }
                                        }
-                               }
-                               return expression;
-                       }
+                                       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
@@ -2923,80 +3187,145 @@ public class Parser implements ITerminalSymbols, CompilerModifiers,
                        // | expr T_IS_GREATER_OR_EQUAL expr
                        while (true) {
                                switch (token) {
-                               case TokenNameOR_OR:
-                                       getNextToken();
-                                       expression = new OR_OR_Expression(expression, expr(), token);
-                                       break;
-                               case TokenNameAND_AND:
-                                       getNextToken();
-                                       expression = new AND_AND_Expression(expression, expr(),
-                                                       token);
-                                       break;
-                               case TokenNameEQUAL_EQUAL:
-                                       getNextToken();
-                                       expression = new EqualExpression(expression, expr(), token);
-                                       break;
-                               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 TokenNameNOT_EQUAL:
-                               case TokenNameLESS:
-                               case TokenNameLESS_EQUAL:
-                               case TokenNameGREATER:
-                               case TokenNameGREATER_EQUAL:
-                                       getNextToken();
-                                       expression = new BinaryExpression(expression, expr(), token);
-                                       break;
-                               // | expr T_INSTANCEOF class_name_reference
-                               // | expr '?' expr ':' expr
-                               case TokenNameinstanceof:
-                                       getNextToken();
-                                       TypeReference classRef = class_name_reference();
-                                       if (classRef != null) {
-                                               expression = new InstanceOfExpression(expression,
-                                                               classRef, OperatorIds.INSTANCEOF);
-                                               expression.sourceStart = exprSourceStart;
-                                               expression.sourceEnd = scanner
-                                                               .getCurrentTokenEndPosition();
-                                       }
-                                       break;
-                               case TokenNameQUESTION:
-                                       getNextToken();
-                                       Expression valueIfTrue = expr();
-                                       if (token != TokenNameCOLON) {
-                                               throwSyntaxError("':' expected in conditional expression.");
-                                       }
-                                       getNextToken();
-                                       Expression valueIfFalse = expr();
+                                       case OR_OR:
+                                               getNextToken();
+                                               expression = new OR_OR_Expression(expression, expr_without_variable (only_variable, initHandler, bColonAllowed), OperatorIds.OR_OR);
+                                               break;
+                                       case AND_AND:
+                                               getNextToken();
+                                               expression = new AND_AND_Expression(expression, expr_without_variable (only_variable, initHandler, bColonAllowed), OperatorIds.AND_AND);
+                                               break;
+                                       case EQUAL_EQUAL:
+                                               getNextToken();
+                                               expression = new EqualExpression(expression, expr_without_variable (only_variable, initHandler, bColonAllowed), OperatorIds.EQUAL_EQUAL);
+                                               break;
+                                       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();
 
-                                       expression = new ConditionalExpression(expression,
-                                                       valueIfTrue, valueIfFalse);
-                                       break;
-                               default:
-                                       return expression;
-                               }
-                       }
+                                               if (classRef != null) {
+                                                       expression = new InstanceOfExpression (expression, classRef, OperatorIds.INSTANCEOF);
+                                                       expression.sourceStart = exprSourceStart;
+                                                       expression.sourceEnd = scanner.getCurrentTokenEndPosition();
+                                               }
+                                               break;
+
+                                       case TERNARY_SHORT:
+                                               getNextToken();
+                                               expression = new EqualExpression(expression, expr_without_variable (only_variable, initHandler, bColonAllowed), OperatorIds.TERNARY_SHORT);
+                                               break;
+
+                                       case QUESTION:
+                                               getNextToken();
+                                               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 == TokenNameSEMICOLON) {
+                       if (token == TokenName.SEMICOLON) {
                                getNextToken();
                                return expression;
                        }
-                       if (token == TokenNameRBRACE || token == TokenNameRPAREN
-                                       || token == TokenNameRBRACKET) {
+
+                       if (token == TokenName.RBRACE ||
+                           token == TokenName.RPAREN ||
+                               token == TokenName.RBRACKET) {
                                getNextToken();
                                return expression;
                        }
@@ -3004,6 +3333,9 @@ public class Parser implements ITerminalSymbols, CompilerModifiers,
                }
        }
 
+       /**
+        *
+        */
        private SingleTypeReference class_name_reference() {
                // class_name_reference:
                // T_STRING
@@ -3012,15 +3344,15 @@ public class Parser implements ITerminalSymbols, CompilerModifiers,
                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 == TokenNamePAAMAYIM_NEKUDOTAYIM) {
+                       if (token == TokenName.PAAMAYIM_NEKUDOTAYIM) {
                                // Not terminated by T_STRING, reduce to dynamic_class_name_reference
                                scanner.currentPosition = pos;
-                               token = TokenNameIdentifier;
+                               token = TokenName.IDENTIFIER;
                                ref = null;
                                dynamic_class_name_reference();
                        }
@@ -3040,7 +3372,7 @@ public class Parser implements ITerminalSymbols, CompilerModifiers,
                        System.out.println("TRACE: dynamic_class_name_reference()");
                }
                base_variable(true);
-               if (token == TokenNameMINUS_GREATER) {
+               if (token == TokenName.MINUS_GREATER) {
                        getNextToken();
                        object_property();
                        dynamic_class_name_variable_properties();
@@ -3056,7 +3388,7 @@ public class Parser implements ITerminalSymbols, CompilerModifiers,
                        System.out
                                        .println("TRACE: dynamic_class_name_variable_properties()");
                }
-               while (token == TokenNameMINUS_GREATER) {
+               while (token == TokenName.MINUS_GREATER) {
                        dynamic_class_name_variable_property();
                }
        }
@@ -3067,7 +3399,7 @@ public class Parser implements ITerminalSymbols, CompilerModifiers,
                if (Scanner.TRACE) {
                        System.out.println("TRACE: dynamic_class_name_variable_property()");
                }
-               if (token == TokenNameMINUS_GREATER) {
+               if (token == TokenName.MINUS_GREATER) {
                        getNextToken();
                        object_property();
                }
@@ -3077,14 +3409,14 @@ public class Parser implements ITerminalSymbols, CompilerModifiers,
                // ctor_arguments:
                // /* empty */
                // | '(' function_call_parameter_list ')'
-               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 ctor_arguments.");
                        }
                        getNextToken();
@@ -3097,7 +3429,7 @@ public class Parser implements ITerminalSymbols, CompilerModifiers,
                // | assignment_list_element
                while (true) {
                        assignment_list_element();
-                       if (token != TokenNameCOMMA) {
+                       if (token != TokenName.COMMA) {
                                break;
                        }
                        getNextToken();
@@ -3109,19 +3441,19 @@ public class Parser implements ITerminalSymbols, CompilerModifiers,
                // variable
                // | T_LIST '(' assignment_list ')'
                // | /* empty */
-               if (token == TokenNameVariable) {
+               if (token == TokenName.VARIABLE) {
                        variable(true, false);
-               } else if (token == TokenNameDOLLAR) {
+               } else if (token == TokenName.DOLLAR) {
                        variable(false, false);
-               } else if (token == TokenNameIdentifier) {
-                       identifier(true, true);
+               } 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();
@@ -3137,7 +3469,7 @@ public class Parser implements ITerminalSymbols, CompilerModifiers,
                // /* empty */
                // | non_empty_array_pair_list possible_comma
                non_empty_array_pair_list();
-               if (token == TokenNameCOMMA) {
+               if (token == TokenName.COMMA) {
                        getNextToken();
                }
        }
@@ -3153,17 +3485,17 @@ public class Parser implements ITerminalSymbols, CompilerModifiers,
                // | expr T_DOUBLE_ARROW '&' w_variable
                // | '&' w_variable
                while (true) {
-                       if (token == TokenNameAND) {
+                       if (token == TokenName.OP_AND) {
                                getNextToken();
                                variable(true, false);
                        } else {
                                expr();
-                               if (token == TokenNameAND) {
+                               if (token == TokenName.OP_AND) {
                                        getNextToken();
                                        variable(true, false);
-                               } else if (token == TokenNameEQUAL_GREATER) {
+                               } else if (token == TokenName.EQUAL_GREATER) {
                                        getNextToken();
-                                       if (token == TokenNameAND) {
+                                       if (token == TokenName.OP_AND) {
                                                getNextToken();
                                                variable(true, false);
                                        } else {
@@ -3171,11 +3503,11 @@ public class Parser implements ITerminalSymbols, CompilerModifiers,
                                        }
                                }
                        }
-                       if (token != TokenNameCOMMA) {
+                       if (token != TokenName.COMMA) {
                                return;
                        }
                        getNextToken();
-                       if (token == TokenNameRPAREN) {
+                       if (token == TokenName.RPAREN) {
                                return;
                        }
                }
@@ -3184,7 +3516,7 @@ public class Parser implements ITerminalSymbols, CompilerModifiers,
        // private void variableList() {
        // do {
        // variable();
-       // if (token == TokenNameCOMMA) {
+       // if (token == TokenName.COMMA) {
        // getNextToken();
        // } else {
        // break;
@@ -3199,7 +3531,7 @@ public class Parser implements ITerminalSymbols, CompilerModifiers,
                if (Scanner.TRACE) {
                        System.out.println("TRACE: variable_without_objects()");
                }
-               while (token == TokenNameDOLLAR) {
+               while (token == TokenName.DOLLAR) {
                        getNextToken();
                }
                return reference_variable(lefthandside, ignoreVar);
@@ -3219,18 +3551,18 @@ public class Parser implements ITerminalSymbols, CompilerModifiers,
                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:
+                       case PAAMAYIM_NEKUDOTAYIM:
                                // static member:
                                defineName = null;
                                getNextToken();
-                               if (token == TokenNameIdentifier) {
+                               if (token == TokenName.IDENTIFIER) {
                                        // class _constant
                                        getNextToken();
                                } else {
@@ -3242,26 +3574,33 @@ public class Parser implements ITerminalSymbols, CompilerModifiers,
                } else {
                        ref = variable_without_objects(lefthandside, ignoreVar);
                }
-               if (token != TokenNameLPAREN) {
+               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') {
+                                       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') {
+                                       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') {
+                                       } 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') {
+                                       if (defineName[0] == 'f' &&
+                                           defineName[1] == 'a' &&
+                                               defineName[2] == 'l' &&
+                                               defineName[3] == 's' &&
+                                               defineName[4] == 'e') {
                                                defineName = null;
                                        }
                                }
@@ -3278,20 +3617,23 @@ public class Parser implements ITerminalSymbols, CompilerModifiers,
                        }
                } else {
                        getNextToken();
-                       if (token == TokenNameRPAREN) {
+                       if (token == TokenName.RPAREN) {
                                getNextToken();
                                return ref;
                        }
+
                        non_empty_function_call_parameter_list();
-                       if (token != TokenNameRPAREN) {
+
+                       if (token != TokenName.RPAREN) {
                                String functionName;
+
                                if (ident == null) {
                                        functionName = new String(" ");
                                } else {
                                        functionName = new String(ident);
                                }
-                               throwSyntaxError("')' expected in function call ("
-                                               + functionName + ").");
+
+                               throwSyntaxError("')' expected in function call (" + functionName + ").");
                        }
                        getNextToken();
                }
@@ -3323,19 +3665,19 @@ public class Parser implements ITerminalSymbols, CompilerModifiers,
                initHandler.setFunctionName(functionName);
                while (true) {
                        initHandler.incrementArgumentCount();
-                       if (token == TokenNameAND) {
+                       if (token == TokenName.OP_AND) {
                                getNextToken();
                                w_variable(true);
                        } else {
-                               // if (token == TokenNameIdentifier || token ==
-                               // TokenNameVariable
-                               // || token == TokenNameDOLLAR) {
+                               // if (token == TokenName.Identifier || token ==
+                               // TokenName.Variable
+                               // || token == TokenName.DOLLAR) {
                                // variable();
                                // } else {
-                               expr_without_variable(true, initHandler);
+                               expr_without_variable(true, initHandler, false);
                                // }
                        }
-                       if (token != TokenNameCOMMA) {
+                       if (token != TokenName.COMMA) {
                                break;
                        }
                        getNextToken();
@@ -3343,7 +3685,7 @@ public class Parser implements ITerminalSymbols, CompilerModifiers,
        }
 
        private void fully_qualified_class_name() {
-               if (token == TokenNameIdentifier) {
+               if (token == TokenName.IDENTIFIER) {
                        getNextToken();
                } else {
                        throwSyntaxError("Class name expected.");
@@ -3358,41 +3700,56 @@ public class Parser implements ITerminalSymbols, CompilerModifiers,
                        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(false, false);
        }
 
-       private Expression base_variable_with_function_calls(boolean lefthandside,
-                       boolean ignoreVar) {
-               // base_variable_with_function_calls:
-               // base_variable
-               // | function_call
+       /**
+        * 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()");
                }
+
                return function_call(lefthandside, ignoreVar);
        }
 
-       private Expression base_variable(boolean lefthandside) {
-               // base_variable:
-               // reference_variable
-               // | simple_indirect_reference reference_variable
-               // | static_member
+       /**
+        * 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(lefthandside, false);
+
+                       reference_variable (lefthandside, false);
                }
+
                return ref;
        }
 
@@ -3401,8 +3758,7 @@ public class Parser implements ITerminalSymbols, CompilerModifiers,
        // // '$'
        // //| simple_indirect_reference '$'
        // }
-       private Expression reference_variable(boolean lefthandside,
-                       boolean ignoreVar) {
+       private Expression reference_variable (boolean lefthandside, boolean ignoreVar) {
                // reference_variable:
                // reference_variable '[' dim_offset ']'
                // | reference_variable '{' expr '}'
@@ -3413,23 +3769,23 @@ public class Parser implements ITerminalSymbols, CompilerModifiers,
                }
                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) {
+                                       if (token != TokenName.RBRACKET) {
                                                throwSyntaxError("']' expected in reference variable.");
                                        }
                                }
@@ -3441,51 +3797,59 @@ public class Parser implements ITerminalSymbols, CompilerModifiers,
                return ref;
        }
 
-       private Expression compound_variable(boolean lefthandside, boolean ignoreVar) {
+       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);
+                                       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());
+
+                       FieldReference ref = new FieldReference (scanner.getCurrentIdentifierSource(),
+                                                                                                        scanner.getCurrentTokenStartPosition());
                        getNextToken();
                        return ref;
-               } else {
+               }
+               else {
                        // because of simple_indirect_reference
-                       while (token == TokenNameDOLLAR) {
+                       while (token == TokenName.DOLLAR) {
                                getNextToken();
                        }
-                       if (token != TokenNameLBRACE) {
+
+                       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();
                }
+
                return null;
        } // private void dim_offset() { // // dim_offset: // // /* empty */
 
@@ -3499,9 +3863,12 @@ public class Parser implements ITerminalSymbols, CompilerModifiers,
                if (Scanner.TRACE) {
                        System.out.println("TRACE: object_property()");
                }
-               if (token == TokenNameVariable || token == TokenNameDOLLAR) {
-                       variable_without_objects(false, false);
-               } else {
+
+               if ((token == TokenName.VARIABLE) ||
+                       (token == TokenName.DOLLAR)) {
+                       variable_without_objects (false, false);
+               }
+               else {
                        object_dim_list();
                }
        }
@@ -3514,27 +3881,37 @@ public class Parser implements ITerminalSymbols, CompilerModifiers,
                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;
                        }
                }
@@ -3547,20 +3924,32 @@ public class Parser implements ITerminalSymbols, CompilerModifiers,
                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();
                }
        }
@@ -3577,20 +3966,32 @@ public class Parser implements ITerminalSymbols, CompilerModifiers,
                variable(false, false);
        }
 
-       private Expression variable(boolean lefthandside, boolean ignoreVar) {
-               // variable:
-               // base_variable_with_function_calls T_OBJECT_OPERATOR
-               // object_property method_or_not variable_properties
-               // | base_variable_with_function_calls
-               Expression ref = base_variable_with_function_calls(lefthandside,
-                               ignoreVar);
-               if (token == TokenNameMINUS_GREATER) {
-                       ref = null;
+       /**
+        *
+        * 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();
                }
+
                return ref;
        }
 
@@ -3598,7 +3999,7 @@ public class Parser implements ITerminalSymbols, CompilerModifiers,
                // variable_properties:
                // variable_properties variable_property
                // | /* empty */
-               while (token == TokenNameMINUS_GREATER) {
+               while (token == TokenName.MINUS_GREATER) {
                        variable_property();
                }
        }
@@ -3609,144 +4010,203 @@ public class Parser implements ITerminalSymbols, CompilerModifiers,
                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.");
                }
        }
 
-       private Expression identifier(boolean lefthandside, boolean ignoreVar) {
-               // 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 ')'
+       /**
+        *
+        * 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;
+               char[] ident      = null;
+               int startPos      = 0;
+               int endPos        = 0;
+               Expression ref    = null;
+
                if (Scanner.TRACE) {
                        System.out.println("TRACE: function_call()");
                }
-               if (token == TokenNameIdentifier) {
-                       ident = scanner.getCurrentIdentifierSource();
+
+               if (token == TokenName.IDENTIFIER) {
+                       ident      = scanner.getCurrentIdentifierSource();
                        defineName = ident;
-                       startPos = scanner.getCurrentTokenStartPosition();
-                       endPos = scanner.getCurrentTokenEndPosition();
-                       getNextToken();
+                       startPos   = scanner.getCurrentTokenStartPosition();
+                       endPos     = scanner.getCurrentTokenEndPosition();
 
-                       if (token == TokenNameEQUAL || token == TokenNamePLUS_EQUAL
-                                       || token == TokenNameMINUS_EQUAL
-                                       || token == TokenNameMULTIPLY_EQUAL
-                                       || token == TokenNameDIVIDE_EQUAL
-                                       || token == TokenNameDOT_EQUAL
-                                       || token == TokenNameREMAINDER_EQUAL
-                                       || token == TokenNameAND_EQUAL
-                                       || token == TokenNameOR_EQUAL
-                                       || token == TokenNameXOR_EQUAL
-                                       || token == TokenNameRIGHT_SHIFT_EQUAL
-                                       || token == TokenNameLEFT_SHIFT_EQUAL) {
-                               String error = "Assignment operator '"
-                                               + scanner.toStringAction(token)
-                                               + "' not allowed after identifier '"
-                                               + new String(ident)
-                                               + "' (use 'define(...)' to define constants).";
-                               reportSyntaxError(error);
-                       }
+                       getNextToken();              // Get the token after the identifier
 
                        switch (token) {
-                       case TokenNamePAAMAYIM_NEKUDOTAYIM:
-                               // static member:
-                               defineName = null;
-                               getNextToken();
-                               if (token == TokenNameIdentifier) {
-                                       // class _constant
-                                       getNextToken();
-                               } else {
-                                       // static member:
-                                       variable_without_objects(true, false);
-                               }
-                               break;
-                       }
-               } else {
+                               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 != TokenNameLPAREN) {
-                       if (defineName != null) {
-                               // does this identifier contain only uppercase characters?
-                               if (defineName.length == 3) {
-                                       if (defineName[0] == 'd' && defineName[1] == 'i'
-                                                       && defineName[2] == 'e') {
+
+               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 (defineName[0] == 't' && defineName[1] == 'r'
-                                                       && defineName[2] == 'u' && defineName[3] == 'e') {
+                               }
+                               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' && defineName[1] == 'u'
-                                                       && defineName[2] == 'l' && defineName[3] == 'l') {
+                                       }
+                                       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 (defineName[0] == 'f' && defineName[1] == 'a'
-                                                       && defineName[2] == 'l' && defineName[3] == 's'
-                                                       && defineName[4] == 'e') {
+                               }
+                               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;
-                                               }
-                                       }
+                                   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.");
-               } else {
-                       getNextToken();
-
-                       if (token == TokenNameRPAREN) {
-                               getNextToken();
-                               ref = null;
-                       } else {
-                               String functionName;
-                               if (ident == null) {
-                                       functionName = new String(" ");
-                               } else {
-                                       functionName = new String(ident);
-                               }
-                               non_empty_function_call_parameter_list(functionName);
-                               if (token != TokenNameRPAREN) {
-                                       throwSyntaxError("')' expected in function call ("
-                                                       + functionName + ").");
-                               }
-                               getNextToken();
-                       }
                }
-               if (token == TokenNameMINUS_GREATER) {
+
+               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;
        }
 
@@ -3757,14 +4217,14 @@ public class Parser implements ITerminalSymbols, CompilerModifiers,
                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();
@@ -3775,16 +4235,16 @@ public class Parser implements ITerminalSymbols, CompilerModifiers,
                // /* empty */
                // | '(' ')'
                // | '(' expr ')'
-               if (token != TokenNameLPAREN) {
+               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();
@@ -3805,32 +4265,32 @@ public class Parser implements ITerminalSymbols, CompilerModifiers,
        // // | /* empty */
        // while (true) {
        // switch (token) {
-       // case TokenNameSTRING:
+       // case TokenName.STRING:
        // getNextToken();
        // break;
-       // case TokenNameLBRACE:
+       // case TokenName.LBRACE:
        // // scanner.encapsedStringStack.pop();
        // getNextToken();
        // break;
-       // case TokenNameRBRACE:
+       // case TokenName.RBRACE:
        // // scanner.encapsedStringStack.pop();
        // getNextToken();
        // break;
-       // case TokenNameLBRACKET:
+       // case TokenName.LBRACKET:
        // // scanner.encapsedStringStack.pop();
        // getNextToken();
        // break;
-       // case TokenNameRBRACKET:
+       // case TokenName.RBRACKET:
        // // scanner.encapsedStringStack.pop();
        // getNextToken();
        // break;
-       // case TokenNameMINUS_GREATER:
+       // case TokenName.MINUS_GREATER:
        // // scanner.encapsedStringStack.pop();
        // getNextToken();
        // break;
-       // case TokenNameVariable:
-       // case TokenNameDOLLAR_LBRACE:
-       // case TokenNameLBRACE_DOLLAR:
+       // case TokenName.Variable:
+       // case TokenName.DOLLAR_LBRACE:
+       // case TokenName.LBRACE_DOLLAR:
        // encaps_var();
        // break;
        // default:
@@ -3842,22 +4302,22 @@ public class Parser implements ITerminalSymbols, CompilerModifiers,
        // scanner.encapsedStringStack.peek()).charValue();
        // switch (encapsedChar) {
        // case '`':
-       // if (token == TokenNameEncapsedString0) {
+       // if (token == TokenName.EncapsedString0) {
        // return;
        // }
-       // token = TokenNameSTRING;
+       // token = TokenName.STRING;
        // continue;
        // case '\'':
-       // if (token == TokenNameEncapsedString1) {
+       // if (token == TokenName.EncapsedString1) {
        // return;
        // }
-       // token = TokenNameSTRING;
+       // token = TokenName.STRING;
        // continue;
        // case '"':
-       // if (token == TokenNameEncapsedString2) {
+       // if (token == TokenName.EncapsedString2) {
        // return;
        // }
-       // token = TokenNameSTRING;
+       // token = TokenName.STRING;
        // continue;
        // }
        // }
@@ -3874,20 +4334,20 @@ public class Parser implements ITerminalSymbols, CompilerModifiers,
        // // | T_DOLLAR_OPEN_CURLY_BRACES T_STRING_VARNAME '[' expr ']' '}'
        // // | T_CURLY_OPEN variable '}'
        // switch (token) {
-       // case TokenNameVariable:
+       // case TokenName.Variable:
        // getNextToken();
-       // if (token == TokenNameLBRACKET) {
+       // if (token == TokenName.LBRACKET) {
        // getNextToken();
        // expr(); //encaps_var_offset();
-       // if (token != TokenNameRBRACKET) {
+       // if (token != TokenName.RBRACKET) {
        // throwSyntaxError("']' expected after variable.");
        // }
        // // scanner.encapsedStringStack.pop();
        // getNextToken();
        // // }
-       // } else if (token == TokenNameMINUS_GREATER) {
+       // } else if (token == TokenName.MINUS_GREATER) {
        // getNextToken();
-       // if (token != TokenNameIdentifier) {
+       // if (token != TokenName.Identifier) {
        // throwSyntaxError("Identifier expected after '->'.");
        // }
        // // scanner.encapsedStringStack.pop();
@@ -3895,32 +4355,32 @@ public class Parser implements ITerminalSymbols, CompilerModifiers,
        // }
        // // else {
        // // // scanner.encapsedStringStack.pop();
-       // // int tempToken = TokenNameSTRING;
+       // // int tempToken = TokenName.STRING;
        // // if (!scanner.encapsedStringStack.isEmpty()
-       // // && (token == TokenNameEncapsedString0
-       // // || token == TokenNameEncapsedString1
-       // // || token == TokenNameEncapsedString2 || token ==
-       // // TokenNameERROR)) {
+       // // && (token == TokenName.EncapsedString0
+       // // || token == TokenName.EncapsedString1
+       // // || token == TokenName.EncapsedString2 || token ==
+       // // TokenName.ERROR)) {
        // // char encapsedChar = ((Character)
        // // scanner.encapsedStringStack.peek())
        // // .charValue();
        // // switch (token) {
-       // // case TokenNameEncapsedString0 :
+       // // case TokenName.EncapsedString0 :
        // // if (encapsedChar == '`') {
-       // // tempToken = TokenNameEncapsedString0;
+       // // tempToken = TokenName.EncapsedString0;
        // // }
        // // break;
-       // // case TokenNameEncapsedString1 :
+       // // case TokenName.EncapsedString1 :
        // // if (encapsedChar == '\'') {
-       // // tempToken = TokenNameEncapsedString1;
+       // // tempToken = TokenName.EncapsedString1;
        // // }
        // // break;
-       // // case TokenNameEncapsedString2 :
+       // // case TokenName.EncapsedString2 :
        // // if (encapsedChar == '"') {
-       // // tempToken = TokenNameEncapsedString2;
+       // // tempToken = TokenName.EncapsedString2;
        // // }
        // // break;
-       // // case TokenNameERROR :
+       // // case TokenName.ERROR :
        // // if (scanner.source[scanner.currentPosition - 1] == '\\') {
        // // scanner.currentPosition--;
        // // getNextToken();
@@ -3931,19 +4391,19 @@ public class Parser implements ITerminalSymbols, CompilerModifiers,
        // // token = tempToken;
        // // }
        // break;
-       // case TokenNameDOLLAR_LBRACE:
+       // case TokenName.DOLLAR_LBRACE:
        // getNextToken();
-       // if (token == TokenNameDOLLAR_LBRACE) {
+       // if (token == TokenName.DOLLAR_LBRACE) {
        // encaps_var();
-       // } else if (token == TokenNameIdentifier) {
+       // } else if (token == TokenName.Identifier) {
        // getNextToken();
-       // if (token == TokenNameLBRACKET) {
+       // if (token == TokenName.LBRACKET) {
        // getNextToken();
-       // // if (token == TokenNameRBRACKET) {
+       // // if (token == TokenName.RBRACKET) {
        // // getNextToken();
        // // } else {
        // expr();
-       // if (token != TokenNameRBRACKET) {
+       // if (token != TokenName.RBRACKET) {
        // throwSyntaxError("']' expected after '${'.");
        // }
        // getNextToken();
@@ -3952,55 +4412,55 @@ public class Parser implements ITerminalSymbols, CompilerModifiers,
        // } else {
        // expr();
        // }
-       // if (token != TokenNameRBRACE) {
+       // if (token != TokenName.RBRACE) {
        // throwSyntaxError("'}' expected.");
        // }
        // getNextToken();
        // break;
-       // case TokenNameLBRACE_DOLLAR:
+       // case TokenName.LBRACE_DOLLAR:
        // getNextToken();
-       // if (token == TokenNameLBRACE_DOLLAR) {
+       // if (token == TokenName.LBRACE_DOLLAR) {
        // encaps_var();
-       // } else if (token == TokenNameIdentifier || token > TokenNameKEYWORD) {
+       // } else if (token == TokenName.Identifier || token > TokenName.KEYWORD) {
        // getNextToken();
-       // if (token == TokenNameLBRACKET) {
+       // if (token == TokenName.LBRACKET) {
        // getNextToken();
-       // // if (token == TokenNameRBRACKET) {
+       // // if (token == TokenName.RBRACKET) {
        // // getNextToken();
        // // } else {
        // expr();
-       // if (token != TokenNameRBRACKET) {
+       // if (token != TokenName.RBRACKET) {
        // throwSyntaxError("']' expected.");
        // }
        // getNextToken();
        // // }
-       // } else if (token == TokenNameMINUS_GREATER) {
+       // } else if (token == TokenName.MINUS_GREATER) {
        // getNextToken();
-       // if (token != TokenNameIdentifier && token != TokenNameVariable) {
+       // if (token != TokenName.Identifier && token != TokenName.Variable) {
        // throwSyntaxError("String or Variable token expected.");
        // }
        // getNextToken();
-       // if (token == TokenNameLBRACKET) {
+       // if (token == TokenName.LBRACKET) {
        // getNextToken();
-       // // if (token == TokenNameRBRACKET) {
+       // // if (token == TokenName.RBRACKET) {
        // // getNextToken();
        // // } else {
        // expr();
-       // if (token != TokenNameRBRACKET) {
+       // if (token != TokenName.RBRACKET) {
        // throwSyntaxError("']' expected after '${'.");
        // }
        // getNextToken();
        // // }
        // }
        // }
-       // // if (token != TokenNameRBRACE) {
+       // // if (token != TokenName.RBRACE) {
        // // throwSyntaxError("'}' expected after '{$'.");
        // // }
        // // // scanner.encapsedStringStack.pop();
        // // getNextToken();
        // } else {
        // expr();
-       // if (token != TokenNameRBRACE) {
+       // if (token != TokenName.RBRACE) {
        // throwSyntaxError("'}' expected.");
        // }
        // // scanner.encapsedStringStack.pop();
@@ -4015,16 +4475,16 @@ public class Parser implements ITerminalSymbols, CompilerModifiers,
        // // | T_NUM_STRING
        // // | T_VARIABLE
        // switch (token) {
-       // case TokenNameSTRING:
+       // case TokenName.STRING:
        // getNextToken();
        // break;
-       // case TokenNameIntegerLiteral:
+       // case TokenName.IntegerLiteral:
        // getNextToken();
        // break;
-       // case TokenNameVariable:
+       // case TokenName.Variable:
        // getNextToken();
        // break;
-       // case TokenNameIdentifier:
+       // case TokenName.Identifier:
        // getNextToken();
        // break;
        // default:
@@ -4033,61 +4493,64 @@ public class Parser implements ITerminalSymbols, CompilerModifiers,
        // }
        // }
 
+       /**
+        *
+        */
        private void internal_functions_in_yacc() {
                // int start = 0;
                switch (token) {
-               // case TokenNameisset:
+               // case TokenName.isset:
                // // T_ISSET '(' isset_variables ')'
                // getNextToken();
-               // if (token != TokenNameLPAREN) {
+               // if (token != TokenName.LPAREN) {
                // throwSyntaxError("'(' expected after keyword 'isset'");
                // }
                // getNextToken();
                // isset_variables();
-               // if (token != TokenNameRPAREN) {
+               // if (token != TokenName.RPAREN) {
                // throwSyntaxError("')' expected after keyword 'isset'");
                // }
                // getNextToken();
                // break;
-               // case TokenNameempty:
+               // case TokenName.empty:
                // // T_EMPTY '(' variable ')'
                // getNextToken();
-               // if (token != TokenNameLPAREN) {
+               // if (token != TokenName.LPAREN) {
                // throwSyntaxError("'(' expected after keyword 'empty'");
                // }
                // getNextToken();
                // variable(false);
-               // if (token != TokenNameRPAREN) {
+               // if (token != TokenName.RPAREN) {
                // throwSyntaxError("')' expected after keyword 'empty'");
                // }
                // getNextToken();
                // break;
-               case TokenNameinclude:
+               case INCLUDE:
                        // T_INCLUDE expr
                        checkFileName(token);
                        break;
-               case TokenNameinclude_once:
+               case INCLUDE_ONCE:
                        // T_INCLUDE_ONCE expr
                        checkFileName(token);
                        break;
-               case TokenNameeval:
+               case EVAL:
                        // T_EVAL '(' expr ')'
                        getNextToken();
-                       if (token != TokenNameLPAREN) {
+                       if (token != TokenName.LPAREN) {
                                throwSyntaxError("'(' expected after keyword 'eval'");
                        }
                        getNextToken();
                        expr();
-                       if (token != TokenNameRPAREN) {
+                       if (token != TokenName.RPAREN) {
                                throwSyntaxError("')' expected after keyword 'eval'");
                        }
                        getNextToken();
                        break;
-               case TokenNamerequire:
+               case REQUIRE:
                        // T_REQUIRE expr
                        checkFileName(token);
                        break;
-               case TokenNamerequire_once:
+               case REQUIRE_ONCE:
                        // T_REQUIRE_ONCE expr
                        checkFileName(token);
                        break;
@@ -4096,21 +4559,21 @@ public class Parser implements ITerminalSymbols, CompilerModifiers,
 
        /**
         * Parse and check the include file name
-        * 
+        *
         * @param includeToken
         */
-       private void checkFileName(int includeToken) {
+       private void checkFileName(TokenName includeToken) {
                // <include-token> expr
                int start = scanner.getCurrentTokenStartPosition();
                boolean hasLPAREN = false;
                getNextToken();
-               if (token == TokenNameLPAREN) {
+               if (token == TokenName.LPAREN) {
                        hasLPAREN = true;
                        getNextToken();
                }
                Expression expression = expr();
                if (hasLPAREN) {
-                       if (token == TokenNameRPAREN) {
+                       if (token == TokenName.RPAREN) {
                                getNextToken();
                        } else {
                                throwSyntaxError("')' expected for keyword '"
@@ -4201,12 +4664,12 @@ public class Parser implements ITerminalSymbols, CompilerModifiers,
        private void isset_variables() {
                // variable
                // | isset_variables ','
-               if (token == TokenNameRPAREN) {
+               if (token == TokenName.RPAREN) {
                        throwSyntaxError("Variable expected after keyword 'isset'");
                }
                while (true) {
                        variable(true, false);
-                       if (token == TokenNameCOMMA) {
+                       if (token == TokenName.COMMA) {
                                getNextToken();
                        } else {
                                break;
@@ -4225,34 +4688,34 @@ public class Parser implements ITerminalSymbols, CompilerModifiers,
                // | T_METHOD_C
                // | T_FUNC_C
                switch (token) {
-               case TokenNameIntegerLiteral:
+               case INTEGERLITERAL:
                        getNextToken();
                        return true;
-               case TokenNameDoubleLiteral:
+               case DOUBLELITERAL:
                        getNextToken();
                        return true;
-               case TokenNameStringDoubleQuote:
+               case STRINGDOUBLEQUOTE:
                        getNextToken();
                        return true;
-               case TokenNameStringSingleQuote:
+               case STRINGSINGLEQUOTE:
                        getNextToken();
                        return true;
-               case TokenNameStringInterpolated:
+               case STRINGINTERPOLATED:
                        getNextToken();
                        return true;
-               case TokenNameFILE:
+               case FILE:
                        getNextToken();
                        return true;
-               case TokenNameLINE:
+               case LINE:
                        getNextToken();
                        return true;
-               case TokenNameCLASS_C:
+               case CLASS_C:
                        getNextToken();
                        return true;
-               case TokenNameMETHOD_C:
+               case METHOD_C:
                        getNextToken();
                        return true;
-               case TokenNameFUNC_C:
+               case FUNC_C:
                        getNextToken();
                        return true;
                }
@@ -4283,20 +4746,20 @@ public class Parser implements ITerminalSymbols, CompilerModifiers,
                        return;
                }
                switch (token) {
-               case TokenNameIdentifier:
+               case IDENTIFIER:
                        getNextToken();
                        // static_class_constant:
                        // T_STRING T_PAAMAYIM_NEKUDOTAYIM T_STRING
-                       if (token == TokenNamePAAMAYIM_NEKUDOTAYIM) {
+                       if (token == TokenName.PAAMAYIM_NEKUDOTAYIM) {
                                getNextToken();
-                               if (token == TokenNameIdentifier) {
+                               if (token == TokenName.IDENTIFIER) {
                                        getNextToken();
                                } else {
                                        throwSyntaxError("Identifier expected after '::' operator.");
                                }
                        }
                        break;
-               case TokenNameEncapsedString0:
+               case ENCAPSEDSTRING0:
                        try {
                                scanner.currentCharacter = scanner.source[scanner.currentPosition++];
                                while (scanner.currentCharacter != '`') {
@@ -4310,7 +4773,7 @@ public class Parser implements ITerminalSymbols, CompilerModifiers,
                                throwSyntaxError("'`' expected at end of static string.");
                        }
                        break;
-               // case TokenNameEncapsedString1:
+               // case TokenName.EncapsedString1:
                // try {
                // scanner.currentCharacter = scanner.source[scanner.currentPosition++];
                // while (scanner.currentCharacter != '\'') {
@@ -4324,7 +4787,7 @@ public class Parser implements ITerminalSymbols, CompilerModifiers,
                // throwSyntaxError("'\'' expected at end of static string.");
                // }
                // break;
-               // case TokenNameEncapsedString2:
+               // case TokenName.EncapsedString2:
                // try {
                // scanner.currentCharacter = scanner.source[scanner.currentPosition++];
                // while (scanner.currentCharacter != '"') {
@@ -4338,43 +4801,43 @@ public class Parser implements ITerminalSymbols, CompilerModifiers,
                // throwSyntaxError("'\"' expected at end of static string.");
                // }
                // break;
-               case TokenNameStringSingleQuote:
+               case STRINGSINGLEQUOTE:
                        getNextToken();
                        break;
-               case TokenNameStringDoubleQuote:
+               case STRINGDOUBLEQUOTE:
                        getNextToken();
                        break;
-               case TokenNamePLUS:
+               case PLUS:
                        getNextToken();
                        static_scalar();
                        break;
-               case TokenNameMINUS:
+               case MINUS:
                        getNextToken();
                        static_scalar();
                        break;
-               case TokenNamearray:
+               case ARRAY:
                        getNextToken();
-                       if (token != TokenNameLPAREN) {
+                       if (token != TokenName.LPAREN) {
                                throwSyntaxError("'(' expected after keyword 'array'");
                        }
                        getNextToken();
-                       if (token == TokenNameRPAREN) {
+                       if (token == TokenName.RPAREN) {
                                getNextToken();
                                break;
                        }
                        non_empty_static_array_pair_list();
-                       if (token != TokenNameRPAREN) {
+                       if (token != TokenName.RPAREN) {
                                throwSyntaxError("')' or ',' expected after keyword 'array'");
                        }
                        getNextToken();
                        break;
-               // case TokenNamenull :
+               // case TokenName.null :
                // getNextToken();
                // break;
-               // case TokenNamefalse :
+               // case TokenName.false :
                // getNextToken();
                // break;
-               // case TokenNametrue :
+               // case TokenName.true :
                // getNextToken();
                // break;
                default:
@@ -4391,15 +4854,15 @@ public class Parser implements ITerminalSymbols, CompilerModifiers,
                // | 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;
                        }
                }
@@ -4945,17 +5408,17 @@ public class Parser implements ITerminalSymbols, CompilerModifiers,
        // 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 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) {
                /*
@@ -4994,13 +5457,13 @@ public class Parser implements ITerminalSymbols, CompilerModifiers,
                // incastrix
                //String projectPath = ProjectPrefUtil.getDocumentRoot(file.getProject())
                //              .toString();
-                String filePath = file.getFullPath().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()
@@ -5027,7 +5490,7 @@ public class Parser implements ITerminalSymbols, CompilerModifiers,
                        "$_SERVER" };
 
        /**
-        * 
+        *
         */
        private void pushFunctionVariableSet() {
                HashSet set = new HashSet();
@@ -5068,7 +5531,7 @@ public class Parser implements ITerminalSymbols, CompilerModifiers,
        /**
         * add the current identifier source to the <i>set of assigned variables
         * </i>
-        * 
+        *
         * @param set
         */
        private void addVariableSet(HashSet set) {
@@ -5080,7 +5543,7 @@ public class Parser implements ITerminalSymbols, CompilerModifiers,
        /**
         * add the current identifier source to the <i>set of assigned variables
         * </i>
-        * 
+        *
         */
        private void addVariableSet() {
                HashSet set = peekVariableSet();
@@ -5092,7 +5555,7 @@ public class Parser implements ITerminalSymbols, CompilerModifiers,
        /**
         * add the current identifier source to the <i>set of assigned variables
         * </i>
-        * 
+        *
         */
        private void addVariableSet(char[] token) {
                HashSet set = peekVariableSet();
@@ -5105,7 +5568,7 @@ public class Parser implements ITerminalSymbols, CompilerModifiers,
         * 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());
@@ -5126,4 +5589,4 @@ public class Parser implements ITerminalSymbols, CompilerModifiers,
                }
                return true;
        }
-}
\ No newline at end of file
+}