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     this.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     this.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         getNextToken();
1335         if (token == TokenNameIdentifier) {
1336           getNextToken();
1337         } else {
1338           throwSyntaxError("ClassDeclaration name expected after keyword 'extends'.");
1339         }
1340       }
1341     } else {
1342       if (token > TokenNameKEYWORD) {
1343         throwSyntaxError("Don't use keyword for class declaration [" + token + "].");
1344       }
1345       throwSyntaxError("ClassDeclaration name expected after keyword 'class'.");
1346     }
1347   }
1348
1349   private void classBody() throws CoreException {
1350     //'{' [class-element-list] '}'
1351     if (token == TokenNameLBRACE) {
1352       getNextToken();
1353       if (token != TokenNameRBRACE) {
1354         classElementList();
1355       }
1356       if (token == TokenNameRBRACE) {
1357         getNextToken();
1358       } else {
1359         throwSyntaxError("'}' expected at end of class body.");
1360       }
1361     } else {
1362       throwSyntaxError("'{' expected at start of class body.");
1363     }
1364   }
1365
1366   private void classElementList() throws CoreException {
1367     do {
1368       classElement();
1369     } while (token == TokenNamefunction || token == TokenNamevar);
1370   }
1371
1372   private void classElement() throws CoreException {
1373     //class-property
1374     //function-definition
1375     if (token == TokenNamefunction) {
1376       getNextToken();
1377       functionDefinition();
1378     } else if (token == TokenNamevar) {
1379       getNextToken();
1380       classProperty();
1381     } else {
1382       throwSyntaxError("'function' or 'var' expected.");
1383     }
1384   }
1385
1386   private void classProperty() throws CoreException {
1387     //'var' variable ';'
1388     //'var' variable '=' constant ';'
1389     do {
1390       if (token == TokenNameVariable) {
1391         getNextToken();
1392         if (token == TokenNameEQUAL) {
1393           getNextToken();
1394           constant();
1395         }
1396       } else {
1397         if (token == TokenNamethis) {
1398           throwSyntaxError("Reserved word '$this' not allowed after keyword 'var'.");
1399         }
1400         throwSyntaxError("Variable expected after keyword 'var'.");
1401       }
1402       if (token != TokenNameCOMMA) {
1403         break;
1404       }
1405       getNextToken();
1406     } while (true);
1407     if (token == TokenNameSEMICOLON) {
1408       getNextToken();
1409     } else {
1410       throwSyntaxError("';' expected after variable declaration.");
1411     }
1412   }
1413
1414   private void functionDefinition() throws CoreException {
1415     functionDeclarator();
1416     compoundStatement();
1417   }
1418
1419   private void functionDeclarator() throws CoreException {
1420     //identifier '(' [parameter-list] ')'
1421     if (token == TokenNameAND) {
1422       getNextToken();
1423     }
1424     if (token == TokenNameIdentifier) {
1425       getNextToken();
1426       if (token == TokenNameLPAREN) {
1427         getNextToken();
1428       } else {
1429         throwSyntaxError("'(' expected in function declaration.");
1430       }
1431       if (token != TokenNameRPAREN) {
1432         parameterList();
1433       }
1434       if (token != TokenNameRPAREN) {
1435         throwSyntaxError("')' expected in function declaration.");
1436       } else {
1437         getNextToken();
1438       }
1439     } else {
1440       if (token > TokenNameKEYWORD) {
1441         throwSyntaxError("Don't use keyword for function declaration [" + token + "].");
1442       }
1443       throwSyntaxError("Function name expected after keyword 'function'.");
1444     }
1445   }
1446   //
1447   private void parameterList() throws CoreException {
1448     //parameter-declaration
1449     //parameter-list ',' parameter-declaration
1450     do {
1451       parameterDeclaration();
1452       if (token != TokenNameCOMMA) {
1453         break;
1454       }
1455       getNextToken();
1456     } while (true);
1457   }
1458
1459   private void parameterDeclaration() throws CoreException {
1460     //variable
1461     //variable-reference
1462     if (token == TokenNameAND) {
1463       getNextToken();
1464       if (isVariable()) {
1465         getNextToken();
1466       } else {
1467         throwSyntaxError("Variable expected after reference operator '&'.");
1468       }
1469     }
1470     //variable '=' constant
1471     if (token == TokenNameVariable) {
1472       getNextToken();
1473       if (token == TokenNameEQUAL) {
1474         getNextToken();
1475         constant();
1476       }
1477       return;
1478     }
1479     if (token == TokenNamethis) {
1480       throwSyntaxError("Reserved word '$this' not allowed in parameter declaration.");
1481     }
1482   }
1483
1484   private void labeledStatementList() throws CoreException {
1485     if (token != TokenNamecase && token != TokenNamedefault) {
1486       throwSyntaxError("'case' or 'default' expected.");
1487     }
1488     do {
1489       if (token == TokenNamecase) {
1490         getNextToken();
1491         expression(); //constant();
1492         if (token == TokenNameCOLON) {
1493           getNextToken();
1494           if (token == TokenNamecase || token == TokenNamedefault) { // empty case statement ?
1495             continue;
1496           }
1497           statementList();
1498         } else if (token == TokenNameSEMICOLON) {
1499           //          setMarker(
1500           //            "':' expected after 'case' keyword (Found token: "
1501           //              + scanner.toStringAction(token)
1502           //              + ")",
1503           //            rowCount,
1504           //            PHPParser.INFO);
1505           setMarker(
1506             "':' expected after 'case' keyword (Found token: " + scanner.toStringAction(token) + ")",
1507             scanner.getCurrentTokenStartPosition(),
1508             scanner.getCurrentTokenEndPosition(),
1509             INFO);
1510           getNextToken();
1511           if (token == TokenNamecase) { // empty case statement ?
1512             continue;
1513           }
1514           statementList();
1515         } else {
1516           throwSyntaxError("':' character after 'case' constant expected (Found token: " + scanner.toStringAction(token) + ")");
1517         }
1518       } else { // TokenNamedefault
1519         getNextToken();
1520         if (token == TokenNameCOLON) {
1521           getNextToken();
1522           statementList();
1523         } else {
1524           throwSyntaxError("':' character after 'default' expected.");
1525         }
1526       }
1527     } while (token == TokenNamecase || token == TokenNamedefault);
1528   }
1529
1530   //  public void labeledStatement() {
1531   //    if (token == TokenNamecase) {
1532   //      getNextToken();
1533   //      constant();
1534   //      if (token == TokenNameDDOT) {
1535   //        getNextToken();
1536   //        statement();
1537   //      } else {
1538   //        throwSyntaxError("':' character after 'case' constant expected.");
1539   //      }
1540   //      return;
1541   //    } else if (token == TokenNamedefault) {
1542   //      getNextToken();
1543   //      if (token == TokenNameDDOT) {
1544   //        getNextToken();
1545   //        statement();
1546   //      } else {
1547   //        throwSyntaxError("':' character after 'default' expected.");
1548   //      }
1549   //      return;
1550   //    }
1551   //  }
1552
1553   //  public void expressionStatement() {
1554   //  }
1555
1556   //  private void inclusionStatement() {
1557   //  }
1558
1559   //  public void compoundStatement() {
1560   //  }
1561
1562   //  public void selectionStatement() {
1563   //  }
1564   //
1565   //  public void iterationStatement() {
1566   //  }
1567   //
1568   //  public void jumpStatement() {
1569   //  }
1570   //
1571   //  public void outputStatement() {
1572   //  }
1573   //
1574   //  public void scopeStatement() {
1575   //  }
1576   //
1577   //  public void flowStatement() {
1578   //  }
1579   //
1580   //  public void definitionStatement() {
1581   //  }
1582
1583   private void ifStatement() throws CoreException {
1584     // ':' statement-list [elseif-list] [else-colon-statement] 'endif' ';'
1585     if (token == TokenNameCOLON) {
1586       getNextToken();
1587       if (token != TokenNameendif) {
1588         statementList();
1589         switch (token) {
1590           case TokenNameelse :
1591             getNextToken();
1592             if (token == TokenNameCOLON) {
1593               getNextToken();
1594               if (token != TokenNameendif) {
1595                 statementList();
1596               }
1597             } else {
1598               if (token == TokenNameif) { //'else if'
1599                 getNextToken();
1600                 elseifStatementList();
1601               } else {
1602                 throwSyntaxError("':' expected after 'else'.");
1603               }
1604             }
1605             break;
1606           case TokenNameelseif :
1607             getNextToken();
1608             elseifStatementList();
1609             break;
1610         }
1611       }
1612
1613       if (token != TokenNameendif) {
1614         throwSyntaxError("'endif' expected.");
1615       }
1616       getNextToken();
1617       if (token != TokenNameSEMICOLON) {
1618         throwSyntaxError("';' expected after if-statement.");
1619       }
1620       getNextToken();
1621     } else {
1622       // statement [else-statement]
1623       statement(TokenNameEOF);
1624       if (token == TokenNameelseif) {
1625         getNextToken();
1626         if (token == TokenNameLPAREN) {
1627           getNextToken();
1628         } else {
1629           throwSyntaxError("'(' expected after 'elseif' keyword.");
1630         }
1631         expression();
1632         if (token == TokenNameRPAREN) {
1633           getNextToken();
1634         } else {
1635           throwSyntaxError("')' expected after 'elseif' condition.");
1636         }
1637         ifStatement();
1638       } else if (token == TokenNameelse) {
1639         getNextToken();
1640         statement(TokenNameEOF);
1641       }
1642     }
1643   }
1644
1645   private void elseifStatementList() throws CoreException {
1646     do {
1647       elseifStatement();
1648       switch (token) {
1649         case TokenNameelse :
1650           getNextToken();
1651           if (token == TokenNameCOLON) {
1652             getNextToken();
1653             if (token != TokenNameendif) {
1654               statementList();
1655             }
1656             return;
1657           } else {
1658             if (token == TokenNameif) { //'else if'
1659               getNextToken();
1660             } else {
1661               throwSyntaxError("':' expected after 'else'.");
1662             }
1663           }
1664           break;
1665         case TokenNameelseif :
1666           getNextToken();
1667           break;
1668         default :
1669           return;
1670       }
1671     } while (true);
1672   }
1673
1674   private void elseifStatement() throws CoreException {
1675     if (token == TokenNameLPAREN) {
1676       getNextToken();
1677       expression();
1678       if (token != TokenNameRPAREN) {
1679         throwSyntaxError("')' expected in else-if-statement.");
1680       }
1681       getNextToken();
1682       if (token != TokenNameCOLON) {
1683         throwSyntaxError("':' expected in else-if-statement.");
1684       }
1685       getNextToken();
1686       if (token != TokenNameendif) {
1687         statementList();
1688       }
1689     }
1690   }
1691
1692   private void switchStatement() throws CoreException {
1693     if (token == TokenNameCOLON) {
1694       // ':' [labeled-statement-list] 'endswitch' ';'
1695       getNextToken();
1696       labeledStatementList();
1697       if (token != TokenNameendswitch) {
1698         throwSyntaxError("'endswitch' expected.");
1699       }
1700       getNextToken();
1701       if (token != TokenNameSEMICOLON) {
1702         throwSyntaxError("';' expected after switch-statement.");
1703       }
1704       getNextToken();
1705     } else {
1706       // '{' [labeled-statement-list] '}'
1707       if (token != TokenNameLBRACE) {
1708         throwSyntaxError("'{' expected in switch statement.");
1709       }
1710       getNextToken();
1711       if (token != TokenNameRBRACE) {
1712         labeledStatementList();
1713       }
1714       if (token != TokenNameRBRACE) {
1715         throwSyntaxError("'}' expected in switch statement.");
1716       }
1717       getNextToken();
1718
1719     }
1720   }
1721
1722   private void forStatement() throws CoreException {
1723     if (token == TokenNameCOLON) {
1724       getNextToken();
1725       statementList();
1726       if (token != TokenNameendfor) {
1727         throwSyntaxError("'endfor' expected.");
1728       }
1729       getNextToken();
1730       if (token != TokenNameSEMICOLON) {
1731         throwSyntaxError("';' expected after for-statement.");
1732       }
1733       getNextToken();
1734     } else {
1735       statement(TokenNameEOF);
1736     }
1737   }
1738
1739   private void whileStatement() throws CoreException {
1740     // ':' statement-list 'endwhile' ';'
1741     if (token == TokenNameCOLON) {
1742       getNextToken();
1743       statementList();
1744       if (token != TokenNameendwhile) {
1745         throwSyntaxError("'endwhile' expected.");
1746       }
1747       getNextToken();
1748       if (token != TokenNameSEMICOLON) {
1749         throwSyntaxError("';' expected after while-statement.");
1750       }
1751       getNextToken();
1752     } else {
1753       statement(TokenNameEOF);
1754     }
1755   }
1756
1757   private void foreachStatement() throws CoreException {
1758     if (token == TokenNameCOLON) {
1759       getNextToken();
1760       statementList();
1761       if (token != TokenNameendforeach) {
1762         throwSyntaxError("'endforeach' expected.");
1763       }
1764       getNextToken();
1765       if (token != TokenNameSEMICOLON) {
1766         throwSyntaxError("';' expected after foreach-statement.");
1767       }
1768       getNextToken();
1769     } else {
1770       statement(TokenNameEOF);
1771     }
1772   }
1773
1774   private void exitStatus() throws CoreException {
1775     if (token == TokenNameLPAREN) {
1776       getNextToken();
1777     } else {
1778       throwSyntaxError("'(' expected in 'exit-status'.");
1779     }
1780     if (token != TokenNameRPAREN) {
1781       expression();
1782     }
1783     if (token == TokenNameRPAREN) {
1784       getNextToken();
1785     } else {
1786       throwSyntaxError("')' expected after 'exit-status'.");
1787     }
1788   }
1789
1790   private void expressionList() throws CoreException {
1791     do {
1792       expression();
1793       if (token == TokenNameCOMMA) {
1794         getNextToken();
1795       } else {
1796         break;
1797       }
1798     } while (true);
1799   }
1800
1801   private void expression() throws CoreException {
1802     //todo: find a better way to get the expression
1803     //    expression = new StringBuffer();
1804     //    for (int i = chIndx; i < str.length(); i++) {
1805     //      if (str.charAt(i) == ';') {
1806     //        break;
1807     //      }
1808     //      expression.append(str.charAt(i));
1809     //    }
1810
1811     //    if (token == TokenNameSTRING_CONSTANT || token == TokenNameINTERPOLATED_STRING) {
1812     //      getNextToken();
1813     //    } else {
1814     logicalinclusiveorExpression();
1815     //      while (token != TokenNameSEMICOLON) {
1816     //        getNextToken();
1817     //      //      }
1818     //    }
1819   }
1820
1821   private void postfixExpression() throws CoreException {
1822     //  String ident;
1823     char[] ident;
1824     boolean castFlag = false;
1825     boolean arrayFlag = false;
1826     switch (token) {
1827       case TokenNamenew :
1828         getNextToken();
1829         expression();
1830         break;
1831       case TokenNamenull :
1832         getNextToken();
1833         break;
1834       case TokenNamefalse :
1835         getNextToken();
1836         break;
1837       case TokenNametrue :
1838         getNextToken();
1839         break;
1840       case TokenNameStringConstant :
1841         getNextToken();
1842         break;
1843       case TokenNameHEREDOC :
1844       case TokenNameStringInterpolated :
1845       case TokenNameStringLiteral :
1846         getNextToken();
1847         break;
1848       case TokenNameLPAREN :
1849         getNextToken();
1850
1851         if (token == TokenNameIdentifier) {
1852           // check if identifier is a type:
1853           //    ident = identifier;
1854           ident = scanner.getCurrentIdentifierSource();
1855           String str = new String(ident).toLowerCase();
1856           for (int i = 0; i < PHP_TYPES.length; i++) {
1857             if (PHP_TYPES[i].equals(str)) {
1858               castFlag = true;
1859               if (PHP_TYPES[i].equals("array")) {
1860                 arrayFlag = true;
1861               }
1862               break;
1863             }
1864           }
1865         }
1866
1867         if (castFlag) {
1868           getNextToken();
1869           if (arrayFlag && token == TokenNameLPAREN) {
1870             getNextToken();
1871             if (token == TokenNameRPAREN) {
1872               getNextToken();
1873             } else {
1874               expression();
1875               if (token != TokenNameRPAREN) {
1876                 throwSyntaxError(") expected after 'array('.");
1877               }
1878             }
1879           }
1880           if (token != TokenNameRPAREN) {
1881             throwSyntaxError(") expected after cast-type '" + str + "'.");
1882           }
1883           getNextToken();
1884           expression();
1885           break;
1886         } else {
1887           expression();
1888         }
1889         if (token != TokenNameRPAREN) {
1890           throwSyntaxError(") expected in postfix-expression.");
1891         }
1892         getNextToken();
1893         break;
1894       case TokenNameDoubleLiteral :
1895         getNextToken();
1896         break;
1897       case TokenNameIntegerLiteral :
1898         getNextToken();
1899         break;
1900       case TokenNameDOLLAR_LBRACE :
1901         getNextToken();
1902         expression();
1903         if (token != TokenNameRBRACE) {
1904           throwSyntaxError("'}' expected after indirect variable token '${'.");
1905         }
1906         getNextToken();
1907         break;
1908       case TokenNameVariable :
1909       case TokenNamethis :
1910         ident = scanner.getCurrentIdentifierSource();
1911         getNextToken();
1912         if (token == TokenNameLBRACE) {
1913           getNextToken();
1914           expression();
1915           if (token != TokenNameRBRACE) {
1916             throwSyntaxError("'}' expected after variable '" + new String(ident) + "' in variable-expression.");
1917           }
1918           getNextToken();
1919         } else if (token == TokenNameLPAREN) {
1920           getNextToken();
1921           if (token != TokenNameRPAREN) {
1922             expressionList();
1923             if (token != TokenNameRPAREN) {
1924               throwSyntaxError("')' expected after variable '" + new String(ident) + "' in postfix-expression.");
1925             }
1926           }
1927           getNextToken();
1928         }
1929         break;
1930       case TokenNameIdentifier :
1931         ident = scanner.getCurrentIdentifierSource();
1932         getNextToken();
1933         if (token == TokenNameLPAREN) {
1934           getNextToken();
1935           if (token != TokenNameRPAREN) {
1936             expressionList();
1937             if (token != TokenNameRPAREN) {
1938               throwSyntaxError(
1939                 "')' expected after identifier '"
1940                   + new String(ident)
1941                   + "' in postfix-expression."
1942                   + "(Found token: "
1943                   + scanner.toStringAction(token)
1944                   + ")");
1945             }
1946           }
1947           getNextToken();
1948         }
1949         break;
1950       case TokenNameprint :
1951         getNextToken();
1952         expression();
1953         //        if (token == TokenNameSEMICOLON) {
1954         //          getNextToken();
1955         //        } else {
1956         //          if (token != TokenNameStopPHP) {
1957         //            throwSyntaxError("';' expected after 'print' statement.");
1958         //          }
1959         //          getNextToken();
1960         //        }
1961         break;
1962       case TokenNamelist :
1963         getNextToken();
1964         if (token == TokenNameLPAREN) {
1965           getNextToken();
1966           if (token == TokenNameCOMMA) {
1967             getNextToken();
1968           }
1969           expressionList();
1970           if (token != TokenNameRPAREN) {
1971             throwSyntaxError("')' expected after 'list' keyword.");
1972           }
1973           getNextToken();
1974           //          if (token == TokenNameSET) {
1975           //            getNextToken();
1976           //            logicalinclusiveorExpression();
1977           //          }
1978         } else {
1979           throwSyntaxError("'(' expected after 'list' keyword.");
1980         }
1981         break;
1982         //      case TokenNameexit :
1983         //        getNextToken();
1984         //        if (token != TokenNameSEMICOLON) {
1985         //          exitStatus();
1986         //        }
1987         //        if (token == TokenNameSEMICOLON) {
1988         //          getNextToken();
1989         //        } else {
1990         //          if (token != TokenNameStopPHP) {
1991         //            throwSyntaxError("';' expected after 'exit' expression.");
1992         //          }
1993         //          getNextToken();
1994         //        }
1995         //        break;
1996         //      case TokenNamedie :
1997         //        getNextToken();
1998         //        if (token != TokenNameSEMICOLON) {
1999         //          exitStatus();
2000         //        }
2001         //        if (token == TokenNameSEMICOLON) {
2002         //          getNextToken();
2003         //        } else {
2004         //          if (token != TokenNameStopPHP) {
2005         //            throwSyntaxError("';' expected after 'die' expression.");
2006         //          }
2007         //        }
2008         //        break;
2009
2010         //      case TokenNamearray :
2011         //        getNextToken();
2012         //        if (token == TokenNameARGOPEN) {
2013         //          getNextToken();
2014         //          if (token == TokenNameCOMMA) {
2015         //            getNextToken();
2016         //          }
2017         //          expressionList();
2018         //          if (token != TokenNameARGCLOSE) {
2019         //            throwSyntaxError("')' expected after 'list' keyword.");
2020         //          }
2021         //          getNextToken();
2022         //          if (token == TokenNameSET) {
2023         //            getNextToken();
2024         //            logicalinclusiveorExpression();
2025         //          }
2026         //        } else {
2027         //          throwSyntaxError("'(' expected after 'list' keyword.");
2028         //        }
2029         //        break;
2030     }
2031     boolean while_flag = true;
2032     do {
2033       switch (token) {
2034         case TokenNameLBRACKET :
2035           getNextToken();
2036           expression();
2037           if (token != TokenNameRBRACKET) {
2038             throwSyntaxError("] expected in postfix-expression.");
2039           }
2040           getNextToken();
2041           break;
2042         case TokenNameCOLON_COLON : // ::
2043         case TokenNameMINUS_GREATER : // ->
2044           getNextToken();
2045           if (token > TokenNameKEYWORD) {
2046             ident = scanner.getCurrentIdentifierSource();
2047             //            setMarker(
2048             //              "Avoid using keyword '"
2049             //                + new String(ident)
2050             //                + "' as variable name.",
2051             //              rowCount,
2052             //              PHPParser.INFO);
2053             setMarker(
2054               "Avoid using keyword '" + new String(ident) + "' as variable name.",
2055               scanner.getCurrentTokenStartPosition(),
2056               scanner.getCurrentTokenEndPosition(),
2057               INFO);
2058           }
2059           switch (token) {
2060             case TokenNameVariable :
2061               ident = scanner.getCurrentIdentifierSource();
2062               getNextToken();
2063               //              if (token == TokenNameARGOPEN) {
2064               //                getNextToken();
2065               //                expressionList();
2066               //                if (token != TokenNameARGCLOSE) {
2067               //                  throwSyntaxError(") expected after variable '" + ident + "'.");
2068               //                }
2069               //                getNextToken();
2070               //              }
2071               break;
2072             case TokenNameIdentifier :
2073               //ident = scanner.getCurrentIdentifierSource();
2074               getNextToken();
2075               break;
2076             case TokenNameLBRACE :
2077               getNextToken();
2078               expression();
2079               if (token != TokenNameRBRACE) {
2080                 throwSyntaxError("} expected in postfix-expression.");
2081               }
2082               getNextToken();
2083               break;
2084             default :
2085               throwSyntaxError("Syntax error after '->' token.");
2086           } while (token == TokenNameLBRACKET || token == TokenNameLPAREN || token == TokenNameLBRACE) {
2087               if (token == TokenNameLBRACKET) {
2088                 getNextToken();
2089                 expressionList();
2090                 if (token != TokenNameRBRACKET) {
2091                   throwSyntaxError("] expected after '->'.");
2092                 }
2093                 getNextToken();
2094               } else if (token == TokenNameLPAREN) {
2095                 getNextToken();
2096                 expressionList();
2097                 if (token != TokenNameRPAREN) {
2098                   throwSyntaxError(") expected after '->'.");
2099                 }
2100                 getNextToken();
2101               } else if (token == TokenNameLBRACE) {
2102                 getNextToken();
2103                 expression();
2104                 if (token != TokenNameRBRACE) {
2105                   throwSyntaxError("} expected after '->'.");
2106                 }
2107                 getNextToken();
2108               }
2109             }
2110           break;
2111         case TokenNamePLUS_PLUS :
2112           getNextToken();
2113           break;
2114         case TokenNameMINUS_MINUS :
2115           getNextToken();
2116           break;
2117         default :
2118           while_flag = false;
2119       }
2120
2121     }
2122     while (while_flag);
2123   }
2124
2125   private void unaryExpression() throws CoreException {
2126     switch (token) {
2127       case TokenNamePLUS_PLUS :
2128         getNextToken();
2129         unaryExpression();
2130         break;
2131       case TokenNameMINUS_MINUS :
2132         getNextToken();
2133         unaryExpression();
2134         break;
2135         // '@' '&' '*' '+' '-' '~' '!'
2136       case TokenNameAT :
2137         getNextToken();
2138         if (token == TokenNameinclude
2139           || token == TokenNameinclude_once
2140           || token == TokenNamerequire
2141           || token == TokenNamerequire_once) {
2142           statement(TokenNameAT);
2143         } else {
2144           postfixExpression(); //  castExpression();
2145         }
2146         break;
2147       case TokenNameAND :
2148         getNextToken();
2149         castExpression();
2150         break;
2151       case TokenNameMULTIPLY :
2152         getNextToken();
2153         castExpression();
2154         break;
2155       case TokenNamePLUS :
2156         getNextToken();
2157         castExpression();
2158         break;
2159       case TokenNameMINUS :
2160         getNextToken();
2161         castExpression();
2162         break;
2163       case TokenNameTWIDDLE :
2164         getNextToken();
2165         castExpression();
2166         break;
2167       case TokenNameNOT :
2168         getNextToken();
2169         castExpression();
2170         break;
2171       default :
2172         postfixExpression();
2173     }
2174   }
2175
2176   private void castExpression() throws CoreException {
2177     //    if (token == TokenNameARGOPEN) {
2178     //      getNextToken();
2179     //      typeName();
2180     //      if (token != TokenNameARGCLOSE) {
2181     //        throwSyntaxError(") expected after cast-expression.");
2182     //      }
2183     //      getNextToken();
2184     //    }
2185     unaryExpression();
2186   }
2187
2188   private void assignExpression() throws CoreException {
2189     castExpression();
2190     if (token == TokenNameEQUAL) { // =
2191       getNextToken();
2192       logicalinclusiveorExpression();
2193     } else if (token == TokenNameDOT_EQUAL) { // .=
2194       getNextToken();
2195       logicalinclusiveorExpression();
2196     } else if (token == TokenNameEQUAL_GREATER) { // =>
2197       getNextToken();
2198       logicalinclusiveorExpression();
2199     } else if (token == TokenNamePLUS_EQUAL) { // +=
2200       getNextToken();
2201       logicalinclusiveorExpression();
2202     } else if (token == TokenNameMINUS_EQUAL) { // -=
2203       getNextToken();
2204       logicalinclusiveorExpression();
2205     } else if (token == TokenNameMULTIPLY_EQUAL) { // *=
2206       getNextToken();
2207       logicalinclusiveorExpression();
2208     } else if (token == TokenNameDIVIDE_EQUAL) { // *=
2209       getNextToken();
2210       logicalinclusiveorExpression();
2211     } else if (token == TokenNameREMAINDER_EQUAL) { // %=
2212       getNextToken();
2213       logicalinclusiveorExpression();
2214     } else if (token == TokenNameAND_EQUAL) { // &=
2215       getNextToken();
2216       logicalinclusiveorExpression();
2217     } else if (token == TokenNameOR_EQUAL) { // |=
2218       getNextToken();
2219       logicalinclusiveorExpression();
2220     } else if (token == TokenNameXOR_EQUAL) { // ^=
2221       getNextToken();
2222       logicalinclusiveorExpression();
2223     } else if (token == TokenNameLEFT_SHIFT_EQUAL) { // <<=
2224       getNextToken();
2225       logicalinclusiveorExpression();
2226     } else if (token == TokenNameRIGHT_SHIFT_EQUAL) { // >>=
2227       getNextToken();
2228       logicalinclusiveorExpression();
2229     } else if (token == TokenNameTWIDDLE_EQUAL) { // ~=
2230       getNextToken();
2231       logicalinclusiveorExpression();
2232     }
2233   }
2234
2235   private void multiplicativeExpression() throws CoreException {
2236     do {
2237       assignExpression();
2238       if (token != TokenNameMULTIPLY && token != TokenNameDIVIDE && token != TokenNameREMAINDER) {
2239         return;
2240       }
2241       getNextToken();
2242     } while (true);
2243   }
2244
2245   private void concatenationExpression() throws CoreException {
2246     do {
2247       multiplicativeExpression();
2248       if (token != TokenNameDOT) {
2249         return;
2250       }
2251       getNextToken();
2252     } while (true);
2253   }
2254
2255   private void additiveExpression() throws CoreException {
2256     do {
2257       concatenationExpression();
2258       if (token != TokenNamePLUS && token != TokenNameMINUS) {
2259         return;
2260       }
2261       getNextToken();
2262     } while (true);
2263   }
2264
2265   private void shiftExpression() throws CoreException {
2266     do {
2267       additiveExpression();
2268       if (token != TokenNameLEFT_SHIFT && token != TokenNameRIGHT_SHIFT) {
2269         return;
2270       }
2271       getNextToken();
2272     } while (true);
2273   }
2274
2275   private void relationalExpression() throws CoreException {
2276     do {
2277       shiftExpression();
2278       if (token != TokenNameLESS && token != TokenNameGREATER && token != TokenNameLESS_EQUAL && token != TokenNameGREATER_EQUAL) {
2279         return;
2280       }
2281       getNextToken();
2282     } while (true);
2283   }
2284
2285   private void identicalExpression() throws CoreException {
2286     do {
2287       relationalExpression();
2288       if (token != TokenNameEQUAL_EQUAL_EQUAL && token != TokenNameNOT_EQUAL_EQUAL) {
2289         return;
2290       }
2291       getNextToken();
2292     } while (true);
2293   }
2294
2295   private void equalityExpression() throws CoreException {
2296     do {
2297       identicalExpression();
2298       if (token != TokenNameEQUAL_EQUAL && token != TokenNameNOT_EQUAL) {
2299         return;
2300       }
2301       getNextToken();
2302     } while (true);
2303   }
2304
2305   private void ternaryExpression() throws CoreException {
2306     equalityExpression();
2307     if (token == TokenNameQUESTION) {
2308       getNextToken();
2309       expression();
2310       if (token == TokenNameCOLON) {
2311         getNextToken();
2312         expression();
2313       } else {
2314         throwSyntaxError("':' expected in ternary operator '? :'.");
2315       }
2316     }
2317   }
2318
2319   private void andExpression() throws CoreException {
2320     do {
2321       ternaryExpression();
2322       if (token != TokenNameAND) {
2323         return;
2324       }
2325       getNextToken();
2326     } while (true);
2327   }
2328
2329   private void exclusiveorExpression() throws CoreException {
2330     do {
2331       andExpression();
2332       if (token != TokenNameXOR) {
2333         return;
2334       }
2335       getNextToken();
2336     } while (true);
2337   }
2338
2339   private void inclusiveorExpression() throws CoreException {
2340     do {
2341       exclusiveorExpression();
2342       if (token != TokenNameOR) {
2343         return;
2344       }
2345       getNextToken();
2346     } while (true);
2347   }
2348
2349   private void booleanandExpression() throws CoreException {
2350     do {
2351       inclusiveorExpression();
2352       if (token != TokenNameAND_AND) {
2353         return;
2354       }
2355       getNextToken();
2356     } while (true);
2357   }
2358
2359   private void booleanorExpression() throws CoreException {
2360     do {
2361       booleanandExpression();
2362       if (token != TokenNameOR_OR) {
2363         return;
2364       }
2365       getNextToken();
2366     } while (true);
2367   }
2368
2369   private void logicalandExpression() throws CoreException {
2370     do {
2371       booleanorExpression();
2372       if (token != TokenNameAND) {
2373         return;
2374       }
2375       getNextToken();
2376     } while (true);
2377   }
2378
2379   private void logicalexclusiveorExpression() throws CoreException {
2380     do {
2381       logicalandExpression();
2382       if (token != TokenNameXOR) {
2383         return;
2384       }
2385       getNextToken();
2386     } while (true);
2387   }
2388
2389   private void logicalinclusiveorExpression() throws CoreException {
2390     do {
2391       logicalexclusiveorExpression();
2392       if (token != TokenNameOR) {
2393         return;
2394       }
2395       getNextToken();
2396     } while (true);
2397   }
2398
2399   //  public void assignmentExpression() {
2400   //    if (token == TokenNameVARIABLE) {
2401   //      getNextToken();
2402   //      if (token == TokenNameSET) {
2403   //        getNextToken();
2404   //        logicalinclusiveorExpression();
2405   //      }
2406   //    } else {
2407   //      logicalinclusiveorExpression();
2408   //    }
2409   //  }
2410
2411   private void variableList() throws CoreException {
2412     do {
2413       variable();
2414       if (token == TokenNameCOMMA) {
2415         getNextToken();
2416       } else {
2417         break;
2418       }
2419     } while (true);
2420   }
2421
2422   private void variable() throws CoreException {
2423     if (token == TokenNameDOLLAR_LBRACE) {
2424       getNextToken();
2425       expression();
2426       ;
2427       if (token != TokenNameRBRACE) {
2428         throwSyntaxError("'}' expected after indirect variable token '${'.");
2429       }
2430       getNextToken();
2431     } else {
2432       if (token == TokenNameVariable) {
2433         getNextToken();
2434         if (token == TokenNameLBRACKET) {
2435           getNextToken();
2436           expression();
2437           if (token != TokenNameRBRACKET) {
2438             throwSyntaxError("']' expected in variable-list.");
2439           }
2440           getNextToken();
2441         } else if (token == TokenNameEQUAL) {
2442           getNextToken();
2443           constant();
2444         }
2445       } else {
2446         throwSyntaxError("$-variable expected in variable-list.");
2447       }
2448     }
2449   }
2450
2451   /**
2452    * It will look for a value (after a '=' for example)
2453    * @throws CoreException
2454    */
2455   private void constant() throws CoreException {
2456     //   String ident;
2457     switch (token) {
2458       case TokenNamePLUS :
2459         getNextToken();
2460         switch (token) {
2461           case TokenNameDoubleLiteral :
2462             getNextToken();
2463             break;
2464           case TokenNameIntegerLiteral :
2465             getNextToken();
2466             break;
2467           default :
2468             throwSyntaxError("Constant expected after '+' presign.");
2469         }
2470         break;
2471       case TokenNameMINUS :
2472         getNextToken();
2473         switch (token) {
2474           case TokenNameDoubleLiteral :
2475             getNextToken();
2476             break;
2477           case TokenNameIntegerLiteral :
2478             getNextToken();
2479             break;
2480           default :
2481             throwSyntaxError("Constant expected after '-' presign.");
2482         }
2483         break;
2484       case TokenNamenull :
2485         getNextToken();
2486         break;
2487       case TokenNamefalse :
2488         getNextToken();
2489         break;
2490       case TokenNametrue :
2491         getNextToken();
2492         break;
2493       case TokenNameIdentifier :
2494         //   ident = identifier;
2495         char[] ident = scanner.getCurrentIdentifierSource();
2496         getNextToken();
2497         if (token == TokenNameLPAREN) {
2498           getNextToken();
2499           if (token != TokenNameRPAREN) {
2500             expressionList();
2501             if (token != TokenNameRPAREN) {
2502               throwSyntaxError("')' expected after identifier '" + new String(ident) + "' in postfix-expression.");
2503             }
2504           }
2505           getNextToken();
2506         }
2507         break;
2508       case TokenNameStringLiteral :
2509         getNextToken();
2510         break;
2511       case TokenNameStringConstant :
2512         getNextToken();
2513         break;
2514       case TokenNameStringInterpolated :
2515         getNextToken();
2516         break;
2517       case TokenNameDoubleLiteral :
2518         getNextToken();
2519         break;
2520       case TokenNameIntegerLiteral :
2521         getNextToken();
2522         break;
2523       default :
2524         throwSyntaxError("Constant expected.");
2525     }
2526   }
2527
2528 }