net.sourceforge.phpeclipse/src/net/sourceforge/phpdt/internal/compiler/parser/Parser.java

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