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 import java.util.Hashtable;
  15
  16 import net.sourceforge.phpdt.core.compiler.*;
  17 import net.sourceforge.phpdt.internal.compiler.parser.*;
  18 import net.sourceforge.phpeclipse.PHPeclipsePlugin;
  19 import net.sourceforge.phpeclipse.phpeditor.PHPString;
  20 import net.sourceforge.phpeclipse.phpeditor.php.PHPKeywords;
  21
  22 import org.eclipse.core.resources.IFile;
  23 import org.eclipse.core.resources.IMarker;
  24 import org.eclipse.core.runtime.CoreException;
  25 import org.eclipse.jface.preference.IPreferenceStore;
  26 import org.eclipse.ui.texteditor.MarkerUtilities;
  27 import test.PHPParserSuperclass;
  28
  29 public class Parser extends PHPParserSuperclass implements PHPKeywords, ITerminalSymbols {
  30
  31   public static final int ERROR = 2;
  32   public static final int WARNING = 1;
  33   public static final int INFO = 0;
  34
  35   public static final boolean DEBUG = false;
  36   //scanner token
  37   public Scanner scanner;
  38
  39   private IFile fileToParse;
  40   private ArrayList phpList;
  41
  42   private int currentPHPString;
  43   private boolean phpEnd;
  44
  45   // private static HashMap keywordMap = null;
  46   private String str;
  47
  48   // current character
  49 //  char ch;
  50   // current token
  51   int token;
  52
  53   // row counter for syntax errors:
  54   //int rowCount;
  55   // column counter for syntax errors:
  56   //int columnCount;
  57
  58   //int chIndx;
  59   //
  60   //    // current identifier
  61   //    String identifier;
  62
  63   Long longNumber;
  64   Double doubleNumber;
  65
  66   private String stringValue;
  67
  68   /** Contains the current expression. */
  69  // private StringBuffer expression;
  70
  71   private boolean phpMode;
  72
  73   //    final static int TokenNameEOF = 0;
  74   //    final static int TokenNameERROR = 1;
  75   //    final static int TokenNameHTML = 2;
  76   //
  77   //    final static int TokenNameREMAINDER = 30;
  78   //    final static int TokenNameNOT = 31;
  79   //    final static int TokenNameDOT = 32;
  80   //    final static int TokenNameXOR = 33;
  81   //    final static int TokenNameDIVIDE = 34;
  82   //    final static int TokenNameMULTIPLY = 35;
  83   //    final static int TokenNameMINUS = 36;
  84   //    final static int TokenNamePLUS = 37;
  85   //    final static int TokenNameEQUAL_EQUAL = 38;
  86   //    final static int TokenNameNOT_EQUAL = 39;
  87   //    final static int TokenNameGREATER = 40;
  88   //    final static int TokenNameGREATER_EQUAL = 41;
  89   //    final static int TokenNameLESS = 42;
  90   //    final static int TokenNameLESS_EQUAL = 43;
  91   //    final static int TokenNameAND_AND = 44;
  92   //    final static int TokenNameOR_OR = 45;
  93   //    // final static int TokenNameHASH = 46;
  94   //    final static int TokenNameCOLON = 47;
  95   //    final static int TokenNameDOT_EQUAL = 48;
  96   //
  97   //    final static int TokenNameEQUAL = 49;
  98   //    final static int TokenNameMINUS_GREATER = 50; // ->
  99   //    final static int TokenNameFOREACH = 51;
 100   //    final static int TokenNameAND = 52;
 101   //    //final static int TokenNameDOLLARLISTOPEN = 53;
 102   //    final static int TokenNameTWIDDLE = 54;
 103   //    final static int TokenNameTWIDDLE_EQUAL = 55;
 104   //    final static int TokenNameREMAINDER_EQUAL = 56;
 105   //    final static int TokenNameXOR_EQUAL = 57;
 106   //    final static int TokenNameRIGHT_SHIFT_EQUAL = 58;
 107   //    final static int TokenNameLEFT_SHIFT_EQUAL = 59;
 108   //    final static int TokenNameAND_EQUAL = 60;
 109   //    final static int TokenNameOR_EQUAL = 61;
 110   //    final static int TokenNameQUESTION = 62;
 111   //    final static int TokenNameCOLON_COLON = 63;
 112   //    final static int TokenNameAT = 63;
 113   //    // final static int TokenNameHEREDOC = 64;
 114   //
 115   //    final static int TokenNameDOLLAROPEN = 127;
 116   //    final static int TokenNameLPAREN = 128;
 117   //    final static int TokenNameRPAREN = 129;
 118   //    final static int TokenNameLBRACE = 130;
 119   //    final static int TokenNameRBRACE = 131;
 120   //    final static int TokenNameLBRACKET = 132;
 121   //    final static int TokenNameRBRACKET = 133;
 122   //    final static int TokenNameCOMMA = 134;
 123   //
 124   //    final static int TokenNameStringLiteral = 136;
 125   //    final static int TokenNameIdentifier = 138;
 126   //    // final static int TokenNameDIGIT = 139;
 127   //    final static int TokenNameSEMICOLON = 140;
 128   //    // final static int TokenNameSLOT = 141;
 129   //    // final static int TokenNameSLOTSEQUENCE = 142;
 130   //    final static int TokenNameMINUS_MINUS = 144;
 131   //    final static int TokenNamePLUS_PLUS = 145;
 132   //    final static int TokenNamePLUS_EQUAL = 146;
 133   //    final static int TokenNameDIVIDE_EQUAL = 147;
 134   //    final static int TokenNameMINUS_EQUAL = 148;
 135   //    final static int TokenNameMULTIPLY_EQUAL = 149;
 136   //    final static int TokenNameVariable = 150;
 137   //    final static int TokenNameIntegerLiteral = 151;
 138   //    final static int TokenNameDoubleLiteral = 152;
 139   //    final static int TokenNameStringInterpolated = 153;
 140   //    final static int TokenNameStringConstant = 154;
 141   //
 142   //    final static int TokenNameLEFT_SHIFT = 155;
 143   //    final static int TokenNameRIGHT_SHIFT = 156;
 144   //    final static int TokenNameEQUAL_EQUAL_EQUAL = 157;
 145   //    final static int TokenNameNOT_EQUAL_EQUAL = 158;
 146   //    final static int TokenNameOR = 159;
 147   //  final static int TokenNameAT = 153; // @
 148
 149   public Parser() {
 150   }
 151
 152   public void setFileToParse(IFile fileToParse) {
 153     this.currentPHPString = 0;
 154     this.fileToParse = fileToParse;
 155     this.phpList = null;
 156     this.str = "";
 157     this.token = TokenNameEOF;
 158     this.phpEnd = false;
 159     this.initializeScanner();
 160   }
 161   /**
 162    *  Class Constructor.
 163    *
 164    *@param  s
 165    *@param  sess  Description of Parameter
 166    *@see
 167    */
 168   public Parser(IFile fileToParse) {
 169 //    if (keywordMap == null) {
 170 //      keywordMap = new HashMap();
 171 //      for (int i = 0; i < PHP_KEYWORS.length; i++) {
 172 //        keywordMap.put(PHP_KEYWORS[i], new Integer(PHP_KEYWORD_TOKEN[i]));
 173 //      }
 174 //    }
 175     this.currentPHPString = 0;
 176     this.fileToParse = fileToParse;
 177     this.phpList = null;
 178     this.str = "";
 179     this.token = TokenNameEOF;
 180 //    this.chIndx = 0;
 181 //    this.rowCount = 1;
 182 //    this.columnCount = 0;
 183     this.phpEnd = false;
 184     //   getNextToken();
 185
 186     this.initializeScanner();
 187   }
 188
 189   public void initializeScanner() {
 190     this.scanner = new Scanner(false, false, false, false);
 191   }
 192   /**
 193    * Create marker for the parse error
 194    */
 195   private void setMarker(
 196     String message,
 197     int charStart,
 198     int charEnd,
 199     int errorLevel)
 200     throws CoreException {
 201     setMarker(fileToParse, message, charStart, charEnd, errorLevel);
 202   }
 203
 204   public static void setMarker(
 205     IFile file,
 206     String message,
 207     int charStart,
 208     int charEnd,
 209     int errorLevel)
 210     throws CoreException {
 211     if (file != null) {
 212       Hashtable attributes = new Hashtable();
 213       MarkerUtilities.setMessage(attributes, message);
 214       switch (errorLevel) {
 215         case ERROR :
 216           attributes.put(IMarker.SEVERITY, new Integer(IMarker.SEVERITY_ERROR));
 217           break;
 218         case WARNING :
 219           attributes.put(
 220             IMarker.SEVERITY,
 221             new Integer(IMarker.SEVERITY_WARNING));
 222           break;
 223         case INFO :
 224           attributes.put(IMarker.SEVERITY, new Integer(IMarker.SEVERITY_INFO));
 225           break;
 226       }
 227       MarkerUtilities.setCharStart(attributes, charStart);
 228       MarkerUtilities.setCharEnd(attributes, charEnd);
 229       // setLineNumber(attributes, lineNumber);
 230       MarkerUtilities.createMarker(file, attributes, IMarker.PROBLEM);
 231     }
 232   }
 233
 234   /**
 235    * This method will throw the SyntaxError.
 236    * It will add the good lines and columns to the Error
 237    * @param error the error message
 238    * @throws SyntaxError the error raised
 239    */
 240   private void throwSyntaxError(String error) {
 241
 242 //    if (str.length() < chIndx) {
 243 //      chIndx--;
 244 //    }
 245 //    // read until end-of-line
 246 //    int eol = chIndx;
 247 //    while (str.length() > eol) {
 248 //      ch = str.charAt(eol++);
 249 //      if (ch == '\n') {
 250 //        eol--;
 251 //        break;
 252 //      }
 253 //    }
 254 //    throw new SyntaxError(
 255 //      rowCount,
 256 //      chIndx - columnCount + 1,
 257 //      str.substring(columnCount, eol),
 258 //      error);
 259     throw new SyntaxError(
 260       1,
 261       1,
 262       "",
 263       error);
 264   }
 265
 266   /**
 267    * This method will throw the SyntaxError.
 268    * It will add the good lines and columns to the Error
 269    * @param error the error message
 270    * @throws SyntaxError the error raised
 271    */
 272   private void throwSyntaxError(String error, int startRow) {
 273     throw new SyntaxError(startRow, 0, " ", error);
 274   }
 275
 276   /**
 277    *  Method Declaration.
 278    *
 279    *@see
 280    */
 281 //  private void getChar() {
 282 //    if (str.length() > chIndx) {
 283 //      ch = str.charAt(chIndx++);
 284 //
 285 //      return;
 286 //    }
 287 //
 288 //    chIndx = str.length() + 1;
 289 //    ch = ' ';
 290 //    //  token = TokenNameEOF;
 291 //    phpEnd = true;
 292 //  }
 293
 294   /**
 295    * gets the next token from input
 296    */
 297   private void getNextToken() throws CoreException {
 298     try {
 299       token = scanner.getNextToken();
 300       if (DEBUG) {
 301         int currentEndPosition = scanner.getCurrentTokenEndPosition();
 302         int currentStartPosition = scanner.getCurrentTokenStartPosition();
 303
 304         System.out.print(
 305           currentStartPosition + "," + currentEndPosition + ": ");
 306         System.out.println(scanner.toStringAction(token));
 307       }
 308     } catch (InvalidInputException e) {
 309       token = TokenNameERROR;
 310     }
 311     return;
 312
 313     //          boolean phpFound = false;
 314     //          char ch2;
 315     //
 316     //          phpEnd = false;
 317     //          try {
 318     //                  if (!phpMode) {
 319     //
 320     //                          while (str.length() > chIndx) {
 321     //                                  token = TokenNameERROR;
 322     //                                  ch = str.charAt(chIndx++);
 323     //
 324     //                                  if (ch == '\n') {
 325     //                                          rowCount++;
 326     //                                  }
 327     //                                  if (ch == '<') {
 328     //                                          ch2 = str.charAt(chIndx++);
 329     //                                          if (ch2 == '?') {
 330     //                                                  ch2 = str.charAt(chIndx++);
 331     //                                                  if (Character.isWhitespace(ch2)) {
 332     //                                                          // php start
 333     //                                                          phpMode = true;
 334     //                                                          phpFound = true;
 335     //                                                          break;
 336     //                                                  } else if (ch2 == 'p' || ch2 == 'P') {
 337     //                                                          ch2 = str.charAt(chIndx++);
 338     //                                                          if (ch2 == 'h' || ch2 == 'H') {
 339     //                                                                  ch2 = str.charAt(chIndx++);
 340     //                                                                  if (ch2 == 'p' || ch2 == 'P') {
 341     //                                                                          phpMode = true;
 342     //                                                                          phpFound = true;
 343     //                                                                          break;
 344     //                                                                  }
 345     //                                                                  chIndx--;
 346     //                                                          }
 347     //                                                          chIndx--;
 348     //                                                  }
 349     //                                                  chIndx--;
 350     //                                          }
 351     //                                          chIndx--;
 352     //                                  }
 353     //                          }
 354     //
 355     //                  }
 356     //
 357     //                  if (phpMode) {
 358     //                          while (str.length() > chIndx) {
 359     //                                  ch = str.charAt(chIndx++);
 360     //                                  token = TokenNameERROR;
 361     //                                  if (ch == '\n') {
 362     //                                          rowCount++;
 363     //                                          columnCount = chIndx;
 364     //                                          continue; // while loop
 365     //                                  }
 366     //                                  if (str.length() == chIndx) {
 367     //                                          phpEnd = true;
 368     //                                  }
 369     //                                  if (!Character.isWhitespace(ch)) {
 370     //                                          if (ch == '$') {
 371     //                                                  if (str.length() > chIndx) {
 372     //                                                          if (str.charAt(chIndx) == '{') {
 373     //                                                                  chIndx++;
 374     //                                                                  token = TokenNameDOLLAROPEN;
 375     //                                                                  return;
 376     //                                                          }
 377     //                                                  }
 378     //                                                  getIdentifier();
 379     //                                                  return;
 380     //                                          }
 381     //                                          if ((ch >= 'a' && ch <= 'z')
 382     //                                                  || (ch >= 'A' && ch <= 'Z')
 383     //                                                  || (ch == '_')
 384     //                                                  || (ch == '$')) {
 385     //                                                  getIdentifier();
 386     //                                                  return;
 387     //                                          }
 388     //                                          if (ch >= '0' && ch <= '9') {
 389     //                                                  getNumber();
 390     //                                                  return;
 391     //                                          }
 392     //                                          if (ch == '/') {
 393     //                                                  if (str.length() > chIndx) {
 394     //                                                          if (str.charAt(chIndx) == '/') {
 395     //                                                                  ch = '/';
 396     //                                                                  chIndx++;
 397     //                                                                  // read comment until end of line:
 398     //                                                                  while ((str.length() > chIndx)
 399     //                                                                          && (ch != '\n')) {
 400     //                                                                          ch = str.charAt(chIndx++);
 401     //                                                                          if (ch == '?') {
 402     //                                                                                  ch2 = str.charAt(chIndx);
 403     //                                                                                  if (ch2 == '>') {
 404     //                                                                                          chIndx++;
 405     //                                                                                          token = TokenNameHTML;
 406     //                                                                                          // php end
 407     //                                                                                          phpMode = false;
 408     //                                                                                          phpEnd = true;
 409     //                                                                                          return;
 410     //                                                                                  }
 411     //                                                                          }
 412     //                                                                  }
 413     //                                                                  rowCount++;
 414     //                                                                  continue;
 415     //
 416     //                                                          } else if (str.charAt(chIndx) == '*') {
 417     //                                                                  chIndx++;
 418     //                                                                  // multi line comment:
 419     //                                                                  while (str.length() > chIndx) {
 420     //                                                                          if (str.charAt(chIndx) == '*'
 421     //                                                                                  && (str.length() > (chIndx + 1))
 422     //                                                                                  && str.charAt(chIndx + 1) == '/') {
 423     //                                                                                  chIndx += 2;
 424     //                                                                                  break;
 425     //                                                                          }
 426     //                                                                          ch = str.charAt(chIndx++);
 427     //                                                                          if (ch == '\n') {
 428     //                                                                                  rowCount++;
 429     //                                                                                  columnCount = chIndx;
 430     //                                                                          }
 431     //                                                                  }
 432     //                                                                  continue;
 433     //                                                          }
 434     //                                                  }
 435     //                                          } else if (ch == '#') {
 436     //                                                  // read comment until end of line:
 437     //                                                  while ((str.length() > chIndx) && (ch != '\n')) {
 438     //                                                          ch = str.charAt(chIndx++);
 439     //                                                          if (ch == '?') {
 440     //                                                                  ch2 = str.charAt(chIndx);
 441     //                                                                  if (ch2 == '>') {
 442     //                                                                          chIndx++;
 443     //                                                                          token = TokenNameHTML;
 444     //                                                                          // php end
 445     //                                                                          phpMode = false;
 446     //                                                                          phpEnd = true;
 447     //                                                                          return;
 448     //                                                                  }
 449     //                                                          }
 450     //                                                  }
 451     //                                                  rowCount++;
 452     //                                                  continue;
 453     //
 454     //                                          } else if (ch == '"') {
 455     //                                                  getString(
 456     //                                                          '"',
 457     //                                                          TokenNameStringInterpolated,
 458     //                                                          "Open string character '\"' at end of file.");
 459     //                                                  return;
 460     //                                          } else if (ch == '\'') {
 461     //                                                  getString(
 462     //                                                          '\'',
 463     //                                                          TokenNameStringConstant,
 464     //                                                          "Open string character \"'\" at end of file.");
 465     //                                                  return;
 466     //                                          } else if (ch == '`') {
 467     //                                                  getString(
 468     //                                                          '`',
 469     //                                                          TokenNameStringConstant,
 470     //                                                          "Open string character \"`\" at end of file.");
 471     //                                                  setMarker(
 472     //                                                          "Other string delimiters prefered (found \"`\").",
 473     //                                                          rowCount,
 474     //                                                          PHPParser.INFO);
 475     //                                                  return;
 476     //                                          }
 477     //
 478     //                                          switch (ch) {
 479     //
 480     //                                                  case '(' :
 481     //                                                          token = TokenNameLPAREN;
 482     //
 483     //                                                          break;
 484     //                                                  case ')' :
 485     //                                                          token = TokenNameRPAREN;
 486     //
 487     //                                                          break;
 488     //                                                  case '{' :
 489     //                                                          token = TokenNameLBRACE;
 490     //
 491     //                                                          break;
 492     //                                                  case '}' :
 493     //                                                          token = TokenNameRBRACE;
 494     //
 495     //                                                          break;
 496     //                                                  case '[' :
 497     //                                                          token = TokenNameLBRACKET;
 498     //
 499     //                                                          break;
 500     //                                                  case ']' :
 501     //                                                          token = TokenNameRBRACKET;
 502     //
 503     //                                                          break;
 504     //                                                  case ',' :
 505     //                                                          token = TokenNameCOMMA;
 506     //
 507     //                                                          break;
 508     //                                                  case '?' :
 509     //                                                          token = TokenNameQUESTION;
 510     //                                                          if (str.length() > chIndx) {
 511     //                                                                  if (str.charAt(chIndx) == '>') {
 512     //                                                                          chIndx++;
 513     //                                                                          token = TokenNameHTML;
 514     //                                                                          // php end
 515     //                                                                          phpMode = false;
 516     //                                                                          phpEnd = true;
 517     //                                                                          break;
 518     //                                                                  }
 519     //                                                          }
 520     //
 521     //                                                          break;
 522     //                                                  case '@' :
 523     //                                                          token = TokenNameAT;
 524     //                                                          break;
 525     //                                                  case '~' :
 526     //                                                          token = TokenNameTWIDDLE;
 527     //                                                          if (str.length() > chIndx) {
 528     //                                                                  if (str.charAt(chIndx) == '=') {
 529     //                                                                          chIndx++;
 530     //                                                                          token = TokenNameTWIDDLE_EQUAL;
 531     //
 532     //                                                                          break;
 533     //                                                                  }
 534     //                                                          }
 535     //                                                          break;
 536     //                                                  case '.' :
 537     //                                                          token = TokenNameDOT;
 538     //                                                          if (str.length() > chIndx) {
 539     //                                                                  if (str.charAt(chIndx) == '=') {
 540     //                                                                          chIndx++;
 541     //                                                                          token = TokenNameDOT_EQUAL;
 542     //
 543     //                                                                          break;
 544     //                                                                  }
 545     //                                                          }
 546     //
 547     //                                                          break;
 548     //                                                  case '"' :
 549     //                                                          token = TokenNameStringLiteral;
 550     //
 551     //                                                          break;
 552     //                                                  case '%' :
 553     //                                                          token = TokenNameREMAINDER;
 554     //                                                          if (str.length() > chIndx) {
 555     //                                                                  if (str.charAt(chIndx) == '=') {
 556     //                                                                          chIndx++;
 557     //                                                                          token = TokenNameREMAINDER_EQUAL;
 558     //
 559     //                                                                          break;
 560     //                                                                  }
 561     //                                                          }
 562     //                                                          break;
 563     //                                                  case ';' :
 564     //                                                          token = TokenNameSEMICOLON;
 565     //
 566     //                                                          break;
 567     //                                                  case '^' :
 568     //                                                          token = TokenNameXOR;
 569     //                                                          if (str.length() > chIndx) {
 570     //                                                                  if (str.charAt(chIndx) == '=') {
 571     //                                                                          chIndx++;
 572     //                                                                          token = TokenNameXOR_EQUAL;
 573     //
 574     //                                                                          break;
 575     //                                                                  }
 576     //                                                          }
 577     //                                                          break;
 578     //                                                  case '/' :
 579     //                                                          token = TokenNameDIVIDE;
 580     //
 581     //                                                          if (str.length() > chIndx) {
 582     //                                                                  if (str.charAt(chIndx) == '=') {
 583     //                                                                          chIndx++;
 584     //                                                                          token = TokenNameDIVIDE_EQUAL;
 585     //
 586     //                                                                          break;
 587     //                                                                  }
 588     //                                                          }
 589     //
 590     //                                                          break;
 591     //                                                  case '*' :
 592     //                                                          token = TokenNameMULTIPLY;
 593     //                                                          if (str.length() > chIndx) {
 594     //                                                                  if (str.charAt(chIndx) == '*') {
 595     //                                                                          chIndx++;
 596     //                                                                          token = TokenNameXOR;
 597     //
 598     //                                                                          break;
 599     //                                                                  }
 600     //                                                                  if (str.charAt(chIndx) == '=') {
 601     //                                                                          chIndx++;
 602     //                                                                          token = TokenNameMULTIPLY_EQUAL;
 603     //
 604     //                                                                          break;
 605     //                                                                  }
 606     //                                                          }
 607     //
 608     //                                                          break;
 609     //                                                  case '+' :
 610     //                                                          token = TokenNamePLUS;
 611     //                                                          if (str.length() > chIndx) {
 612     //                                                                  if (str.charAt(chIndx) == '+') {
 613     //                                                                          chIndx++;
 614     //                                                                          token = TokenNamePLUS_PLUS;
 615     //
 616     //                                                                          break;
 617     //                                                                  }
 618     //                                                                  if (str.charAt(chIndx) == '=') {
 619     //                                                                          chIndx++;
 620     //                                                                          token = TokenNamePLUS_EQUAL;
 621     //
 622     //                                                                          break;
 623     //                                                                  }
 624     //                                                          }
 625     //                                                          break;
 626     //                                                  case '-' :
 627     //                                                          token = TokenNameMINUS;
 628     //                                                          if (str.length() > chIndx) {
 629     //                                                                  if (str.charAt(chIndx) == '-') {
 630     //                                                                          chIndx++;
 631     //                                                                          token = TokenNameMINUS_MINUS;
 632     //
 633     //                                                                          break;
 634     //                                                                  }
 635     //                                                                  if (str.charAt(chIndx) == '=') {
 636     //                                                                          chIndx++;
 637     //                                                                          token = TokenNameMINUS_EQUAL;
 638     //
 639     //                                                                          break;
 640     //                                                                  }
 641     //                                                                  if (str.charAt(chIndx) == '>') {
 642     //                                                                          chIndx++;
 643     //                                                                          token = TokenNameMINUS_GREATER;
 644     //
 645     //                                                                          break;
 646     //                                                                  }
 647     //                                                          }
 648     //
 649     //                                                          break;
 650     //                                                  case '=' :
 651     //                                                          token = TokenNameEQUAL;
 652     //
 653     //                                                          if (str.length() > chIndx) {
 654     //                                                                  ch = str.charAt(chIndx);
 655     //
 656     //                                                                  if (ch == '=') {
 657     //                                                                          chIndx++;
 658     //                                                                          token = TokenNameEQUAL_EQUAL;
 659     //                                                                          if (str.length() > chIndx) {
 660     //                                                                                  ch = str.charAt(chIndx);
 661     //
 662     //                                                                                  if (ch == '=') {
 663     //                                                                                          chIndx++;
 664     //                                                                                          token =
 665     //                                                                                                  TokenNameEQUAL_EQUAL_EQUAL;
 666     //                                                                                  }
 667     //                                                                          }
 668     //                                                                          break;
 669     //                                                                  }
 670     //                                                                  if (ch == '>') {
 671     //                                                                          chIndx++;
 672     //                                                                          token = TokenNameEQUAL_GREATER;
 673     //
 674     //                                                                          break;
 675     //                                                                  }
 676     //                                                          }
 677     //
 678     //                                                          break;
 679     //                                                  case '!' :
 680     //                                                          token = TokenNameNOT;
 681     //
 682     //                                                          if (str.length() > chIndx) {
 683     //                                                                  if (str.charAt(chIndx) == '=') {
 684     //                                                                          chIndx++;
 685     //                                                                          token = TokenNameNOT_EQUAL;
 686     //                                                                          if (str.length() > chIndx) {
 687     //                                                                                  ch = str.charAt(chIndx);
 688     //
 689     //                                                                                  if (ch == '=') {
 690     //                                                                                          chIndx++;
 691     //                                                                                          token =
 692     //                                                                                                  TokenNameNOT_EQUAL_EQUAL;
 693     //                                                                                  }
 694     //                                                                          }
 695     //                                                                          break;
 696     //                                                                  }
 697     //                                                          }
 698     //
 699     //                                                          break;
 700     //                                                  case '>' :
 701     //                                                          token = TokenNameGREATER;
 702     //
 703     //                                                          if (str.length() > chIndx) {
 704     //                                                                  if (str.charAt(chIndx) == '=') {
 705     //                                                                          chIndx++;
 706     //                                                                          token = TokenNameGREATER_EQUAL;
 707     //                                                                          break;
 708     //                                                                  }
 709     //                                                                  if (str.charAt(chIndx) == '>') {
 710     //                                                                          chIndx++;
 711     //                                                                          token = TokenNameRIGHT_SHIFT;
 712     //                                                                          if (str.length() > chIndx) {
 713     //                                                                                  if (str.charAt(chIndx) == '=') {
 714     //                                                                                          chIndx++;
 715     //                                                                                          token =
 716     //                                                                                                  TokenNameRIGHT_SHIFT_EQUAL;
 717     //                                                                                          break;
 718     //                                                                                  }
 719     //                                                                          }
 720     //                                                                          break;
 721     //                                                                  }
 722     //                                                          }
 723     //
 724     //                                                          break;
 725     //                                                  case '<' :
 726     //                                                          token = TokenNameLESS;
 727     //
 728     //                                                          if (str.length() > chIndx) {
 729     //                                                                  if (str.charAt(chIndx) == '=') {
 730     //                                                                          chIndx++;
 731     //                                                                          token = TokenNameLESS_EQUAL;
 732     //
 733     //                                                                          break;
 734     //                                                                  }
 735     //                                                                  if (str.charAt(chIndx) == '<') {
 736     //                                                                          chIndx++;
 737     //                                                                          token = TokenNameLEFT_SHIFT;
 738     //                                                                          if (str.charAt(chIndx) == '<') {
 739     //                                                                                  // heredoc
 740     //                                                                                  int startRow = rowCount;
 741     //                                                                                  if (str.length() > chIndx) {
 742     //
 743     //                                                                                          ch = str.charAt(++chIndx);
 744     //                                                                                          if ((ch >= 'a' && ch <= 'z')
 745     //                                                                                                  || (ch >= 'A' && ch <= 'Z')
 746     //                                                                                                  || (ch == '_')) {
 747     //                                                                                                  chIndx++;
 748     //                                                                                                  getIdentifier();
 749     //                                                                                                  token =
 750     //                                                                                                          TokenNameStringConstant;
 751     //                                                                                                  while (str.length()
 752     //                                                                                                          > chIndx) {
 753     //                                                                                                          ch =
 754     //                                                                                                                  str.charAt(
 755     //                                                                                                                          chIndx++);
 756     //                                                                                                          if (ch == '\n') {
 757     //                                                                                                                  if (str.length()
 758     //                                                                                                                          >= chIndx
 759     //                                                                                                                                  + identifier
 760     //                                                                                                                                          .length()) {
 761     //                                                                                                                          if (str
 762     //                                                                                                                                  .substring(
 763     //                                                                                                                                          chIndx,
 764     //                                                                                                                                          chIndx
 765     //                                                                                                                                                  + identifier
 766     //                                                                                                                                                          .length())
 767     //                                                                                                                                  .equals(identifier)) {
 768     //                                                                                                                                  chIndx
 769     //                                                                                                                                          += identifier
 770     //                                                                                                                                                  .length();
 771     //                                                                                                                                  return;
 772     //                                                                                                                          }
 773     //                                                                                                                  }
 774     //                                                                                                          }
 775     //                                                                                                  }
 776     //                                                                                          }
 777     //                                                                                  }
 778     //                                                                                  throwSyntaxError(
 779     //                                                                                          "Open heredoc syntax after operator '<<<'.",
 780     //                                                                                          startRow);
 781     //                                                                          } else if (str.charAt(chIndx) == '=') {
 782     //                                                                                  chIndx++;
 783     //                                                                                  token = TokenNameLEFT_SHIFT_EQUAL;
 784     //                                                                                  break;
 785     //                                                                          }
 786     //                                                                          break;
 787     //                                                                  }
 788     //                                                          }
 789     //
 790     //                                                          break;
 791     //
 792     //                                                  case '|' :
 793     //                                                          token = TokenNameOR;
 794     //
 795     //                                                          if (str.length() > chIndx) {
 796     //                                                                  if (str.charAt(chIndx) == '|') {
 797     //                                                                          chIndx++;
 798     //                                                                          token = TokenNameOR_OR;
 799     //                                                                          break;
 800     //                                                                  }
 801     //                                                                  if (str.charAt(chIndx) == '=') {
 802     //                                                                          chIndx++;
 803     //                                                                          token = TokenNameOR_EQUAL;
 804     //                                                                          break;
 805     //                                                                  }
 806     //                                                          }
 807     //
 808     //                                                          break;
 809     //                                                  case '&' :
 810     //                                                          token = TokenNameAND;
 811     //                                                          if (str.length() > chIndx) {
 812     //                                                                  if (str.charAt(chIndx) == '&') {
 813     //                                                                          chIndx++;
 814     //                                                                          token = TokenNameAND_AND;
 815     //                                                                          break;
 816     //                                                                  }
 817     //                                                                  if (str.charAt(chIndx) == '=') {
 818     //                                                                          chIndx++;
 819     //                                                                          token = TokenNameAND_EQUAL;
 820     //                                                                          break;
 821     //                                                                  }
 822     //                                                                  break;
 823     //                                                          }
 824     //
 825     //                                                          break;
 826     //                                                  case ':' :
 827     //                                                          token = TokenNameCOLON;
 828     //                                                          if (str.length() > chIndx) {
 829     //                                                                  if (str.charAt(chIndx) == ':') {
 830     //                                                                          chIndx++;
 831     //                                                                          token = TokenNameCOLON_COLON;
 832     //                                                                  }
 833     //                                                          }
 834     //                                                          break;
 835     //                                                          //              case '#' :
 836     //                                                          //                token = TokenNameHASH;
 837     //                                                          //
 838     //                                                          //                break;
 839     //                                                          //          case '@' :
 840     //                                                          //            token = TokenNameAT;
 841     //                                                          //
 842     //                                                          //            break;
 843     //                                                  default :
 844     //                                                          throwSyntaxError(
 845     //                                                                  "unexpected character: '" + ch + "'");
 846     //                                          }
 847     //
 848     //                                          if (token == TokenNameERROR) {
 849     //                                                  throwSyntaxError("token not found");
 850     //                                          }
 851     //
 852     //                                          return;
 853     //                                  }
 854     //                          }
 855     //                  }
 856     //          } catch (StringIndexOutOfBoundsException e) {
 857     //                  // catched from charAt
 858     //          }
 859     //
 860     //          chIndx = str.length() + 1;
 861     //          ch = ' ';
 862     //          token = TokenNameEOF;
 863     //          phpEnd = true;
 864     //          //PHPString temp;
 865     //          //    if (phpList != null) {
 866     //          //      if (currentPHPString < phpList.size()) {
 867     //          //        token = TokenNameUNDEFINED;
 868     //          //        temp = (PHPString) phpList.get(currentPHPString++);
 869     //          //        this.str = temp.getPHPString();
 870     //          //        this.token = TokenNameEOF;
 871     //          //        this.chIndx = 0;
 872     //          //        this.rowCount = temp.getLineNumber();
 873     //          //        this.columnCount = 0;
 874     //          //        getNextToken();
 875     //          //        phpEnd = true;
 876     //          //      } else {
 877     //          //        token = TokenNameUNDEFINED;
 878     //          //        return;
 879     //          //      }
 880     //          //    }
 881   }
 882
 883   //    /**
 884   //     * Get an identifier.
 885   //     */
 886   //    private void getIdentifier() {
 887   //            //  StringBuffer ident = new StringBuffer();
 888   //            int startPosition = chIndx - 1;
 889   //            //    ident.append(ch);
 890   //            if (ch == '$') {
 891   //                    getChar();
 892   //                    // attention recursive call:
 893   //                    getIdentifier();
 894   //                    token = TokenNameVariable;
 895   //                    return;
 896   //            } else {
 897   //                    token = TokenNameIdentifier;
 898   //            }
 899   //
 900   //            getChar();
 901   //
 902   //            //this will read the buffer until the next character is a forbidden character for identifier
 903   //            while ((ch >= 'a' && ch <= 'z')
 904   //                    || (ch >= 'A' && ch <= 'Z')
 905   //                    || (ch >= '0' && ch <= '9')
 906   //                    || (ch == '_')) {
 907   //                    //    ident.append(ch);
 908   //                    getChar();
 909   //            }
 910   //            int endPosition = chIndx--;
 911   //            int length = (--endPosition) - startPosition;
 912   //
 913   //            identifier = str.substring(startPosition, endPosition);
 914   //            // System.out.println(identifier);
 915   //
 916   //            // determine if this identitfer is a keyword
 917   //            // @todo improve this in future version
 918   //            Integer i = (Integer) keywordMap.get(identifier.toLowerCase());
 919   //            if (i != null) {
 920   //                    token = i.intValue();
 921   //            }
 922   //    }
 923
 924   /**
 925    * Get a number.
 926    * if it's a <code>double</code> the number will be stored in <code>doubleNumber</code> and the token will have the
 927    * value {@link Parser#TokenNameDOUBLE_NUMBER}<br />
 928    * if it's a <code>double</code> the number will be stored in <code>longNumber</code> and the token will have the
 929    * value {@link Parser#TokenNameINT_NUMBER}
 930    */
 931 //  private void getNumber() {
 932 //    StringBuffer inum = new StringBuffer();
 933 //    char dFlag = ' ';
 934 //    int numFormat = 10;
 935 //
 936 //    // save first digit
 937 //    char firstCh = ch;
 938 //    inum.append(ch);
 939 //
 940 //    getChar();
 941 //    // determine number conversions:
 942 //    if (firstCh == '0') {
 943 //      switch (ch) {
 944 //        case 'b' :
 945 //          numFormat = 2;
 946 //          getChar();
 947 //          break;
 948 //        case 'B' :
 949 //          numFormat = 2;
 950 //          getChar();
 951 //          break;
 952 //        case 'o' :
 953 //          numFormat = 8;
 954 //          getChar();
 955 //          break;
 956 //        case 'O' :
 957 //          numFormat = 8;
 958 //          getChar();
 959 //          break;
 960 //        case 'x' :
 961 //          numFormat = 16;
 962 //          getChar();
 963 //          break;
 964 //        case 'X' :
 965 //          numFormat = 16;
 966 //          getChar();
 967 //          break;
 968 //      }
 969 //    }
 970 //
 971 //    if (numFormat == 16) {
 972 //      while ((ch >= '0' && ch <= '9')
 973 //        || (ch >= 'a' && ch <= 'f')
 974 //        || (ch >= 'A' && ch <= 'F')) {
 975 //        inum.append(ch);
 976 //        getChar();
 977 //      }
 978 //    } else {
 979 //      while ((ch >= '0' && ch <= '9')
 980 //        || (ch == '.')
 981 //        || (ch == 'E')
 982 //        || (ch == 'e')) {
 983 //        if ((ch == '.') || (ch == 'E') || (ch == 'e')) {
 984 //          if (ch == '.' && dFlag != ' ') {
 985 //            break;
 986 //          }
 987 //          if ((dFlag == 'E') || (dFlag == 'e')) {
 988 //            break;
 989 //          }
 990 //          dFlag = ch;
 991 //          inum.append(ch);
 992 //          getChar();
 993 //          if ((ch == '-') || (ch == '+')) {
 994 //            inum.append(ch);
 995 //            getChar();
 996 //          }
 997 //        } else {
 998 //          inum.append(ch);
 999 //          getChar();
1000 //        }
1001 //      }
1002 //    }
1003 //    chIndx--;
1004 //
1005 //    try {
1006 //      if (dFlag != ' ') {
1007 //        doubleNumber = new Double(inum.toString());
1008 //        token = TokenNameDoubleLiteral;
1009 //        return;
1010 //      } else {
1011 //        longNumber = Long.valueOf(inum.toString(), numFormat);
1012 //        token = TokenNameIntegerLiteral;
1013 //        return;
1014 //      }
1015 //
1016 //    } catch (Throwable e) {
1017 //      throwSyntaxError("Number format error: " + inum.toString());
1018 //    }
1019 //  }
1020 //
1021 //  /**
1022 //   * Get a String.
1023 //   * @param openChar the opening char ('\'', '"', '`')
1024 //   * @param typeString the type of string {@link #TokenNameSTRING_CONSTANT},{@link #TokenNameINTERPOLATED_STRING}
1025 //   * @param errorMsg the error message in case of parse error in the string
1026 //   */
1027 //  private void getString(
1028 //    final char openChar,
1029 //    final int typeString,
1030 //    final String errorMsg) {
1031 //    StringBuffer sBuffer = new StringBuffer();
1032 //    boolean openString = true;
1033 //    int startRow = rowCount;
1034 //    while (str.length() > chIndx) {
1035 //      ch = str.charAt(chIndx++);
1036 //      if (ch == '\\') {
1037 //        sBuffer.append(ch);
1038 //        if (str.length() > chIndx) {
1039 //          ch = str.charAt(chIndx++);
1040 //          sBuffer.append(ch);
1041 //        }
1042 //      } else if (ch == openChar) {
1043 //        openString = false;
1044 //        break;
1045 //      } else if (ch == '\n') {
1046 //        rowCount++;
1047 //        columnCount = chIndx;
1048 //      } else {
1049 //        sBuffer.append(ch);
1050 //      }
1051 //    }
1052 //    if (openString) {
1053 //      if (typeString == TokenNameStringConstant) {
1054 //        throwSyntaxError(errorMsg, startRow);
1055 //      } else {
1056 //        throwSyntaxError(errorMsg);
1057 //      }
1058 //    }
1059 //    token = typeString;
1060 //    stringValue = sBuffer.toString();
1061 //  }
1062
1063   //    public void htmlParserTester(String input) {
1064   //            int lineNumber = 1;
1065   //            int startLineNumber = 1;
1066   //            int startIndex = 0;
1067   //            char ch;
1068   //            char ch2;
1069   //            boolean phpMode = false;
1070   //            boolean phpFound = false;
1071   //
1072   //            phpList = new ArrayList();
1073   //            currentPHPString = 0;
1074   //
1075   //            try {
1076   //                    int i = 0;
1077   //                    while (i < input.length()) {
1078   //                            ch = input.charAt(i++);
1079   //                            if (ch == '\n') {
1080   //                                    lineNumber++;
1081   //                            }
1082   //                            if ((!phpMode) && ch == '<') {
1083   //                                    ch2 = input.charAt(i++);
1084   //                                    if (ch2 == '?') {
1085   //                                            ch2 = input.charAt(i++);
1086   //                                            if (Character.isWhitespace(ch2)) {
1087   //                                                    // php start
1088   //                                                    phpMode = true;
1089   //                                                    phpFound = true;
1090   //                                                    startIndex = i;
1091   //                                                    startLineNumber = lineNumber;
1092   //                                                    continue;
1093   //                                            } else if (ch2 == 'p') {
1094   //                                                    ch2 = input.charAt(i++);
1095   //                                                    if (ch2 == 'h') {
1096   //                                                            ch2 = input.charAt(i++);
1097   //                                                            if (ch2 == 'p') {
1098   //                                                                    phpMode = true;
1099   //                                                                    phpFound = true;
1100   //                                                                    startIndex = i;
1101   //                                                                    startLineNumber = lineNumber;
1102   //                                                                    continue;
1103   //                                                            }
1104   //                                                            i--;
1105   //                                                    }
1106   //                                                    i--;
1107   //                                            } else if (ch2 == 'P') {
1108   //                                                    ch2 = input.charAt(i++);
1109   //                                                    if (ch2 == 'H') {
1110   //                                                            ch2 = input.charAt(i++);
1111   //                                                            if (ch2 == 'P') {
1112   //                                                                    phpMode = true;
1113   //                                                                    phpFound = true;
1114   //                                                                    startIndex = i;
1115   //                                                                    startLineNumber = lineNumber;
1116   //                                                                    continue;
1117   //                                                            }
1118   //                                                            i--;
1119   //                                                    }
1120   //                                                    i--;
1121   //                                            }
1122   //                                            i--;
1123   //                                    }
1124   //                                    i--;
1125   //                            }
1126   //
1127   //                            if (phpMode) {
1128   //                                    if (ch == '/' && i < input.length()) {
1129   //                                            ch2 = input.charAt(i++);
1130   //                                            if (ch2 == '/') {
1131   //                                                    while (i < input.length()) {
1132   //                                                            ch = input.charAt(i++);
1133   //                                                            if (ch == '?' && i < input.length()) {
1134   //                                                                    ch2 = input.charAt(i++);
1135   //                                                                    if (ch2 == '>') {
1136   //                                                                            // php end
1137   //                                                                            phpMode = false;
1138   //                                                                            phpList.add(
1139   //                                                                                    new PHPString(
1140   //                                                                                            input.substring(
1141   //                                                                                                    startIndex,
1142   //                                                                                                    i - 2),
1143   //                                                                                            startLineNumber));
1144   //                                                                            continue;
1145   //                                                                    }
1146   //                                                                    i--;
1147   //                                                            } else if (ch == '\n') {
1148   //                                                                    lineNumber++;
1149   //                                                                    break;
1150   //                                                            }
1151   //                                                    }
1152   //                                                    continue;
1153   //                                            } else if (ch2 == '*') {
1154   //                                                    // multi-line comment
1155   //                                                    while (i < input.length()) {
1156   //                                                            ch = input.charAt(i++);
1157   //                                                            if (ch == '\n') {
1158   //                                                                    lineNumber++;
1159   //                                                            } else if (ch == '*' && i < input.length()) {
1160   //                                                                    ch2 = input.charAt(i++);
1161   //                                                                    if (ch2 == '/') {
1162   //                                                                            break;
1163   //                                                                    }
1164   //                                                                    i--;
1165   //                                                            }
1166   //                                                    }
1167   //                                                    continue;
1168   //                                            } else {
1169   //                                                    i--;
1170   //                                            }
1171   //                                    } else if (ch == '#') {
1172   //                                            while (i < input.length()) {
1173   //                                                    ch = input.charAt(i++);
1174   //                                                    if (ch == '?' && i < input.length()) {
1175   //                                                            ch2 = input.charAt(i++);
1176   //                                                            if (ch2 == '>') {
1177   //                                                                    // php end
1178   //                                                                    phpMode = false;
1179   //                                                                    phpList.add(
1180   //                                                                            new PHPString(
1181   //                                                                                    input.substring(startIndex, i - 2),
1182   //                                                                                    startLineNumber));
1183   //                                                                    continue;
1184   //                                                            }
1185   //                                                            i--;
1186   //                                                    } else if (ch == '\n') {
1187   //                                                            lineNumber++;
1188   //                                                            break;
1189   //                                                    }
1190   //                                            }
1191   //                                            continue;
1192   //                                    } else if (ch == '"') {
1193   //                                            ch = ' ';
1194   //                                            while (i < input.length()) {
1195   //                                                    ch = input.charAt(i++);
1196   //                                                    if (ch == '\n') {
1197   //                                                            lineNumber++;
1198   //                                                    } else if (
1199   //                                                            ch == '\\' && i < input.length()) { // escape
1200   //                                                            i++;
1201   //                                                    } else if (ch == '"') {
1202   //                                                            break;
1203   //                                                    }
1204   //                                            }
1205   //                                            continue;
1206   //                                    } else if (ch == '\'') {
1207   //                                            ch = ' ';
1208   //                                            while (i < input.length()) {
1209   //                                                    ch = input.charAt(i++);
1210   //                                                    if (ch == '\n') {
1211   //                                                            lineNumber++;
1212   //                                                    } else if (
1213   //                                                            ch == '\\' && i < input.length()) { // escape
1214   //                                                            i++;
1215   //                                                    } else if (ch == '\'') {
1216   //                                                            break;
1217   //                                                    }
1218   //                                            }
1219   //                                            continue;
1220   //                                    }
1221   //
1222   //                                    if (ch == '?' && i < input.length()) {
1223   //                                            ch2 = input.charAt(i++);
1224   //                                            if (ch2 == '>') {
1225   //                                                    // php end
1226   //                                                    phpMode = false;
1227   //                                                    phpList.add(
1228   //                                                            new PHPString(
1229   //                                                                    input.substring(startIndex, i - 2),
1230   //                                                                    startLineNumber));
1231   //                                                    continue;
1232   //                                            }
1233   //                                            i--;
1234   //                                    }
1235   //                            }
1236   //                    }
1237   //
1238   //                    if (!phpFound) {
1239   //                            setMarker(
1240   //                                    "No PHP source code found.",
1241   //                                    lineNumber,
1242   //                                    PHPParser.INFO);
1243   //                    } else {
1244   //                            if (phpMode) {
1245   //                                    setMarker(
1246   //                                            "Open PHP tag at end of file.",
1247   //                                            lineNumber,
1248   //                                            PHPParser.INFO);
1249   //                                    phpList.add(
1250   //                                            new PHPString(
1251   //                                                    input.substring(startIndex, i - 2),
1252   //                                                    startLineNumber));
1253   //                            }
1254   //                            //        for (int j=0;j<phpList.size();j++) {
1255   //                            //          String temp = ((PHPString)phpList.get(j)).getPHPString();
1256   //                            //          int startIndx = temp.length()-10;
1257   //                            //          if (startIndx<0) {
1258   //                            //            startIndx = 0;
1259   //                            //          }
1260   //                            //          System.out.println(temp.substring(startIndx)+"?>");
1261   //                            //        }
1262   //                            phpParserTester(null, 1);
1263   //                            //        PHPString temp;
1264   //                            //        for(int j=0;j<phpList.size();j++) {
1265   //                            //          temp = (PHPString) phpList.get(j);
1266   //                            //          parser.start(temp.getPHPString(), temp.getLineNumber());
1267   //                            //        }
1268   //                    }
1269   //            } catch (CoreException e) {
1270   //            }
1271   //    }
1272
1273   public void phpParserTester(String s, int rowCount) throws CoreException {
1274     this.str = s;
1275     if (s == null) {
1276       if (phpList.size() != 0) {
1277         this.str = ((PHPString) phpList.get(currentPHPString++)).getPHPString();
1278       }
1279     }
1280     this.token = TokenNameEOF;
1281 //    this.chIndx = 0;
1282 //    this.rowCount = rowCount;
1283 //    this.columnCount = 0;
1284     this.phpEnd = false;
1285     this.phpMode = true;
1286     scanner.setSource(s.toCharArray());
1287     scanner.setPHPMode(true);
1288     getNextToken();
1289     do {
1290       try {
1291         if (token != TokenNameEOF && token != TokenNameERROR) {
1292           statementList();
1293         }
1294         if (token != TokenNameEOF && token != TokenNameERROR) {
1295           if (token == TokenNameRPAREN) {
1296             throwSyntaxError("Too many closing ')'; end-of-file not reached.");
1297           }
1298           if (token == TokenNameRBRACE) {
1299             throwSyntaxError("Too many closing '}'; end-of-file not reached.");
1300           }
1301           if (token == TokenNameRBRACKET) {
1302             throwSyntaxError("Too many closing ']'; end-of-file not reached.");
1303           }
1304
1305           if (token == TokenNameLPAREN) {
1306             throwSyntaxError("Read character '('; end-of-file not reached.");
1307           }
1308           if (token == TokenNameLBRACE) {
1309             throwSyntaxError("Read character '{';  end-of-file not reached.");
1310           }
1311           if (token == TokenNameLBRACKET) {
1312             throwSyntaxError("Read character '[';  end-of-file not reached.");
1313           }
1314
1315           throwSyntaxError("End-of-file not reached.");
1316         }
1317         return;
1318       } catch (SyntaxError err) {
1319         if (s != null) {
1320           throw err;
1321         } else {
1322           //   setMarker(err.getMessage(), err.getLine(), ERROR);
1323           setMarker(
1324             err.getMessage(),
1325             scanner.getCurrentTokenStartPosition(),
1326             scanner.getCurrentTokenEndPosition(),
1327             ERROR);
1328         }
1329         // if an error occured,
1330         // try to find keywords 'class' or 'function'
1331         // to parse the rest of the string
1332         while (token != TokenNameEOF && token != TokenNameERROR) {
1333           if (token == TokenNameclass || token == TokenNamefunction) {
1334             break;
1335           }
1336           getNextToken();
1337         }
1338         if (token == TokenNameEOF || token == TokenNameERROR) {
1339           return;
1340         }
1341       }
1342     }
1343     while (true);
1344   }
1345
1346   /**
1347    * Parses a string with php tags
1348    * i.e. '&lt;body&gt; &lt;?php phpinfo() ?&gt; &lt;/body&gt;'
1349    */
1350   public void parse(String s) throws CoreException {
1351     this.str = s;
1352     this.token = TokenNameEOF;
1353 //    this.chIndx = 0;
1354 //    this.rowCount = 1;
1355 //    this.columnCount = 0;
1356     this.phpEnd = false;
1357     this.phpMode = false;
1358     /* scanner initialization */
1359     scanner.setSource(s.toCharArray());
1360     scanner.setPHPMode(false);
1361     getNextToken();
1362     do {
1363       try {
1364         if (token != TokenNameEOF && token != TokenNameERROR) {
1365           statementList();
1366         }
1367         if (token != TokenNameEOF && token != TokenNameERROR) {
1368           if (token == TokenNameRPAREN) {
1369             throwSyntaxError("Too many closing ')'; end-of-file not reached.");
1370           }
1371           if (token == TokenNameRBRACE) {
1372             throwSyntaxError("Too many closing '}'; end-of-file not reached.");
1373           }
1374           if (token == TokenNameRBRACKET) {
1375             throwSyntaxError("Too many closing ']'; end-of-file not reached.");
1376           }
1377
1378           if (token == TokenNameLPAREN) {
1379             throwSyntaxError("Read character '('; end-of-file not reached.");
1380           }
1381           if (token == TokenNameLBRACE) {
1382             throwSyntaxError("Read character '{';  end-of-file not reached.");
1383           }
1384           if (token == TokenNameLBRACKET) {
1385             throwSyntaxError("Read character '[';  end-of-file not reached.");
1386           }
1387
1388           throwSyntaxError("End-of-file not reached.");
1389         }
1390         return;
1391       } catch (SyntaxError sytaxErr1) {
1392         // setMarker(sytaxErr1.getMessage(), sytaxErr1.getLine(), ERROR);
1393         setMarker(
1394           sytaxErr1.getMessage(),
1395           scanner.getCurrentTokenStartPosition(),
1396           scanner.getCurrentTokenEndPosition(),
1397           ERROR);
1398         try {
1399           // if an error occured,
1400           // try to find keywords 'class' or 'function'
1401           // to parse the rest of the string
1402           while (token != TokenNameEOF && token != TokenNameERROR) {
1403             if (token == TokenNameclass || token == TokenNamefunction) {
1404               break;
1405             }
1406             getNextToken();
1407           }
1408           if (token == TokenNameEOF || token == TokenNameERROR) {
1409             return;
1410           }
1411         } catch (SyntaxError sytaxErr2) {
1412           //    setMarker(sytaxErr2.getMessage(), sytaxErr2.getLine(), ERROR);
1413           setMarker(
1414             sytaxErr2.getMessage(),
1415             scanner.getCurrentTokenStartPosition(),
1416             scanner.getCurrentTokenEndPosition(),
1417             ERROR);
1418           return;
1419         }
1420       }
1421     }
1422     while (true);
1423   }
1424
1425   public PHPOutlineInfo parseInfo(Object parent, String s) {
1426     PHPOutlineInfo outlineInfo = new PHPOutlineInfo(parent);
1427     //    Stack stack = new Stack();
1428     //    stack.push(outlineInfo.getDeclarations());
1429
1430     this.str = s;
1431     this.token = TokenNameEOF;
1432 //    this.chIndx = 0;
1433 //    this.rowCount = 1;
1434 //    this.columnCount = 0;
1435     this.phpEnd = false;
1436     this.phpMode = false;
1437     scanner.setSource(s.toCharArray());
1438     scanner.setPHPMode(false);
1439
1440     try {
1441       getNextToken();
1442       parseDeclarations(outlineInfo, outlineInfo.getDeclarations(), false);
1443     } catch (CoreException e) {
1444     }
1445     return outlineInfo;
1446   }
1447
1448   private void parseDeclarations(
1449     PHPOutlineInfo outlineInfo,
1450     PHPSegmentWithChildren current,
1451     boolean goBack) {
1452     char[] ident;
1453     //   PHPClassDeclaration current = (PHPClassDeclaration) stack.peek();
1454     PHPSegmentWithChildren temp;
1455     int counter = 0;
1456
1457     IPreferenceStore store = PHPeclipsePlugin.getDefault().getPreferenceStore();
1458     try {
1459       while (token != TokenNameEOF && token != TokenNameERROR) {
1460         if (token == TokenNameVariable) {
1461           ident = scanner.getCurrentIdentifierSource();
1462           outlineInfo.addVariable(new String(ident));
1463           getNextToken();
1464         } else if (token == TokenNamevar) {
1465           getNextToken();
1466           if (token == TokenNameVariable
1467             && store.getBoolean(PHPeclipsePlugin.PHP_OUTLINE_VAR)) {
1468             ident = scanner.getCurrentIdentifierSource();
1469             String variableName = new String(ident);
1470             outlineInfo.addVariable(variableName);
1471             getNextToken();
1472             if (token != TokenNameSEMICOLON) {
1473
1474               getNextToken();
1475               ident = scanner.getCurrentTokenSource();
1476               if (token > TokenNameKEYWORD) {
1477                 current.add(new PHPVarDeclaration(current, variableName,
1478                 //                      chIndx - ident.length,
1479                 scanner.getCurrentTokenStartPosition(), new String(ident)));
1480               } else {
1481                 switch (token) {
1482                   case TokenNameVariable :
1483                     current.add(new PHPVarDeclaration(current, variableName,
1484                     //                      chIndx - ident.length,
1485                     scanner.getCurrentTokenStartPosition(), new String(ident)));
1486                     break;
1487                   case TokenNameIdentifier :
1488                     current.add(new PHPVarDeclaration(current, variableName,
1489                     //                    chIndx - ident.length,
1490                     scanner.getCurrentTokenStartPosition(), new String(ident)));
1491                     break;
1492                   case TokenNameDoubleLiteral :
1493                     current
1494                       .add(new PHPVarDeclaration(
1495                         current,
1496                         variableName + doubleNumber,
1497                     //   chIndx - ident.length,
1498                     scanner.getCurrentTokenStartPosition(), new String(ident)));
1499                     break;
1500                   case TokenNameIntegerLiteral :
1501                     current.add(new PHPVarDeclaration(current, variableName,
1502                     //                 chIndx - ident.length,
1503                     scanner.getCurrentTokenStartPosition(), new String(ident)));
1504                     break;
1505                   case TokenNameStringInterpolated :
1506                   case TokenNameStringLiteral :
1507                     current.add(new PHPVarDeclaration(current, variableName,
1508                     //              chIndx - ident.length,
1509                     scanner.getCurrentTokenStartPosition(), new String(ident)));
1510                     break;
1511                   case TokenNameStringConstant :
1512                     current.add(new PHPVarDeclaration(current, variableName,
1513                     //   chIndx - ident.length,
1514                     scanner.getCurrentTokenStartPosition(), new String(ident)));
1515                     break;
1516                   default :
1517                     current.add(new PHPVarDeclaration(current, variableName,
1518                     //               chIndx - ident.length
1519                     scanner.getCurrentTokenStartPosition()));
1520                     break;
1521                 }
1522               }
1523
1524             } else {
1525               ident = scanner.getCurrentIdentifierSource();
1526
1527               current.add(new PHPVarDeclaration(current, variableName,
1528               //          chIndx - ident.length
1529               scanner.getCurrentTokenStartPosition()));
1530             }
1531           }
1532         } else if (token == TokenNamefunction) {
1533           getNextToken();
1534           if (token == TokenNameAND) {
1535             getNextToken();
1536           }
1537           if (token == TokenNameIdentifier
1538             && store.getBoolean(PHPeclipsePlugin.PHP_OUTLINE_FUNC)) {
1539             ident = scanner.getCurrentIdentifierSource();
1540             outlineInfo.addVariable(new String(ident));
1541             temp = new PHPFunctionDeclaration(current, new String(ident),
1542               // chIndx - ident.length
1543   scanner.getCurrentTokenStartPosition());
1544             current.add(temp);
1545             getNextToken();
1546             parseDeclarations(outlineInfo, temp, true);
1547           }
1548         } else if (token == TokenNameclass) {
1549           getNextToken();
1550           if (token == TokenNameIdentifier
1551             && store.getBoolean(PHPeclipsePlugin.PHP_OUTLINE_CLASS)) {
1552             ident = scanner.getCurrentIdentifierSource();
1553             outlineInfo.addVariable(new String(ident));
1554             temp = new PHPClassDeclaration(current, new String(ident),
1555               //      chIndx - ident.len
1556   scanner.getCurrentTokenStartPosition());
1557             current.add(temp);
1558             //        stack.push(temp);
1559             getNextToken();
1560
1561             //skip tokens for classname, extends and others until we have the opening '{'
1562             while (token != TokenNameLBRACE
1563               && token != TokenNameEOF
1564               && token != TokenNameERROR) {
1565               getNextToken();
1566             }
1567             parseDeclarations(outlineInfo, temp, true);
1568             //        stack.pop();
1569           }
1570         } else if (token == TokenNameLBRACE) {
1571           getNextToken();
1572           counter++;
1573         } else if (token == TokenNameRBRACE) {
1574           getNextToken();
1575           --counter;
1576           if (counter == 0 && goBack) {
1577             return;
1578           }
1579         } else if (
1580           token == TokenNamerequire
1581             || token == TokenNamerequire_once
1582             || token == TokenNameinclude
1583             || token == TokenNameinclude_once) {
1584           ident =   scanner.getCurrentTokenSource();
1585
1586           getNextToken();
1587           int startPosition = scanner.getCurrentTokenStartPosition();
1588           expression();
1589           char[] expr =   scanner.getCurrentTokenSource(startPosition);
1590           outlineInfo.addVariable(new String(ident));
1591           current.add(new PHPReqIncDeclaration(current, new String(ident),
1592           //    chIndx - ident.length,
1593           startPosition, new String(expr)));
1594           getNextToken();
1595         } else {
1596           getNextToken();
1597         }
1598       }
1599     } catch (CoreException e) {
1600     } catch (SyntaxError sytaxErr) {
1601       try {
1602         //  setMarker(sytaxErr.getMessage(), sytaxErr.getLine(), ERROR);
1603         setMarker(
1604           sytaxErr.getMessage(),
1605           scanner.getCurrentTokenStartPosition(),
1606           scanner.getCurrentTokenEndPosition(),
1607           ERROR);
1608       } catch (CoreException e) {
1609       }
1610     }
1611   }
1612
1613   private void statementList() throws CoreException {
1614     do {
1615       statement();
1616       if ((token == TokenNameRBRACE)
1617         || (token == TokenNamecase)
1618         || (token == TokenNamedefault)
1619         || (token == TokenNameelseif)
1620         || (token == TokenNameendif)
1621         || (token == TokenNameendfor)
1622         || (token == TokenNameendforeach)
1623         || (token == TokenNameendwhile)
1624         || (token == TokenNameendswitch)
1625         || (token == TokenNameEOF)
1626         || (token == TokenNameERROR)) {
1627         return;
1628       }
1629     } while (true);
1630   }
1631
1632   private void compoundStatement() throws CoreException {
1633     // '{' [statement-list] '}'
1634     if (token == TokenNameLBRACE) {
1635       getNextToken();
1636     } else {
1637       throwSyntaxError("'{' expected in compound-statement.");
1638     }
1639     if (token != TokenNameRBRACE) {
1640       statementList();
1641     }
1642     if (token == TokenNameRBRACE) {
1643       getNextToken();
1644     } else {
1645       throwSyntaxError("'}' expected in compound-statement.");
1646     }
1647   }
1648
1649   private void statement() throws CoreException {
1650     //   if (token > TokenNameKEYWORD && token != TokenNamelist && token != TokenNamenew) {
1651     //  char[] ident = scanner.getCurrentIdentifierSource();
1652     //  String keyword = new String(ident);
1653     if (token == TokenNameinclude || token == TokenNameinclude_once) {
1654       getNextToken();
1655       expression();
1656       if (token == TokenNameSEMICOLON) {
1657         getNextToken();
1658       } else {
1659         if (token != TokenNameStopPHP) {
1660           throwSyntaxError("';' character after 'include' or 'include_once' expected.");
1661         }
1662         getNextToken();
1663       }
1664       return;
1665     } else if (token == TokenNamerequire || token == TokenNamerequire_once) {
1666       getNextToken();
1667       //constant();
1668       expression();
1669       if (token == TokenNameSEMICOLON) {
1670         getNextToken();
1671       } else {
1672         if (token != TokenNameStopPHP) {
1673           throwSyntaxError("';' character after 'require' or 'require_once' expected.");
1674         }
1675         getNextToken();
1676       }
1677       return;
1678     } else if (token == TokenNameif) {
1679       getNextToken();
1680       if (token == TokenNameLPAREN) {
1681         getNextToken();
1682       } else {
1683         throwSyntaxError("'(' expected after 'if' keyword.");
1684       }
1685       expression();
1686       if (token == TokenNameRPAREN) {
1687         getNextToken();
1688       } else {
1689         throwSyntaxError("')' expected after 'if' condition.");
1690       }
1691       ifStatement();
1692       return;
1693
1694     } else if (token == TokenNameswitch) {
1695       getNextToken();
1696       if (token == TokenNameLPAREN) {
1697         getNextToken();
1698       } else {
1699         throwSyntaxError("'(' expected after 'switch' keyword.");
1700       }
1701       expression();
1702       if (token == TokenNameRPAREN) {
1703         getNextToken();
1704       } else {
1705         throwSyntaxError("')' expected after 'switch' condition.");
1706       }
1707       switchStatement();
1708       return;
1709     } else if (token == TokenNamefor) {
1710       getNextToken();
1711       if (token == TokenNameLPAREN) {
1712         getNextToken();
1713       } else {
1714         throwSyntaxError("'(' expected after 'for' keyword.");
1715       }
1716       if (token == TokenNameSEMICOLON) {
1717         getNextToken();
1718       } else {
1719         expressionList();
1720         if (token == TokenNameSEMICOLON) {
1721           getNextToken();
1722         } else {
1723           throwSyntaxError("';' expected after 'for'.");
1724         }
1725       }
1726       if (token == TokenNameSEMICOLON) {
1727         getNextToken();
1728       } else {
1729         expressionList();
1730         if (token == TokenNameSEMICOLON) {
1731           getNextToken();
1732         } else {
1733           throwSyntaxError("';' expected after 'for'.");
1734         }
1735       }
1736       if (token == TokenNameRPAREN) {
1737         getNextToken();
1738       } else {
1739         expressionList();
1740         if (token == TokenNameRPAREN) {
1741           getNextToken();
1742         } else {
1743           throwSyntaxError("')' expected after 'for'.");
1744         }
1745       }
1746       forStatement();
1747       return;
1748     } else if (token == TokenNamewhile) {
1749       getNextToken();
1750       if (token == TokenNameLPAREN) {
1751         getNextToken();
1752       } else {
1753         throwSyntaxError("'(' expected after 'while' keyword.");
1754       }
1755       expression();
1756       if (token == TokenNameRPAREN) {
1757         getNextToken();
1758       } else {
1759         throwSyntaxError("')' expected after 'while' condition.");
1760       }
1761       whileStatement();
1762       return;
1763     } else if (token == TokenNamedo) {
1764       getNextToken();
1765       if (token == TokenNameLBRACE) {
1766         getNextToken();
1767       } else {
1768         throwSyntaxError("'{' expected after 'do' keyword.");
1769       }
1770       if (token != TokenNameRBRACE) {
1771         statementList();
1772       }
1773       if (token == TokenNameRBRACE) {
1774         getNextToken();
1775       } else {
1776         throwSyntaxError("'}' expected after 'do' keyword.");
1777       }
1778       if (token == TokenNamewhile) {
1779         getNextToken();
1780         if (token == TokenNameLPAREN) {
1781           getNextToken();
1782         } else {
1783           throwSyntaxError("'(' expected after 'while' keyword.");
1784         }
1785         expression();
1786         if (token == TokenNameRPAREN) {
1787           getNextToken();
1788         } else {
1789           throwSyntaxError("')' expected after 'while' condition.");
1790         }
1791       } else {
1792         throwSyntaxError("'while' expected after 'do' keyword.");
1793       }
1794       if (token == TokenNameSEMICOLON) {
1795         getNextToken();
1796       } else {
1797         if (token != TokenNameStopPHP) {
1798           throwSyntaxError("';' expected after do-while statement.");
1799         }
1800         getNextToken();
1801       }
1802       return;
1803     } else if (token == TokenNameforeach) {
1804       getNextToken();
1805       if (token == TokenNameLPAREN) {
1806         getNextToken();
1807       } else {
1808         throwSyntaxError("'(' expected after 'foreach' keyword.");
1809       }
1810       expression();
1811       if (token == TokenNameas) {
1812         getNextToken();
1813       } else {
1814         throwSyntaxError("'as' expected after 'foreach' exxpression.");
1815       }
1816       variable();
1817       if (token == TokenNameEQUAL_GREATER) {
1818         getNextToken();
1819         variable();
1820       }
1821       if (token == TokenNameRPAREN) {
1822         getNextToken();
1823       } else {
1824         throwSyntaxError("')' expected after 'foreach' expression.");
1825       }
1826       foreachStatement();
1827       return;
1828
1829     } else if (
1830       token == TokenNamecontinue
1831         || token == TokenNamebreak
1832         || token == TokenNamereturn) {
1833       getNextToken();
1834       if (token != TokenNameSEMICOLON) {
1835         expression();
1836       }
1837       if (token == TokenNameSEMICOLON) {
1838         getNextToken();
1839       } else {
1840         if (token != TokenNameStopPHP) {
1841           throwSyntaxError("';' expected after 'continue', 'break' or 'return'.");
1842         }
1843         getNextToken();
1844       }
1845       return;
1846
1847     } else if (token == TokenNameecho) {
1848       getNextToken();
1849       expressionList();
1850       if (token == TokenNameSEMICOLON) {
1851         getNextToken();
1852       } else {
1853         if (token != TokenNameStopPHP) {
1854           throwSyntaxError("';' expected after 'echo' statement.");
1855         }
1856         getNextToken();
1857       }
1858       return;
1859       //    } else if (token == TokenNameprint) {
1860       //      getNextToken();
1861       //      expression();
1862       //      if (token == TokenNameSEMICOLON) {
1863       //        getNextToken();
1864       //      } else {
1865       //        if (token != TokenNameStopPHP) {
1866       //          throwSyntaxError("';' expected after 'print' statement.");
1867       //        }
1868       //        getNextToken();
1869       //      }
1870       //      return;
1871
1872     } else if (token == TokenNameglobal || token == TokenNamestatic) {
1873       getNextToken();
1874       variableList();
1875       if (token == TokenNameSEMICOLON) {
1876         getNextToken();
1877       } else {
1878         if (token != TokenNameStopPHP) {
1879           throwSyntaxError("';' expected after 'global' or 'static' statement.");
1880         }
1881         getNextToken();
1882       }
1883       return;
1884
1885       //      } else if (token == TokenNameunset) {
1886       //        getNextToken();
1887       //        if (token == TokenNameARGOPEN) {
1888       //          getNextToken();
1889       //        } else {
1890       //          throwSyntaxError("'(' expected after 'unset' keyword.");
1891       //        }
1892       //        variableList();
1893       //        if (token == TokenNameARGCLOSE) {
1894       //          getNextToken();
1895       //        } else {
1896       //          throwSyntaxError("')' expected after 'unset' statement.");
1897       //        }
1898       //        if (token == TokenNameSEMICOLON) {
1899       //          getNextToken();
1900       //        } else {
1901       //          if (token != TokenNameStopPHP) {
1902       //            throwSyntaxError("';' expected after 'unset' statement.");
1903       //          }
1904       //          getNextToken();
1905       //        }
1906       //        return;
1907
1908       //      } else if (token == TokenNameexit || token == TokenNamedie) {
1909       //        getNextToken();
1910       //        if (token != TokenNameSEMICOLON) {
1911       //          exitStatus();
1912       //        }
1913       //        if (token == TokenNameSEMICOLON) {
1914       //          getNextToken();
1915       //        } else {
1916       //          if (token != TokenNameStopPHP) {
1917       //            throwSyntaxError("';' expected after 'exit' or 'die' statement.");
1918       //          }
1919       //          getNextToken();
1920       //        }
1921       //        return;
1922
1923     } else if (token == TokenNamedefine) {
1924       getNextToken();
1925       if (token == TokenNameLPAREN) {
1926         getNextToken();
1927       } else {
1928         throwSyntaxError("'(' expected after 'define' keyword.");
1929       }
1930       expression();
1931       if (token == TokenNameCOMMA) {
1932         getNextToken();
1933       } else {
1934         throwSyntaxError("',' expected after first 'define' constant.");
1935       }
1936       expression();
1937       if (token == TokenNameCOMMA) {
1938         getNextToken();
1939         expression();
1940       }
1941       if (token == TokenNameRPAREN) {
1942         getNextToken();
1943       } else {
1944         throwSyntaxError("')' expected after 'define' statement.");
1945       }
1946       if (token == TokenNameSEMICOLON) {
1947         getNextToken();
1948       } else {
1949         if (token != TokenNameStopPHP) {
1950           throwSyntaxError("';' expected after 'define' statement.");
1951         }
1952         getNextToken();
1953       }
1954       return;
1955     } else if (token == TokenNamefunction) {
1956       getNextToken();
1957       functionDefinition();
1958       return;
1959     } else if (token == TokenNameclass) {
1960       getNextToken();
1961       classDeclarator();
1962       classBody();
1963       return;
1964       //      } else {
1965       //        throwSyntaxError("Unexpected keyword '" + keyword + "'");
1966     } else if (token == TokenNameLBRACE) {
1967       // compoundStatement
1968       getNextToken();
1969       if (token != TokenNameRBRACE) {
1970         statementList();
1971       }
1972       if (token == TokenNameRBRACE) {
1973         getNextToken();
1974         return;
1975       } else {
1976         throwSyntaxError("'}' expected.");
1977       }
1978     } else {
1979       if (token != TokenNameSEMICOLON) {
1980         expression();
1981       }
1982       if (token == TokenNameSEMICOLON) {
1983         getNextToken();
1984         return;
1985       } else {
1986         if (token != TokenNameStopPHP && token != TokenNameEOF) {
1987           throwSyntaxError(
1988             "';' expected after expression (Found token: "
1989               + scanner.toStringAction(token)
1990               + ")");
1991         }
1992         getNextToken();
1993       }
1994     }
1995   }
1996
1997   private void classDeclarator() throws CoreException {
1998     //identifier
1999     //identifier 'extends' identifier
2000     if (token == TokenNameIdentifier) {
2001       getNextToken();
2002       if (token == TokenNameextends) {
2003         getNextToken();
2004         if (token == TokenNameIdentifier) {
2005           getNextToken();
2006         } else {
2007           throwSyntaxError("Class name expected after keyword 'extends'.");
2008         }
2009       }
2010     } else {
2011       throwSyntaxError("Class name expected after keyword 'class'.");
2012     }
2013   }
2014
2015   private void classBody() throws CoreException {
2016     //'{' [class-element-list] '}'
2017     if (token == TokenNameLBRACE) {
2018       getNextToken();
2019       if (token != TokenNameRBRACE) {
2020         classElementList();
2021       }
2022       if (token == TokenNameRBRACE) {
2023         getNextToken();
2024       } else {
2025         throwSyntaxError("'}' expected at end of class body.");
2026       }
2027     } else {
2028       throwSyntaxError("'{' expected at start of class body.");
2029     }
2030   }
2031
2032   private void classElementList() throws CoreException {
2033     do {
2034       classElement();
2035     } while (token == TokenNamefunction || token == TokenNamevar);
2036   }
2037
2038   private void classElement() throws CoreException {
2039     //class-property
2040     //function-definition
2041     if (token == TokenNamefunction) {
2042       getNextToken();
2043       functionDefinition();
2044     } else if (token == TokenNamevar) {
2045       getNextToken();
2046       classProperty();
2047     } else {
2048       throwSyntaxError("'function' or 'var' expected.");
2049     }
2050   }
2051
2052   private void classProperty() throws CoreException {
2053     //'var' variable ';'
2054     //'var' variable '=' constant ';'
2055     do {
2056       if (token == TokenNameVariable) {
2057         getNextToken();
2058         if (token == TokenNameEQUAL) {
2059           getNextToken();
2060           constant();
2061         }
2062       } else {
2063         throwSyntaxError("Variable expected after keyword 'var'.");
2064       }
2065       if (token != TokenNameCOMMA) {
2066         break;
2067       }
2068       getNextToken();
2069     } while (true);
2070     if (token == TokenNameSEMICOLON) {
2071       getNextToken();
2072     } else {
2073       throwSyntaxError("';' expected after variable declaration.");
2074     }
2075   }
2076
2077   private void functionDefinition() throws CoreException {
2078     functionDeclarator();
2079     compoundStatement();
2080   }
2081
2082   private void functionDeclarator() throws CoreException {
2083     //identifier '(' [parameter-list] ')'
2084     if (token == TokenNameAND) {
2085       getNextToken();
2086     }
2087     if (token == TokenNameIdentifier) {
2088       getNextToken();
2089       if (token == TokenNameLPAREN) {
2090         getNextToken();
2091       } else {
2092         throwSyntaxError("'(' expected in function declaration.");
2093       }
2094       if (token != TokenNameRPAREN) {
2095         parameterList();
2096       }
2097       if (token != TokenNameRPAREN) {
2098         throwSyntaxError("')' expected in function declaration.");
2099       } else {
2100         getNextToken();
2101       }
2102     }
2103   }
2104   //
2105   private void parameterList() throws CoreException {
2106     //parameter-declaration
2107     //parameter-list ',' parameter-declaration
2108     do {
2109       parameterDeclaration();
2110       if (token != TokenNameCOMMA) {
2111         break;
2112       }
2113       getNextToken();
2114     } while (true);
2115   }
2116
2117   private void parameterDeclaration() throws CoreException {
2118     //variable
2119     //variable-reference
2120     if (token == TokenNameAND) {
2121       getNextToken();
2122       if (token == TokenNameVariable) {
2123         getNextToken();
2124       } else {
2125         throwSyntaxError("Variable expected after reference operator '&'.");
2126       }
2127     }
2128     //variable '=' constant
2129     if (token == TokenNameVariable) {
2130       getNextToken();
2131       if (token == TokenNameEQUAL) {
2132         getNextToken();
2133         constant();
2134       }
2135       return;
2136     }
2137   }
2138
2139   private void labeledStatementList() throws CoreException {
2140     if (token != TokenNamecase && token != TokenNamedefault) {
2141       throwSyntaxError("'case' or 'default' expected.");
2142     }
2143     do {
2144       if (token == TokenNamecase) {
2145         getNextToken();
2146         constant();
2147         if (token == TokenNameCOLON) {
2148           getNextToken();
2149           if (token == TokenNamecase
2150             || token == TokenNamedefault) { // empty case statement ?
2151             continue;
2152           }
2153           statementList();
2154         } else if (token == TokenNameSEMICOLON) {
2155           //          setMarker(
2156           //            "':' expected after 'case' keyword (Found token: "
2157           //              + scanner.toStringAction(token)
2158           //              + ")",
2159           //            rowCount,
2160           //            PHPParser.INFO);
2161           setMarker(
2162             "':' expected after 'case' keyword (Found token: "
2163               + scanner.toStringAction(token)
2164               + ")",
2165             scanner.getCurrentTokenStartPosition(),
2166             scanner.getCurrentTokenEndPosition(),
2167             INFO);
2168           getNextToken();
2169           if (token == TokenNamecase) { // empty case statement ?
2170             continue;
2171           }
2172           statementList();
2173         } else {
2174           throwSyntaxError(
2175             "':' character after 'case' constant expected (Found token: "
2176               + scanner.toStringAction(token)
2177               + ")");
2178         }
2179       } else { // TokenNamedefault
2180         getNextToken();
2181         if (token == TokenNameCOLON) {
2182           getNextToken();
2183           statementList();
2184         } else {
2185           throwSyntaxError("':' character after 'default' expected.");
2186         }
2187       }
2188     } while (token == TokenNamecase || token == TokenNamedefault);
2189   }
2190
2191   //  public void labeledStatement() {
2192   //    if (token == TokenNamecase) {
2193   //      getNextToken();
2194   //      constant();
2195   //      if (token == TokenNameDDOT) {
2196   //        getNextToken();
2197   //        statement();
2198   //      } else {
2199   //        throwSyntaxError("':' character after 'case' constant expected.");
2200   //      }
2201   //      return;
2202   //    } else if (token == TokenNamedefault) {
2203   //      getNextToken();
2204   //      if (token == TokenNameDDOT) {
2205   //        getNextToken();
2206   //        statement();
2207   //      } else {
2208   //        throwSyntaxError("':' character after 'default' expected.");
2209   //      }
2210   //      return;
2211   //    }
2212   //  }
2213
2214   //  public void expressionStatement() {
2215   //  }
2216
2217   //  private void inclusionStatement() {
2218   //  }
2219
2220   //  public void compoundStatement() {
2221   //  }
2222
2223   //  public void selectionStatement() {
2224   //  }
2225   //
2226   //  public void iterationStatement() {
2227   //  }
2228   //
2229   //  public void jumpStatement() {
2230   //  }
2231   //
2232   //  public void outputStatement() {
2233   //  }
2234   //
2235   //  public void scopeStatement() {
2236   //  }
2237   //
2238   //  public void flowStatement() {
2239   //  }
2240   //
2241   //  public void definitionStatement() {
2242   //  }
2243
2244   private void ifStatement() throws CoreException {
2245     // ':' statement-list [elseif-list] [else-colon-statement] 'endif' ';'
2246     if (token == TokenNameCOLON) {
2247       getNextToken();
2248       statementList();
2249       switch (token) {
2250         case TokenNameelse :
2251           getNextToken();
2252           if (token == TokenNameCOLON) {
2253             getNextToken();
2254             statementList();
2255           } else {
2256             if (token == TokenNameif) { //'else if'
2257               getNextToken();
2258               elseifStatementList();
2259             } else {
2260               throwSyntaxError("':' expected after 'else'.");
2261             }
2262           }
2263           break;
2264         case TokenNameelseif :
2265           getNextToken();
2266           elseifStatementList();
2267           break;
2268       }
2269
2270       if (token != TokenNameendif) {
2271         throwSyntaxError("'endif' expected.");
2272       }
2273       getNextToken();
2274       if (token != TokenNameSEMICOLON) {
2275         throwSyntaxError("';' expected after if-statement.");
2276       }
2277       getNextToken();
2278     } else {
2279       // statement [else-statement]
2280       statement();
2281       if (token == TokenNameelseif) {
2282         getNextToken();
2283         if (token == TokenNameLPAREN) {
2284           getNextToken();
2285         } else {
2286           throwSyntaxError("'(' expected after 'elseif' keyword.");
2287         }
2288         expression();
2289         if (token == TokenNameRPAREN) {
2290           getNextToken();
2291         } else {
2292           throwSyntaxError("')' expected after 'elseif' condition.");
2293         }
2294         ifStatement();
2295       } else if (token == TokenNameelse) {
2296         getNextToken();
2297         statement();
2298       }
2299     }
2300   }
2301
2302   private void elseifStatementList() throws CoreException {
2303     do {
2304       elseifStatement();
2305       switch (token) {
2306         case TokenNameelse :
2307           getNextToken();
2308           if (token == TokenNameCOLON) {
2309             getNextToken();
2310             statementList();
2311             return;
2312           } else {
2313             if (token == TokenNameif) { //'else if'
2314               getNextToken();
2315             } else {
2316               throwSyntaxError("':' expected after 'else'.");
2317             }
2318           }
2319           break;
2320         case TokenNameelseif :
2321           getNextToken();
2322           break;
2323         default :
2324           return;
2325       }
2326     } while (true);
2327   }
2328
2329   private void elseifStatement() throws CoreException {
2330     if (token == TokenNameLPAREN) {
2331       getNextToken();
2332       expression();
2333       if (token != TokenNameLPAREN) {
2334         throwSyntaxError("')' expected in else-if-statement.");
2335       }
2336       getNextToken();
2337       if (token != TokenNameCOLON) {
2338         throwSyntaxError("':' expected in else-if-statement.");
2339       }
2340       getNextToken();
2341       statementList();
2342     }
2343   }
2344
2345   private void switchStatement() throws CoreException {
2346     if (token == TokenNameCOLON) {
2347       // ':' [labeled-statement-list] 'endswitch' ';'
2348       getNextToken();
2349       labeledStatementList();
2350       if (token != TokenNameendswitch) {
2351         throwSyntaxError("'endswitch' expected.");
2352       }
2353       getNextToken();
2354       if (token != TokenNameSEMICOLON) {
2355         throwSyntaxError("';' expected after switch-statement.");
2356       }
2357       getNextToken();
2358     } else {
2359       // '{' [labeled-statement-list] '}'
2360       if (token != TokenNameLBRACE) {
2361         throwSyntaxError("'{' expected in switch statement.");
2362       }
2363       getNextToken();
2364       if (token != TokenNameRBRACE) {
2365         labeledStatementList();
2366       }
2367       if (token != TokenNameRBRACE) {
2368         throwSyntaxError("'}' expected in switch statement.");
2369       }
2370       getNextToken();
2371
2372     }
2373   }
2374
2375   private void forStatement() throws CoreException {
2376     if (token == TokenNameCOLON) {
2377       getNextToken();
2378       statementList();
2379       if (token != TokenNameendfor) {
2380         throwSyntaxError("'endfor' expected.");
2381       }
2382       getNextToken();
2383       if (token != TokenNameSEMICOLON) {
2384         throwSyntaxError("';' expected after for-statement.");
2385       }
2386       getNextToken();
2387     } else {
2388       statement();
2389     }
2390   }
2391
2392   private void whileStatement() throws CoreException {
2393     // ':' statement-list 'endwhile' ';'
2394     if (token == TokenNameCOLON) {
2395       getNextToken();
2396       statementList();
2397       if (token != TokenNameendwhile) {
2398         throwSyntaxError("'endwhile' expected.");
2399       }
2400       getNextToken();
2401       if (token != TokenNameSEMICOLON) {
2402         throwSyntaxError("';' expected after while-statement.");
2403       }
2404       getNextToken();
2405     } else {
2406       statement();
2407     }
2408   }
2409
2410   private void foreachStatement() throws CoreException {
2411     if (token == TokenNameCOLON) {
2412       getNextToken();
2413       statementList();
2414       if (token != TokenNameendforeach) {
2415         throwSyntaxError("'endforeach' expected.");
2416       }
2417       getNextToken();
2418       if (token != TokenNameSEMICOLON) {
2419         throwSyntaxError("';' expected after foreach-statement.");
2420       }
2421       getNextToken();
2422     } else {
2423       statement();
2424     }
2425   }
2426
2427   private void exitStatus() throws CoreException {
2428     if (token == TokenNameLPAREN) {
2429       getNextToken();
2430     } else {
2431       throwSyntaxError("'(' expected in 'exit-status'.");
2432     }
2433     if (token != TokenNameRPAREN) {
2434       expression();
2435     }
2436     if (token == TokenNameRPAREN) {
2437       getNextToken();
2438     } else {
2439       throwSyntaxError("')' expected after 'exit-status'.");
2440     }
2441   }
2442
2443   private void expressionList() throws CoreException {
2444     do {
2445       expression();
2446       if (token == TokenNameCOMMA) {
2447         getNextToken();
2448       } else {
2449         break;
2450       }
2451     } while (true);
2452   }
2453
2454   private void expression() throws CoreException {
2455     //todo: find a better way to get the expression
2456 //    expression = new StringBuffer();
2457 //    for (int i = chIndx; i < str.length(); i++) {
2458 //      if (str.charAt(i) == ';') {
2459 //        break;
2460 //      }
2461 //      expression.append(str.charAt(i));
2462 //    }
2463
2464     //    if (token == TokenNameSTRING_CONSTANT || token == TokenNameINTERPOLATED_STRING) {
2465     //      getNextToken();
2466     //    } else {
2467     logicalinclusiveorExpression();
2468     //      while (token != TokenNameSEMICOLON) {
2469     //        getNextToken();
2470     //      //      }
2471     //    }
2472   }
2473
2474   private void postfixExpression() throws CoreException {
2475     //  String ident;
2476     char[] ident;
2477     boolean castFlag = false;
2478     switch (token) {
2479       case TokenNamenew :
2480         getNextToken();
2481         expression();
2482         break;
2483       case TokenNamenull :
2484         getNextToken();
2485         break;
2486       case TokenNamefalse :
2487         getNextToken();
2488         break;
2489       case TokenNametrue :
2490         getNextToken();
2491         break;
2492       case TokenNameStringConstant :
2493         getNextToken();
2494         break;
2495       case TokenNameHEREDOC :
2496       case TokenNameStringInterpolated :
2497       case TokenNameStringLiteral :
2498         getNextToken();
2499         break;
2500       case TokenNameLPAREN :
2501         getNextToken();
2502         if (token == TokenNameIdentifier) {
2503           // check if identifier is a type:
2504           //    ident = identifier;
2505           ident = scanner.getCurrentIdentifierSource();
2506           String str = new String(ident).toLowerCase();
2507           for (int i = 0; i < PHP_TYPES.length; i++) {
2508             if (PHP_TYPES[i].equals(str)) {
2509               castFlag = true;
2510               break;
2511             }
2512           }
2513           if (castFlag) {
2514             getNextToken();
2515             if (token != TokenNameRPAREN) {
2516               throwSyntaxError(") expected after cast-type '" + str + "'.");
2517             }
2518             getNextToken();
2519             expression();
2520             break;
2521           }
2522         }
2523         if (!castFlag) {
2524           expression();
2525         }
2526         if (token != TokenNameRPAREN) {
2527           throwSyntaxError(") expected in postfix-expression.");
2528         }
2529         getNextToken();
2530         break;
2531       case TokenNameDoubleLiteral :
2532         getNextToken();
2533         break;
2534       case TokenNameIntegerLiteral :
2535         getNextToken();
2536         break;
2537       case TokenNameDOLLAR_LBRACE :
2538         getNextToken();
2539         expression();
2540         if (token != TokenNameRBRACE) {
2541           throwSyntaxError("'}' expected after indirect variable token '${'.");
2542         }
2543         getNextToken();
2544         break;
2545       case TokenNameVariable :
2546         ident = scanner.getCurrentIdentifierSource();
2547         getNextToken();
2548         if (token == TokenNameLBRACE) {
2549           getNextToken();
2550           expression();
2551           if (token != TokenNameRBRACE) {
2552             throwSyntaxError(
2553               "'}' expected after variable '"
2554                 + new String(ident)
2555                 + "' in variable-expression.");
2556           }
2557           getNextToken();
2558         } else if (token == TokenNameLPAREN) {
2559           getNextToken();
2560           if (token != TokenNameRPAREN) {
2561             expressionList();
2562             if (token != TokenNameRPAREN) {
2563               throwSyntaxError(
2564                 "')' expected after variable '"
2565                   + new String(ident)
2566                   + "' in postfix-expression.");
2567             }
2568           }
2569           getNextToken();
2570         }
2571         break;
2572       case TokenNameIdentifier :
2573         ident = scanner.getCurrentIdentifierSource();
2574         getNextToken();
2575         if (token == TokenNameLPAREN) {
2576           getNextToken();
2577           if (token != TokenNameRPAREN) {
2578             expressionList();
2579             if (token != TokenNameRPAREN) {
2580               throwSyntaxError(
2581                 "')' expected after identifier '"
2582                   + new String(ident)
2583                   + "' in postfix-expression."
2584                   + "(Found token: "
2585                   + scanner.toStringAction(token)
2586                   + ")");
2587             }
2588           }
2589           getNextToken();
2590         }
2591         break;
2592       case TokenNameprint :
2593         getNextToken();
2594         expression();
2595         //        if (token == TokenNameSEMICOLON) {
2596         //          getNextToken();
2597         //        } else {
2598         //          if (token != TokenNameStopPHP) {
2599         //            throwSyntaxError("';' expected after 'print' statement.");
2600         //          }
2601         //          getNextToken();
2602         //        }
2603         break;
2604       case TokenNamelist :
2605         getNextToken();
2606         if (token == TokenNameLPAREN) {
2607           getNextToken();
2608           if (token == TokenNameCOMMA) {
2609             getNextToken();
2610           }
2611           expressionList();
2612           if (token != TokenNameRPAREN) {
2613             throwSyntaxError("')' expected after 'list' keyword.");
2614           }
2615           getNextToken();
2616           //          if (token == TokenNameSET) {
2617           //            getNextToken();
2618           //            logicalinclusiveorExpression();
2619           //          }
2620         } else {
2621           throwSyntaxError("'(' expected after 'list' keyword.");
2622         }
2623         break;
2624         //      case TokenNameexit :
2625         //        getNextToken();
2626         //        if (token != TokenNameSEMICOLON) {
2627         //          exitStatus();
2628         //        }
2629         //        if (token == TokenNameSEMICOLON) {
2630         //          getNextToken();
2631         //        } else {
2632         //          if (token != TokenNameStopPHP) {
2633         //            throwSyntaxError("';' expected after 'exit' expression.");
2634         //          }
2635         //          getNextToken();
2636         //        }
2637         //        break;
2638         //      case TokenNamedie :
2639         //        getNextToken();
2640         //        if (token != TokenNameSEMICOLON) {
2641         //          exitStatus();
2642         //        }
2643         //        if (token == TokenNameSEMICOLON) {
2644         //          getNextToken();
2645         //        } else {
2646         //          if (token != TokenNameStopPHP) {
2647         //            throwSyntaxError("';' expected after 'die' expression.");
2648         //          }
2649         //        }
2650         //        break;
2651
2652         //      case TokenNamearray :
2653         //        getNextToken();
2654         //        if (token == TokenNameARGOPEN) {
2655         //          getNextToken();
2656         //          if (token == TokenNameCOMMA) {
2657         //            getNextToken();
2658         //          }
2659         //          expressionList();
2660         //          if (token != TokenNameARGCLOSE) {
2661         //            throwSyntaxError("')' expected after 'list' keyword.");
2662         //          }
2663         //          getNextToken();
2664         //          if (token == TokenNameSET) {
2665         //            getNextToken();
2666         //            logicalinclusiveorExpression();
2667         //          }
2668         //        } else {
2669         //          throwSyntaxError("'(' expected after 'list' keyword.");
2670         //        }
2671         //        break;
2672     }
2673     boolean while_flag = true;
2674     do {
2675       switch (token) {
2676         case TokenNameLBRACKET :
2677           getNextToken();
2678           expression();
2679           if (token != TokenNameRBRACKET) {
2680             throwSyntaxError("] expected in postfix-expression.");
2681           }
2682           getNextToken();
2683           break;
2684         case TokenNameCOLON_COLON : // ::
2685         case TokenNameMINUS_GREATER : // ->
2686           getNextToken();
2687           if (token > TokenNameKEYWORD) {
2688             ident = scanner.getCurrentIdentifierSource();
2689             //            setMarker(
2690             //              "Avoid using keyword '"
2691             //                + new String(ident)
2692             //                + "' as variable name.",
2693             //              rowCount,
2694             //              PHPParser.INFO);
2695             setMarker(
2696               "Avoid using keyword '"
2697                 + new String(ident)
2698                 + "' as variable name.",
2699               scanner.getCurrentTokenStartPosition(),
2700               scanner.getCurrentTokenEndPosition(),
2701               INFO);
2702           }
2703           switch (token) {
2704             case TokenNameVariable :
2705               ident = scanner.getCurrentIdentifierSource();
2706               getNextToken();
2707               //              if (token == TokenNameARGOPEN) {
2708               //                getNextToken();
2709               //                expressionList();
2710               //                if (token != TokenNameARGCLOSE) {
2711               //                  throwSyntaxError(") expected after variable '" + ident + "'.");
2712               //                }
2713               //                getNextToken();
2714               //              }
2715               break;
2716             case TokenNameIdentifier :
2717               //ident = scanner.getCurrentIdentifierSource();
2718               getNextToken();
2719               break;
2720             case TokenNameLBRACE :
2721               getNextToken();
2722               expression();
2723               if (token != TokenNameRBRACE) {
2724                 throwSyntaxError("} expected in postfix-expression.");
2725               }
2726               getNextToken();
2727               break;
2728             default :
2729               throwSyntaxError("Syntax error after '->' token.");
2730           } while (
2731             token == TokenNameLBRACKET
2732               || token == TokenNameLPAREN
2733               || token == TokenNameLBRACE) {
2734               if (token == TokenNameLBRACKET) {
2735                 getNextToken();
2736                 expressionList();
2737                 if (token != TokenNameRBRACKET) {
2738                   throwSyntaxError("] expected after '->'.");
2739                 }
2740                 getNextToken();
2741               }
2742               if (token == TokenNameLPAREN) {
2743                 getNextToken();
2744                 expressionList();
2745                 if (token != TokenNameRPAREN) {
2746                   throwSyntaxError(") expected after '->'.");
2747                 }
2748                 getNextToken();
2749               }
2750               if (token == TokenNameLBRACE) {
2751                 getNextToken();
2752                 expression();
2753                 if (token != TokenNameRBRACE) {
2754                   throwSyntaxError("} expected after '->'.");
2755                 }
2756                 getNextToken();
2757               }
2758             }
2759           break;
2760         case TokenNamePLUS_PLUS :
2761           getNextToken();
2762           break;
2763         case TokenNameMINUS_MINUS :
2764           getNextToken();
2765           break;
2766         default :
2767           while_flag = false;
2768       }
2769
2770     }
2771     while (while_flag);
2772   }
2773
2774   private void unaryExpression() throws CoreException {
2775     switch (token) {
2776       case TokenNamePLUS_PLUS :
2777         getNextToken();
2778         unaryExpression();
2779         break;
2780       case TokenNameMINUS_MINUS :
2781         getNextToken();
2782         unaryExpression();
2783         break;
2784         // '@' '&' '*' '+' '-' '~' '!'
2785       case TokenNameAT :
2786         getNextToken();
2787         castExpression();
2788         break;
2789       case TokenNameAND :
2790         getNextToken();
2791         castExpression();
2792         break;
2793       case TokenNameMULTIPLY :
2794         getNextToken();
2795         castExpression();
2796         break;
2797       case TokenNamePLUS :
2798         getNextToken();
2799         castExpression();
2800         break;
2801       case TokenNameMINUS :
2802         getNextToken();
2803         castExpression();
2804         break;
2805       case TokenNameTWIDDLE :
2806         getNextToken();
2807         castExpression();
2808         break;
2809       case TokenNameNOT :
2810         getNextToken();
2811         castExpression();
2812         break;
2813       default :
2814         postfixExpression();
2815     }
2816   }
2817
2818   private void castExpression() throws CoreException {
2819     //    if (token == TokenNameARGOPEN) {
2820     //      getNextToken();
2821     //      typeName();
2822     //      if (token != TokenNameARGCLOSE) {
2823     //        throwSyntaxError(") expected after cast-expression.");
2824     //      }
2825     //      getNextToken();
2826     //    }
2827     unaryExpression();
2828   }
2829
2830   private void typeName() throws CoreException {
2831     //'string' 'unset' 'array' 'object'
2832     //'bool' 'boolean'
2833     //'real' 'double' 'float'
2834     //'int' 'integer'
2835     String identifier = "";
2836     if (token == TokenNameIdentifier) {
2837       char[] ident = scanner.getCurrentIdentifierSource();
2838       identifier = new String(ident);
2839       String str = identifier.toLowerCase();
2840       getNextToken();
2841       for (int i = 0; i < PHP_TYPES.length; i++) {
2842         if (PHP_TYPES[i].equals(str)) {
2843           return;
2844         }
2845       }
2846     }
2847     throwSyntaxError(
2848       "Expected type cast '( <type-name> )'; Got '" + identifier + "'.");
2849   }
2850
2851   private void assignExpression() throws CoreException {
2852     castExpression();
2853     if (token == TokenNameEQUAL) { // =
2854       getNextToken();
2855       logicalinclusiveorExpression();
2856     } else if (token == TokenNameDOT_EQUAL) { // .=
2857       getNextToken();
2858       logicalinclusiveorExpression();
2859     } else if (token == TokenNameEQUAL_GREATER) { // =>
2860       getNextToken();
2861       logicalinclusiveorExpression();
2862     } else if (token == TokenNamePLUS_EQUAL) { // +=
2863       getNextToken();
2864       logicalinclusiveorExpression();
2865     } else if (token == TokenNameMINUS_EQUAL) { // -=
2866       getNextToken();
2867       logicalinclusiveorExpression();
2868     } else if (token == TokenNameMULTIPLY_EQUAL) { // *=
2869       getNextToken();
2870       logicalinclusiveorExpression();
2871     } else if (token == TokenNameDIVIDE_EQUAL) { // *=
2872       getNextToken();
2873       logicalinclusiveorExpression();
2874     } else if (token == TokenNameREMAINDER_EQUAL) { // %=
2875       getNextToken();
2876       logicalinclusiveorExpression();
2877     } else if (token == TokenNameAND_EQUAL) { // &=
2878       getNextToken();
2879       logicalinclusiveorExpression();
2880     } else if (token == TokenNameOR_EQUAL) { // |=
2881       getNextToken();
2882       logicalinclusiveorExpression();
2883     } else if (token == TokenNameXOR_EQUAL) { // ^=
2884       getNextToken();
2885       logicalinclusiveorExpression();
2886     } else if (token == TokenNameLEFT_SHIFT_EQUAL) { // <<=
2887       getNextToken();
2888       logicalinclusiveorExpression();
2889     } else if (token == TokenNameRIGHT_SHIFT_EQUAL) { // >>=
2890       getNextToken();
2891       logicalinclusiveorExpression();
2892     } else if (token == TokenNameTWIDDLE_EQUAL) { // ~=
2893       getNextToken();
2894       logicalinclusiveorExpression();
2895     }
2896   }
2897
2898   private void multiplicativeExpression() throws CoreException {
2899     do {
2900       assignExpression();
2901       if (token != TokenNameMULTIPLY
2902         && token != TokenNameDIVIDE
2903         && token != TokenNameREMAINDER) {
2904         return;
2905       }
2906       getNextToken();
2907     } while (true);
2908   }
2909
2910   private void concatenationExpression() throws CoreException {
2911     do {
2912       multiplicativeExpression();
2913       if (token != TokenNameDOT) {
2914         return;
2915       }
2916       getNextToken();
2917     } while (true);
2918   }
2919
2920   private void additiveExpression() throws CoreException {
2921     do {
2922       concatenationExpression();
2923       if (token != TokenNamePLUS && token != TokenNameMINUS) {
2924         return;
2925       }
2926       getNextToken();
2927     } while (true);
2928   }
2929
2930   private void shiftExpression() throws CoreException {
2931     do {
2932       additiveExpression();
2933       if (token != TokenNameLEFT_SHIFT && token != TokenNameRIGHT_SHIFT) {
2934         return;
2935       }
2936       getNextToken();
2937     } while (true);
2938   }
2939
2940   private void relationalExpression() throws CoreException {
2941     do {
2942       shiftExpression();
2943       if (token != TokenNameLESS
2944         && token != TokenNameGREATER
2945         && token != TokenNameLESS_EQUAL
2946         && token != TokenNameGREATER_EQUAL) {
2947         return;
2948       }
2949       getNextToken();
2950     } while (true);
2951   }
2952
2953   private void identicalExpression() throws CoreException {
2954     do {
2955       relationalExpression();
2956       if (token != TokenNameEQUAL_EQUAL_EQUAL
2957         && token != TokenNameNOT_EQUAL_EQUAL) {
2958         return;
2959       }
2960       getNextToken();
2961     } while (true);
2962   }
2963
2964   private void equalityExpression() throws CoreException {
2965     do {
2966       identicalExpression();
2967       if (token != TokenNameEQUAL_EQUAL && token != TokenNameNOT_EQUAL) {
2968         return;
2969       }
2970       getNextToken();
2971     } while (true);
2972   }
2973
2974   private void ternaryExpression() throws CoreException {
2975     equalityExpression();
2976     if (token == TokenNameQUESTION) {
2977       getNextToken();
2978       expression();
2979       if (token == TokenNameCOLON) {
2980         getNextToken();
2981         expression();
2982       } else {
2983         throwSyntaxError("':' expected in ternary operator '? :'.");
2984       }
2985     }
2986   }
2987
2988   private void andExpression() throws CoreException {
2989     do {
2990       ternaryExpression();
2991       if (token != TokenNameAND) {
2992         return;
2993       }
2994       getNextToken();
2995     } while (true);
2996   }
2997
2998   private void exclusiveorExpression() throws CoreException {
2999     do {
3000       andExpression();
3001       if (token != TokenNameXOR) {
3002         return;
3003       }
3004       getNextToken();
3005     } while (true);
3006   }
3007
3008   private void inclusiveorExpression() throws CoreException {
3009     do {
3010       exclusiveorExpression();
3011       if (token != TokenNameOR) {
3012         return;
3013       }
3014       getNextToken();
3015     } while (true);
3016   }
3017
3018   private void booleanandExpression() throws CoreException {
3019     do {
3020       inclusiveorExpression();
3021       if (token != TokenNameAND_AND) {
3022         return;
3023       }
3024       getNextToken();
3025     } while (true);
3026   }
3027
3028   private void booleanorExpression() throws CoreException {
3029     do {
3030       booleanandExpression();
3031       if (token != TokenNameOR_OR) {
3032         return;
3033       }
3034       getNextToken();
3035     } while (true);
3036   }
3037
3038   private void logicalandExpression() throws CoreException {
3039     do {
3040       booleanorExpression();
3041       if (token != TokenNameAND) {
3042         return;
3043       }
3044       getNextToken();
3045     } while (true);
3046   }
3047
3048   private void logicalexclusiveorExpression() throws CoreException {
3049     do {
3050       logicalandExpression();
3051       if (token != TokenNameXOR) {
3052         return;
3053       }
3054       getNextToken();
3055     } while (true);
3056   }
3057
3058   private void logicalinclusiveorExpression() throws CoreException {
3059     do {
3060       logicalexclusiveorExpression();
3061       if (token != TokenNameOR) {
3062         return;
3063       }
3064       getNextToken();
3065     } while (true);
3066   }
3067
3068   //  public void assignmentExpression() {
3069   //    if (token == TokenNameVARIABLE) {
3070   //      getNextToken();
3071   //      if (token == TokenNameSET) {
3072   //        getNextToken();
3073   //        logicalinclusiveorExpression();
3074   //      }
3075   //    } else {
3076   //      logicalinclusiveorExpression();
3077   //    }
3078   //  }
3079
3080   private void variableList() throws CoreException {
3081     do {
3082       variable();
3083       if (token == TokenNameCOMMA) {
3084         getNextToken();
3085       } else {
3086         break;
3087       }
3088     } while (true);
3089   }
3090
3091   private void variable() throws CoreException {
3092     if (token == TokenNameDOLLAR_LBRACE) {
3093       getNextToken();
3094       expression();
3095       ;
3096       if (token != TokenNameRBRACE) {
3097         throwSyntaxError("'}' expected after indirect variable token '${'.");
3098       }
3099       getNextToken();
3100     } else {
3101       if (token == TokenNameVariable) {
3102         getNextToken();
3103         if (token == TokenNameLBRACKET) {
3104           getNextToken();
3105           expression();
3106           if (token != TokenNameRBRACKET) {
3107             throwSyntaxError("']' expected in variable-list.");
3108           }
3109           getNextToken();
3110         } else if (token == TokenNameEQUAL) {
3111           getNextToken();
3112           constant();
3113         }
3114       } else {
3115         throwSyntaxError("$-variable expected in variable-list.");
3116       }
3117     }
3118   }
3119
3120   /**
3121    * It will look for a value (after a '=' for example)
3122    * @throws CoreException
3123    */
3124   private void constant() throws CoreException {
3125     //   String ident;
3126     switch (token) {
3127       case TokenNamePLUS :
3128         getNextToken();
3129         switch (token) {
3130           case TokenNameDoubleLiteral :
3131             getNextToken();
3132             break;
3133           case TokenNameIntegerLiteral :
3134             getNextToken();
3135             break;
3136           default :
3137             throwSyntaxError("Constant expected after '+' presign.");
3138         }
3139         break;
3140       case TokenNameMINUS :
3141         getNextToken();
3142         switch (token) {
3143           case TokenNameDoubleLiteral :
3144             getNextToken();
3145             break;
3146           case TokenNameIntegerLiteral :
3147             getNextToken();
3148             break;
3149           default :
3150             throwSyntaxError("Constant expected after '-' presign.");
3151         }
3152         break;
3153       case TokenNamenull :
3154         getNextToken();
3155         break;
3156       case TokenNamefalse :
3157         getNextToken();
3158         break;
3159       case TokenNametrue :
3160         getNextToken();
3161         break;
3162       case TokenNameIdentifier :
3163         //   ident = identifier;
3164         char[] ident = scanner.getCurrentIdentifierSource();
3165         getNextToken();
3166         if (token == TokenNameLPAREN) {
3167           getNextToken();
3168           if (token != TokenNameRPAREN) {
3169             expressionList();
3170             if (token != TokenNameRPAREN) {
3171               throwSyntaxError(
3172                 "')' expected after identifier '"
3173                   + new String(ident)
3174                   + "' in postfix-expression.");
3175             }
3176           }
3177           getNextToken();
3178         }
3179         break;
3180       case TokenNameStringLiteral :
3181         getNextToken();
3182         break;
3183       case TokenNameStringConstant :
3184         getNextToken();
3185         break;
3186       case TokenNameStringInterpolated :
3187         getNextToken();
3188         break;
3189       case TokenNameDoubleLiteral :
3190         getNextToken();
3191         break;
3192       case TokenNameIntegerLiteral :
3193         getNextToken();
3194         break;
3195       default :
3196         throwSyntaxError("Constant expected.");
3197     }
3198   }
3199
3200 }