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