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