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