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