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