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