net.sourceforge.phpeclipse/src/net/sourceforge/phpeclipse/phpeditor/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;
  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.php.PHPKeywords;
  21 import org.eclipse.core.resources.IFile;
  22 import org.eclipse.core.resources.IMarker;
  23 import org.eclipse.core.runtime.CoreException;
  24 import org.eclipse.core.runtime.IPath;
  25 import org.eclipse.jface.preference.IPreferenceStore;
  26 import org.eclipse.ui.texteditor.MarkerUtilities;
  27
  28 public class PHPParser extends PHPKeywords {
  29   // strings for external parser call
  30   private static final String PARSE_ERROR_STRING = "Parse error"; //$NON-NLS-1$
  31   private static final String PARSE_WARNING_STRING = "Warning"; //$NON-NLS-1$
  32
  33   public static final int ERROR = 2;
  34   public static final int WARNING = 1;
  35   public static final int INFO = 0;
  36   private IFile fileToParse;
  37   private ArrayList phpList;
  38
  39   private int currentPHPString;
  40   private boolean phpEnd;
  41
  42   private static HashMap keywordMap = null;
  43   private String str;
  44
  45   // current character
  46   char ch;
  47   // current token
  48   int token;
  49
  50   // row counter for syntax errors:
  51   int rowCount;
  52   // column counter for syntax errors:
  53   int columnCount;
  54
  55   int chIndx;
  56
  57   // current identifier
  58   String identifier;
  59
  60   Long longNumber;
  61   Double doubleNumber;
  62
  63   final static int TT_EOF = 0;
  64   final static int TT_UNDEFINED = 1;
  65
  66   final static int TT_MOD = 30;
  67   final static int TT_NOT = 31;
  68   final static int TT_DOT = 32;
  69   final static int TT_POW = 33;
  70   final static int TT_DIV = 34;
  71   final static int TT_MULTIPLY = 35;
  72   final static int TT_SUBTRACT = 36;
  73   final static int TT_ADD = 37;
  74   final static int TT_EQUAL = 38;
  75   final static int TT_UNEQUAL = 39;
  76   final static int TT_GREATER = 40;
  77   final static int TT_GREATEREQUAL = 41;
  78   final static int TT_LESS = 42;
  79   final static int TT_LESSEQUAL = 43;
  80   final static int TT_AND = 44;
  81   final static int TT_OR = 45;
  82   final static int TT_HASH = 46;
  83   final static int TT_DDOT = 47;
  84   final static int TT_DOTASSIGN = 48;
  85
  86   final static int TT_ASSIGN = 49;
  87   final static int TT_REF = 50;
  88   final static int TT_FOREACH = 51;
  89   final static int TT_AMPERSAND = 52;
  90   final static int TT_DOLLARLISTOPEN = 53;
  91   final static int TT_TILDE = 54;
  92   final static int TT_TILDEASSIGN = 55;
  93   final static int TT_MODASSIGN = 56;
  94   final static int TT_POWASSIGN = 57;
  95   final static int TT_RSHIFTASSIGN = 58;
  96   final static int TT_LSHIFTASSIGN = 59;
  97   final static int TT_ANDASSIGN = 60;
  98   final static int TT_QUESTIONMARK = 61;
  99   final static int TT_DDOT2 = 62;
 100   final static int TT_AT = 63;
 101   // final static int TT_HEREDOC = 64;
 102
 103   final static int TT_DOLLAROPEN = 127;
 104   final static int TT_ARGOPEN = 128;
 105   final static int TT_ARGCLOSE = 129;
 106   final static int TT_LISTOPEN = 130;
 107   final static int TT_LISTCLOSE = 131;
 108   final static int TT_PARTOPEN = 132;
 109   final static int TT_PARTCLOSE = 133;
 110   final static int TT_COMMA = 134;
 111
 112   final static int TT_STRING = 136;
 113   final static int TT_IDENTIFIER = 138;
 114   final static int TT_DIGIT = 139;
 115   final static int TT_SEMICOLON = 140;
 116   final static int TT_SLOT = 141;
 117   final static int TT_SLOTSEQUENCE = 142;
 118   final static int TT_DECREMENT = 144;
 119   final static int TT_INCREMENT = 145;
 120   final static int TT_ADDTO = 146;
 121   final static int TT_DIVIDEBY = 147;
 122   final static int TT_SUBTRACTFROM = 148;
 123   final static int TT_TIMESBY = 149;
 124   final static int TT_VARIABLE = 150;
 125   final static int TT_INT_NUMBER = 151;
 126   final static int TT_DOUBLE_NUMBER = 152;
 127   final static int TT_INTERPOLATED_STRING = 153;
 128   final static int TT_STRING_CONSTANT = 154;
 129
 130   final static int TT_LSHIFT = 155;
 131   final static int TT_RSHIFT = 156;
 132   final static int TT_EX_EQUAL = 157;
 133   final static int TT_EX_UNEQUAL = 158;
 134   final static int TT_LINE = 159;
 135   //  final static int TT_AT = 153; // @
 136   /**
 137    *  Class Constructor.
 138    *
 139    *@param  s
 140    *@param  sess  Description of Parameter
 141    *@see
 142    */
 143   public PHPParser(IFile fileToParse) {
 144     if (keywordMap == null) {
 145       keywordMap = new HashMap();
 146       for (int i = 0; i < PHP_KEYWORS.length; i++) {
 147         keywordMap.put(PHP_KEYWORS[i], new Integer(PHP_KEYWORD_TOKEN[i]));
 148       }
 149     }
 150     this.currentPHPString = 0;
 151     this.fileToParse = fileToParse;
 152     this.phpList = null;
 153     this.str = "";
 154     this.token = TT_EOF;
 155     this.chIndx = 0;
 156     this.rowCount = 1;
 157     this.columnCount = 0;
 158     this.phpEnd = false;
 159
 160     //   getNextToken();
 161   }
 162
 163   /**
 164    * Create marker for the parse error
 165    */
 166   private void setMarker(String message, int lineNumber, int errorLevel) throws CoreException {
 167     setMarker(fileToParse, message, lineNumber, errorLevel);
 168   }
 169
 170   public static void setMarker(IFile file, String message, int lineNumber, int errorLevel) throws CoreException {
 171
 172     Hashtable attributes = new Hashtable();
 173     MarkerUtilities.setMessage(attributes, message);
 174     switch (errorLevel) {
 175       case ERROR :
 176         attributes.put(IMarker.SEVERITY, new Integer(IMarker.SEVERITY_ERROR));
 177         break;
 178       case WARNING :
 179         attributes.put(IMarker.SEVERITY, new Integer(IMarker.SEVERITY_WARNING));
 180         break;
 181       case INFO :
 182         attributes.put(IMarker.SEVERITY, new Integer(IMarker.SEVERITY_INFO));
 183         break;
 184     }
 185     MarkerUtilities.setLineNumber(attributes, lineNumber);
 186     MarkerUtilities.createMarker(file, attributes, IMarker.PROBLEM);
 187   }
 188
 189   private void throwSyntaxError(String error) {
 190
 191     if (str.length() < chIndx) {
 192       chIndx--;
 193     }
 194     // read until end-of-line
 195     int eol = chIndx;
 196     while (str.length() > eol) {
 197       ch = str.charAt(eol++);
 198       if (ch == '\n') {
 199         eol--;
 200         break;
 201       }
 202     }
 203     throw new SyntaxError(rowCount, chIndx - columnCount + 1, str.substring(columnCount, eol), error);
 204   }
 205
 206   private void throwSyntaxError(String error, int startRow) {
 207
 208     throw new SyntaxError(startRow, 0, " ", error);
 209   }
 210
 211   /**
 212    *  Method Declaration.
 213    *
 214    *@see
 215    */
 216   private void getChar() {
 217     if (str.length() > chIndx) {
 218       ch = str.charAt(chIndx++);
 219
 220       return;
 221     }
 222
 223     chIndx = str.length() + 1;
 224     ch = ' ';
 225     //  token = TT_EOF;
 226     phpEnd = true;
 227   }
 228
 229   /**
 230    * gets the next token from input
 231    */
 232   private void getNextToken() throws CoreException {
 233     phpEnd = false;
 234
 235     while (str.length() > chIndx) {
 236       ch = str.charAt(chIndx++);
 237       token = TT_UNDEFINED;
 238       if (ch == '\n') {
 239         rowCount++;
 240         columnCount = chIndx;
 241         continue; // while loop
 242       }
 243       if (str.length() == chIndx) {
 244         phpEnd = true;
 245       }
 246       if (!Character.isWhitespace(ch)) {
 247         if (ch == '$') {
 248           if (str.length() > chIndx) {
 249             if (str.charAt(chIndx) == '{') {
 250               chIndx++;
 251               token = TT_DOLLAROPEN;
 252               return;
 253             }
 254           }
 255           getIdentifier();
 256           return;
 257         }
 258         if ((ch >= 'a' && ch <= 'z') || (ch >= 'A' && ch <= 'Z') || (ch == '_') || (ch == '$')) {
 259           getIdentifier();
 260           return;
 261         }
 262         if (ch >= '0' && ch <= '9') {
 263           getNumber();
 264           return;
 265         }
 266         if (ch == '/') {
 267           if (str.length() > chIndx) {
 268             if (str.charAt(chIndx) == '/') {
 269               chIndx++;
 270               // read comment until end of line:
 271               while ((str.length() > chIndx) && (str.charAt(chIndx) != '\n')) {
 272                 chIndx++;
 273               }
 274               continue;
 275             } else if (str.charAt(chIndx) == '*') {
 276               chIndx++;
 277               // multi line comment:
 278               while (str.length() > chIndx) {
 279                 if (str.charAt(chIndx) == '*' && (str.length() > (chIndx + 1)) && str.charAt(chIndx + 1) == '/') {
 280                   chIndx += 2;
 281                   break;
 282                 }
 283                 ch = str.charAt(chIndx++);
 284                 if (ch == '\n') {
 285                   rowCount++;
 286                   columnCount = chIndx;
 287                 }
 288               }
 289               continue;
 290             }
 291           }
 292         } else if (ch == '#') {
 293           // read comment until end of line:
 294           while ((str.length() > chIndx) && (str.charAt(chIndx) != '\n')) {
 295             chIndx++;
 296           }
 297           continue;
 298         } else if (ch == '"') {
 299           // read string until end
 300           boolean openString = true;
 301           while (str.length() > chIndx) {
 302             ch = str.charAt(chIndx++);
 303             if (ch == '\\') {
 304               if (str.length() > chIndx) {
 305                 ch = str.charAt(chIndx++);
 306               }
 307             } else if (ch == '"') {
 308               openString = false;
 309               break;
 310             } else if (ch == '\n') {
 311               rowCount++;
 312               columnCount = chIndx;
 313             }
 314           }
 315           if (openString) {
 316             throwSyntaxError("Open string character '\"' at end of file.");
 317           }
 318           token = TT_INTERPOLATED_STRING;
 319           return;
 320         } else if (ch == '\'') {
 321           // read string until end
 322           boolean openString = true;
 323           int startRow = rowCount;
 324           while (str.length() > chIndx) {
 325             ch = str.charAt(chIndx++);
 326             if (ch == '\\') {
 327               if (str.length() > chIndx) {
 328                 ch = str.charAt(chIndx++);
 329               }
 330             } else if (ch == '\'') {
 331               openString = false;
 332               break;
 333             } else if (ch == '\n') {
 334               rowCount++;
 335               columnCount = chIndx;
 336             }
 337           }
 338           if (openString) {
 339             throwSyntaxError("Open string character \"'\" at end of file.", startRow);
 340           }
 341           token = TT_STRING_CONSTANT;
 342           return;
 343         } else if (ch == '`') {
 344           // read string until end
 345           boolean openString = true;
 346           int startRow = rowCount;
 347           while (str.length() > chIndx) {
 348             ch = str.charAt(chIndx++);
 349             if (ch == '\\') {
 350               if (str.length() > chIndx) {
 351                 ch = str.charAt(chIndx++);
 352               }
 353             } else if (ch == '`') {
 354               openString = false;
 355               break;
 356             } else if (ch == '\n') {
 357               rowCount++;
 358               columnCount = chIndx;
 359             }
 360           }
 361           if (openString) {
 362             throwSyntaxError("Open string character \"`\" at end of file.", startRow);
 363           }
 364           setMarker("Other string delimiters prefered (found \"`\").", rowCount, PHPParser.INFO);
 365           token = TT_STRING_CONSTANT;
 366           return;
 367         }
 368
 369         switch (ch) {
 370
 371           case '(' :
 372             token = TT_ARGOPEN;
 373
 374             break;
 375           case ')' :
 376             token = TT_ARGCLOSE;
 377
 378             break;
 379           case '{' :
 380             token = TT_LISTOPEN;
 381
 382             break;
 383           case '}' :
 384             token = TT_LISTCLOSE;
 385
 386             break;
 387           case '[' :
 388             token = TT_PARTOPEN;
 389
 390             break;
 391           case ']' :
 392             token = TT_PARTCLOSE;
 393
 394             break;
 395           case ',' :
 396             token = TT_COMMA;
 397
 398             break;
 399           case '?' :
 400             token = TT_QUESTIONMARK;
 401             break;
 402           case '@' :
 403             token = TT_AT;
 404             break;
 405           case '~' :
 406             token = TT_TILDE;
 407             if (str.length() > chIndx) {
 408               if (str.charAt(chIndx) == '=') {
 409                 chIndx++;
 410                 token = TT_TILDEASSIGN;
 411
 412                 break;
 413               }
 414             }
 415             break;
 416           case '.' :
 417             token = TT_DOT;
 418             if (str.length() > chIndx) {
 419               if (str.charAt(chIndx) == '=') {
 420                 chIndx++;
 421                 token = TT_DOTASSIGN;
 422
 423                 break;
 424               }
 425             }
 426
 427             break;
 428           case '"' :
 429             token = TT_STRING;
 430
 431             break;
 432           case '%' :
 433             token = TT_MOD;
 434             if (str.length() > chIndx) {
 435               if (str.charAt(chIndx) == '=') {
 436                 chIndx++;
 437                 token = TT_MODASSIGN;
 438
 439                 break;
 440               }
 441             }
 442             break;
 443           case ';' :
 444             token = TT_SEMICOLON;
 445
 446             break;
 447           case '^' :
 448             token = TT_POW;
 449             if (str.length() > chIndx) {
 450               if (str.charAt(chIndx) == '=') {
 451                 chIndx++;
 452                 token = TT_POWASSIGN;
 453
 454                 break;
 455               }
 456             }
 457             break;
 458           case '/' :
 459             token = TT_DIV;
 460
 461             if (str.length() > chIndx) {
 462               if (str.charAt(chIndx) == '=') {
 463                 chIndx++;
 464                 token = TT_DIVIDEBY;
 465
 466                 break;
 467               }
 468             }
 469
 470             break;
 471           case '*' :
 472             token = TT_MULTIPLY;
 473             if (str.length() > chIndx) {
 474               if (str.charAt(chIndx) == '*') {
 475                 chIndx++;
 476                 token = TT_POW;
 477
 478                 break;
 479               }
 480               if (str.charAt(chIndx) == '=') {
 481                 chIndx++;
 482                 token = TT_TIMESBY;
 483
 484                 break;
 485               }
 486             }
 487
 488             break;
 489           case '+' :
 490             token = TT_ADD;
 491             if (str.length() > chIndx) {
 492               if (str.charAt(chIndx) == '+') {
 493                 chIndx++;
 494                 token = TT_INCREMENT;
 495
 496                 break;
 497               }
 498               if (str.charAt(chIndx) == '=') {
 499                 chIndx++;
 500                 token = TT_ADDTO;
 501
 502                 break;
 503               }
 504             }
 505             break;
 506           case '-' :
 507             token = TT_SUBTRACT;
 508             if (str.length() > chIndx) {
 509               if (str.charAt(chIndx) == '-') {
 510                 chIndx++;
 511                 token = TT_DECREMENT;
 512
 513                 break;
 514               }
 515               if (str.charAt(chIndx) == '=') {
 516                 chIndx++;
 517                 token = TT_SUBTRACTFROM;
 518
 519                 break;
 520               }
 521               if (str.charAt(chIndx) == '>') {
 522                 chIndx++;
 523                 token = TT_REF;
 524
 525                 break;
 526               }
 527             }
 528
 529             break;
 530           case '=' :
 531             token = TT_ASSIGN;
 532
 533             if (str.length() > chIndx) {
 534               ch = str.charAt(chIndx);
 535
 536               if (ch == '=') {
 537                 chIndx++;
 538                 token = TT_EQUAL;
 539                 if (str.length() > chIndx) {
 540                   ch = str.charAt(chIndx);
 541
 542                   if (ch == '=') {
 543                     chIndx++;
 544                     token = TT_EX_EQUAL;
 545                   }
 546                 }
 547                 break;
 548               }
 549               if (ch == '>') {
 550                 chIndx++;
 551                 token = TT_FOREACH;
 552
 553                 break;
 554               }
 555             }
 556
 557             break;
 558           case '!' :
 559             token = TT_NOT;
 560
 561             if (str.length() > chIndx) {
 562               if (str.charAt(chIndx) == '=') {
 563                 chIndx++;
 564                 token = TT_UNEQUAL;
 565                 if (str.length() > chIndx) {
 566                   ch = str.charAt(chIndx);
 567
 568                   if (ch == '=') {
 569                     chIndx++;
 570                     token = TT_EX_UNEQUAL;
 571                   }
 572                 }
 573                 break;
 574               }
 575             }
 576
 577             break;
 578           case '>' :
 579             token = TT_GREATER;
 580
 581             if (str.length() > chIndx) {
 582               if (str.charAt(chIndx) == '=') {
 583                 chIndx++;
 584                 token = TT_GREATEREQUAL;
 585                 break;
 586               }
 587               if (str.charAt(chIndx) == '>') {
 588                 chIndx++;
 589                 token = TT_RSHIFT;
 590                 if (str.length() > chIndx) {
 591                   if (str.charAt(chIndx) == '=') {
 592                     chIndx++;
 593                     token = TT_RSHIFTASSIGN;
 594                     break;
 595                   }
 596                 }
 597                 break;
 598               }
 599             }
 600
 601             break;
 602           case '<' :
 603             token = TT_LESS;
 604
 605             if (str.length() > chIndx) {
 606               if (str.charAt(chIndx) == '=') {
 607                 chIndx++;
 608                 token = TT_LESSEQUAL;
 609
 610                 break;
 611               }
 612               if (str.charAt(chIndx) == '<') {
 613                 chIndx++;
 614                 token = TT_LSHIFT;
 615                 if (str.charAt(chIndx) == '<') {
 616                   // heredoc
 617                   int startRow = rowCount;
 618                   if (str.length() > chIndx) {
 619
 620                     ch = str.charAt(++chIndx);
 621                     if ((ch >= 'a' && ch <= 'z') || (ch >= 'A' && ch <= 'Z') || (ch == '_')) {
 622                       chIndx++;
 623                       getIdentifier();
 624                       token = TT_STRING_CONSTANT;
 625                       while (str.length() > chIndx) {
 626                         ch = str.charAt(chIndx++);
 627                         if (ch == '\n') {
 628                           if (str.length() >= chIndx + identifier.length()) {
 629                             if (str.substring(chIndx, chIndx + identifier.length()).equals(identifier)) {
 630                               chIndx += identifier.length();
 631                               return;
 632                             }
 633                           }
 634                         }
 635                       }
 636                     }
 637                   }
 638                   throwSyntaxError("Open heredoc syntax after operator '<<<'.", startRow);
 639                 } else if (str.charAt(chIndx) == '=') {
 640                   chIndx++;
 641                   token = TT_LSHIFTASSIGN;
 642                   break;
 643                 }
 644                 break;
 645               }
 646             }
 647
 648             break;
 649
 650           case '|' :
 651             token = TT_LINE;
 652
 653             if (str.length() > chIndx) {
 654               if (str.charAt(chIndx) == '|') {
 655                 chIndx++;
 656                 token = TT_OR;
 657
 658                 break;
 659               }
 660             }
 661
 662             break;
 663           case '&' :
 664             token = TT_AMPERSAND;
 665             if (str.length() > chIndx) {
 666               if (str.charAt(chIndx) == '&') {
 667                 chIndx++;
 668                 token = TT_AND;
 669                 break;
 670               }
 671               if (str.charAt(chIndx) == '=') {
 672                 chIndx++;
 673                 token = TT_ANDASSIGN;
 674                 break;
 675               }
 676               break;
 677             }
 678
 679             break;
 680           case ':' :
 681             token = TT_DDOT;
 682             if (str.length() > chIndx) {
 683               if (str.charAt(chIndx) == ':') {
 684                 chIndx++;
 685                 token = TT_DDOT2;
 686               }
 687             }
 688             break;
 689           case '#' :
 690             token = TT_HASH;
 691
 692             break;
 693             //          case '@' :
 694             //            token = TT_AT;
 695             //
 696             //            break;
 697           default :
 698             throwSyntaxError("unexpected character: '" + ch + "'");
 699         }
 700
 701         if (token == TT_UNDEFINED) {
 702           throwSyntaxError("token not found");
 703         }
 704
 705         return;
 706       }
 707     }
 708
 709     chIndx = str.length() + 1;
 710     ch = ' ';
 711     token = TT_EOF;
 712     phpEnd = true;
 713     PHPString temp;
 714     if (phpList != null) {
 715       if (currentPHPString < phpList.size()) {
 716         token = TT_UNDEFINED;
 717         temp = (PHPString) phpList.get(currentPHPString++);
 718         this.str = temp.getPHPString();
 719         this.token = TT_EOF;
 720         this.chIndx = 0;
 721         this.rowCount = temp.getLineNumber();
 722         this.columnCount = 0;
 723         getNextToken();
 724         phpEnd = true;
 725       } else {
 726         token = TT_UNDEFINED;
 727         return;
 728       }
 729     }
 730   }
 731
 732   private void getIdentifier() {
 733     StringBuffer ident = new StringBuffer();
 734
 735     ident.append(ch);
 736     if (ch == '$') {
 737       token = TT_VARIABLE;
 738     } else {
 739       token = TT_IDENTIFIER;
 740     }
 741     getChar();
 742     while ((ch >= 'a' && ch <= 'z') || (ch >= 'A' && ch <= 'Z') || (ch >= '0' && ch <= '9') || (ch == '_')) {
 743       ident.append(ch);
 744       getChar();
 745     }
 746     identifier = ident.toString();
 747     chIndx--;
 748
 749     Integer i = (Integer) keywordMap.get(identifier.toLowerCase());
 750     if (i != null) {
 751       token = i.intValue();
 752     }
 753   }
 754
 755   private void getNumber() {
 756     StringBuffer inum = new StringBuffer();
 757     char dFlag = ' ';
 758     int numFormat = 10;
 759
 760     // save first digit
 761     char firstCh = ch;
 762     inum.append(ch);
 763
 764     getChar();
 765     // determine number conversions:
 766     if (firstCh == '0') {
 767       switch (ch) {
 768         case 'b' :
 769           numFormat = 2;
 770           getChar();
 771           break;
 772         case 'B' :
 773           numFormat = 2;
 774           getChar();
 775           break;
 776         case 'o' :
 777           numFormat = 8;
 778           getChar();
 779           break;
 780         case 'O' :
 781           numFormat = 8;
 782           getChar();
 783           break;
 784         case 'x' :
 785           numFormat = 16;
 786           getChar();
 787           break;
 788         case 'X' :
 789           numFormat = 16;
 790           getChar();
 791           break;
 792       }
 793     }
 794
 795     if (numFormat == 16) {
 796       while ((ch >= '0' && ch <= '9') || (ch >= 'a' && ch <= 'f') || (ch >= 'A' && ch <= 'F')) {
 797         inum.append(ch);
 798         getChar();
 799       }
 800     } else {
 801       while ((ch >= '0' && ch <= '9') || (ch == '.') || (ch == 'E') || (ch == 'e')) {
 802         if ((ch == '.') || (ch == 'E') || (ch == 'e')) {
 803           if (ch == '.' && dFlag != ' ') {
 804             break;
 805           }
 806           if ((dFlag == 'E') || (dFlag == 'e')) {
 807             break;
 808           }
 809           dFlag = ch;
 810           inum.append(ch);
 811           getChar();
 812           if ((ch == '-') || (ch == '+')) {
 813             inum.append(ch);
 814             getChar();
 815           }
 816         } else {
 817           inum.append(ch);
 818           getChar();
 819         }
 820       }
 821     }
 822     chIndx--;
 823
 824     try {
 825       if (dFlag != ' ') {
 826         doubleNumber = new Double(inum.toString());
 827         token = TT_DOUBLE_NUMBER;
 828         return;
 829       } else {
 830         longNumber = Long.valueOf(inum.toString(), numFormat);
 831         token = TT_INT_NUMBER;
 832         return;
 833       }
 834
 835     } catch (Throwable e) {
 836       throwSyntaxError("Number format error: " + inum.toString());
 837     }
 838   }
 839
 840   public void htmlParse(String input) {
 841     int lineNumber = 1;
 842     int startLineNumber = 1;
 843     int startIndex = 0;
 844     char ch;
 845     char ch2;
 846     boolean phpMode = false;
 847     boolean phpFound = false;
 848
 849     phpList = new ArrayList();
 850     currentPHPString = 0;
 851
 852     try {
 853       int i = 0;
 854       while (i < input.length()) {
 855         ch = input.charAt(i++);
 856         if (ch == '\n') {
 857           lineNumber++;
 858         }
 859         if ((!phpMode) && ch == '<') {
 860           ch2 = input.charAt(i++);
 861           if (ch2 == '?') {
 862             ch2 = input.charAt(i++);
 863             if (Character.isWhitespace(ch2)) {
 864               // php start
 865               phpMode = true;
 866               phpFound = true;
 867               startIndex = i;
 868               startLineNumber = lineNumber;
 869               continue;
 870             } else if (ch2 == 'p') {
 871               ch2 = input.charAt(i++);
 872               if (ch2 == 'h') {
 873                 ch2 = input.charAt(i++);
 874                 if (ch2 == 'p') {
 875                   phpMode = true;
 876                   phpFound = true;
 877                   startIndex = i;
 878                   startLineNumber = lineNumber;
 879                   continue;
 880                 }
 881                 i--;
 882               }
 883               i--;
 884             } else if (ch2 == 'P') {
 885               ch2 = input.charAt(i++);
 886               if (ch2 == 'H') {
 887                 ch2 = input.charAt(i++);
 888                 if (ch2 == 'P') {
 889                   phpMode = true;
 890                   phpFound = true;
 891                   startIndex = i;
 892                   startLineNumber = lineNumber;
 893                   continue;
 894                 }
 895                 i--;
 896               }
 897               i--;
 898             }
 899             i--;
 900           }
 901           i--;
 902         }
 903
 904         if (phpMode) {
 905           if (ch == '/' && i < input.length()) {
 906             ch2 = input.charAt(i++);
 907             if (ch2 == '/') {
 908               while (i < input.length()) {
 909                 ch = input.charAt(i++);
 910                 if (ch == '?' && i < input.length()) {
 911                   ch2 = input.charAt(i++);
 912                   if (ch2 == '>') {
 913                     // php end
 914                     phpMode = false;
 915                     phpList.add(new PHPString(input.substring(startIndex, i - 2), startLineNumber));
 916                     continue;
 917                   }
 918                   i--;
 919                 } else if (ch == '\n') {
 920                   lineNumber++;
 921                   break;
 922                 }
 923               }
 924               continue;
 925             } else if (ch2 == '*') {
 926               // multi-line comment
 927               while (i < input.length()) {
 928                 ch = input.charAt(i++);
 929                 if (ch == '\n') {
 930                   lineNumber++;
 931                 } else if (ch == '*' && i < input.length()) {
 932                   ch2 = input.charAt(i++);
 933                   if (ch2 == '/') {
 934                     break;
 935                   }
 936                   i--;
 937                 }
 938               }
 939               continue;
 940             } else {
 941               i--;
 942             }
 943           } else if (ch == '#') {
 944             while (i < input.length()) {
 945               ch = input.charAt(i++);
 946               if (ch == '?' && i < input.length()) {
 947                 ch2 = input.charAt(i++);
 948                 if (ch2 == '>') {
 949                   // php end
 950                   phpMode = false;
 951                   phpList.add(new PHPString(input.substring(startIndex, i - 2), startLineNumber));
 952                   continue;
 953                 }
 954                 i--;
 955               } else if (ch == '\n') {
 956                 lineNumber++;
 957                 break;
 958               }
 959             }
 960             continue;
 961           } else if (ch == '"') {
 962             ch = ' ';
 963             while (i < input.length()) {
 964               ch = input.charAt(i++);
 965               if (ch == '\n') {
 966                 lineNumber++;
 967               } else if (ch == '\\' && i < input.length()) { // escape
 968                 i++;
 969               } else if (ch == '"') {
 970                 break;
 971               }
 972             }
 973             continue;
 974           } else if (ch == '\'') {
 975             ch = ' ';
 976             while (i < input.length()) {
 977               ch = input.charAt(i++);
 978               if (ch == '\n') {
 979                 lineNumber++;
 980               } else if (ch == '\\' && i < input.length()) { // escape
 981                 i++;
 982               } else if (ch == '\'') {
 983                 break;
 984               }
 985             }
 986             continue;
 987           }
 988
 989           if (ch == '?' && i < input.length()) {
 990             ch2 = input.charAt(i++);
 991             if (ch2 == '>') {
 992               // php end
 993               phpMode = false;
 994               phpList.add(new PHPString(input.substring(startIndex, i - 2), startLineNumber));
 995               continue;
 996             }
 997             i--;
 998           }
 999         }
1000       }
1001
1002       if (!phpFound) {
1003         setMarker("No PHP source code found.", lineNumber, PHPParser.INFO);
1004       } else {
1005         if (phpMode) {
1006           setMarker("Open PHP tag at end of file.", lineNumber, PHPParser.INFO);
1007           phpList.add(new PHPString(input.substring(startIndex, i - 2), startLineNumber));
1008         }
1009         //        for (int j=0;j<phpList.size();j++) {
1010         //          String temp = ((PHPString)phpList.get(j)).getPHPString();
1011         //          int startIndx = temp.length()-10;
1012         //          if (startIndx<0) {
1013         //            startIndx = 0;
1014         //          }
1015         //          System.out.println(temp.substring(startIndx)+"?>");
1016         //        }
1017         phpParse(null, 1);
1018         //        PHPString temp;
1019         //        for(int j=0;j<phpList.size();j++) {
1020         //          temp = (PHPString) phpList.get(j);
1021         //          parser.start(temp.getPHPString(), temp.getLineNumber());
1022         //        }
1023       }
1024     } catch (CoreException e) {
1025     }
1026   }
1027
1028   public void phpParse(String s, int rowCount) throws CoreException {
1029     this.str = s;
1030     if (s == null) {
1031       if (phpList.size() != 0) {
1032         this.str = ((PHPString) phpList.get(currentPHPString++)).getPHPString();
1033       }
1034     }
1035     this.token = TT_EOF;
1036     this.chIndx = 0;
1037     this.rowCount = rowCount;
1038     this.columnCount = 0;
1039     this.phpEnd = false;
1040     getNextToken();
1041     do {
1042       try {
1043         if (token != TT_EOF && token != TT_UNDEFINED) {
1044           statementList();
1045         }
1046         if (token != TT_EOF && token != TT_UNDEFINED) {
1047           if (token == TT_ARGCLOSE) {
1048             throwSyntaxError("Too many closing ')'; end-of-file not reached.");
1049           }
1050           if (token == TT_LISTCLOSE) {
1051             throwSyntaxError("Too many closing '}'; end-of-file not reached.");
1052           }
1053           if (token == TT_PARTCLOSE) {
1054             throwSyntaxError("Too many closing ']'; end-of-file not reached.");
1055           }
1056
1057           if (token == TT_ARGOPEN) {
1058             throwSyntaxError("Read character '('; end-of-file not reached.");
1059           }
1060           if (token == TT_LISTOPEN) {
1061             throwSyntaxError("Read character '{';  end-of-file not reached.");
1062           }
1063           if (token == TT_PARTOPEN) {
1064             throwSyntaxError("Read character '[';  end-of-file not reached.");
1065           }
1066
1067           throwSyntaxError("End-of-file not reached.");
1068         }
1069         return;
1070       } catch (SyntaxError err) {
1071         if (s != null) {
1072           throw err;
1073         } else {
1074           setMarker(err.getMessage(), err.getLine(), ERROR);
1075         }
1076         // if an error occured,
1077         // try to find keywords 'class' or 'function'
1078         // to parse the rest of the string
1079         while (token != TT_EOF && token != TT_UNDEFINED) {
1080           if (token == TT_class || token == TT_function) {
1081             break;
1082           }
1083           getNextToken();
1084         }
1085         if (token == TT_EOF || token == TT_UNDEFINED) {
1086           return;
1087         }
1088       }
1089     }
1090     while (true);
1091   }
1092
1093   private void statementList() throws CoreException {
1094     do {
1095       statement();
1096       if ((token == TT_LISTCLOSE)
1097         || (token == TT_case)
1098         || (token == TT_default)
1099         || (token == TT_elseif)
1100         || (token == TT_endif)
1101         || (token == TT_endfor)
1102         || (token == TT_endforeach)
1103         || (token == TT_endwhile)
1104         || (token == TT_endswitch)
1105         || (token == TT_EOF)
1106         || (token == TT_UNDEFINED)) {
1107         return;
1108       }
1109     } while (true);
1110   }
1111
1112   private void compoundStatement() throws CoreException {
1113     // '{' [statement-list] '}'
1114     if (token == TT_LISTOPEN) {
1115       getNextToken();
1116     } else {
1117       throwSyntaxError("'{' expected in compound-statement.");
1118     }
1119     if (token != TT_LISTCLOSE) {
1120       statementList();
1121     }
1122     if (token == TT_LISTCLOSE) {
1123       getNextToken();
1124     } else {
1125       throwSyntaxError("'}' expected in compound-statement.");
1126     }
1127   }
1128
1129   private void statement() throws CoreException {
1130     //   if (token > TT_KEYWORD && token != TT_list && token != TT_new) {
1131     String keyword = identifier;
1132     if (token == TT_include || token == TT_include_once) {
1133       getNextToken();
1134       expression();
1135       if (token == TT_SEMICOLON) {
1136         getNextToken();
1137       } else {
1138         if (!phpEnd) {
1139           throwSyntaxError("';' character after 'include' or 'include_once' expected.");
1140         }
1141       }
1142       return;
1143     } else if (token == TT_require || token == TT_require_once) {
1144       getNextToken();
1145       //constant();
1146       expression();
1147       if (token == TT_SEMICOLON) {
1148         getNextToken();
1149       } else {
1150         if (!phpEnd) {
1151           throwSyntaxError("';' character after 'require' or 'require_once' expected.");
1152         }
1153       }
1154       return;
1155     } else if (token == TT_if) {
1156       getNextToken();
1157       if (token == TT_ARGOPEN) {
1158         getNextToken();
1159       } else {
1160         throwSyntaxError("'(' expected after 'if' keyword.");
1161       }
1162       expression();
1163       if (token == TT_ARGCLOSE) {
1164         getNextToken();
1165       } else {
1166         throwSyntaxError("')' expected after 'if' condition.");
1167       }
1168       ifStatement();
1169       return;
1170
1171     } else if (token == TT_switch) {
1172       getNextToken();
1173       if (token == TT_ARGOPEN) {
1174         getNextToken();
1175       } else {
1176         throwSyntaxError("'(' expected after 'switch' keyword.");
1177       }
1178       expression();
1179       if (token == TT_ARGCLOSE) {
1180         getNextToken();
1181       } else {
1182         throwSyntaxError("')' expected after 'switch' condition.");
1183       }
1184       switchStatement();
1185       return;
1186     } else if (token == TT_for) {
1187       getNextToken();
1188       if (token == TT_ARGOPEN) {
1189         getNextToken();
1190       } else {
1191         throwSyntaxError("'(' expected after 'for' keyword.");
1192       }
1193       if (token == TT_SEMICOLON) {
1194         getNextToken();
1195       } else {
1196         expressionList();
1197         if (token == TT_SEMICOLON) {
1198           getNextToken();
1199         } else {
1200           throwSyntaxError("';' expected after 'for'.");
1201         }
1202       }
1203       if (token == TT_SEMICOLON) {
1204         getNextToken();
1205       } else {
1206         expressionList();
1207         if (token == TT_SEMICOLON) {
1208           getNextToken();
1209         } else {
1210           throwSyntaxError("';' expected after 'for'.");
1211         }
1212       }
1213       if (token == TT_ARGCLOSE) {
1214         getNextToken();
1215       } else {
1216         expressionList();
1217         if (token == TT_ARGCLOSE) {
1218           getNextToken();
1219         } else {
1220           throwSyntaxError("')' expected after 'for'.");
1221         }
1222       }
1223       forStatement();
1224       return;
1225     } else if (token == TT_while) {
1226       getNextToken();
1227       if (token == TT_ARGOPEN) {
1228         getNextToken();
1229       } else {
1230         throwSyntaxError("'(' expected after 'while' keyword.");
1231       }
1232       expression();
1233       if (token == TT_ARGCLOSE) {
1234         getNextToken();
1235       } else {
1236         throwSyntaxError("')' expected after 'while' condition.");
1237       }
1238       whileStatement();
1239       return;
1240     } else if (token == TT_do) {
1241       getNextToken();
1242       if (token == TT_LISTOPEN) {
1243         getNextToken();
1244       } else {
1245         throwSyntaxError("'{' expected after 'do' keyword.");
1246       }
1247       if (token != TT_LISTCLOSE) {
1248         statementList();
1249       }
1250       if (token == TT_LISTCLOSE) {
1251         getNextToken();
1252       } else {
1253         throwSyntaxError("'}' expected after 'do' keyword.");
1254       }
1255       if (token == TT_while) {
1256         getNextToken();
1257         if (token == TT_ARGOPEN) {
1258           getNextToken();
1259         } else {
1260           throwSyntaxError("'(' expected after 'while' keyword.");
1261         }
1262         expression();
1263         if (token == TT_ARGCLOSE) {
1264           getNextToken();
1265         } else {
1266           throwSyntaxError("')' expected after 'while' condition.");
1267         }
1268       } else {
1269         throwSyntaxError("'while' expected after 'do' keyword.");
1270       }
1271       if (token == TT_SEMICOLON) {
1272         getNextToken();
1273       } else {
1274         if (!phpEnd) {
1275           throwSyntaxError("';' expected after do-while statement.");
1276         }
1277       }
1278       return;
1279     } else if (token == TT_foreach) {
1280       getNextToken();
1281       if (token == TT_ARGOPEN) {
1282         getNextToken();
1283       } else {
1284         throwSyntaxError("'(' expected after 'foreach' keyword.");
1285       }
1286       expression();
1287       if (token == TT_as) {
1288         getNextToken();
1289       } else {
1290         throwSyntaxError("'as' expected after 'foreach' exxpression.");
1291       }
1292       variable();
1293       if (token == TT_FOREACH) {
1294         getNextToken();
1295         variable();
1296       }
1297       if (token == TT_ARGCLOSE) {
1298         getNextToken();
1299       } else {
1300         throwSyntaxError("')' expected after 'foreach' expression.");
1301       }
1302       foreachStatement();
1303       return;
1304
1305     } else if (token == TT_continue || token == TT_break || token == TT_return) {
1306       getNextToken();
1307       if (token != TT_SEMICOLON) {
1308         expression();
1309       }
1310       if (token == TT_SEMICOLON) {
1311         getNextToken();
1312       } else {
1313         if (!phpEnd) {
1314           throwSyntaxError("';' expected after 'continue', 'break' or 'return'.");
1315         }
1316       }
1317       return;
1318
1319     } else if (token == TT_echo) {
1320       getNextToken();
1321       expressionList();
1322       if (token == TT_SEMICOLON) {
1323         getNextToken();
1324       } else {
1325         if (!phpEnd) {
1326           throwSyntaxError("';' expected after 'echo' statement.");
1327         }
1328       }
1329       return;
1330       //    } else if (token == TT_print) {
1331       //      getNextToken();
1332       //      expression();
1333       //      if (token == TT_SEMICOLON) {
1334       //        getNextToken();
1335       //      } else {
1336       //        if (!phpEnd) {
1337       //          throwSyntaxError("';' expected after 'print' statement.");
1338       //        }
1339       //      }
1340       //      return;
1341
1342     } else if (token == TT_global || token == TT_static) {
1343       getNextToken();
1344       variableList();
1345       if (token == TT_SEMICOLON) {
1346         getNextToken();
1347       } else {
1348         if (!phpEnd) {
1349           throwSyntaxError("';' expected after 'global' or 'static' statement.");
1350         }
1351       }
1352       return;
1353
1354       //      } else if (token == TT_unset) {
1355       //        getNextToken();
1356       //        if (token == TT_ARGOPEN) {
1357       //          getNextToken();
1358       //        } else {
1359       //          throwSyntaxError("'(' expected after 'unset' keyword.");
1360       //        }
1361       //        variableList();
1362       //        if (token == TT_ARGCLOSE) {
1363       //          getNextToken();
1364       //        } else {
1365       //          throwSyntaxError("')' expected after 'unset' statement.");
1366       //        }
1367       //        if (token == TT_SEMICOLON) {
1368       //          getNextToken();
1369       //        } else {
1370       //          if (!phpEnd) {
1371       //            throwSyntaxError("';' expected after 'unset' statement.");
1372       //          }
1373       //        }
1374       //        return;
1375
1376       //      } else if (token == TT_exit || token == TT_die) {
1377       //        getNextToken();
1378       //        if (token != TT_SEMICOLON) {
1379       //          exitStatus();
1380       //        }
1381       //        if (token == TT_SEMICOLON) {
1382       //          getNextToken();
1383       //        } else {
1384       //          if (!phpEnd) {
1385       //            throwSyntaxError("';' expected after 'exit' or 'die' statement.");
1386       //          }
1387       //        }
1388       //        return;
1389
1390     } else if (token == TT_define) {
1391       getNextToken();
1392       if (token == TT_ARGOPEN) {
1393         getNextToken();
1394       } else {
1395         throwSyntaxError("'(' expected after 'define' keyword.");
1396       }
1397       expression();
1398       if (token == TT_COMMA) {
1399         getNextToken();
1400       } else {
1401         throwSyntaxError("',' expected after first 'define' constant.");
1402       }
1403       expression();
1404       if (token == TT_COMMA) {
1405         getNextToken();
1406         expression();
1407       }
1408       if (token == TT_ARGCLOSE) {
1409         getNextToken();
1410       } else {
1411         throwSyntaxError("')' expected after 'define' statement.");
1412       }
1413       if (token == TT_SEMICOLON) {
1414         getNextToken();
1415       } else {
1416         if (!phpEnd) {
1417           throwSyntaxError("';' expected after 'define' statement.");
1418         }
1419       }
1420       return;
1421     } else if (token == TT_function) {
1422       getNextToken();
1423       functionDefinition();
1424       return;
1425     } else if (token == TT_class) {
1426       getNextToken();
1427       classDeclarator();
1428       classBody();
1429       return;
1430       //      } else {
1431       //        throwSyntaxError("Unexpected keyword '" + keyword + "'");
1432     } else if (token == TT_LISTOPEN) {
1433       // compoundStatement
1434       getNextToken();
1435       if (token != TT_LISTCLOSE) {
1436         statementList();
1437       }
1438       if (token == TT_LISTCLOSE) {
1439         getNextToken();
1440         return;
1441       } else {
1442         throwSyntaxError("'}' expected.");
1443       }
1444     } else {
1445       if (token != TT_SEMICOLON) {
1446         expression();
1447       }
1448       if (token == TT_SEMICOLON) {
1449         getNextToken();
1450         return;
1451       } else {
1452         if (!phpEnd) {
1453           throwSyntaxError("';' expected after expression.");
1454         }
1455       }
1456     }
1457   }
1458
1459   private void classDeclarator() throws CoreException {
1460     //identifier
1461     //identifier 'extends' identifier
1462     if (token == TT_IDENTIFIER) {
1463       getNextToken();
1464       if (token == TT_extends) {
1465         getNextToken();
1466         if (token == TT_IDENTIFIER) {
1467           getNextToken();
1468         } else {
1469           throwSyntaxError("Class name expected after keyword 'extends'.");
1470         }
1471       }
1472     } else {
1473       throwSyntaxError("Class name expected after keyword 'class'.");
1474     }
1475   }
1476
1477   private void classBody() throws CoreException {
1478     //'{' [class-element-list] '}'
1479     if (token == TT_LISTOPEN) {
1480       getNextToken();
1481       if (token != TT_LISTCLOSE) {
1482         classElementList();
1483       }
1484       if (token == TT_LISTCLOSE) {
1485         getNextToken();
1486       } else {
1487         throwSyntaxError("'}' expected at end of class body.");
1488       }
1489     } else {
1490       throwSyntaxError("'{' expected at start of class body.");
1491     }
1492   }
1493
1494   private void classElementList() throws CoreException {
1495     do {
1496       classElement();
1497     } while (token == TT_function || token == TT_var);
1498   }
1499
1500   private void classElement() throws CoreException {
1501     //class-property
1502     //function-definition
1503     if (token == TT_function) {
1504       getNextToken();
1505       functionDefinition();
1506     } else if (token == TT_var) {
1507       getNextToken();
1508       classProperty();
1509     } else {
1510       throwSyntaxError("'function' or 'var' expected.");
1511     }
1512   }
1513
1514   private void classProperty() throws CoreException {
1515     //'var' variable ';'
1516     //'var' variable '=' constant ';'
1517     do {
1518       if (token == TT_VARIABLE) {
1519         getNextToken();
1520         if (token == TT_ASSIGN) {
1521           getNextToken();
1522           constant();
1523         }
1524       } else {
1525         throwSyntaxError("Variable expected after keyword 'var'.");
1526       }
1527       if (token != TT_COMMA) {
1528         break;
1529       }
1530       getNextToken();
1531     } while (true);
1532     if (token == TT_SEMICOLON) {
1533       getNextToken();
1534     } else {
1535       throwSyntaxError("';' expected after variable declaration.");
1536     }
1537   }
1538
1539   private void functionDefinition() throws CoreException {
1540     functionDeclarator();
1541     compoundStatement();
1542   }
1543
1544   private void functionDeclarator() throws CoreException {
1545     //identifier '(' [parameter-list] ')'
1546     if (token == TT_AMPERSAND) {
1547       getNextToken();
1548     }
1549     if (token == TT_IDENTIFIER) {
1550       getNextToken();
1551       if (token == TT_ARGOPEN) {
1552         getNextToken();
1553       } else {
1554         throwSyntaxError("'(' expected in function declaration.");
1555       }
1556       if (token != TT_ARGCLOSE) {
1557         parameterList();
1558       }
1559       if (token != TT_ARGCLOSE) {
1560         throwSyntaxError("')' expected in function declaration.");
1561       } else {
1562         getNextToken();
1563       }
1564     }
1565   }
1566   //
1567   private void parameterList() throws CoreException {
1568     //parameter-declaration
1569     //parameter-list ',' parameter-declaration
1570     do {
1571       parameterDeclaration();
1572       if (token != TT_COMMA) {
1573         break;
1574       }
1575       getNextToken();
1576     } while (true);
1577   }
1578
1579   private void parameterDeclaration() throws CoreException {
1580     //variable
1581     //variable-reference
1582     if (token == TT_AMPERSAND) {
1583       getNextToken();
1584       if (token == TT_VARIABLE) {
1585         getNextToken();
1586       } else {
1587         throwSyntaxError("Variable expected after reference operator '&'.");
1588       }
1589     }
1590     //variable '=' constant
1591     if (token == TT_VARIABLE) {
1592       getNextToken();
1593       if (token == TT_ASSIGN) {
1594         getNextToken();
1595         constant();
1596       }
1597       return;
1598     }
1599   }
1600
1601   private void labeledStatementList() throws CoreException {
1602     if (token != TT_case && token != TT_default) {
1603       throwSyntaxError("'case' or 'default' expected.");
1604     }
1605     do {
1606       if (token == TT_case) {
1607         getNextToken();
1608         constant();
1609         if (token == TT_DDOT) {
1610           getNextToken();
1611           if (token == TT_case || token == TT_default) { // empty case statement ?
1612             continue;
1613           }
1614           statementList();
1615         } else if (token == TT_SEMICOLON) {
1616           setMarker("':' expected after 'case' keyword found ';'.", rowCount, PHPParser.INFO);
1617           getNextToken();
1618           if (token == TT_case) { // empty case statement ?
1619             continue;
1620           }
1621           statementList();
1622         } else {
1623           throwSyntaxError("':' character after 'case' constant expected.");
1624         }
1625       } else { // TT_default
1626         getNextToken();
1627         if (token == TT_DDOT) {
1628           getNextToken();
1629           statementList();
1630         } else {
1631           throwSyntaxError("':' character after 'default' expected.");
1632         }
1633       }
1634     } while (token == TT_case || token == TT_default);
1635   }
1636
1637   //  public void labeledStatement() {
1638   //    if (token == TT_case) {
1639   //      getNextToken();
1640   //      constant();
1641   //      if (token == TT_DDOT) {
1642   //        getNextToken();
1643   //        statement();
1644   //      } else {
1645   //        throwSyntaxError("':' character after 'case' constant expected.");
1646   //      }
1647   //      return;
1648   //    } else if (token == TT_default) {
1649   //      getNextToken();
1650   //      if (token == TT_DDOT) {
1651   //        getNextToken();
1652   //        statement();
1653   //      } else {
1654   //        throwSyntaxError("':' character after 'default' expected.");
1655   //      }
1656   //      return;
1657   //    }
1658   //  }
1659
1660   //  public void expressionStatement() {
1661   //  }
1662
1663   //  private void inclusionStatement() {
1664   //  }
1665
1666   //  public void compoundStatement() {
1667   //  }
1668
1669   //  public void selectionStatement() {
1670   //  }
1671   //
1672   //  public void iterationStatement() {
1673   //  }
1674   //
1675   //  public void jumpStatement() {
1676   //  }
1677   //
1678   //  public void outputStatement() {
1679   //  }
1680   //
1681   //  public void scopeStatement() {
1682   //  }
1683   //
1684   //  public void flowStatement() {
1685   //  }
1686   //
1687   //  public void definitionStatement() {
1688   //  }
1689
1690   private void ifStatement() throws CoreException {
1691     // ':' statement-list [elseif-list] [else-colon-statement] 'endif' ';'
1692     if (token == TT_DDOT) {
1693       getNextToken();
1694       statementList();
1695       switch (token) {
1696         case TT_else :
1697           getNextToken();
1698           if (token == TT_DDOT) {
1699             getNextToken();
1700             statementList();
1701           } else {
1702             if (token == TT_if) { //'else if'
1703               getNextToken();
1704               elseifStatementList();
1705             } else {
1706               throwSyntaxError("':' expected after 'else'.");
1707             }
1708           }
1709           break;
1710         case TT_elseif :
1711           getNextToken();
1712           elseifStatementList();
1713           break;
1714       }
1715
1716       if (token != TT_endif) {
1717         throwSyntaxError("'endif' expected.");
1718       }
1719       getNextToken();
1720       if (token != TT_SEMICOLON) {
1721         throwSyntaxError("';' expected after if-statement.");
1722       }
1723       getNextToken();
1724     } else {
1725       // statement [else-statement]
1726       statement();
1727       if (token == TT_elseif) {
1728         getNextToken();
1729         if (token == TT_ARGOPEN) {
1730           getNextToken();
1731         } else {
1732           throwSyntaxError("'(' expected after 'elseif' keyword.");
1733         }
1734         expression();
1735         if (token == TT_ARGCLOSE) {
1736           getNextToken();
1737         } else {
1738           throwSyntaxError("')' expected after 'elseif' condition.");
1739         }
1740         ifStatement();
1741       } else if (token == TT_else) {
1742         getNextToken();
1743         statement();
1744       }
1745     }
1746   }
1747
1748   private void elseifStatementList() throws CoreException {
1749     do {
1750       elseifStatement();
1751       switch (token) {
1752         case TT_else :
1753           getNextToken();
1754           if (token == TT_DDOT) {
1755             getNextToken();
1756             statementList();
1757             return;
1758           } else {
1759             if (token == TT_if) { //'else if'
1760               getNextToken();
1761             } else {
1762               throwSyntaxError("':' expected after 'else'.");
1763             }
1764           }
1765           break;
1766         case TT_elseif :
1767           getNextToken();
1768           break;
1769         default :
1770           return;
1771       }
1772     } while (true);
1773   }
1774
1775   private void elseifStatement() throws CoreException {
1776     if (token == TT_ARGOPEN) {
1777       getNextToken();
1778       expression();
1779       if (token != TT_ARGOPEN) {
1780         throwSyntaxError("')' expected in else-if-statement.");
1781       }
1782       getNextToken();
1783       if (token != TT_DDOT) {
1784         throwSyntaxError("':' expected in else-if-statement.");
1785       }
1786       getNextToken();
1787       statementList();
1788     }
1789   }
1790
1791   private void switchStatement() throws CoreException {
1792     if (token == TT_DDOT) {
1793       // ':' [labeled-statement-list] 'endswitch' ';'
1794       getNextToken();
1795       labeledStatementList();
1796       if (token != TT_endswitch) {
1797         throwSyntaxError("'endswitch' expected.");
1798       }
1799       getNextToken();
1800       if (token != TT_SEMICOLON) {
1801         throwSyntaxError("';' expected after switch-statement.");
1802       }
1803       getNextToken();
1804     } else {
1805       // '{' [labeled-statement-list] '}'
1806       if (token != TT_LISTOPEN) {
1807         throwSyntaxError("'{' expected in switch statement.");
1808       }
1809       getNextToken();
1810       if (token != TT_LISTCLOSE) {
1811         labeledStatementList();
1812       }
1813       if (token != TT_LISTCLOSE) {
1814         throwSyntaxError("'}' expected in switch statement.");
1815       }
1816       getNextToken();
1817
1818     }
1819   }
1820
1821   private void forStatement() throws CoreException {
1822     if (token == TT_DDOT) {
1823       getNextToken();
1824       statementList();
1825       if (token != TT_endfor) {
1826         throwSyntaxError("'endfor' expected.");
1827       }
1828       getNextToken();
1829       if (token != TT_SEMICOLON) {
1830         throwSyntaxError("';' expected after for-statement.");
1831       }
1832       getNextToken();
1833     } else {
1834       statement();
1835     }
1836   }
1837
1838   private void whileStatement() throws CoreException {
1839     // ':' statement-list 'endwhile' ';'
1840     if (token == TT_DDOT) {
1841       getNextToken();
1842       statementList();
1843       if (token != TT_endwhile) {
1844         throwSyntaxError("'endwhile' expected.");
1845       }
1846       getNextToken();
1847       if (token != TT_SEMICOLON) {
1848         throwSyntaxError("';' expected after while-statement.");
1849       }
1850       getNextToken();
1851     } else {
1852       statement();
1853     }
1854   }
1855
1856   private void foreachStatement() throws CoreException {
1857     if (token == TT_DDOT) {
1858       getNextToken();
1859       statementList();
1860       if (token != TT_endforeach) {
1861         throwSyntaxError("'endforeach' expected.");
1862       }
1863       getNextToken();
1864       if (token != TT_SEMICOLON) {
1865         throwSyntaxError("';' expected after foreach-statement.");
1866       }
1867       getNextToken();
1868     } else {
1869       statement();
1870     }
1871   }
1872
1873   private void exitStatus() throws CoreException {
1874     if (token == TT_ARGOPEN) {
1875       getNextToken();
1876     } else {
1877       throwSyntaxError("'(' expected in 'exit-status'.");
1878     }
1879     if (token != TT_ARGCLOSE) {
1880       expression();
1881     }
1882     if (token == TT_ARGCLOSE) {
1883       getNextToken();
1884     } else {
1885       throwSyntaxError("')' expected after 'exit-status'.");
1886     }
1887   }
1888
1889   private void expressionList() throws CoreException {
1890     do {
1891       expression();
1892       if (token == TT_COMMA) {
1893         getNextToken();
1894       } else {
1895         break;
1896       }
1897     } while (true);
1898   }
1899
1900   private void expression() throws CoreException {
1901     //    if (token == TT_STRING_CONSTANT || token == TT_INTERPOLATED_STRING) {
1902     //      getNextToken();
1903     //    } else {
1904     logicalinclusiveorExpression();
1905     //      while (token != TT_SEMICOLON) {
1906     //        getNextToken();
1907     //      //      }
1908     //    }
1909   }
1910
1911   private void postfixExpression() throws CoreException {
1912     String ident;
1913     boolean castFlag = false;
1914     switch (token) {
1915       case TT_new :
1916         getNextToken();
1917         expression();
1918         break;
1919       case TT_null :
1920         getNextToken();
1921         break;
1922       case TT_false :
1923         getNextToken();
1924         break;
1925       case TT_true :
1926         getNextToken();
1927         break;
1928       case TT_STRING_CONSTANT :
1929         getNextToken();
1930         break;
1931       case TT_INTERPOLATED_STRING :
1932         getNextToken();
1933         break;
1934       case TT_ARGOPEN :
1935         getNextToken();
1936         if (token == TT_IDENTIFIER) {
1937           // check if identifier is a type:
1938           ident = identifier;
1939           String str = identifier.toLowerCase();
1940           for (int i = 0; i < PHP_TYPES.length; i++) {
1941             if (PHP_TYPES[i].equals(str)) {
1942               castFlag = true;
1943               break;
1944             }
1945           }
1946           if (castFlag) {
1947             getNextToken();
1948             if (token != TT_ARGCLOSE) {
1949               throwSyntaxError(") expected after cast-type '" + ident + "'.");
1950             }
1951             getNextToken();
1952             expression();
1953             break;
1954           }
1955         }
1956         if (!castFlag) {
1957           expression();
1958         }
1959         if (token != TT_ARGCLOSE) {
1960           throwSyntaxError(") expected in postfix-expression.");
1961         }
1962         getNextToken();
1963         break;
1964       case TT_DOUBLE_NUMBER :
1965         getNextToken();
1966         break;
1967       case TT_INT_NUMBER :
1968         getNextToken();
1969         break;
1970       case TT_DOLLAROPEN :
1971         getNextToken();
1972         expression();
1973         if (token != TT_LISTCLOSE) {
1974           throwSyntaxError("'}' expected after indirect variable token '${'.");
1975         }
1976         getNextToken();
1977         break;
1978       case TT_VARIABLE :
1979         ident = identifier;
1980         getNextToken();
1981         if (token == TT_LISTOPEN) {
1982           getNextToken();
1983           expression();
1984           if (token != TT_LISTCLOSE) {
1985             throwSyntaxError("'}' expected after variable '" + ident + "' in variable-expression.");
1986           }
1987           getNextToken();
1988         } else if (token == TT_ARGOPEN) {
1989           getNextToken();
1990           if (token != TT_ARGCLOSE) {
1991             expressionList();
1992             if (token != TT_ARGCLOSE) {
1993               throwSyntaxError("')' expected after variable '" + ident + "' in postfix-expression.");
1994             }
1995           }
1996           getNextToken();
1997         }
1998         break;
1999       case TT_IDENTIFIER :
2000         ident = identifier;
2001         getNextToken();
2002         if (token == TT_ARGOPEN) {
2003           getNextToken();
2004           if (token != TT_ARGCLOSE) {
2005             expressionList();
2006             if (token != TT_ARGCLOSE) {
2007               throwSyntaxError("')' expected after identifier '" + ident + "' in postfix-expression.");
2008             }
2009           }
2010           getNextToken();
2011         }
2012         break;
2013       case TT_print :
2014         getNextToken();
2015         expression();
2016         //        if (token == TT_SEMICOLON) {
2017         //          getNextToken();
2018         //        } else {
2019         //          if (!phpEnd) {
2020         //            throwSyntaxError("';' expected after 'print' statement.");
2021         //          }
2022         //        }
2023         break;
2024       case TT_list :
2025         getNextToken();
2026         if (token == TT_ARGOPEN) {
2027           getNextToken();
2028           if (token == TT_COMMA) {
2029             getNextToken();
2030           }
2031           expressionList();
2032           if (token != TT_ARGCLOSE) {
2033             throwSyntaxError("')' expected after 'list' keyword.");
2034           }
2035           getNextToken();
2036           //          if (token == TT_SET) {
2037           //            getNextToken();
2038           //            logicalinclusiveorExpression();
2039           //          }
2040         } else {
2041           throwSyntaxError("'(' expected after 'list' keyword.");
2042         }
2043         break;
2044         //      case TT_exit :
2045         //        getNextToken();
2046         //        if (token != TT_SEMICOLON) {
2047         //          exitStatus();
2048         //        }
2049         //        if (token == TT_SEMICOLON) {
2050         //          getNextToken();
2051         //        } else {
2052         //          if (!phpEnd) {
2053         //            throwSyntaxError("';' expected after 'exit' expression.");
2054         //          }
2055         //        }
2056         //        break;
2057         //      case TT_die :
2058         //        getNextToken();
2059         //        if (token != TT_SEMICOLON) {
2060         //          exitStatus();
2061         //        }
2062         //        if (token == TT_SEMICOLON) {
2063         //          getNextToken();
2064         //        } else {
2065         //          if (!phpEnd) {
2066         //            throwSyntaxError("';' expected after 'die' expression.");
2067         //          }
2068         //        }
2069         //        break;
2070
2071         //      case TT_array :
2072         //        getNextToken();
2073         //        if (token == TT_ARGOPEN) {
2074         //          getNextToken();
2075         //          if (token == TT_COMMA) {
2076         //            getNextToken();
2077         //          }
2078         //          expressionList();
2079         //          if (token != TT_ARGCLOSE) {
2080         //            throwSyntaxError("')' expected after 'list' keyword.");
2081         //          }
2082         //          getNextToken();
2083         //          if (token == TT_SET) {
2084         //            getNextToken();
2085         //            logicalinclusiveorExpression();
2086         //          }
2087         //        } else {
2088         //          throwSyntaxError("'(' expected after 'list' keyword.");
2089         //        }
2090         //        break;
2091     }
2092     boolean while_flag = true;
2093     do {
2094       switch (token) {
2095         case TT_PARTOPEN :
2096           getNextToken();
2097           expression();
2098           if (token != TT_PARTCLOSE) {
2099             throwSyntaxError("] expected in postfix-expression.");
2100           }
2101           getNextToken();
2102           break;
2103         case TT_DDOT2 : // ::
2104         case TT_REF : // ->
2105           getNextToken();
2106           if (token > TT_KEYWORD) {
2107             ident = identifier;
2108             setMarker("Avoid using keyword '" + ident + "' as variable name.", rowCount, PHPParser.INFO);
2109             getNextToken();
2110             if (token == TT_ARGOPEN) {
2111               getNextToken();
2112               expressionList();
2113               if (token != TT_ARGCLOSE) {
2114                 throwSyntaxError(") expected after identifier '" + ident + "'.");
2115               }
2116               getNextToken();
2117             }
2118             break;
2119           } else {
2120             switch (token) {
2121               case TT_VARIABLE :
2122                 ident = identifier;
2123                 getNextToken();
2124                 //              if (token == TT_ARGOPEN) {
2125                 //                getNextToken();
2126                 //                expressionList();
2127                 //                if (token != TT_ARGCLOSE) {
2128                 //                  throwSyntaxError(") expected after variable '" + ident + "'.");
2129                 //                }
2130                 //                getNextToken();
2131                 //              }
2132                 break;
2133               case TT_IDENTIFIER :
2134                 ident = identifier;
2135                 getNextToken();
2136                 if (token == TT_ARGOPEN) {
2137                   getNextToken();
2138                   expressionList();
2139                   if (token != TT_ARGCLOSE) {
2140                     throwSyntaxError(") expected after identifier '" + ident + "'.");
2141                   }
2142                   getNextToken();
2143                 }
2144                 break;
2145               case TT_LISTOPEN :
2146                 getNextToken();
2147                 expression();
2148                 if (token != TT_LISTCLOSE) {
2149                   throwSyntaxError("} expected in postfix-expression.");
2150                 }
2151                 getNextToken();
2152                 break;
2153               default :
2154                 throwSyntaxError("Syntax error after '->' token.");
2155             }
2156           }
2157           break;
2158         case TT_INCREMENT :
2159           getNextToken();
2160           break;
2161         case TT_DECREMENT :
2162           getNextToken();
2163           break;
2164         default :
2165           while_flag = false;
2166       }
2167
2168     } while (while_flag);
2169   }
2170
2171   private void unaryExpression() throws CoreException {
2172     switch (token) {
2173       case TT_INCREMENT :
2174         getNextToken();
2175         unaryExpression();
2176         break;
2177       case TT_DECREMENT :
2178         getNextToken();
2179         unaryExpression();
2180         break;
2181         // '@' '&' '*' '+' '-' '~' '!'
2182       case TT_AT :
2183         getNextToken();
2184         castExpression();
2185         break;
2186       case TT_AMPERSAND :
2187         getNextToken();
2188         castExpression();
2189         break;
2190       case TT_MULTIPLY :
2191         getNextToken();
2192         castExpression();
2193         break;
2194       case TT_ADD :
2195         getNextToken();
2196         castExpression();
2197         break;
2198       case TT_SUBTRACT :
2199         getNextToken();
2200         castExpression();
2201         break;
2202       case TT_TILDE :
2203         getNextToken();
2204         castExpression();
2205         break;
2206       case TT_NOT :
2207         getNextToken();
2208         castExpression();
2209         break;
2210       default :
2211         postfixExpression();
2212     }
2213   }
2214
2215   private void castExpression() throws CoreException {
2216     //    if (token == TT_ARGOPEN) {
2217     //      getNextToken();
2218     //      typeName();
2219     //      if (token != TT_ARGCLOSE) {
2220     //        throwSyntaxError(") expected after cast-expression.");
2221     //      }
2222     //      getNextToken();
2223     //    }
2224     unaryExpression();
2225   }
2226
2227   private void typeName() throws CoreException {
2228     //'string' 'unset' 'array' 'object'
2229     //'bool' 'boolean'
2230     //'real' 'double' 'float'
2231     //'int' 'integer'
2232     String ident = "";
2233     if (token == TT_IDENTIFIER) {
2234       ident = identifier;
2235       String str = identifier.toLowerCase();
2236       getNextToken();
2237       for (int i = 0; i < PHP_TYPES.length; i++) {
2238         if (PHP_TYPES[i].equals(str)) {
2239           return;
2240         }
2241       }
2242     }
2243     throwSyntaxError("Expected type cast '( <type-name> )'; Got '" + ident + "'.");
2244   }
2245
2246   private void assignExpression() throws CoreException {
2247     castExpression();
2248     if (token == TT_ASSIGN) { // =
2249       getNextToken();
2250       logicalinclusiveorExpression();
2251     } else if (token == TT_DOTASSIGN) { // .=
2252       getNextToken();
2253       logicalinclusiveorExpression();
2254     } else if (token == TT_FOREACH) { // =>
2255       getNextToken();
2256       logicalinclusiveorExpression();
2257     } else if (token == TT_ADDTO) { // +=
2258       getNextToken();
2259       logicalinclusiveorExpression();
2260     } else if (token == TT_SUBTRACTFROM) { // -=
2261       getNextToken();
2262       logicalinclusiveorExpression();
2263     } else if (token == TT_TIMESBY) { // *=
2264       getNextToken();
2265       logicalinclusiveorExpression();
2266     } else if (token == TT_DIVIDEBY) { // *=
2267       getNextToken();
2268       logicalinclusiveorExpression();
2269     } else if (token == TT_MODASSIGN) { // %=
2270       getNextToken();
2271       logicalinclusiveorExpression();
2272     } else if (token == TT_ANDASSIGN) { // &=
2273       getNextToken();
2274       logicalinclusiveorExpression();
2275     } else if (token == TT_POWASSIGN) { // ^=
2276       getNextToken();
2277       logicalinclusiveorExpression();
2278     } else if (token == TT_LSHIFTASSIGN) { // <<=
2279       getNextToken();
2280       logicalinclusiveorExpression();
2281     } else if (token == TT_RSHIFTASSIGN) { // >>=
2282       getNextToken();
2283       logicalinclusiveorExpression();
2284     } else if (token == TT_TILDEASSIGN) { // ~=
2285       getNextToken();
2286       logicalinclusiveorExpression();
2287     }
2288   }
2289
2290   private void multiplicativeExpression() throws CoreException {
2291     do {
2292       assignExpression();
2293       if (token != TT_MULTIPLY && token != TT_DIV && token != TT_MOD) {
2294         return;
2295       }
2296       getNextToken();
2297     } while (true);
2298   }
2299
2300   private void concatenationExpression() throws CoreException {
2301     do {
2302       multiplicativeExpression();
2303       if (token != TT_DOT) {
2304         return;
2305       }
2306       getNextToken();
2307     } while (true);
2308   }
2309
2310   private void additiveExpression() throws CoreException {
2311     do {
2312       concatenationExpression();
2313       if (token != TT_ADD && token != TT_SUBTRACT) {
2314         return;
2315       }
2316       getNextToken();
2317     } while (true);
2318   }
2319
2320   private void shiftExpression() throws CoreException {
2321     do {
2322       additiveExpression();
2323       if (token != TT_LSHIFT && token != TT_RSHIFT) {
2324         return;
2325       }
2326       getNextToken();
2327     } while (true);
2328   }
2329
2330   private void relationalExpression() throws CoreException {
2331     do {
2332       shiftExpression();
2333       if (token != TT_LESS && token != TT_GREATER && token != TT_LESSEQUAL && token != TT_GREATEREQUAL) {
2334         return;
2335       }
2336       getNextToken();
2337     } while (true);
2338   }
2339
2340   private void identicalExpression() throws CoreException {
2341     do {
2342       relationalExpression();
2343       if (token != TT_EX_EQUAL && token != TT_EX_UNEQUAL) {
2344         return;
2345       }
2346       getNextToken();
2347     } while (true);
2348   }
2349
2350   private void equalityExpression() throws CoreException {
2351     do {
2352       identicalExpression();
2353       if (token != TT_EQUAL && token != TT_UNEQUAL) {
2354         return;
2355       }
2356       getNextToken();
2357     } while (true);
2358   }
2359
2360   private void ternaryExpression() throws CoreException {
2361     equalityExpression();
2362     if (token == TT_QUESTIONMARK) {
2363       getNextToken();
2364       expression();
2365       if (token == TT_DDOT) {
2366         getNextToken();
2367         expression();
2368       } else {
2369         throwSyntaxError("':' expected in ternary operator '? :'.");
2370       }
2371     }
2372   }
2373
2374   private void andExpression() throws CoreException {
2375     do {
2376       ternaryExpression();
2377       if (token != TT_AMPERSAND) {
2378         return;
2379       }
2380       getNextToken();
2381     } while (true);
2382   }
2383
2384   private void exclusiveorExpression() throws CoreException {
2385     do {
2386       andExpression();
2387       if (token != TT_POW) {
2388         return;
2389       }
2390       getNextToken();
2391     } while (true);
2392   }
2393
2394   private void inclusiveorExpression() throws CoreException {
2395     do {
2396       exclusiveorExpression();
2397       if (token != TT_LINE) {
2398         return;
2399       }
2400       getNextToken();
2401     } while (true);
2402   }
2403
2404   private void booleanandExpression() throws CoreException {
2405     do {
2406       inclusiveorExpression();
2407       if (token != TT_AND) {
2408         return;
2409       }
2410       getNextToken();
2411     } while (true);
2412   }
2413
2414   private void booleanorExpression() throws CoreException {
2415     do {
2416       booleanandExpression();
2417       if (token != TT_OR) {
2418         return;
2419       }
2420       getNextToken();
2421     } while (true);
2422   }
2423
2424   private void logicalandExpression() throws CoreException {
2425     do {
2426       booleanorExpression();
2427       if (token != TT_and) {
2428         return;
2429       }
2430       getNextToken();
2431     } while (true);
2432   }
2433
2434   private void logicalexclusiveorExpression() throws CoreException {
2435     do {
2436       logicalandExpression();
2437       if (token != TT_xor) {
2438         return;
2439       }
2440       getNextToken();
2441     } while (true);
2442   }
2443
2444   private void logicalinclusiveorExpression() throws CoreException {
2445     do {
2446       logicalexclusiveorExpression();
2447       if (token != TT_or) {
2448         return;
2449       }
2450       getNextToken();
2451     } while (true);
2452   }
2453
2454   //  public void assignmentExpression() {
2455   //    if (token == TT_VARIABLE) {
2456   //      getNextToken();
2457   //      if (token == TT_SET) {
2458   //        getNextToken();
2459   //        logicalinclusiveorExpression();
2460   //      }
2461   //    } else {
2462   //      logicalinclusiveorExpression();
2463   //    }
2464   //  }
2465
2466   private void variableList() throws CoreException {
2467     do {
2468       variable();
2469       if (token == TT_COMMA) {
2470         getNextToken();
2471       } else {
2472         break;
2473       }
2474     } while (true);
2475   }
2476
2477   private void variable() throws CoreException {
2478     if (token == TT_DOLLAROPEN) {
2479       getNextToken();
2480       expression();
2481       ;
2482       if (token != TT_LISTCLOSE) {
2483         throwSyntaxError("'}' expected after indirect variable token '${'.");
2484       }
2485       getNextToken();
2486     } else {
2487       if (token == TT_VARIABLE) {
2488         getNextToken();
2489         if (token == TT_PARTOPEN) {
2490           getNextToken();
2491           expression();
2492           if (token != TT_PARTCLOSE) {
2493             throwSyntaxError("']' expected in variable-list.");
2494           }
2495           getNextToken();
2496         } else if (token == TT_ASSIGN) {
2497           getNextToken();
2498           constant();
2499         }
2500       } else {
2501         throwSyntaxError("$-variable expected in variable-list.");
2502       }
2503     }
2504   }
2505
2506   private void constant() throws CoreException {
2507     String ident;
2508     switch (token) {
2509       case TT_ADD :
2510         getNextToken();
2511         switch (token) {
2512           case TT_DOUBLE_NUMBER :
2513             getNextToken();
2514             break;
2515           case TT_INT_NUMBER :
2516             getNextToken();
2517             break;
2518           default :
2519             throwSyntaxError("Constant expected after '+' presign.");
2520         }
2521         break;
2522       case TT_SUBTRACT :
2523         getNextToken();
2524         switch (token) {
2525           case TT_DOUBLE_NUMBER :
2526             getNextToken();
2527             break;
2528           case TT_INT_NUMBER :
2529             getNextToken();
2530             break;
2531           default :
2532             throwSyntaxError("Constant expected after '-' presign.");
2533         }
2534         break;
2535       case TT_null :
2536         getNextToken();
2537         break;
2538       case TT_false :
2539         getNextToken();
2540         break;
2541       case TT_true :
2542         getNextToken();
2543         break;
2544       case TT_IDENTIFIER :
2545         ident = identifier;
2546         getNextToken();
2547         if (token == TT_ARGOPEN) {
2548           getNextToken();
2549           if (token != TT_ARGCLOSE) {
2550             expressionList();
2551             if (token != TT_ARGCLOSE) {
2552               throwSyntaxError("')' expected after identifier '" + ident + "' in postfix-expression.");
2553             }
2554           }
2555           getNextToken();
2556         }
2557         break;
2558       case TT_STRING_CONSTANT :
2559         getNextToken();
2560         break;
2561       case TT_INTERPOLATED_STRING :
2562         getNextToken();
2563         break;
2564       case TT_DOUBLE_NUMBER :
2565         getNextToken();
2566         break;
2567       case TT_INT_NUMBER :
2568         getNextToken();
2569         break;
2570       default :
2571         throwSyntaxError("Constant expected.");
2572     }
2573   }
2574
2575   /**
2576    * Call the php parse command ( php -l -f &lt;filename&gt; )
2577    * and create markers according to the external parser output
2578    */
2579   public static void phpExternalParse(IFile file) {
2580     //IFile file = (IFile) resource;
2581     IPath path = file.getFullPath();
2582     IPreferenceStore store = PHPeclipsePlugin.getDefault().getPreferenceStore();
2583     String filename = file.getLocation().toString();
2584
2585     String[] arguments = { filename };
2586     MessageFormat form = new MessageFormat(store.getString(PHPeclipsePlugin.EXTERNAL_PARSER_PREF));
2587     String command = form.format(arguments);
2588
2589     String parserResult = PHPStartApacheAction.execute(command, "External parser: ");
2590
2591     try {
2592       // parse the buffer to find the errors and warnings
2593       createMarkers(parserResult, file);
2594     } catch (CoreException e) {
2595     }
2596   }
2597
2598   /**
2599    * Create markers according to the external parser output
2600    */
2601   private static void createMarkers(String output, IFile file) throws CoreException {
2602     // delete all markers
2603     file.deleteMarkers(IMarker.PROBLEM, false, 0);
2604
2605     int indx = 0;
2606     int brIndx = 0;
2607     boolean flag = true;
2608     while ((brIndx = output.indexOf("<br />", indx)) != -1) {
2609       // newer php error output (tested with 4.2.3)
2610       scanLine(output, file, indx, brIndx);
2611       indx = brIndx + 6;
2612       flag = false;
2613     }
2614     if (flag) {
2615       while ((brIndx = output.indexOf("<br>", indx)) != -1) {
2616         // older php error output (tested with 4.2.3)
2617         scanLine(output, file, indx, brIndx);
2618         indx = brIndx + 4;
2619       }
2620     }
2621   }
2622
2623   private static void scanLine(String output, IFile file, int indx, int brIndx) throws CoreException {
2624     String current;
2625     String outLineNumberString;
2626     StringBuffer lineNumberBuffer = new StringBuffer(10);
2627     char ch;
2628     current = output.substring(indx, brIndx);
2629
2630     if (current.indexOf(PARSE_WARNING_STRING) != -1 || current.indexOf(PARSE_ERROR_STRING) != -1) {
2631       int onLine = current.indexOf("on line <b>");
2632       if (onLine != -1) {
2633         lineNumberBuffer.delete(0, lineNumberBuffer.length());
2634         for (int i = onLine; i < current.length(); i++) {
2635           ch = current.charAt(i);
2636           if ('0' <= ch && '9' >= ch) {
2637             lineNumberBuffer.append(ch);
2638           }
2639         }
2640
2641         int lineNumber = Integer.parseInt(lineNumberBuffer.toString());
2642
2643         Hashtable attributes = new Hashtable();
2644
2645         current = current.replaceAll("\n", "");
2646         current = current.replaceAll("<b>", "");
2647         current = current.replaceAll("</b>", "");
2648         MarkerUtilities.setMessage(attributes, current);
2649
2650         if (current.indexOf(PARSE_ERROR_STRING) != -1)
2651           attributes.put(IMarker.SEVERITY, new Integer(IMarker.SEVERITY_ERROR));
2652         else if (current.indexOf(PARSE_WARNING_STRING) != -1)
2653           attributes.put(IMarker.SEVERITY, new Integer(IMarker.SEVERITY_WARNING));
2654         else
2655           attributes.put(IMarker.SEVERITY, new Integer(IMarker.SEVERITY_INFO));
2656         MarkerUtilities.setLineNumber(attributes, lineNumber);
2657         MarkerUtilities.createMarker(file, attributes, IMarker.PROBLEM);
2658       }
2659     }
2660   }
2661 }