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

   1 /**********************************************************************
   2 Copyright (c) 2002 Klaus Hartlage - www.eclipseproject.de
   3 All rights reserved. This program and the accompanying materials
   4 are made available under the terms of the Common Public License v1.0
   5 which accompanies this distribution, and is available at
   6 http://www.eclipse.org/legal/cpl-v10.html
   7
   8 Contributors:
   9     Klaus Hartlage - www.eclipseproject.de
  10 **********************************************************************/
  11 package net.sourceforge.phpdt.internal.compiler.parser;
  12
  13 import java.util.ArrayList;
  14
  15 import net.sourceforge.phpdt.core.compiler.ITerminalSymbols;
  16 import net.sourceforge.phpdt.core.compiler.InvalidInputException;
  17 import net.sourceforge.phpeclipse.PHPeclipsePlugin;
  18 import net.sourceforge.phpeclipse.phpeditor.PHPString;
  19
  20 import org.eclipse.core.resources.IFile;
  21 import org.eclipse.core.runtime.CoreException;
  22 import org.eclipse.jface.preference.IPreferenceStore;
  23
  24 import test.PHPParserSuperclass;
  25
  26 public class Parser extends PHPParserSuperclass implements ITerminalSymbols {
  27
  28   //scanner token
  29   public Scanner scanner;
  30
  31   private ArrayList phpList;
  32
  33   private int currentPHPString;
  34   private boolean phpEnd;
  35
  36   // private static HashMap keywordMap = null;
  37   private String str;
  38
  39   // current character
  40   //  char ch;
  41   // current token
  42   int token;
  43
  44   // row counter for syntax errors:
  45   //int rowCount;
  46   // column counter for syntax errors:
  47   //int columnCount;
  48
  49   //int chIndx;
  50   //
  51   //    // current identifier
  52   //    String identifier;
  53
  54   Long longNumber;
  55   Double doubleNumber;
  56
  57   private String stringValue;
  58
  59   /** Contains the current expression. */
  60   // private StringBuffer expression;
  61
  62   private boolean phpMode;
  63
  64   //    final static int TokenNameEOF = 0;
  65   //    final static int TokenNameERROR = 1;
  66   //    final static int TokenNameHTML = 2;
  67   //
  68   //    final static int TokenNameREMAINDER = 30;
  69   //    final static int TokenNameNOT = 31;
  70   //    final static int TokenNameDOT = 32;
  71   //    final static int TokenNameXOR = 33;
  72   //    final static int TokenNameDIVIDE = 34;
  73   //    final static int TokenNameMULTIPLY = 35;
  74   //    final static int TokenNameMINUS = 36;
  75   //    final static int TokenNamePLUS = 37;
  76   //    final static int TokenNameEQUAL_EQUAL = 38;
  77   //    final static int TokenNameNOT_EQUAL = 39;
  78   //    final static int TokenNameGREATER = 40;
  79   //    final static int TokenNameGREATER_EQUAL = 41;
  80   //    final static int TokenNameLESS = 42;
  81   //    final static int TokenNameLESS_EQUAL = 43;
  82   //    final static int TokenNameAND_AND = 44;
  83   //    final static int TokenNameOR_OR = 45;
  84   //    // final static int TokenNameHASH = 46;
  85   //    final static int TokenNameCOLON = 47;
  86   //    final static int TokenNameDOT_EQUAL = 48;
  87   //
  88   //    final static int TokenNameEQUAL = 49;
  89   //    final static int TokenNameMINUS_GREATER = 50; // ->
  90   //    final static int TokenNameFOREACH = 51;
  91   //    final static int TokenNameAND = 52;
  92   //    //final static int TokenNameDOLLARLISTOPEN = 53;
  93   //    final static int TokenNameTWIDDLE = 54;
  94   //    final static int TokenNameTWIDDLE_EQUAL = 55;
  95   //    final static int TokenNameREMAINDER_EQUAL = 56;
  96   //    final static int TokenNameXOR_EQUAL = 57;
  97   //    final static int TokenNameRIGHT_SHIFT_EQUAL = 58;
  98   //    final static int TokenNameLEFT_SHIFT_EQUAL = 59;
  99   //    final static int TokenNameAND_EQUAL = 60;
 100   //    final static int TokenNameOR_EQUAL = 61;
 101   //    final static int TokenNameQUESTION = 62;
 102   //    final static int TokenNameCOLON_COLON = 63;
 103   //    final static int TokenNameAT = 63;
 104   //    // final static int TokenNameHEREDOC = 64;
 105   //
 106   //    final static int TokenNameDOLLAROPEN = 127;
 107   //    final static int TokenNameLPAREN = 128;
 108   //    final static int TokenNameRPAREN = 129;
 109   //    final static int TokenNameLBRACE = 130;
 110   //    final static int TokenNameRBRACE = 131;
 111   //    final static int TokenNameLBRACKET = 132;
 112   //    final static int TokenNameRBRACKET = 133;
 113   //    final static int TokenNameCOMMA = 134;
 114   //
 115   //    final static int TokenNameStringLiteral = 136;
 116   //    final static int TokenNameIdentifier = 138;
 117   //    // final static int TokenNameDIGIT = 139;
 118   //    final static int TokenNameSEMICOLON = 140;
 119   //    // final static int TokenNameSLOT = 141;
 120   //    // final static int TokenNameSLOTSEQUENCE = 142;
 121   //    final static int TokenNameMINUS_MINUS = 144;
 122   //    final static int TokenNamePLUS_PLUS = 145;
 123   //    final static int TokenNamePLUS_EQUAL = 146;
 124   //    final static int TokenNameDIVIDE_EQUAL = 147;
 125   //    final static int TokenNameMINUS_EQUAL = 148;
 126   //    final static int TokenNameMULTIPLY_EQUAL = 149;
 127   //    final static int TokenNameVariable = 150;
 128   //    final static int TokenNameIntegerLiteral = 151;
 129   //    final static int TokenNameDoubleLiteral = 152;
 130   //    final static int TokenNameStringInterpolated = 153;
 131   //    final static int TokenNameStringConstant = 154;
 132   //
 133   //    final static int TokenNameLEFT_SHIFT = 155;
 134   //    final static int TokenNameRIGHT_SHIFT = 156;
 135   //    final static int TokenNameEQUAL_EQUAL_EQUAL = 157;
 136   //    final static int TokenNameNOT_EQUAL_EQUAL = 158;
 137   //    final static int TokenNameOR = 159;
 138   //  final static int TokenNameAT = 153; // @
 139
 140   public Parser() {
 141   }
 142
 143   public void setFileToParse(IFile fileToParse) {
 144     this.currentPHPString = 0;
 145                 PHPParserSuperclass.fileToParse = fileToParse;
 146     this.phpList = null;
 147     this.str = "";
 148     this.token = TokenNameEOF;
 149     this.phpEnd = false;
 150     this.initializeScanner();
 151   }
 152   /**
 153    *  ClassDeclaration Constructor.
 154    *
 155    *@param  s
 156    *@param  sess  Description of Parameter
 157    *@see
 158    */
 159   public Parser(IFile fileToParse) {
 160     //    if (keywordMap == null) {
 161     //      keywordMap = new HashMap();
 162     //      for (int i = 0; i < PHP_KEYWORS.length; i++) {
 163     //        keywordMap.put(PHP_KEYWORS[i], new Integer(PHP_KEYWORD_TOKEN[i]));
 164     //      }
 165     //    }
 166     this.currentPHPString = 0;
 167                 PHPParserSuperclass.fileToParse = fileToParse;
 168     this.phpList = null;
 169     this.str = "";
 170     this.token = TokenNameEOF;
 171     //    this.chIndx = 0;
 172     //    this.rowCount = 1;
 173     //    this.columnCount = 0;
 174     this.phpEnd = false;
 175     //   getNextToken();
 176
 177     this.initializeScanner();
 178   }
 179
 180   public void initializeScanner() {
 181     this.scanner = new Scanner(false, false, false, false);
 182   }
 183   /**
 184    * Create marker for the parse error
 185    */
 186   private void setMarker(String message, int charStart, int charEnd, int errorLevel) throws CoreException {
 187     setMarker(fileToParse, message, charStart, charEnd, errorLevel);
 188   }
 189
 190   /**
 191    * This method will throw the SyntaxError.
 192    * It will add the good lines and columns to the Error
 193    * @param error the error message
 194    * @throws SyntaxError the error raised
 195    */
 196   private void throwSyntaxError(String error) {
 197
 198     //    if (str.length() < chIndx) {
 199     //      chIndx--;
 200     //    }
 201     //    // read until end-of-line
 202     //    int eol = chIndx;
 203     //    while (str.length() > eol) {
 204     //      ch = str.charAt(eol++);
 205     //      if (ch == '\n') {
 206     //        eol--;
 207     //        break;
 208     //      }
 209     //    }
 210     //    throw new SyntaxError(
 211     //      rowCount,
 212     //      chIndx - columnCount + 1,
 213     //      str.substring(columnCount, eol),
 214     //      error);
 215     throw new SyntaxError(1, 1, "", error);
 216   }
 217
 218   /**
 219    * This method will throw the SyntaxError.
 220    * It will add the good lines and columns to the Error
 221    * @param error the error message
 222    * @throws SyntaxError the error raised
 223    */
 224   private void throwSyntaxError(String error, int startRow) {
 225     throw new SyntaxError(startRow, 0, " ", error);
 226   }
 227
 228   /**
 229    *  Method Declaration.
 230    *
 231    *@see
 232    */
 233   //  private void getChar() {
 234   //    if (str.length() > chIndx) {
 235   //      ch = str.charAt(chIndx++);
 236   //
 237   //      return;
 238   //    }
 239   //
 240   //    chIndx = str.length() + 1;
 241   //    ch = ' ';
 242   //    //  token = TokenNameEOF;
 243   //    phpEnd = true;
 244   //  }
 245
 246   /**
 247    * gets the next token from input
 248    */
 249   private void getNextToken() throws CoreException {
 250     try {
 251       token = scanner.getNextToken();
 252       if (Scanner.DEBUG) {
 253         int currentEndPosition = scanner.getCurrentTokenEndPosition();
 254         int currentStartPosition = scanner.getCurrentTokenStartPosition();
 255
 256         System.out.print(currentStartPosition + "," + currentEndPosition + ": ");
 257         System.out.println(scanner.toStringAction(token));
 258       }
 259     } catch (InvalidInputException e) {
 260       token = TokenNameERROR;
 261     }
 262     return;
 263
 264   }
 265
 266   /**
 267    * Get a number.
 268    * if it's a <code>double</code> the number will be stored in <code>doubleNumber</code> and the token will have the
 269    * value {@link Parser#TokenNameDOUBLE_NUMBER}<br />
 270    * if it's a <code>double</code> the number will be stored in <code>longNumber</code> and the token will have the
 271    * value {@link Parser#TokenNameINT_NUMBER}
 272    */
 273   //  private void getNumber() {
 274   //    StringBuffer inum = new StringBuffer();
 275   //    char dFlag = ' ';
 276   //    int numFormat = 10;
 277   //
 278   //    // save first digit
 279   //    char firstCh = ch;
 280   //    inum.append(ch);
 281   //
 282   //    getChar();
 283   //    // determine number conversions:
 284   //    if (firstCh == '0') {
 285   //      switch (ch) {
 286   //        case 'b' :
 287   //          numFormat = 2;
 288   //          getChar();
 289   //          break;
 290   //        case 'B' :
 291   //          numFormat = 2;
 292   //          getChar();
 293   //          break;
 294   //        case 'o' :
 295   //          numFormat = 8;
 296   //          getChar();
 297   //          break;
 298   //        case 'O' :
 299   //          numFormat = 8;
 300   //          getChar();
 301   //          break;
 302   //        case 'x' :
 303   //          numFormat = 16;
 304   //          getChar();
 305   //          break;
 306   //        case 'X' :
 307   //          numFormat = 16;
 308   //          getChar();
 309   //          break;
 310   //      }
 311   //    }
 312   //
 313   //    if (numFormat == 16) {
 314   //      while ((ch >= '0' && ch <= '9')
 315   //        || (ch >= 'a' && ch <= 'f')
 316   //        || (ch >= 'A' && ch <= 'F')) {
 317   //        inum.append(ch);
 318   //        getChar();
 319   //      }
 320   //    } else {
 321   //      while ((ch >= '0' && ch <= '9')
 322   //        || (ch == '.')
 323   //        || (ch == 'E')
 324   //        || (ch == 'e')) {
 325   //        if ((ch == '.') || (ch == 'E') || (ch == 'e')) {
 326   //          if (ch == '.' && dFlag != ' ') {
 327   //            break;
 328   //          }
 329   //          if ((dFlag == 'E') || (dFlag == 'e')) {
 330   //            break;
 331   //          }
 332   //          dFlag = ch;
 333   //          inum.append(ch);
 334   //          getChar();
 335   //          if ((ch == '-') || (ch == '+')) {
 336   //            inum.append(ch);
 337   //            getChar();
 338   //          }
 339   //        } else {
 340   //          inum.append(ch);
 341   //          getChar();
 342   //        }
 343   //      }
 344   //    }
 345   //    chIndx--;
 346   //
 347   //    try {
 348   //      if (dFlag != ' ') {
 349   //        doubleNumber = new Double(inum.toString());
 350   //        token = TokenNameDoubleLiteral;
 351   //        return;
 352   //      } else {
 353   //        longNumber = Long.valueOf(inum.toString(), numFormat);
 354   //        token = TokenNameIntegerLiteral;
 355   //        return;
 356   //      }
 357   //
 358   //    } catch (Throwable e) {
 359   //      throwSyntaxError("Number format error: " + inum.toString());
 360   //    }
 361   //  }
 362   //
 363   //  /**
 364   //   * Get a String.
 365   //   * @param openChar the opening char ('\'', '"', '`')
 366   //   * @param typeString the type of string {@link #TokenNameSTRING_CONSTANT},{@link #TokenNameINTERPOLATED_STRING}
 367   //   * @param errorMsg the error message in case of parse error in the string
 368   //   */
 369   //  private void getString(
 370   //    final char openChar,
 371   //    final int typeString,
 372   //    final String errorMsg) {
 373   //    StringBuffer sBuffer = new StringBuffer();
 374   //    boolean openString = true;
 375   //    int startRow = rowCount;
 376   //    while (str.length() > chIndx) {
 377   //      ch = str.charAt(chIndx++);
 378   //      if (ch == '\\') {
 379   //        sBuffer.append(ch);
 380   //        if (str.length() > chIndx) {
 381   //          ch = str.charAt(chIndx++);
 382   //          sBuffer.append(ch);
 383   //        }
 384   //      } else if (ch == openChar) {
 385   //        openString = false;
 386   //        break;
 387   //      } else if (ch == '\n') {
 388   //        rowCount++;
 389   //        columnCount = chIndx;
 390   //      } else {
 391   //        sBuffer.append(ch);
 392   //      }
 393   //    }
 394   //    if (openString) {
 395   //      if (typeString == TokenNameStringConstant) {
 396   //        throwSyntaxError(errorMsg, startRow);
 397   //      } else {
 398   //        throwSyntaxError(errorMsg);
 399   //      }
 400   //    }
 401   //    token = typeString;
 402   //    stringValue = sBuffer.toString();
 403   //  }
 404
 405   //    public void htmlParserTester(String input) {
 406   //            int lineNumber = 1;
 407   //            int startLineNumber = 1;
 408   //            int startIndex = 0;
 409   //            char ch;
 410   //            char ch2;
 411   //            boolean phpMode = false;
 412   //            boolean phpFound = false;
 413   //
 414   //            phpList = new ArrayList();
 415   //            currentPHPString = 0;
 416   //
 417   //            try {
 418   //                    int i = 0;
 419   //                    while (i < input.length()) {
 420   //                            ch = input.charAt(i++);
 421   //                            if (ch == '\n') {
 422   //                                    lineNumber++;
 423   //                            }
 424   //                            if ((!phpMode) && ch == '<') {
 425   //                                    ch2 = input.charAt(i++);
 426   //                                    if (ch2 == '?') {
 427   //                                            ch2 = input.charAt(i++);
 428   //                                            if (Character.isWhitespace(ch2)) {
 429   //                                                    // php start
 430   //                                                    phpMode = true;
 431   //                                                    phpFound = true;
 432   //                                                    startIndex = i;
 433   //                                                    startLineNumber = lineNumber;
 434   //                                                    continue;
 435   //                                            } else if (ch2 == 'p') {
 436   //                                                    ch2 = input.charAt(i++);
 437   //                                                    if (ch2 == 'h') {
 438   //                                                            ch2 = input.charAt(i++);
 439   //                                                            if (ch2 == 'p') {
 440   //                                                                    phpMode = true;
 441   //                                                                    phpFound = true;
 442   //                                                                    startIndex = i;
 443   //                                                                    startLineNumber = lineNumber;
 444   //                                                                    continue;
 445   //                                                            }
 446   //                                                            i--;
 447   //                                                    }
 448   //                                                    i--;
 449   //                                            } else if (ch2 == 'P') {
 450   //                                                    ch2 = input.charAt(i++);
 451   //                                                    if (ch2 == 'H') {
 452   //                                                            ch2 = input.charAt(i++);
 453   //                                                            if (ch2 == 'P') {
 454   //                                                                    phpMode = true;
 455   //                                                                    phpFound = true;
 456   //                                                                    startIndex = i;
 457   //                                                                    startLineNumber = lineNumber;
 458   //                                                                    continue;
 459   //                                                            }
 460   //                                                            i--;
 461   //                                                    }
 462   //                                                    i--;
 463   //                                            }
 464   //                                            i--;
 465   //                                    }
 466   //                                    i--;
 467   //                            }
 468   //
 469   //                            if (phpMode) {
 470   //                                    if (ch == '/' && i < input.length()) {
 471   //                                            ch2 = input.charAt(i++);
 472   //                                            if (ch2 == '/') {
 473   //                                                    while (i < input.length()) {
 474   //                                                            ch = input.charAt(i++);
 475   //                                                            if (ch == '?' && i < input.length()) {
 476   //                                                                    ch2 = input.charAt(i++);
 477   //                                                                    if (ch2 == '>') {
 478   //                                                                            // php end
 479   //                                                                            phpMode = false;
 480   //                                                                            phpList.add(
 481   //                                                                                    new PHPString(
 482   //                                                                                            input.substring(
 483   //                                                                                                    startIndex,
 484   //                                                                                                    i - 2),
 485   //                                                                                            startLineNumber));
 486   //                                                                            continue;
 487   //                                                                    }
 488   //                                                                    i--;
 489   //                                                            } else if (ch == '\n') {
 490   //                                                                    lineNumber++;
 491   //                                                                    break;
 492   //                                                            }
 493   //                                                    }
 494   //                                                    continue;
 495   //                                            } else if (ch2 == '*') {
 496   //                                                    // multi-line comment
 497   //                                                    while (i < input.length()) {
 498   //                                                            ch = input.charAt(i++);
 499   //                                                            if (ch == '\n') {
 500   //                                                                    lineNumber++;
 501   //                                                            } else if (ch == '*' && i < input.length()) {
 502   //                                                                    ch2 = input.charAt(i++);
 503   //                                                                    if (ch2 == '/') {
 504   //                                                                            break;
 505   //                                                                    }
 506   //                                                                    i--;
 507   //                                                            }
 508   //                                                    }
 509   //                                                    continue;
 510   //                                            } else {
 511   //                                                    i--;
 512   //                                            }
 513   //                                    } else if (ch == '#') {
 514   //                                            while (i < input.length()) {
 515   //                                                    ch = input.charAt(i++);
 516   //                                                    if (ch == '?' && i < input.length()) {
 517   //                                                            ch2 = input.charAt(i++);
 518   //                                                            if (ch2 == '>') {
 519   //                                                                    // php end
 520   //                                                                    phpMode = false;
 521   //                                                                    phpList.add(
 522   //                                                                            new PHPString(
 523   //                                                                                    input.substring(startIndex, i - 2),
 524   //                                                                                    startLineNumber));
 525   //                                                                    continue;
 526   //                                                            }
 527   //                                                            i--;
 528   //                                                    } else if (ch == '\n') {
 529   //                                                            lineNumber++;
 530   //                                                            break;
 531   //                                                    }
 532   //                                            }
 533   //                                            continue;
 534   //                                    } else if (ch == '"') {
 535   //                                            ch = ' ';
 536   //                                            while (i < input.length()) {
 537   //                                                    ch = input.charAt(i++);
 538   //                                                    if (ch == '\n') {
 539   //                                                            lineNumber++;
 540   //                                                    } else if (
 541   //                                                            ch == '\\' && i < input.length()) { // escape
 542   //                                                            i++;
 543   //                                                    } else if (ch == '"') {
 544   //                                                            break;
 545   //                                                    }
 546   //                                            }
 547   //                                            continue;
 548   //                                    } else if (ch == '\'') {
 549   //                                            ch = ' ';
 550   //                                            while (i < input.length()) {
 551   //                                                    ch = input.charAt(i++);
 552   //                                                    if (ch == '\n') {
 553   //                                                            lineNumber++;
 554   //                                                    } else if (
 555   //                                                            ch == '\\' && i < input.length()) { // escape
 556   //                                                            i++;
 557   //                                                    } else if (ch == '\'') {
 558   //                                                            break;
 559   //                                                    }
 560   //                                            }
 561   //                                            continue;
 562   //                                    }
 563   //
 564   //                                    if (ch == '?' && i < input.length()) {
 565   //                                            ch2 = input.charAt(i++);
 566   //                                            if (ch2 == '>') {
 567   //                                                    // php end
 568   //                                                    phpMode = false;
 569   //                                                    phpList.add(
 570   //                                                            new PHPString(
 571   //                                                                    input.substring(startIndex, i - 2),
 572   //                                                                    startLineNumber));
 573   //                                                    continue;
 574   //                                            }
 575   //                                            i--;
 576   //                                    }
 577   //                            }
 578   //                    }
 579   //
 580   //                    if (!phpFound) {
 581   //                            setMarker(
 582   //                                    "No PHP source code found.",
 583   //                                    lineNumber,
 584   //                                    PHPParser.INFO);
 585   //                    } else {
 586   //                            if (phpMode) {
 587   //                                    setMarker(
 588   //                                            "Open PHP tag at end of file.",
 589   //                                            lineNumber,
 590   //                                            PHPParser.INFO);
 591   //                                    phpList.add(
 592   //                                            new PHPString(
 593   //                                                    input.substring(startIndex, i - 2),
 594   //                                                    startLineNumber));
 595   //                            }
 596   //                            //        for (int j=0;j<phpList.size();j++) {
 597   //                            //          String temp = ((PHPString)phpList.get(j)).getPHPString();
 598   //                            //          int startIndx = temp.length()-10;
 599   //                            //          if (startIndx<0) {
 600   //                            //            startIndx = 0;
 601   //                            //          }
 602   //                            //          System.out.println(temp.substring(startIndx)+"?>");
 603   //                            //        }
 604   //                            phpParserTester(null, 1);
 605   //                            //        PHPString temp;
 606   //                            //        for(int j=0;j<phpList.size();j++) {
 607   //                            //          temp = (PHPString) phpList.get(j);
 608   //                            //          parser.start(temp.getPHPString(), temp.getLineNumber());
 609   //                            //        }
 610   //                    }
 611   //            } catch (CoreException e) {
 612   //            }
 613   //    }
 614
 615   public void phpParserTester(String s, int rowCount) throws CoreException {
 616     this.str = s;
 617     if (s == null) {
 618       if (phpList.size() != 0) {
 619         this.str = ((PHPString) phpList.get(currentPHPString++)).getPHPString();
 620       }
 621     }
 622     this.token = TokenNameEOF;
 623     //    this.chIndx = 0;
 624     //    this.rowCount = rowCount;
 625     //    this.columnCount = 0;
 626     this.phpEnd = false;
 627     this.phpMode = true;
 628     scanner.setSource(s.toCharArray());
 629     scanner.setPHPMode(true);
 630     getNextToken();
 631     do {
 632       try {
 633         if (token != TokenNameEOF && token != TokenNameERROR) {
 634           statementList();
 635         }
 636         if (token != TokenNameEOF) {
 637           if (token == TokenNameERROR) {
 638             throwSyntaxError("Scanner error (Found unknown token: " + scanner.toStringAction(token) + ")");
 639           }
 640           if (token == TokenNameRPAREN) {
 641             throwSyntaxError("Too many closing ')'; end-of-file not reached.");
 642           }
 643           if (token == TokenNameRBRACE) {
 644             throwSyntaxError("Too many closing '}'; end-of-file not reached.");
 645           }
 646           if (token == TokenNameRBRACKET) {
 647             throwSyntaxError("Too many closing ']'; end-of-file not reached.");
 648           }
 649
 650           if (token == TokenNameLPAREN) {
 651             throwSyntaxError("Read character '('; end-of-file not reached.");
 652           }
 653           if (token == TokenNameLBRACE) {
 654             throwSyntaxError("Read character '{';  end-of-file not reached.");
 655           }
 656           if (token == TokenNameLBRACKET) {
 657             throwSyntaxError("Read character '[';  end-of-file not reached.");
 658           }
 659
 660           throwSyntaxError("End-of-file not reached.");
 661         }
 662         return;
 663       } catch (SyntaxError err) {
 664         if (s != null) {
 665           throw err;
 666         } else {
 667           //   setMarker(err.getMessage(), err.getLine(), ERROR);
 668           setMarker(err.getMessage(), scanner.getCurrentTokenStartPosition(), scanner.getCurrentTokenEndPosition(), ERROR);
 669         }
 670         // if an error occured,
 671         // try to find keywords 'class' or 'function'
 672         // to parse the rest of the string
 673         while (token != TokenNameEOF && token != TokenNameERROR) {
 674           if (token == TokenNameclass || token == TokenNamefunction) {
 675             break;
 676           }
 677           getNextToken();
 678         }
 679         if (token == TokenNameEOF || token == TokenNameERROR) {
 680           return;
 681         }
 682       }
 683     }
 684     while (true);
 685   }
 686
 687   /**
 688    * Parses a string with php tags
 689    * i.e. '&lt;body&gt; &lt;?php phpinfo() ?&gt; &lt;/body&gt;'
 690    */
 691   public void parse(String s) throws CoreException {
 692     this.str = s;
 693     this.token = TokenNameEOF;
 694     //    this.chIndx = 0;
 695     //    this.rowCount = 1;
 696     //    this.columnCount = 0;
 697     this.phpEnd = false;
 698     this.phpMode = false;
 699     /* scanner initialization */
 700     scanner.setSource(s.toCharArray());
 701     scanner.setPHPMode(false);
 702     getNextToken();
 703     do {
 704       try {
 705         if (token != TokenNameEOF && token != TokenNameERROR) {
 706           statementList();
 707         }
 708         if (token != TokenNameEOF) {
 709           if (token == TokenNameERROR) {
 710             throwSyntaxError("Scanner error (Found unknown token: " + scanner.toStringAction(token) + ")");
 711           }
 712           if (token == TokenNameRPAREN) {
 713             throwSyntaxError("Too many closing ')'; end-of-file not reached.");
 714           }
 715           if (token == TokenNameRBRACE) {
 716             throwSyntaxError("Too many closing '}'; end-of-file not reached.");
 717           }
 718           if (token == TokenNameRBRACKET) {
 719             throwSyntaxError("Too many closing ']'; end-of-file not reached.");
 720           }
 721
 722           if (token == TokenNameLPAREN) {
 723             throwSyntaxError("Read character '('; end-of-file not reached.");
 724           }
 725           if (token == TokenNameLBRACE) {
 726             throwSyntaxError("Read character '{';  end-of-file not reached.");
 727           }
 728           if (token == TokenNameLBRACKET) {
 729             throwSyntaxError("Read character '[';  end-of-file not reached.");
 730           }
 731
 732           throwSyntaxError("End-of-file not reached.");
 733         }
 734         return;
 735       } catch (SyntaxError sytaxErr1) {
 736         // setMarker(sytaxErr1.getMessage(), sytaxErr1.getLine(), ERROR);
 737         setMarker(sytaxErr1.getMessage(), scanner.getCurrentTokenStartPosition(), scanner.getCurrentTokenEndPosition(), ERROR);
 738         try {
 739           // if an error occured,
 740           // try to find keywords 'class' or 'function'
 741           // to parse the rest of the string
 742           while (token != TokenNameEOF && token != TokenNameERROR) {
 743             if (token == TokenNameclass || token == TokenNamefunction) {
 744               break;
 745             }
 746             getNextToken();
 747           }
 748           if (token == TokenNameEOF || token == TokenNameERROR) {
 749             return;
 750           }
 751         } catch (SyntaxError sytaxErr2) {
 752           //    setMarker(sytaxErr2.getMessage(), sytaxErr2.getLine(), ERROR);
 753           setMarker(sytaxErr2.getMessage(), scanner.getCurrentTokenStartPosition(), scanner.getCurrentTokenEndPosition(), ERROR);
 754           return;
 755         }
 756       }
 757     }
 758     while (true);
 759   }
 760
 761   public PHPOutlineInfo parseInfo(Object parent, String s) {
 762     PHPOutlineInfo outlineInfo = new PHPOutlineInfo(parent);
 763     //    Stack stack = new Stack();
 764     //    stack.push(outlineInfo.getDeclarations());
 765
 766     this.str = s;
 767     this.token = TokenNameEOF;
 768     //    this.chIndx = 0;
 769     //    this.rowCount = 1;
 770     //    this.columnCount = 0;
 771     this.phpEnd = false;
 772     this.phpMode = false;
 773     scanner.setSource(s.toCharArray());
 774     scanner.setPHPMode(false);
 775
 776     try {
 777       getNextToken();
 778       parseDeclarations(outlineInfo, outlineInfo.getDeclarations(), false);
 779     } catch (CoreException e) {
 780     }
 781     return outlineInfo;
 782   }
 783
 784   private boolean isVariable() {
 785     return token == TokenNameVariable || token == TokenNamethis;
 786   }
 787
 788   private void parseDeclarations(PHPOutlineInfo outlineInfo, OutlineableWithChildren current, boolean goBack) {
 789     char[] ident;
 790     //   PHPClassDeclaration current = (PHPClassDeclaration) stack.peek();
 791     PHPSegmentWithChildren temp;
 792     int counter = 0;
 793
 794     IPreferenceStore store = PHPeclipsePlugin.getDefault().getPreferenceStore();
 795     try {
 796       while (token != TokenNameEOF && token != TokenNameERROR) {
 797         if (token == TokenNameVariable) {
 798           ident = scanner.getCurrentIdentifierSource();
 799           outlineInfo.addVariable(new String(ident));
 800           getNextToken();
 801         } else if (token == TokenNamevar) {
 802           getNextToken();
 803           if (token == TokenNameVariable && store.getBoolean(PHPeclipsePlugin.PHP_OUTLINE_VAR)) {
 804             ident = scanner.getCurrentIdentifierSource();
 805             //substring(1) added because PHPVarDeclaration doesn't need the $ anymore
 806             String variableName = new String(ident).substring(1);
 807             outlineInfo.addVariable(variableName);
 808             getNextToken();
 809             if (token != TokenNameSEMICOLON) {
 810
 811               getNextToken();
 812               ident = scanner.getCurrentTokenSource();
 813               if (token > TokenNameKEYWORD) {
 814                 current.add(new PHPVarDeclaration(current, variableName,
 815                 //                      chIndx - ident.length,
 816                 scanner.getCurrentTokenStartPosition(), new String(ident)));
 817               } else {
 818                 switch (token) {
 819                   case TokenNameVariable :
 820                   case TokenNamethis :
 821                     current.add(new PHPVarDeclaration(current, variableName,
 822                     //                      chIndx - ident.length,
 823                     scanner.getCurrentTokenStartPosition(), new String(ident)));
 824                     break;
 825                   case TokenNameIdentifier :
 826                     current.add(new PHPVarDeclaration(current, variableName,
 827                     //                    chIndx - ident.length,
 828                     scanner.getCurrentTokenStartPosition(), new String(ident)));
 829                     break;
 830                   case TokenNameDoubleLiteral :
 831                     current.add(new PHPVarDeclaration(current, variableName + doubleNumber,
 832                     //   chIndx - ident.length,
 833                     scanner.getCurrentTokenStartPosition(), new String(ident)));
 834                     break;
 835                   case TokenNameIntegerLiteral :
 836                     current.add(new PHPVarDeclaration(current, variableName,
 837                     //                 chIndx - ident.length,
 838                     scanner.getCurrentTokenStartPosition(), new String(ident)));
 839                     break;
 840                   case TokenNameStringInterpolated :
 841                   case TokenNameStringLiteral :
 842                     current.add(new PHPVarDeclaration(current, variableName,
 843                     //              chIndx - ident.length,
 844                     scanner.getCurrentTokenStartPosition(), new String(ident)));
 845                     break;
 846                   case TokenNameStringConstant :
 847                     current.add(new PHPVarDeclaration(current, variableName,
 848                     //   chIndx - ident.length,
 849                     scanner.getCurrentTokenStartPosition(), new String(ident)));
 850                     break;
 851                   default :
 852                     current.add(new PHPVarDeclaration(current, variableName,
 853                     //               chIndx - ident.length
 854                     scanner.getCurrentTokenStartPosition()));
 855                     break;
 856                 }
 857               }
 858
 859             } else {
 860               ident = scanner.getCurrentIdentifierSource();
 861
 862               current.add(new PHPVarDeclaration(current, variableName,
 863               //          chIndx - ident.length
 864               scanner.getCurrentTokenStartPosition()));
 865             }
 866           }
 867         } else if (token == TokenNamefunction) {
 868           getNextToken();
 869           if (token == TokenNameAND) {
 870             getNextToken();
 871           }
 872           if (token == TokenNameIdentifier && store.getBoolean(PHPeclipsePlugin.PHP_OUTLINE_FUNC)) {
 873             ident = scanner.getCurrentIdentifierSource();
 874             outlineInfo.addVariable(new String(ident));
 875             temp = new PHPFunctionDeclaration(current, new String(ident),
 876               // chIndx - ident.length
 877   scanner.getCurrentTokenStartPosition());
 878             current.add(temp);
 879             getNextToken();
 880             parseDeclarations(outlineInfo, temp, true);
 881           }
 882         } else if (token == TokenNameclass) {
 883           getNextToken();
 884           if (token == TokenNameIdentifier && store.getBoolean(PHPeclipsePlugin.PHP_OUTLINE_CLASS)) {
 885             ident = scanner.getCurrentIdentifierSource();
 886             outlineInfo.addVariable(new String(ident));
 887             temp = new PHPClassDeclaration(current, new String(ident),
 888               //      chIndx - ident.len
 889   scanner.getCurrentTokenStartPosition());
 890             current.add(temp);
 891             //        stack.push(temp);
 892             getNextToken();
 893
 894             //skip tokens for classname, extends and others until we have the opening '{'
 895             while (token != TokenNameLBRACE && token != TokenNameEOF && token != TokenNameERROR) {
 896               getNextToken();
 897             }
 898             parseDeclarations(outlineInfo, temp, true);
 899             //        stack.pop();
 900           }
 901         } else if ((token == TokenNameLBRACE) || (token == TokenNameDOLLAR_LBRACE)) {
 902           getNextToken();
 903           counter++;
 904         } else if (token == TokenNameRBRACE) {
 905           getNextToken();
 906           --counter;
 907           if (counter == 0 && goBack) {
 908             return;
 909           }
 910         } else if (
 911           token == TokenNamerequire
 912             || token == TokenNamerequire_once
 913             || token == TokenNameinclude
 914             || token == TokenNameinclude_once) {
 915           ident = scanner.getCurrentTokenSource();
 916
 917           getNextToken();
 918           int startPosition = scanner.getCurrentTokenStartPosition();
 919           expression();
 920           char[] expr = scanner.getCurrentTokenSource(startPosition);
 921           outlineInfo.addVariable(new String(ident));
 922           current.add(new PHPReqIncDeclaration(current, new String(ident),
 923           //    chIndx - ident.length,
 924           startPosition, new String(expr)));
 925           getNextToken();
 926         } else {
 927           getNextToken();
 928         }
 929       }
 930     } catch (CoreException e) {
 931     } catch (SyntaxError sytaxErr) {
 932       try {
 933         //  setMarker(sytaxErr.getMessage(), sytaxErr.getLine(), ERROR);
 934         setMarker(sytaxErr.getMessage(), scanner.getCurrentTokenStartPosition(), scanner.getCurrentTokenEndPosition(), ERROR);
 935       } catch (CoreException e) {
 936       }
 937     }
 938   }
 939
 940   private void statementList() throws CoreException {
 941     do {
 942       statement(TokenNameEOF);
 943       if ((token == TokenNameRBRACE)
 944         || (token == TokenNamecase)
 945         || (token == TokenNamedefault)
 946         || (token == TokenNameelse)
 947         || (token == TokenNameelseif)
 948         || (token == TokenNameendif)
 949         || (token == TokenNameendfor)
 950         || (token == TokenNameendforeach)
 951         || (token == TokenNameendwhile)
 952         || (token == TokenNameendswitch)
 953         || (token == TokenNameEOF)
 954         || (token == TokenNameERROR)) {
 955         return;
 956       }
 957     } while (true);
 958   }
 959
 960   private void compoundStatement() throws CoreException {
 961     // '{' [statement-list] '}'
 962     if (token == TokenNameLBRACE) {
 963       getNextToken();
 964     } else {
 965       throwSyntaxError("'{' expected in compound-statement.");
 966     }
 967     if (token != TokenNameRBRACE) {
 968       statementList();
 969     }
 970     if (token == TokenNameRBRACE) {
 971       getNextToken();
 972     } else {
 973       throwSyntaxError("'}' expected in compound-statement.");
 974     }
 975   }
 976
 977   private void statement(int previousToken) throws CoreException {
 978     //   if (token > TokenNameKEYWORD && token != TokenNamelist && token != TokenNamenew) {
 979     //  char[] ident = scanner.getCurrentIdentifierSource();
 980     //  String keyword = new String(ident);
 981     if (token == TokenNameinclude || token == TokenNameinclude_once) {
 982       getNextToken();
 983       if (token == TokenNameLPAREN) {
 984         expression();
 985         if (token == TokenNameSEMICOLON) {
 986           getNextToken();
 987         } else {
 988           if (previousToken != TokenNameAT && token != TokenNameStopPHP) {
 989             throwSyntaxError("';' expected after 'include' or 'include_once'.");
 990           }
 991           //        getNextToken();
 992         }
 993       } else {
 994         concatenationExpression();
 995       }
 996
 997       return;
 998     } else if (token == TokenNamerequire || token == TokenNamerequire_once) {
 999       getNextToken();
1000       //constant();
1001       if (token == TokenNameLPAREN) {
1002         expression();
1003         if (token == TokenNameSEMICOLON) {
1004           getNextToken();
1005         } else {
1006           if (previousToken != TokenNameAT && token != TokenNameStopPHP) {
1007             throwSyntaxError("';' expected after 'require' or 'require_once'.");
1008           }
1009           //        getNextToken();
1010         }
1011       } else {
1012         concatenationExpression();
1013       }
1014       return;
1015     } else if (token == TokenNameif) {
1016       getNextToken();
1017       if (token == TokenNameLPAREN) {
1018         getNextToken();
1019       } else {
1020         throwSyntaxError("'(' expected after 'if' keyword.");
1021       }
1022       expression();
1023       if (token == TokenNameRPAREN) {
1024         getNextToken();
1025       } else {
1026         throwSyntaxError("')' expected after 'if' condition.");
1027       }
1028       ifStatement();
1029       return;
1030
1031     } else if (token == TokenNameswitch) {
1032       getNextToken();
1033       if (token == TokenNameLPAREN) {
1034         getNextToken();
1035       } else {
1036         throwSyntaxError("'(' expected after 'switch' keyword.");
1037       }
1038       expression();
1039       if (token == TokenNameRPAREN) {
1040         getNextToken();
1041       } else {
1042         throwSyntaxError("')' expected after 'switch' condition.");
1043       }
1044       switchStatement();
1045       return;
1046     } else if (token == TokenNamefor) {
1047       getNextToken();
1048       if (token == TokenNameLPAREN) {
1049         getNextToken();
1050       } else {
1051         throwSyntaxError("'(' expected after 'for' keyword.");
1052       }
1053       if (token == TokenNameSEMICOLON) {
1054         getNextToken();
1055       } else {
1056         expressionList();
1057         if (token == TokenNameSEMICOLON) {
1058           getNextToken();
1059         } else {
1060           throwSyntaxError("';' expected after 'for'.");
1061         }
1062       }
1063       if (token == TokenNameSEMICOLON) {
1064         getNextToken();
1065       } else {
1066         expressionList();
1067         if (token == TokenNameSEMICOLON) {
1068           getNextToken();
1069         } else {
1070           throwSyntaxError("';' expected after 'for'.");
1071         }
1072       }
1073       if (token == TokenNameRPAREN) {
1074         getNextToken();
1075       } else {
1076         expressionList();
1077         if (token == TokenNameRPAREN) {
1078           getNextToken();
1079         } else {
1080           throwSyntaxError("')' expected after 'for'.");
1081         }
1082       }
1083       forStatement();
1084       return;
1085     } else if (token == TokenNamewhile) {
1086       getNextToken();
1087       if (token == TokenNameLPAREN) {
1088         getNextToken();
1089       } else {
1090         throwSyntaxError("'(' expected after 'while' keyword.");
1091       }
1092       expression();
1093       if (token == TokenNameRPAREN) {
1094         getNextToken();
1095       } else {
1096         throwSyntaxError("')' expected after 'while' condition.");
1097       }
1098       whileStatement();
1099       return;
1100     } else if (token == TokenNamedo) {
1101       getNextToken();
1102       if (token == TokenNameLBRACE) {
1103         getNextToken();
1104       } else {
1105         throwSyntaxError("'{' expected after 'do' keyword.");
1106       }
1107       if (token != TokenNameRBRACE) {
1108         statementList();
1109       }
1110       if (token == TokenNameRBRACE) {
1111         getNextToken();
1112       } else {
1113         throwSyntaxError("'}' expected after 'do' keyword.");
1114       }
1115       if (token == TokenNamewhile) {
1116         getNextToken();
1117         if (token == TokenNameLPAREN) {
1118           getNextToken();
1119         } else {
1120           throwSyntaxError("'(' expected after 'while' keyword.");
1121         }
1122         expression();
1123         if (token == TokenNameRPAREN) {
1124           getNextToken();
1125         } else {
1126           throwSyntaxError("')' expected after 'while' condition.");
1127         }
1128       } else {
1129         throwSyntaxError("'while' expected after 'do' keyword.");
1130       }
1131       if (token == TokenNameSEMICOLON) {
1132         getNextToken();
1133       } else {
1134         if (token != TokenNameStopPHP) {
1135           throwSyntaxError("';' expected after do-while statement.");
1136         }
1137         getNextToken();
1138       }
1139       return;
1140     } else if (token == TokenNameforeach) {
1141       getNextToken();
1142       if (token == TokenNameLPAREN) {
1143         getNextToken();
1144       } else {
1145         throwSyntaxError("'(' expected after 'foreach' keyword.");
1146       }
1147       expression();
1148       if (token == TokenNameas) {
1149         getNextToken();
1150       } else {
1151         throwSyntaxError("'as' expected after 'foreach' exxpression.");
1152       }
1153       variable();
1154       if (token == TokenNameEQUAL_GREATER) {
1155         getNextToken();
1156         variable();
1157       }
1158       if (token == TokenNameRPAREN) {
1159         getNextToken();
1160       } else {
1161         throwSyntaxError("')' expected after 'foreach' expression.");
1162       }
1163       foreachStatement();
1164       return;
1165
1166     } else if (token == TokenNamecontinue || token == TokenNamebreak || token == TokenNamereturn) {
1167       getNextToken();
1168       if (token != TokenNameSEMICOLON) {
1169         expression();
1170       }
1171       if (token == TokenNameSEMICOLON) {
1172         getNextToken();
1173       } else {
1174         if (token != TokenNameStopPHP) {
1175           throwSyntaxError("';' expected after 'continue', 'break' or 'return'.");
1176         }
1177         getNextToken();
1178       }
1179       return;
1180
1181     } else if (token == TokenNameecho) {
1182       getNextToken();
1183       expressionList();
1184       if (token == TokenNameSEMICOLON) {
1185         getNextToken();
1186       } else {
1187         if (token != TokenNameStopPHP) {
1188           throwSyntaxError("';' expected after 'echo' statement.");
1189         }
1190         getNextToken();
1191       }
1192       return;
1193       //    } else if (token == TokenNameprint) {
1194       //      getNextToken();
1195       //      expression();
1196       //      if (token == TokenNameSEMICOLON) {
1197       //        getNextToken();
1198       //      } else {
1199       //        if (token != TokenNameStopPHP) {
1200       //          throwSyntaxError("';' expected after 'print' statement.");
1201       //        }
1202       //        getNextToken();
1203       //      }
1204       //      return;
1205
1206     } else if (token == TokenNameglobal || token == TokenNamestatic) {
1207       getNextToken();
1208       variableList();
1209       if (token == TokenNameSEMICOLON) {
1210         getNextToken();
1211       } else {
1212         if (token != TokenNameStopPHP) {
1213           throwSyntaxError("';' expected after 'global' or 'static' statement.");
1214         }
1215         getNextToken();
1216       }
1217       return;
1218
1219       //      } else if (token == TokenNameunset) {
1220       //        getNextToken();
1221       //        if (token == TokenNameARGOPEN) {
1222       //          getNextToken();
1223       //        } else {
1224       //          throwSyntaxError("'(' expected after 'unset' keyword.");
1225       //        }
1226       //        variableList();
1227       //        if (token == TokenNameARGCLOSE) {
1228       //          getNextToken();
1229       //        } else {
1230       //          throwSyntaxError("')' expected after 'unset' statement.");
1231       //        }
1232       //        if (token == TokenNameSEMICOLON) {
1233       //          getNextToken();
1234       //        } else {
1235       //          if (token != TokenNameStopPHP) {
1236       //            throwSyntaxError("';' expected after 'unset' statement.");
1237       //          }
1238       //          getNextToken();
1239       //        }
1240       //        return;
1241
1242       //      } else if (token == TokenNameexit || token == TokenNamedie) {
1243       //        getNextToken();
1244       //        if (token != TokenNameSEMICOLON) {
1245       //          exitStatus();
1246       //        }
1247       //        if (token == TokenNameSEMICOLON) {
1248       //          getNextToken();
1249       //        } else {
1250       //          if (token != TokenNameStopPHP) {
1251       //            throwSyntaxError("';' expected after 'exit' or 'die' statement.");
1252       //          }
1253       //          getNextToken();
1254       //        }
1255       //        return;
1256
1257     } else if (token == TokenNamedefine) {
1258       getNextToken();
1259       if (token == TokenNameLPAREN) {
1260         getNextToken();
1261       } else {
1262         throwSyntaxError("'(' expected after 'define' keyword.");
1263       }
1264       expression();
1265       if (token == TokenNameCOMMA) {
1266         getNextToken();
1267       } else {
1268         throwSyntaxError("',' expected after first 'define' constant.");
1269       }
1270       expression();
1271       if (token == TokenNameCOMMA) {
1272         getNextToken();
1273         expression();
1274       }
1275       if (token == TokenNameRPAREN) {
1276         getNextToken();
1277       } else {
1278         throwSyntaxError("')' expected after 'define' statement.");
1279       }
1280       if (token == TokenNameSEMICOLON) {
1281         getNextToken();
1282       } else {
1283         if (token != TokenNameStopPHP) {
1284           throwSyntaxError("';' expected after 'define' statement.");
1285         }
1286         getNextToken();
1287       }
1288       return;
1289     } else if (token == TokenNamefunction) {
1290       getNextToken();
1291       functionDefinition();
1292       return;
1293     } else if (token == TokenNameclass) {
1294       getNextToken();
1295       classDeclarator();
1296       classBody();
1297       return;
1298       //      } else {
1299       //        throwSyntaxError("Unexpected keyword '" + keyword + "'");
1300     } else if (token == TokenNameLBRACE) {
1301       // compoundStatement
1302       getNextToken();
1303       if (token != TokenNameRBRACE) {
1304         statementList();
1305       }
1306       if (token == TokenNameRBRACE) {
1307         getNextToken();
1308         return;
1309       } else {
1310         throwSyntaxError("'}' expected.");
1311       }
1312     } else {
1313       if (token != TokenNameSEMICOLON) {
1314         expression();
1315       }
1316       if (token == TokenNameSEMICOLON) {
1317         getNextToken();
1318         return;
1319       } else {
1320         if (token != TokenNameStopPHP && token != TokenNameEOF) {
1321           throwSyntaxError("';' expected after expression (Found token: " + scanner.toStringAction(token) + ")");
1322         }
1323         getNextToken();
1324       }
1325     }
1326   }
1327
1328   private void classDeclarator() throws CoreException {
1329     //identifier
1330     //identifier 'extends' identifier
1331     if (token == TokenNameIdentifier) {
1332       getNextToken();
1333       if (token == TokenNameextends) {
1334         do {
1335           getNextToken();
1336           if (token == TokenNameIdentifier) {
1337             getNextToken();
1338           } else {
1339             throwSyntaxError("ClassDeclaration name expected after keyword 'extends'.");
1340           }
1341         } while (token == TokenNameCOMMA);
1342       }
1343     } else {
1344       if (token > TokenNameKEYWORD) {
1345         throwSyntaxError("Don't use keyword for class declaration [" + token + "].");
1346       }
1347       throwSyntaxError("ClassDeclaration name expected after keyword 'class'.");
1348     }
1349   }
1350
1351   private void classBody() throws CoreException {
1352     //'{' [class-element-list] '}'
1353     if (token == TokenNameLBRACE) {
1354       getNextToken();
1355       if (token != TokenNameRBRACE) {
1356         classElementList();
1357       }
1358       if (token == TokenNameRBRACE) {
1359         getNextToken();
1360       } else {
1361         throwSyntaxError("'}' expected at end of class body.");
1362       }
1363     } else {
1364       throwSyntaxError("'{' expected at start of class body.");
1365     }
1366   }
1367
1368   private void classElementList() throws CoreException {
1369     do {
1370       classElement();
1371     } while (token == TokenNamefunction || token == TokenNamevar);
1372   }
1373
1374   private void classElement() throws CoreException {
1375     //class-property
1376     //function-definition
1377     if (token == TokenNamefunction) {
1378       getNextToken();
1379       functionDefinition();
1380     } else if (token == TokenNamevar) {
1381       getNextToken();
1382       classProperty();
1383     } else {
1384       throwSyntaxError("'function' or 'var' expected.");
1385     }
1386   }
1387
1388   private void classProperty() throws CoreException {
1389     //'var' variable ';'
1390     //'var' variable '=' constant ';'
1391     do {
1392       if (token == TokenNameVariable) {
1393         getNextToken();
1394         if (token == TokenNameEQUAL) {
1395           getNextToken();
1396           constant();
1397         }
1398       } else {
1399         if (token == TokenNamethis) {
1400           throwSyntaxError("Reserved word '$this' not allowed after keyword 'var'.");
1401         }
1402         throwSyntaxError("Variable expected after keyword 'var'.");
1403       }
1404       if (token != TokenNameCOMMA) {
1405         break;
1406       }
1407       getNextToken();
1408     } while (true);
1409     if (token == TokenNameSEMICOLON) {
1410       getNextToken();
1411     } else {
1412       throwSyntaxError("';' expected after variable declaration.");
1413     }
1414   }
1415
1416   private void functionDefinition() throws CoreException {
1417     functionDeclarator();
1418     compoundStatement();
1419   }
1420
1421   private void functionDeclarator() throws CoreException {
1422     //identifier '(' [parameter-list] ')'
1423     if (token == TokenNameAND) {
1424       getNextToken();
1425     }
1426     if (token == TokenNameIdentifier) {
1427       getNextToken();
1428       if (token == TokenNameLPAREN) {
1429         getNextToken();
1430       } else {
1431         throwSyntaxError("'(' expected in function declaration.");
1432       }
1433       if (token != TokenNameRPAREN) {
1434         parameterList();
1435       }
1436       if (token != TokenNameRPAREN) {
1437         throwSyntaxError("')' expected in function declaration.");
1438       } else {
1439         getNextToken();
1440       }
1441     } else {
1442       if (token > TokenNameKEYWORD) {
1443         throwSyntaxError("Don't use keyword for function declaration [" + token + "].");
1444       }
1445       throwSyntaxError("Function name expected after keyword 'function'.");
1446     }
1447   }
1448   //
1449   private void parameterList() throws CoreException {
1450     //parameter-declaration
1451     //parameter-list ',' parameter-declaration
1452     do {
1453       parameterDeclaration();
1454       if (token != TokenNameCOMMA) {
1455         break;
1456       }
1457       getNextToken();
1458     } while (true);
1459   }
1460
1461   private void parameterDeclaration() throws CoreException {
1462     //variable
1463     //variable-reference
1464     if (token == TokenNameAND) {
1465       getNextToken();
1466       if (isVariable()) {
1467         getNextToken();
1468       } else {
1469         throwSyntaxError("Variable expected after reference operator '&'.");
1470       }
1471     }
1472     //variable '=' constant
1473     if (token == TokenNameVariable) {
1474       getNextToken();
1475       if (token == TokenNameEQUAL) {
1476         getNextToken();
1477         constant();
1478       }
1479       return;
1480     }
1481     if (token == TokenNamethis) {
1482       throwSyntaxError("Reserved word '$this' not allowed in parameter declaration.");
1483     }
1484   }
1485
1486   private void labeledStatementList() throws CoreException {
1487     if (token != TokenNamecase && token != TokenNamedefault) {
1488       throwSyntaxError("'case' or 'default' expected.");
1489     }
1490     do {
1491       if (token == TokenNamecase) {
1492         getNextToken();
1493         expression(); //constant();
1494         if (token == TokenNameCOLON) {
1495           getNextToken();
1496           if (token == TokenNamecase || token == TokenNamedefault) { // empty case statement ?
1497             continue;
1498           }
1499           statementList();
1500         } else if (token == TokenNameSEMICOLON) {
1501           //          setMarker(
1502           //            "':' expected after 'case' keyword (Found token: "
1503           //              + scanner.toStringAction(token)
1504           //              + ")",
1505           //            rowCount,
1506           //            PHPParser.INFO);
1507           setMarker(
1508             "':' expected after 'case' keyword (Found token: " + scanner.toStringAction(token) + ")",
1509             scanner.getCurrentTokenStartPosition(),
1510             scanner.getCurrentTokenEndPosition(),
1511             INFO);
1512           getNextToken();
1513           if (token == TokenNamecase) { // empty case statement ?
1514             continue;
1515           }
1516           statementList();
1517         } else {
1518           throwSyntaxError("':' character after 'case' constant expected (Found token: " + scanner.toStringAction(token) + ")");
1519         }
1520       } else { // TokenNamedefault
1521         getNextToken();
1522         if (token == TokenNameCOLON) {
1523           getNextToken();
1524           statementList();
1525         } else {
1526           throwSyntaxError("':' character after 'default' expected.");
1527         }
1528       }
1529     } while (token == TokenNamecase || token == TokenNamedefault);
1530   }
1531
1532   //  public void labeledStatement() {
1533   //    if (token == TokenNamecase) {
1534   //      getNextToken();
1535   //      constant();
1536   //      if (token == TokenNameDDOT) {
1537   //        getNextToken();
1538   //        statement();
1539   //      } else {
1540   //        throwSyntaxError("':' character after 'case' constant expected.");
1541   //      }
1542   //      return;
1543   //    } else if (token == TokenNamedefault) {
1544   //      getNextToken();
1545   //      if (token == TokenNameDDOT) {
1546   //        getNextToken();
1547   //        statement();
1548   //      } else {
1549   //        throwSyntaxError("':' character after 'default' expected.");
1550   //      }
1551   //      return;
1552   //    }
1553   //  }
1554
1555   //  public void expressionStatement() {
1556   //  }
1557
1558   //  private void inclusionStatement() {
1559   //  }
1560
1561   //  public void compoundStatement() {
1562   //  }
1563
1564   //  public void selectionStatement() {
1565   //  }
1566   //
1567   //  public void iterationStatement() {
1568   //  }
1569   //
1570   //  public void jumpStatement() {
1571   //  }
1572   //
1573   //  public void outputStatement() {
1574   //  }
1575   //
1576   //  public void scopeStatement() {
1577   //  }
1578   //
1579   //  public void flowStatement() {
1580   //  }
1581   //
1582   //  public void definitionStatement() {
1583   //  }
1584
1585   private void ifStatement() throws CoreException {
1586     // ':' statement-list [elseif-list] [else-colon-statement] 'endif' ';'
1587     if (token == TokenNameCOLON) {
1588       getNextToken();
1589       if (token != TokenNameendif) {
1590         statementList();
1591         switch (token) {
1592           case TokenNameelse :
1593             getNextToken();
1594             if (token == TokenNameCOLON) {
1595               getNextToken();
1596               if (token != TokenNameendif) {
1597                 statementList();
1598               }
1599             } else {
1600               if (token == TokenNameif) { //'else if'
1601                 getNextToken();
1602                 elseifStatementList();
1603               } else {
1604                 throwSyntaxError("':' expected after 'else'.");
1605               }
1606             }
1607             break;
1608           case TokenNameelseif :
1609             getNextToken();
1610             elseifStatementList();
1611             break;
1612         }
1613       }
1614
1615       if (token != TokenNameendif) {
1616         throwSyntaxError("'endif' expected.");
1617       }
1618       getNextToken();
1619       if (token != TokenNameSEMICOLON) {
1620         throwSyntaxError("';' expected after if-statement.");
1621       }
1622       getNextToken();
1623     } else {
1624       // statement [else-statement]
1625       statement(TokenNameEOF);
1626       if (token == TokenNameelseif) {
1627         getNextToken();
1628         if (token == TokenNameLPAREN) {
1629           getNextToken();
1630         } else {
1631           throwSyntaxError("'(' expected after 'elseif' keyword.");
1632         }
1633         expression();
1634         if (token == TokenNameRPAREN) {
1635           getNextToken();
1636         } else {
1637           throwSyntaxError("')' expected after 'elseif' condition.");
1638         }
1639         ifStatement();
1640       } else if (token == TokenNameelse) {
1641         getNextToken();
1642         statement(TokenNameEOF);
1643       }
1644     }
1645   }
1646
1647   private void elseifStatementList() throws CoreException {
1648     do {
1649       elseifStatement();
1650       switch (token) {
1651         case TokenNameelse :
1652           getNextToken();
1653           if (token == TokenNameCOLON) {
1654             getNextToken();
1655             if (token != TokenNameendif) {
1656               statementList();
1657             }
1658             return;
1659           } else {
1660             if (token == TokenNameif) { //'else if'
1661               getNextToken();
1662             } else {
1663               throwSyntaxError("':' expected after 'else'.");
1664             }
1665           }
1666           break;
1667         case TokenNameelseif :
1668           getNextToken();
1669           break;
1670         default :
1671           return;
1672       }
1673     } while (true);
1674   }
1675
1676   private void elseifStatement() throws CoreException {
1677     if (token == TokenNameLPAREN) {
1678       getNextToken();
1679       expression();
1680       if (token != TokenNameRPAREN) {
1681         throwSyntaxError("')' expected in else-if-statement.");
1682       }
1683       getNextToken();
1684       if (token != TokenNameCOLON) {
1685         throwSyntaxError("':' expected in else-if-statement.");
1686       }
1687       getNextToken();
1688       if (token != TokenNameendif) {
1689         statementList();
1690       }
1691     }
1692   }
1693
1694   private void switchStatement() throws CoreException {
1695     if (token == TokenNameCOLON) {
1696       // ':' [labeled-statement-list] 'endswitch' ';'
1697       getNextToken();
1698       labeledStatementList();
1699       if (token != TokenNameendswitch) {
1700         throwSyntaxError("'endswitch' expected.");
1701       }
1702       getNextToken();
1703       if (token != TokenNameSEMICOLON) {
1704         throwSyntaxError("';' expected after switch-statement.");
1705       }
1706       getNextToken();
1707     } else {
1708       // '{' [labeled-statement-list] '}'
1709       if (token != TokenNameLBRACE) {
1710         throwSyntaxError("'{' expected in switch statement.");
1711       }
1712       getNextToken();
1713       if (token != TokenNameRBRACE) {
1714         labeledStatementList();
1715       }
1716       if (token != TokenNameRBRACE) {
1717         throwSyntaxError("'}' expected in switch statement.");
1718       }
1719       getNextToken();
1720
1721     }
1722   }
1723
1724   private void forStatement() throws CoreException {
1725     if (token == TokenNameCOLON) {
1726       getNextToken();
1727       statementList();
1728       if (token != TokenNameendfor) {
1729         throwSyntaxError("'endfor' expected.");
1730       }
1731       getNextToken();
1732       if (token != TokenNameSEMICOLON) {
1733         throwSyntaxError("';' expected after for-statement.");
1734       }
1735       getNextToken();
1736     } else {
1737       statement(TokenNameEOF);
1738     }
1739   }
1740
1741   private void whileStatement() throws CoreException {
1742     // ':' statement-list 'endwhile' ';'
1743     if (token == TokenNameCOLON) {
1744       getNextToken();
1745       statementList();
1746       if (token != TokenNameendwhile) {
1747         throwSyntaxError("'endwhile' expected.");
1748       }
1749       getNextToken();
1750       if (token != TokenNameSEMICOLON) {
1751         throwSyntaxError("';' expected after while-statement.");
1752       }
1753       getNextToken();
1754     } else {
1755       statement(TokenNameEOF);
1756     }
1757   }
1758
1759   private void foreachStatement() throws CoreException {
1760     if (token == TokenNameCOLON) {
1761       getNextToken();
1762       statementList();
1763       if (token != TokenNameendforeach) {
1764         throwSyntaxError("'endforeach' expected.");
1765       }
1766       getNextToken();
1767       if (token != TokenNameSEMICOLON) {
1768         throwSyntaxError("';' expected after foreach-statement.");
1769       }
1770       getNextToken();
1771     } else {
1772       statement(TokenNameEOF);
1773     }
1774   }
1775
1776   private void exitStatus() throws CoreException {
1777     if (token == TokenNameLPAREN) {
1778       getNextToken();
1779     } else {
1780       throwSyntaxError("'(' expected in 'exit-status'.");
1781     }
1782     if (token != TokenNameRPAREN) {
1783       expression();
1784     }
1785     if (token == TokenNameRPAREN) {
1786       getNextToken();
1787     } else {
1788       throwSyntaxError("')' expected after 'exit-status'.");
1789     }
1790   }
1791
1792   private void expressionList() throws CoreException {
1793     do {
1794       expression();
1795       if (token == TokenNameCOMMA) {
1796         getNextToken();
1797       } else {
1798         break;
1799       }
1800     } while (true);
1801   }
1802
1803   private void expression() throws CoreException {
1804     //todo: find a better way to get the expression
1805     //    expression = new StringBuffer();
1806     //    for (int i = chIndx; i < str.length(); i++) {
1807     //      if (str.charAt(i) == ';') {
1808     //        break;
1809     //      }
1810     //      expression.append(str.charAt(i));
1811     //    }
1812
1813     //    if (token == TokenNameSTRING_CONSTANT || token == TokenNameINTERPOLATED_STRING) {
1814     //      getNextToken();
1815     //    } else {
1816     logicalinclusiveorExpression();
1817     //      while (token != TokenNameSEMICOLON) {
1818     //        getNextToken();
1819     //      //      }
1820     //    }
1821   }
1822
1823   private void postfixExpression() throws CoreException {
1824     //  String ident;
1825     char[] ident;
1826     boolean castFlag = false;
1827     boolean arrayFlag = false;
1828     switch (token) {
1829       case TokenNamenew :
1830         getNextToken();
1831         expression();
1832         break;
1833       case TokenNamenull :
1834         getNextToken();
1835         break;
1836       case TokenNamefalse :
1837         getNextToken();
1838         break;
1839       case TokenNametrue :
1840         getNextToken();
1841         break;
1842       case TokenNameStringConstant :
1843         getNextToken();
1844         break;
1845       case TokenNameHEREDOC :
1846       case TokenNameStringInterpolated :
1847       case TokenNameStringLiteral :
1848         getNextToken();
1849         break;
1850       case TokenNameLPAREN :
1851         getNextToken();
1852
1853         if (token == TokenNameIdentifier) {
1854           // check if identifier is a type:
1855           //    ident = identifier;
1856           ident = scanner.getCurrentIdentifierSource();
1857           String str = new String(ident).toLowerCase();
1858           for (int i = 0; i < PHP_TYPES.length; i++) {
1859             if (PHP_TYPES[i].equals(str)) {
1860               castFlag = true;
1861               if (PHP_TYPES[i].equals("array")) {
1862                 arrayFlag = true;
1863               }
1864               break;
1865             }
1866           }
1867         }
1868
1869         if (castFlag) {
1870           getNextToken();
1871           if (arrayFlag && token == TokenNameLPAREN) {
1872             getNextToken();
1873             if (token == TokenNameRPAREN) {
1874               getNextToken();
1875             } else {
1876               expression();
1877               if (token != TokenNameRPAREN) {
1878                 throwSyntaxError(") expected after 'array('.");
1879               }
1880             }
1881           }
1882           if (token != TokenNameRPAREN) {
1883             throwSyntaxError(") expected after cast-type '" + str + "'.");
1884           }
1885           getNextToken();
1886           expression();
1887           break;
1888         } else {
1889           expression();
1890         }
1891         if (token != TokenNameRPAREN) {
1892           throwSyntaxError(") expected in postfix-expression.");
1893         }
1894         getNextToken();
1895         break;
1896       case TokenNameDoubleLiteral :
1897         getNextToken();
1898         break;
1899       case TokenNameIntegerLiteral :
1900         getNextToken();
1901         break;
1902       case TokenNameDOLLAR_LBRACE :
1903         getNextToken();
1904         expression();
1905         if (token != TokenNameRBRACE) {
1906           throwSyntaxError("'}' expected after indirect variable token '${'.");
1907         }
1908         getNextToken();
1909         break;
1910       case TokenNameVariable :
1911       case TokenNamethis :
1912         ident = scanner.getCurrentIdentifierSource();
1913         getNextToken();
1914         if (token == TokenNameLBRACE) {
1915           getNextToken();
1916           expression();
1917           if (token != TokenNameRBRACE) {
1918             throwSyntaxError("'}' expected after variable '" + new String(ident) + "' in variable-expression.");
1919           }
1920           getNextToken();
1921         } else if (token == TokenNameLPAREN) {
1922           getNextToken();
1923           if (token != TokenNameRPAREN) {
1924             expressionList();
1925             if (token != TokenNameRPAREN) {
1926               throwSyntaxError("')' expected after variable '" + new String(ident) + "' in postfix-expression.");
1927             }
1928           }
1929           getNextToken();
1930         }
1931         break;
1932       case TokenNameIdentifier :
1933         ident = scanner.getCurrentIdentifierSource();
1934         getNextToken();
1935         if (token == TokenNameLPAREN) {
1936           getNextToken();
1937           if (token != TokenNameRPAREN) {
1938             expressionList();
1939             if (token != TokenNameRPAREN) {
1940               throwSyntaxError(
1941                 "')' expected after identifier '"
1942                   + new String(ident)
1943                   + "' in postfix-expression."
1944                   + "(Found token: "
1945                   + scanner.toStringAction(token)
1946                   + ")");
1947             }
1948           }
1949           getNextToken();
1950         }
1951         break;
1952       case TokenNameprint :
1953         getNextToken();
1954         expression();
1955         //        if (token == TokenNameSEMICOLON) {
1956         //          getNextToken();
1957         //        } else {
1958         //          if (token != TokenNameStopPHP) {
1959         //            throwSyntaxError("';' expected after 'print' statement.");
1960         //          }
1961         //          getNextToken();
1962         //        }
1963         break;
1964       case TokenNamelist :
1965         getNextToken();
1966         if (token == TokenNameLPAREN) {
1967           getNextToken();
1968           if (token == TokenNameCOMMA) {
1969             getNextToken();
1970           }
1971           expressionList();
1972           if (token != TokenNameRPAREN) {
1973             throwSyntaxError("')' expected after 'list' keyword.");
1974           }
1975           getNextToken();
1976           //          if (token == TokenNameSET) {
1977           //            getNextToken();
1978           //            logicalinclusiveorExpression();
1979           //          }
1980         } else {
1981           throwSyntaxError("'(' expected after 'list' keyword.");
1982         }
1983         break;
1984         //      case TokenNameexit :
1985         //        getNextToken();
1986         //        if (token != TokenNameSEMICOLON) {
1987         //          exitStatus();
1988         //        }
1989         //        if (token == TokenNameSEMICOLON) {
1990         //          getNextToken();
1991         //        } else {
1992         //          if (token != TokenNameStopPHP) {
1993         //            throwSyntaxError("';' expected after 'exit' expression.");
1994         //          }
1995         //          getNextToken();
1996         //        }
1997         //        break;
1998         //      case TokenNamedie :
1999         //        getNextToken();
2000         //        if (token != TokenNameSEMICOLON) {
2001         //          exitStatus();
2002         //        }
2003         //        if (token == TokenNameSEMICOLON) {
2004         //          getNextToken();
2005         //        } else {
2006         //          if (token != TokenNameStopPHP) {
2007         //            throwSyntaxError("';' expected after 'die' expression.");
2008         //          }
2009         //        }
2010         //        break;
2011
2012         //      case TokenNamearray :
2013         //        getNextToken();
2014         //        if (token == TokenNameARGOPEN) {
2015         //          getNextToken();
2016         //          if (token == TokenNameCOMMA) {
2017         //            getNextToken();
2018         //          }
2019         //          expressionList();
2020         //          if (token != TokenNameARGCLOSE) {
2021         //            throwSyntaxError("')' expected after 'list' keyword.");
2022         //          }
2023         //          getNextToken();
2024         //          if (token == TokenNameSET) {
2025         //            getNextToken();
2026         //            logicalinclusiveorExpression();
2027         //          }
2028         //        } else {
2029         //          throwSyntaxError("'(' expected after 'list' keyword.");
2030         //        }
2031         //        break;
2032     }
2033     boolean while_flag = true;
2034     do {
2035       switch (token) {
2036         case TokenNameLBRACKET :
2037           getNextToken();
2038           expression();
2039           if (token != TokenNameRBRACKET) {
2040             throwSyntaxError("] expected in postfix-expression.");
2041           }
2042           getNextToken();
2043           break;
2044         case TokenNameCOLON_COLON : // ::
2045         case TokenNameMINUS_GREATER : // ->
2046           getNextToken();
2047           if (token > TokenNameKEYWORD) {
2048             ident = scanner.getCurrentIdentifierSource();
2049             //            setMarker(
2050             //              "Avoid using keyword '"
2051             //                + new String(ident)
2052             //                + "' as variable name.",
2053             //              rowCount,
2054             //              PHPParser.INFO);
2055             setMarker(
2056               "Avoid using keyword '" + new String(ident) + "' as variable name.",
2057               scanner.getCurrentTokenStartPosition(),
2058               scanner.getCurrentTokenEndPosition(),
2059               INFO);
2060           }
2061           switch (token) {
2062             case TokenNameVariable :
2063               ident = scanner.getCurrentIdentifierSource();
2064               getNextToken();
2065               //              if (token == TokenNameARGOPEN) {
2066               //                getNextToken();
2067               //                expressionList();
2068               //                if (token != TokenNameARGCLOSE) {
2069               //                  throwSyntaxError(") expected after variable '" + ident + "'.");
2070               //                }
2071               //                getNextToken();
2072               //              }
2073               break;
2074             case TokenNameIdentifier :
2075               //ident = scanner.getCurrentIdentifierSource();
2076               getNextToken();
2077               break;
2078             case TokenNameLBRACE :
2079               getNextToken();
2080               expression();
2081               if (token != TokenNameRBRACE) {
2082                 throwSyntaxError("} expected in postfix-expression.");
2083               }
2084               getNextToken();
2085               break;
2086             default :
2087               throwSyntaxError("Syntax error after '->' token.");
2088           } while (token == TokenNameLBRACKET || token == TokenNameLPAREN || token == TokenNameLBRACE) {
2089               if (token == TokenNameLBRACKET) {
2090                 getNextToken();
2091                 expressionList();
2092                 if (token != TokenNameRBRACKET) {
2093                   throwSyntaxError("] expected after '->'.");
2094                 }
2095                 getNextToken();
2096               } else if (token == TokenNameLPAREN) {
2097                 getNextToken();
2098                 expressionList();
2099                 if (token != TokenNameRPAREN) {
2100                   throwSyntaxError(") expected after '->'.");
2101                 }
2102                 getNextToken();
2103               } else if (token == TokenNameLBRACE) {
2104                 getNextToken();
2105                 expression();
2106                 if (token != TokenNameRBRACE) {
2107                   throwSyntaxError("} expected after '->'.");
2108                 }
2109                 getNextToken();
2110               }
2111             }
2112           break;
2113         case TokenNamePLUS_PLUS :
2114           getNextToken();
2115           break;
2116         case TokenNameMINUS_MINUS :
2117           getNextToken();
2118           break;
2119         default :
2120           while_flag = false;
2121       }
2122
2123     }
2124     while (while_flag);
2125   }
2126
2127   private void unaryExpression() throws CoreException {
2128     switch (token) {
2129       case TokenNamePLUS_PLUS :
2130         getNextToken();
2131         unaryExpression();
2132         break;
2133       case TokenNameMINUS_MINUS :
2134         getNextToken();
2135         unaryExpression();
2136         break;
2137         // '@' '&' '*' '+' '-' '~' '!'
2138       case TokenNameAT :
2139         getNextToken();
2140         if (token == TokenNameinclude
2141           || token == TokenNameinclude_once
2142           || token == TokenNamerequire
2143           || token == TokenNamerequire_once) {
2144           statement(TokenNameAT);
2145         } else {
2146           postfixExpression(); //  castExpression();
2147         }
2148         break;
2149       case TokenNameAND :
2150         getNextToken();
2151         castExpression();
2152         break;
2153       case TokenNameMULTIPLY :
2154         getNextToken();
2155         castExpression();
2156         break;
2157       case TokenNamePLUS :
2158         getNextToken();
2159         castExpression();
2160         break;
2161       case TokenNameMINUS :
2162         getNextToken();
2163         castExpression();
2164         break;
2165       case TokenNameTWIDDLE :
2166         getNextToken();
2167         castExpression();
2168         break;
2169       case TokenNameNOT :
2170         getNextToken();
2171         castExpression();
2172         break;
2173       default :
2174         postfixExpression();
2175     }
2176   }
2177
2178   private void castExpression() throws CoreException {
2179     //    if (token == TokenNameARGOPEN) {
2180     //      getNextToken();
2181     //      typeName();
2182     //      if (token != TokenNameARGCLOSE) {
2183     //        throwSyntaxError(") expected after cast-expression.");
2184     //      }
2185     //      getNextToken();
2186     //    }
2187     unaryExpression();
2188   }
2189
2190   private void assignExpression() throws CoreException {
2191     castExpression();
2192     if (token == TokenNameEQUAL) { // =
2193       getNextToken();
2194       logicalinclusiveorExpression();
2195     } else if (token == TokenNameDOT_EQUAL) { // .=
2196       getNextToken();
2197       logicalinclusiveorExpression();
2198     } else if (token == TokenNameEQUAL_GREATER) { // =>
2199       getNextToken();
2200       logicalinclusiveorExpression();
2201     } else if (token == TokenNamePLUS_EQUAL) { // +=
2202       getNextToken();
2203       logicalinclusiveorExpression();
2204     } else if (token == TokenNameMINUS_EQUAL) { // -=
2205       getNextToken();
2206       logicalinclusiveorExpression();
2207     } else if (token == TokenNameMULTIPLY_EQUAL) { // *=
2208       getNextToken();
2209       logicalinclusiveorExpression();
2210     } else if (token == TokenNameDIVIDE_EQUAL) { // *=
2211       getNextToken();
2212       logicalinclusiveorExpression();
2213     } else if (token == TokenNameREMAINDER_EQUAL) { // %=
2214       getNextToken();
2215       logicalinclusiveorExpression();
2216     } else if (token == TokenNameAND_EQUAL) { // &=
2217       getNextToken();
2218       logicalinclusiveorExpression();
2219     } else if (token == TokenNameOR_EQUAL) { // |=
2220       getNextToken();
2221       logicalinclusiveorExpression();
2222     } else if (token == TokenNameXOR_EQUAL) { // ^=
2223       getNextToken();
2224       logicalinclusiveorExpression();
2225     } else if (token == TokenNameLEFT_SHIFT_EQUAL) { // <<=
2226       getNextToken();
2227       logicalinclusiveorExpression();
2228     } else if (token == TokenNameRIGHT_SHIFT_EQUAL) { // >>=
2229       getNextToken();
2230       logicalinclusiveorExpression();
2231     } else if (token == TokenNameTWIDDLE_EQUAL) { // ~=
2232       getNextToken();
2233       logicalinclusiveorExpression();
2234     }
2235   }
2236
2237   private void multiplicativeExpression() throws CoreException {
2238     do {
2239       assignExpression();
2240       if (token != TokenNameMULTIPLY && token != TokenNameDIVIDE && token != TokenNameREMAINDER) {
2241         return;
2242       }
2243       getNextToken();
2244     } while (true);
2245   }
2246
2247   private void concatenationExpression() throws CoreException {
2248     do {
2249       multiplicativeExpression();
2250       if (token != TokenNameDOT) {
2251         return;
2252       }
2253       getNextToken();
2254     } while (true);
2255   }
2256
2257   private void additiveExpression() throws CoreException {
2258     do {
2259       concatenationExpression();
2260       if (token != TokenNamePLUS && token != TokenNameMINUS) {
2261         return;
2262       }
2263       getNextToken();
2264     } while (true);
2265   }
2266
2267   private void shiftExpression() throws CoreException {
2268     do {
2269       additiveExpression();
2270       if (token != TokenNameLEFT_SHIFT && token != TokenNameRIGHT_SHIFT) {
2271         return;
2272       }
2273       getNextToken();
2274     } while (true);
2275   }
2276
2277   private void relationalExpression() throws CoreException {
2278     do {
2279       shiftExpression();
2280       if (token != TokenNameLESS && token != TokenNameGREATER && token != TokenNameLESS_EQUAL && token != TokenNameGREATER_EQUAL) {
2281         return;
2282       }
2283       getNextToken();
2284     } while (true);
2285   }
2286
2287   private void identicalExpression() throws CoreException {
2288     do {
2289       relationalExpression();
2290       if (token != TokenNameEQUAL_EQUAL_EQUAL && token != TokenNameNOT_EQUAL_EQUAL) {
2291         return;
2292       }
2293       getNextToken();
2294     } while (true);
2295   }
2296
2297   private void equalityExpression() throws CoreException {
2298     do {
2299       identicalExpression();
2300       if (token != TokenNameEQUAL_EQUAL && token != TokenNameNOT_EQUAL) {
2301         return;
2302       }
2303       getNextToken();
2304     } while (true);
2305   }
2306
2307   private void ternaryExpression() throws CoreException {
2308     equalityExpression();
2309     if (token == TokenNameQUESTION) {
2310       getNextToken();
2311       expression();
2312       if (token == TokenNameCOLON) {
2313         getNextToken();
2314         expression();
2315       } else {
2316         throwSyntaxError("':' expected in ternary operator '? :'.");
2317       }
2318     }
2319   }
2320
2321   private void andExpression() throws CoreException {
2322     do {
2323       ternaryExpression();
2324       if (token != TokenNameAND) {
2325         return;
2326       }
2327       getNextToken();
2328     } while (true);
2329   }
2330
2331   private void exclusiveorExpression() throws CoreException {
2332     do {
2333       andExpression();
2334       if (token != TokenNameXOR) {
2335         return;
2336       }
2337       getNextToken();
2338     } while (true);
2339   }
2340
2341   private void inclusiveorExpression() throws CoreException {
2342     do {
2343       exclusiveorExpression();
2344       if (token != TokenNameOR) {
2345         return;
2346       }
2347       getNextToken();
2348     } while (true);
2349   }
2350
2351   private void booleanandExpression() throws CoreException {
2352     do {
2353       inclusiveorExpression();
2354       if (token != TokenNameAND_AND) {
2355         return;
2356       }
2357       getNextToken();
2358     } while (true);
2359   }
2360
2361   private void booleanorExpression() throws CoreException {
2362     do {
2363       booleanandExpression();
2364       if (token != TokenNameOR_OR) {
2365         return;
2366       }
2367       getNextToken();
2368     } while (true);
2369   }
2370
2371   private void logicalandExpression() throws CoreException {
2372     do {
2373       booleanorExpression();
2374       if (token != TokenNameAND) {
2375         return;
2376       }
2377       getNextToken();
2378     } while (true);
2379   }
2380
2381   private void logicalexclusiveorExpression() throws CoreException {
2382     do {
2383       logicalandExpression();
2384       if (token != TokenNameXOR) {
2385         return;
2386       }
2387       getNextToken();
2388     } while (true);
2389   }
2390
2391   private void logicalinclusiveorExpression() throws CoreException {
2392     do {
2393       logicalexclusiveorExpression();
2394       if (token != TokenNameOR) {
2395         return;
2396       }
2397       getNextToken();
2398     } while (true);
2399   }
2400
2401   //  public void assignmentExpression() {
2402   //    if (token == TokenNameVARIABLE) {
2403   //      getNextToken();
2404   //      if (token == TokenNameSET) {
2405   //        getNextToken();
2406   //        logicalinclusiveorExpression();
2407   //      }
2408   //    } else {
2409   //      logicalinclusiveorExpression();
2410   //    }
2411   //  }
2412
2413   private void variableList() throws CoreException {
2414     do {
2415       variable();
2416       if (token == TokenNameCOMMA) {
2417         getNextToken();
2418       } else {
2419         break;
2420       }
2421     } while (true);
2422   }
2423
2424   private void variable() throws CoreException {
2425     if (token == TokenNameDOLLAR_LBRACE) {
2426       getNextToken();
2427       expression();
2428       ;
2429       if (token != TokenNameRBRACE) {
2430         throwSyntaxError("'}' expected after indirect variable token '${'.");
2431       }
2432       getNextToken();
2433     } else {
2434       if (token == TokenNameVariable) {
2435         getNextToken();
2436         if (token == TokenNameLBRACKET) {
2437           getNextToken();
2438           expression();
2439           if (token != TokenNameRBRACKET) {
2440             throwSyntaxError("']' expected in variable-list.");
2441           }
2442           getNextToken();
2443         } else if (token == TokenNameEQUAL) {
2444           getNextToken();
2445           constant();
2446         }
2447       } else {
2448         throwSyntaxError("$-variable expected in variable-list.");
2449       }
2450     }
2451   }
2452
2453   /**
2454    * It will look for a value (after a '=' for example)
2455    * @throws CoreException
2456    */
2457   private void constant() throws CoreException {
2458     //   String ident;
2459     switch (token) {
2460       case TokenNamePLUS :
2461         getNextToken();
2462         switch (token) {
2463           case TokenNameDoubleLiteral :
2464             getNextToken();
2465             break;
2466           case TokenNameIntegerLiteral :
2467             getNextToken();
2468             break;
2469           default :
2470             throwSyntaxError("Constant expected after '+' presign.");
2471         }
2472         break;
2473       case TokenNameMINUS :
2474         getNextToken();
2475         switch (token) {
2476           case TokenNameDoubleLiteral :
2477             getNextToken();
2478             break;
2479           case TokenNameIntegerLiteral :
2480             getNextToken();
2481             break;
2482           default :
2483             throwSyntaxError("Constant expected after '-' presign.");
2484         }
2485         break;
2486       case TokenNamenull :
2487         getNextToken();
2488         break;
2489       case TokenNamefalse :
2490         getNextToken();
2491         break;
2492       case TokenNametrue :
2493         getNextToken();
2494         break;
2495       case TokenNameIdentifier :
2496         //   ident = identifier;
2497         char[] ident = scanner.getCurrentIdentifierSource();
2498         getNextToken();
2499         if (token == TokenNameLPAREN) {
2500           getNextToken();
2501           if (token != TokenNameRPAREN) {
2502             expressionList();
2503             if (token != TokenNameRPAREN) {
2504               throwSyntaxError("')' expected after identifier '" + new String(ident) + "' in postfix-expression.");
2505             }
2506           }
2507           getNextToken();
2508         }
2509         break;
2510       case TokenNameStringLiteral :
2511         getNextToken();
2512         break;
2513       case TokenNameStringConstant :
2514         getNextToken();
2515         break;
2516       case TokenNameStringInterpolated :
2517         getNextToken();
2518         break;
2519       case TokenNameDoubleLiteral :
2520         getNextToken();
2521         break;
2522       case TokenNameIntegerLiteral :
2523         getNextToken();
2524         break;
2525       default :
2526         throwSyntaxError("Constant expected.");
2527     }
2528   }
2529
2530 }