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

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