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