better error messages for unterminated strings and comments
[phpeclipse.git] / net.sourceforge.phpeclipse / src / net / sourceforge / phpdt / internal / compiler / DocumentElementParser.java
index a94618b..4bf670f 100644 (file)
@@ -1,15 +1,24 @@
 /*******************************************************************************
- * Copyright (c) 2000, 2001, 2002 International Business Machines Corp. and others.
+ * Copyright (c) 2000, 2003 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Common Public License v0.5 
+ * are made available under the terms of the Common Public License v1.0
  * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/cpl-v05.html
+ * http://www.eclipse.org/legal/cpl-v10.html
  * 
  * Contributors:
  *     IBM Corporation - initial API and implementation
- ******************************************************************************/
+ *******************************************************************************/
 package net.sourceforge.phpdt.internal.compiler;
 
+import net.sourceforge.phpdt.core.compiler.IProblem;
+import net.sourceforge.phpdt.internal.compiler.env.ICompilationUnit;
+import net.sourceforge.phpdt.internal.compiler.impl.CompilerOptions;
+import net.sourceforge.phpdt.internal.compiler.parser.UnitParser;
+import net.sourceforge.phpdt.internal.compiler.problem.AbortCompilation;
+import net.sourceforge.phpdt.internal.compiler.problem.ProblemReporter;
+import net.sourceforge.phpeclipse.internal.compiler.ast.CompilationUnitDeclaration;
+
+
 /*
  * A document element parser extracts structural information
  * from a piece of source, providing detailed source positions info.
@@ -25,16 +34,7 @@ package net.sourceforge.phpdt.internal.compiler;
  *
  * Any (parsing) problem encountered is also provided.
  */
-import net.sourceforge.phpdt.internal.compiler.env.*;
-
-import net.sourceforge.phpdt.internal.compiler.impl.*;
-import net.sourceforge.phpdt.core.compiler.*;
-import net.sourceforge.phpdt.internal.compiler.ast.*;
-import net.sourceforge.phpdt.internal.compiler.parser.*;
-import net.sourceforge.phpdt.internal.compiler.problem.*;
-import net.sourceforge.phpdt.internal.compiler.util.*;
-
-public class DocumentElementParser extends Parser {
+public class DocumentElementParser extends UnitParser {
        IDocumentElementRequestor requestor;
        private int localIntPtr;
        private int lastFieldEndPosition;
@@ -49,34 +49,34 @@ public class DocumentElementParser extends Parser {
        int[][] intArrayStack;
        int intArrayPtr;
        
-       CompilerOptions options;
+//     CompilerOptions options;
        
 public DocumentElementParser(
        final IDocumentElementRequestor requestor, 
        IProblemFactory problemFactory,
-       CompilerOptions options) {
+       CompilerOptions options) {
        super(new ProblemReporter(
                DefaultErrorHandlingPolicies.exitAfterAllProblems(), 
-               options, 
+               options, 
                problemFactory) {
                public void record(IProblem problem, CompilationResult unitResult) {
                        requestor.acceptProblem(problem);
                }
-       },
-       false,
-       options.assertMode);
+       });
+//     false,
+//     options.sourceLevel >= CompilerOptions.JDK1_4);
        this.requestor = requestor;
        intArrayStack = new int[30][];
-       this.options = options;
+       this.options = options;
 }
 
 /**
  *
  * INTERNAL USE-ONLY
  */
-protected void adjustInterfaceModifiers() {
-       intStack[intPtr - 2] |= AccInterface;
-}
+//protected void adjustInterfaceModifiers() {
+//     intStack[intPtr - 2] |= AccInterface;
+//}
 /*
  * Will clear the comment stack when looking
  * for a potential JavaDoc which might contain @deprecated.
@@ -84,865 +84,852 @@ protected void adjustInterfaceModifiers() {
  * Additionally, before investigating for @deprecated, retrieve the positions
  * of the JavaDoc comments so as to notify requestor with them.
  */
-public void checkAnnotation() {
-
-       /* persisting javadoc positions */
-       pushOnIntArrayStack(this.getJavaDocPositions());
-       boolean deprecated = false;
-       int lastAnnotationIndex = -1;
-
-       //since jdk1.2 look only in the last java doc comment...
-       found : {
-               if ((lastAnnotationIndex = scanner.commentPtr) >= 0) { //look for @deprecated
-                       scanner.commentPtr = -1;
-                       // reset the comment stack, since not necessary after having checked
-                       int commentSourceStart = scanner.commentStarts[lastAnnotationIndex];
-                       // javadoc only (non javadoc comment have negative end positions.)
-                       int commentSourceEnd = scanner.commentStops[lastAnnotationIndex] - 1;
-                       //stop is one over
-                       char[] comment = scanner.source;
-
-                       for (int i = commentSourceStart + 3; i < commentSourceEnd - 10; i++) {
-                               if ((comment[i] == '@')
-                                       && (comment[i + 1] == 'd')
-                                       && (comment[i + 2] == 'e')
-                                       && (comment[i + 3] == 'p')
-                                       && (comment[i + 4] == 'r')
-                                       && (comment[i + 5] == 'e')
-                                       && (comment[i + 6] == 'c')
-                                       && (comment[i + 7] == 'a')
-                                       && (comment[i + 8] == 't')
-                                       && (comment[i + 9] == 'e')
-                                       && (comment[i + 10] == 'd')) {
-                                       // ensure the tag is properly ended: either followed by a space, line end or asterisk.
-                                       int nextPos = i + 11;
-                                       deprecated = 
-                                               (comment[nextPos] == ' ')
-                                                       || (comment[nextPos] == '\n')
-                                                       || (comment[nextPos] == '\r')
-                                                       || (comment[nextPos] == '*'); 
-                                       break found;
-                               }
-                       }
-               }
-       }
-       if (deprecated) {
-               checkAndSetModifiers(AccDeprecated);
-       }
-       // modify the modifier source start to point at the first comment
-       if (lastAnnotationIndex >= 0) {
-               declarationSourceStart = scanner.commentStarts[0];
-       }
-}
-/**
- *
- * INTERNAL USE-ONLY
- */
-protected void consumeClassBodyDeclaration() {
-       // ClassBodyDeclaration ::= Diet Block
-       //push an Initializer
-       //optimize the push/pop
-
-       super.consumeClassBodyDeclaration();
-       Initializer initializer = (Initializer) astStack[astPtr];
-       requestor.acceptInitializer(
-               initializer.declarationSourceStart,
-               initializer.declarationSourceEnd,
-               intArrayStack[intArrayPtr--], 
-               0,
-               modifiersSourceStart, 
-               initializer.block.sourceStart,
-               initializer.block.sourceEnd);
-}
-/**
- *
- * INTERNAL USE-ONLY
- */
-protected void consumeClassDeclaration() {
-       super.consumeClassDeclaration();
-       // we know that we have a TypeDeclaration on the top of the astStack
-       if (isLocalDeclaration()) {
-               // we ignore the local variable declarations
-               return;
-       }
-       requestor.exitClass(endStatementPosition, // '}' is the end of the body 
-        ((TypeDeclaration) astStack[astPtr]).declarationSourceEnd);
-}
-/**
- *
- * INTERNAL USE-ONLY
- */
-protected void consumeClassHeader() {
-       //ClassHeader ::= $empty
-       super.consumeClassHeader();
-       if (isLocalDeclaration()) {
-               // we ignore the local variable declarations
-               intArrayPtr--;
-               return;
-       }
-       TypeDeclaration typeDecl = (TypeDeclaration) astStack[astPtr];
-       TypeReference[] superInterfaces = typeDecl.superInterfaces;
-       char[][] interfaceNames = null;
-       int[] interfaceNameStarts = null;
-       int[] interfaceNameEnds = null;
-       if (superInterfaces != null) {
-               int superInterfacesLength = superInterfaces.length;
-               interfaceNames = new char[superInterfacesLength][];
-               interfaceNameStarts = new int[superInterfacesLength];
-               interfaceNameEnds = new int[superInterfacesLength];
-               for (int i = 0; i < superInterfacesLength; i++) {
-                       TypeReference superInterface = superInterfaces[i];
-                       interfaceNames[i] = CharOperation.concatWith(superInterface.getTypeName(), '.'); 
-                       interfaceNameStarts[i] = superInterface.sourceStart;
-                       interfaceNameEnds[i] = superInterface.sourceEnd;
-               }
-       }
-       // flush the comments related to the class header
-       scanner.commentPtr = -1;
-       TypeReference superclass = typeDecl.superclass;
-       if (superclass == null) {
-               requestor.enterClass(
-                       typeDecl.declarationSourceStart, 
-                       intArrayStack[intArrayPtr--], 
-                       typeDecl.modifiers, 
-                       typeDecl.modifiersSourceStart, 
-                       typeStartPosition, 
-                       typeDecl.name, 
-                       typeDecl.sourceStart, 
-                       typeDecl.sourceEnd, 
-                       null, 
-                       -1, 
-                       -1, 
-                       interfaceNames, 
-                       interfaceNameStarts, 
-                       interfaceNameEnds, 
-                       scanner.currentPosition - 1); 
-       } else {
-               requestor.enterClass(
-                       typeDecl.declarationSourceStart, 
-                       intArrayStack[intArrayPtr--], 
-                       typeDecl.modifiers, 
-                       typeDecl.modifiersSourceStart, 
-                       typeStartPosition, 
-                       typeDecl.name, 
-                       typeDecl.sourceStart, 
-                       typeDecl.sourceEnd, 
-                       CharOperation.concatWith(superclass.getTypeName(), '.'), 
-                       superclass.sourceStart, 
-                       superclass.sourceEnd, 
-                       interfaceNames, 
-                       interfaceNameStarts, 
-                       interfaceNameEnds, 
-                       scanner.currentPosition - 1); 
-
-       }
-}
-protected void consumeClassHeaderName() {
-       // ClassHeaderName ::= Modifiersopt 'class' 'Identifier'
-       TypeDeclaration typeDecl;
-       if (nestedMethod[nestedType] == 0) {
-               if (nestedType != 0) {
-                       typeDecl = new MemberTypeDeclaration(this.compilationUnit.compilationResult);
-               } else {
-                       typeDecl = new TypeDeclaration(this.compilationUnit.compilationResult);
-               }
-       } else {
-               // Record that the block has a declaration for local types
-               typeDecl = new LocalTypeDeclaration(this.compilationUnit.compilationResult);
-               markCurrentMethodWithLocalType();
-               blockReal();
-       }
-
-       //highlight the name of the type
-       long pos = identifierPositionStack[identifierPtr];
-       typeDecl.sourceEnd = (int) pos;
-       typeDecl.sourceStart = (int) (pos >>> 32);
-       typeDecl.name = identifierStack[identifierPtr--];
-       identifierLengthPtr--;
-
-       //compute the declaration source too
-       // 'class' and 'interface' push an int position
-       typeStartPosition = typeDecl.declarationSourceStart = intStack[intPtr--];
-       intPtr--;
-       int declarationSourceStart = intStack[intPtr--];
-       typeDecl.modifiersSourceStart = intStack[intPtr--];
-       typeDecl.modifiers = intStack[intPtr--];
-       if (typeDecl.declarationSourceStart > declarationSourceStart) {
-               typeDecl.declarationSourceStart = declarationSourceStart;
-       }
-       typeDecl.bodyStart = typeDecl.sourceEnd + 1;
-       pushOnAstStack(typeDecl);
-}
-/**
- *
- * INTERNAL USE-ONLY
- */
-protected void consumeCompilationUnit() {
-       // CompilationUnit ::= EnterCompilationUnit PackageDeclarationopt ImportDeclarationsopt
-       requestor.exitCompilationUnit(scanner.source.length - 1);
-}
+//public void checkAnnotation() {
+//
+//     /* persisting javadoc positions */
+//     pushOnIntArrayStack(this.getJavaDocPositions());
+//     boolean deprecated = false;
+//     int lastAnnotationIndex = -1;
+//     int commentPtr = scanner.commentPtr;
+//
+//     //since jdk1.2 look only in the last java doc comment...
+//     nextComment : for (lastAnnotationIndex = scanner.commentPtr; lastAnnotationIndex >= 0; lastAnnotationIndex--){
+//             //look for @deprecated into the first javadoc comment preceeding the declaration
+//             int commentSourceStart = scanner.commentStarts[lastAnnotationIndex];
+//             // javadoc only (non javadoc comment have negative end positions.)
+//             if (modifiersSourceStart != -1 && modifiersSourceStart < commentSourceStart) {
+//                     continue nextComment;
+//             }
+//             if (scanner.commentStops[lastAnnotationIndex] < 0) {
+//                     continue nextComment;
+//             }
+//             int commentSourceEnd = scanner.commentStops[lastAnnotationIndex] - 1; //stop is one over
+//             char[] comment = scanner.source;
+//
+//             deprecated =
+//                     checkDeprecation(
+//                             commentSourceStart,
+//                             commentSourceEnd,
+//                             comment);
+//             break nextComment;
+//     }
+//     if (deprecated) {
+//             checkAndSetModifiers(AccDeprecated);
+//     }
+//     // modify the modifier source start to point at the first comment
+//     if (commentPtr >= 0) {
+//             declarationSourceStart = scanner.commentStarts[0];
+//     }
+//}
 /**
  *
  * INTERNAL USE-ONLY
  */
-protected void consumeConstructorDeclaration() {
-       // ConstructorDeclaration ::= ConstructorHeader ConstructorBody
-       super.consumeConstructorDeclaration();
-       if (isLocalDeclaration()) {
-               // we ignore the local variable declarations
-               return;
-       }
-       ConstructorDeclaration cd = (ConstructorDeclaration) astStack[astPtr];
-       requestor.exitConstructor(endStatementPosition, cd.declarationSourceEnd);
-}
-/**
- *
- * INTERNAL USE-ONLY
- */
-protected void consumeConstructorHeader() {
-       // ConstructorHeader ::= ConstructorHeaderName MethodHeaderParameters MethodHeaderThrowsClauseopt
-       super.consumeConstructorHeader();
-       if (isLocalDeclaration()) {
-               // we ignore the local variable declarations
-               intArrayPtr--;
-               return;
-       }
-       ConstructorDeclaration cd = (ConstructorDeclaration) astStack[astPtr];
-       Argument[] arguments = cd.arguments;
-       char[][] argumentTypes = null;
-       char[][] argumentNames = null;
-       int[] argumentTypeStarts = null;
-       int[] argumentTypeEnds = null;
-       int[] argumentNameStarts = null;
-       int[] argumentNameEnds = null;
-       if (arguments != null) {
-               int argumentLength = arguments.length;
-               argumentTypes = new char[argumentLength][];
-               argumentNames = new char[argumentLength][];
-               argumentNameStarts = new int[argumentLength];
-               argumentNameEnds = new int[argumentLength];
-               argumentTypeStarts = new int[argumentLength];
-               argumentTypeEnds = new int[argumentLength];
-               for (int i = 0; i < argumentLength; i++) {
-                       Argument argument = arguments[i];
-                       TypeReference argumentType = argument.type;
-                       argumentTypes[i] = returnTypeName(argumentType);
-                       argumentNames[i] = argument.name;
-                       argumentNameStarts[i] = argument.sourceStart;
-                       argumentNameEnds[i] = argument.sourceEnd;
-                       argumentTypeStarts[i] = argumentType.sourceStart;
-                       argumentTypeEnds[i] = argumentType.sourceEnd;
-               }
-       }
-       TypeReference[] thrownExceptions = cd.thrownExceptions;
-       char[][] exceptionTypes = null;
-       int[] exceptionTypeStarts = null;
-       int[] exceptionTypeEnds = null;
-       if (thrownExceptions != null) {
-               int thrownExceptionLength = thrownExceptions.length;
-               exceptionTypes = new char[thrownExceptionLength][];
-               exceptionTypeStarts = new int[thrownExceptionLength];
-               exceptionTypeEnds = new int[thrownExceptionLength];
-               for (int i = 0; i < thrownExceptionLength; i++) {
-                       TypeReference exception = thrownExceptions[i];
-                       exceptionTypes[i] = CharOperation.concatWith(exception.getTypeName(), '.');
-                       exceptionTypeStarts[i] = exception.sourceStart;
-                       exceptionTypeEnds[i] = exception.sourceEnd;
-               }
-       }
-       requestor
-               .enterConstructor(
-                       cd.declarationSourceStart, 
-                       intArrayStack[intArrayPtr--], 
-                       cd.modifiers,
-                       cd.modifiersSourceStart, 
-                       cd.selector, 
-                       cd.sourceStart, 
-                       (int) (selectorSourcePositions & 0xFFFFFFFFL), 
-                       // retrieve the source end of the name
-                       argumentTypes, 
-                       argumentTypeStarts, 
-                       argumentTypeEnds, 
-                       argumentNames, 
-                       argumentNameStarts, 
-                       argumentNameEnds, 
-                       rParenPos, 
-                       // right parenthesis
-                       exceptionTypes, 
-                       exceptionTypeStarts, 
-                       exceptionTypeEnds, 
-                       scanner.currentPosition - 1); 
-}
-protected void consumeConstructorHeaderName() {
-       // ConstructorHeaderName ::=  Modifiersopt 'Identifier' '('
-       ConstructorDeclaration cd = new ConstructorDeclaration(this.compilationUnit.compilationResult);
-
-       //name -- this is not really revelant but we do .....
-       cd.selector = identifierStack[identifierPtr];
-       selectorSourcePositions = identifierPositionStack[identifierPtr--];
-       identifierLengthPtr--;
-
-       //modifiers
-       cd.declarationSourceStart = intStack[intPtr--];
-       cd.modifiersSourceStart = intStack[intPtr--];
-       cd.modifiers = intStack[intPtr--];
-
-       //highlight starts at the selector starts
-       cd.sourceStart = (int) (selectorSourcePositions >>> 32);
-       pushOnAstStack(cd);
-
-       cd.sourceEnd = lParenPos;
-       cd.bodyStart = lParenPos + 1;
-}
-protected void consumeDefaultModifiers() {
-       checkAnnotation(); // might update modifiers with AccDeprecated
-       pushOnIntStack(modifiers); // modifiers
-       pushOnIntStack(-1);
-       pushOnIntStack(
-               declarationSourceStart >= 0 ? declarationSourceStart : scanner.startPosition); 
-       resetModifiers();
-}
-protected void consumeDiet() {
-       // Diet ::= $empty
-       super.consumeDiet();
-       /* persisting javadoc positions
-        * Will be consume in consumeClassBodyDeclaration
-        */
-       pushOnIntArrayStack(this.getJavaDocPositions());        
-}
+//protected void consumeClassBodyDeclaration() {
+//     // ClassBodyDeclaration ::= Diet Block
+//     //push an Initializer
+//     //optimize the push/pop
+//
+//     super.consumeClassBodyDeclaration();
+//     Initializer initializer = (Initializer) astStack[astPtr];
+//     requestor.acceptInitializer(
+//             initializer.declarationSourceStart,
+//             initializer.declarationSourceEnd,
+//             intArrayStack[intArrayPtr--], 
+//             0,
+//             modifiersSourceStart, 
+//             initializer.block.sourceStart,
+//             initializer.block.sourceEnd);
+//}
+///**
+// *
+// * INTERNAL USE-ONLY
+// */
+//protected void consumeClassDeclaration() {
+//     super.consumeClassDeclaration();
+//     // we know that we have a TypeDeclaration on the top of the astStack
+//     if (isLocalDeclaration()) {
+//             // we ignore the local variable declarations
+//             return;
+//     }
+//     requestor.exitClass(endStatementPosition, // '}' is the end of the body 
+//      ((TypeDeclaration) astStack[astPtr]).declarationSourceEnd);
+//}
+///**
+// *
+// * INTERNAL USE-ONLY
+// */
+//protected void consumeClassHeader() {
+//     //ClassHeader ::= $empty
+//     super.consumeClassHeader();
+//     if (isLocalDeclaration()) {
+//             // we ignore the local variable declarations
+//             intArrayPtr--;
+//             return;
+//     }
+//     TypeDeclaration typeDecl = (TypeDeclaration) astStack[astPtr];
+//     TypeReference[] superInterfaces = typeDecl.superInterfaces;
+//     char[][] interfaceNames = null;
+//     int[] interfaceNameStarts = null;
+//     int[] interfaceNameEnds = null;
+//     if (superInterfaces != null) {
+//             int superInterfacesLength = superInterfaces.length;
+//             interfaceNames = new char[superInterfacesLength][];
+//             interfaceNameStarts = new int[superInterfacesLength];
+//             interfaceNameEnds = new int[superInterfacesLength];
+//             for (int i = 0; i < superInterfacesLength; i++) {
+//                     TypeReference superInterface = superInterfaces[i];
+//                     interfaceNames[i] = CharOperation.concatWith(superInterface.getTypeName(), '.'); 
+//                     interfaceNameStarts[i] = superInterface.sourceStart;
+//                     interfaceNameEnds[i] = superInterface.sourceEnd;
+//             }
+//     }
+//     // flush the comments related to the class header
+//     scanner.commentPtr = -1;
+//     TypeReference superclass = typeDecl.superclass;
+//     if (superclass == null) {
+//             requestor.enterClass(
+//                     typeDecl.declarationSourceStart, 
+//                     intArrayStack[intArrayPtr--], 
+//                     typeDecl.modifiers, 
+//                     typeDecl.modifiersSourceStart, 
+//                     typeStartPosition, 
+//                     typeDecl.name, 
+//                     typeDecl.sourceStart, 
+//                     typeDecl.sourceEnd, 
+//                     null, 
+//                     -1, 
+//                     -1, 
+//                     interfaceNames, 
+//                     interfaceNameStarts, 
+//                     interfaceNameEnds, 
+//                     scanner.currentPosition - 1); 
+//     } else {
+//             requestor.enterClass(
+//                     typeDecl.declarationSourceStart, 
+//                     intArrayStack[intArrayPtr--], 
+//                     typeDecl.modifiers, 
+//                     typeDecl.modifiersSourceStart, 
+//                     typeStartPosition, 
+//                     typeDecl.name, 
+//                     typeDecl.sourceStart, 
+//                     typeDecl.sourceEnd, 
+//                     CharOperation.concatWith(superclass.getTypeName(), '.'), 
+//                     superclass.sourceStart, 
+//                     superclass.sourceEnd, 
+//                     interfaceNames, 
+//                     interfaceNameStarts, 
+//                     interfaceNameEnds, 
+//                     scanner.currentPosition - 1); 
+//
+//     }
+//}
+//protected void consumeClassHeaderName() {
+//     // ClassHeaderName ::= Modifiersopt 'class' 'Identifier'
+//     TypeDeclaration typeDecl;
+//     if (nestedMethod[nestedType] == 0) {
+//             if (nestedType != 0) {
+//                     typeDecl = new MemberTypeDeclaration(this.compilationUnit.compilationResult);
+//             } else {
+//                     typeDecl = new TypeDeclaration(this.compilationUnit.compilationResult);
+//             }
+//     } else {
+//             // Record that the block has a declaration for local types
+//             typeDecl = new LocalTypeDeclaration(this.compilationUnit.compilationResult);
+//             markEnclosingMemberWithLocalType();
+//             blockReal();
+//     }
+//
+//     //highlight the name of the type
+//     long pos = identifierPositionStack[identifierPtr];
+//     typeDecl.sourceEnd = (int) pos;
+//     typeDecl.sourceStart = (int) (pos >>> 32);
+//     typeDecl.name = identifierStack[identifierPtr--];
+//     identifierLengthPtr--;
+//
+//     //compute the declaration source too
+//     // 'class' and 'interface' push an int position
+//     typeStartPosition = typeDecl.declarationSourceStart = intStack[intPtr--];
+//     intPtr--;
+//     int declarationSourceStart = intStack[intPtr--];
+//     typeDecl.modifiersSourceStart = intStack[intPtr--];
+//     typeDecl.modifiers = intStack[intPtr--];
+//     if (typeDecl.declarationSourceStart > declarationSourceStart) {
+//             typeDecl.declarationSourceStart = declarationSourceStart;
+//     }
+//     typeDecl.bodyStart = typeDecl.sourceEnd + 1;
+//     pushOnAstStack(typeDecl);
+//}
+///**
+// *
+// * INTERNAL USE-ONLY
+// */
+//protected void consumeCompilationUnit() {
+//     // CompilationUnit ::= EnterCompilationUnit PackageDeclarationopt ImportDeclarationsopt
+//     requestor.exitCompilationUnit(scanner.source.length - 1);
+//}
 /**
  *
  * INTERNAL USE-ONLY
  */
-protected void consumeEnterCompilationUnit() {
-       // EnterCompilationUnit ::= $empty
-       requestor.enterCompilationUnit();
-}
+//protected void consumeConstructorDeclaration() {
+//     // ConstructorDeclaration ::= ConstructorHeader ConstructorBody
+//     super.consumeConstructorDeclaration();
+//     if (isLocalDeclaration()) {
+//             // we ignore the local variable declarations
+//             return;
+//     }
+//     ConstructorDeclaration cd = (ConstructorDeclaration) astStack[astPtr];
+//     requestor.exitConstructor(endStatementPosition, cd.declarationSourceEnd);
+//}
+///**
+// *
+// * INTERNAL USE-ONLY
+// */
+//protected void consumeConstructorHeader() {
+//     // ConstructorHeader ::= ConstructorHeaderName MethodHeaderParameters MethodHeaderThrowsClauseopt
+//     super.consumeConstructorHeader();
+//     if (isLocalDeclaration()) {
+//             // we ignore the local variable declarations
+//             intArrayPtr--;
+//             return;
+//     }
+//     ConstructorDeclaration cd = (ConstructorDeclaration) astStack[astPtr];
+//     Argument[] arguments = cd.arguments;
+//     char[][] argumentTypes = null;
+//     char[][] argumentNames = null;
+//     int[] argumentTypeStarts = null;
+//     int[] argumentTypeEnds = null;
+//     int[] argumentNameStarts = null;
+//     int[] argumentNameEnds = null;
+//     if (arguments != null) {
+//             int argumentLength = arguments.length;
+//             argumentTypes = new char[argumentLength][];
+//             argumentNames = new char[argumentLength][];
+//             argumentNameStarts = new int[argumentLength];
+//             argumentNameEnds = new int[argumentLength];
+//             argumentTypeStarts = new int[argumentLength];
+//             argumentTypeEnds = new int[argumentLength];
+//             for (int i = 0; i < argumentLength; i++) {
+//                     Argument argument = arguments[i];
+//                     TypeReference argumentType = argument.type;
+//                     argumentTypes[i] = returnTypeName(argumentType);
+//                     argumentNames[i] = argument.name;
+//                     argumentNameStarts[i] = argument.sourceStart;
+//                     argumentNameEnds[i] = argument.sourceEnd;
+//                     argumentTypeStarts[i] = argumentType.sourceStart;
+//                     argumentTypeEnds[i] = argumentType.sourceEnd;
+//             }
+//     }
+//     TypeReference[] thrownExceptions = cd.thrownExceptions;
+//     char[][] exceptionTypes = null;
+//     int[] exceptionTypeStarts = null;
+//     int[] exceptionTypeEnds = null;
+//     if (thrownExceptions != null) {
+//             int thrownExceptionLength = thrownExceptions.length;
+//             exceptionTypes = new char[thrownExceptionLength][];
+//             exceptionTypeStarts = new int[thrownExceptionLength];
+//             exceptionTypeEnds = new int[thrownExceptionLength];
+//             for (int i = 0; i < thrownExceptionLength; i++) {
+//                     TypeReference exception = thrownExceptions[i];
+//                     exceptionTypes[i] = CharOperation.concatWith(exception.getTypeName(), '.');
+//                     exceptionTypeStarts[i] = exception.sourceStart;
+//                     exceptionTypeEnds[i] = exception.sourceEnd;
+//             }
+//     }
+//     requestor
+//             .enterConstructor(
+//                     cd.declarationSourceStart, 
+//                     intArrayStack[intArrayPtr--], 
+//                     cd.modifiers,
+//                     cd.modifiersSourceStart, 
+//                     cd.selector, 
+//                     cd.sourceStart, 
+//                     (int) (selectorSourcePositions & 0xFFFFFFFFL), 
+//                     // retrieve the source end of the name
+//                     argumentTypes, 
+//                     argumentTypeStarts, 
+//                     argumentTypeEnds, 
+//                     argumentNames, 
+//                     argumentNameStarts, 
+//                     argumentNameEnds, 
+//                     rParenPos, 
+//                     // right parenthesis
+//                     exceptionTypes, 
+//                     exceptionTypeStarts, 
+//                     exceptionTypeEnds, 
+//                     scanner.currentPosition - 1); 
+//}
+//protected void consumeConstructorHeaderName() {
+//     // ConstructorHeaderName ::=  Modifiersopt 'Identifier' '('
+//     ConstructorDeclaration cd = new ConstructorDeclaration(this.compilationUnit.compilationResult);
+//
+//     //name -- this is not really revelant but we do .....
+//     cd.selector = identifierStack[identifierPtr];
+//     selectorSourcePositions = identifierPositionStack[identifierPtr--];
+//     identifierLengthPtr--;
+//
+//     //modifiers
+//     cd.declarationSourceStart = intStack[intPtr--];
+//     cd.modifiersSourceStart = intStack[intPtr--];
+//     cd.modifiers = intStack[intPtr--];
+//
+//     //highlight starts at the selector starts
+//     cd.sourceStart = (int) (selectorSourcePositions >>> 32);
+//     pushOnAstStack(cd);
+//
+//     cd.sourceEnd = lParenPos;
+//     cd.bodyStart = lParenPos + 1;
+//}
+//protected void consumeDefaultModifiers() {
+//     checkAnnotation(); // might update modifiers with AccDeprecated
+//     pushOnIntStack(modifiers); // modifiers
+//     pushOnIntStack(-1);
+//     pushOnIntStack(
+//             declarationSourceStart >= 0 ? declarationSourceStart : scanner.startPosition); 
+//     resetModifiers();
+//}
+//protected void consumeDiet() {
+//     // Diet ::= $empty
+//     super.consumeDiet();
+//     /* persisting javadoc positions
+//      * Will be consume in consumeClassBodyDeclaration
+//      */
+//     pushOnIntArrayStack(this.getJavaDocPositions());        
+//}
+///**
+// *
+// * INTERNAL USE-ONLY
+// */
+//protected void consumeEnterCompilationUnit() {
+//     // EnterCompilationUnit ::= $empty
+//     requestor.enterCompilationUnit();
+//}
+///**
+// *
+// * INTERNAL USE-ONLY
+// */
+//protected void consumeEnterVariable() {
+//     // EnterVariable ::= $empty
+//     boolean isLocalDeclaration = isLocalDeclaration();
+//     if (!isLocalDeclaration && (variablesCounter[nestedType] != 0)) {
+//             requestor.exitField(lastFieldBodyEndPosition, lastFieldEndPosition);
+//     }
+//     char[] name = identifierStack[identifierPtr];
+//     long namePosition = identifierPositionStack[identifierPtr--];
+//     int extendedTypeDimension = intStack[intPtr--];
+//
+//     AbstractVariableDeclaration declaration;
+//     if (nestedMethod[nestedType] != 0) {
+//             // create the local variable declarations
+//             declaration = 
+//                     new LocalDeclaration(null, name, (int) (namePosition >>> 32), (int) namePosition); 
+//     } else {
+//             // create the field declaration
+//             declaration = 
+//                     new FieldDeclaration(null, name, (int) (namePosition >>> 32), (int) namePosition); 
+//     }
+//     identifierLengthPtr--;
+//     TypeReference type;
+//     int variableIndex = variablesCounter[nestedType];
+//     int typeDim = 0;
+//     if (variableIndex == 0) {
+//             // first variable of the declaration (FieldDeclaration or LocalDeclaration)
+//             if (nestedMethod[nestedType] != 0) {
+//                     // local declaration
+//                     declaration.declarationSourceStart = intStack[intPtr--];
+//                     declaration.modifiersSourceStart = intStack[intPtr--];
+//                     declaration.modifiers = intStack[intPtr--];
+//                     type = getTypeReference(typeDim = intStack[intPtr--]); // type dimension
+//                     pushOnAstStack(type);
+//             } else {
+//                     // field declaration
+//                     type = getTypeReference(typeDim = intStack[intPtr--]); // type dimension
+//                     pushOnAstStack(type);
+//                     declaration.declarationSourceStart = intStack[intPtr--];
+//                     declaration.modifiersSourceStart = intStack[intPtr--];
+//                     declaration.modifiers = intStack[intPtr--];
+//             }
+//     } else {
+//             type = (TypeReference) astStack[astPtr - variableIndex];
+//             typeDim = type.dimensions();
+//             AbstractVariableDeclaration previousVariable = 
+//                     (AbstractVariableDeclaration) astStack[astPtr]; 
+//             declaration.declarationSourceStart = previousVariable.declarationSourceStart;
+//             declaration.modifiers = previousVariable.modifiers;
+//             declaration.modifiersSourceStart = previousVariable.modifiersSourceStart;
+//     }
+//
+//     localIntPtr = intPtr;
+//
+//     if (extendedTypeDimension == 0) {
+//             declaration.type = type;
+//     } else {
+//             int dimension = typeDim + extendedTypeDimension;
+//             //on the identifierLengthStack there is the information about the type....
+//             int baseType;
+//             if ((baseType = identifierLengthStack[identifierLengthPtr + 1]) < 0) {
+//                     //it was a baseType
+//                     declaration.type = TypeReference.baseTypeReference(-baseType, dimension);
+//                     declaration.type.sourceStart = type.sourceStart;
+//                     declaration.type.sourceEnd = type.sourceEnd;
+//             } else {
+//                     declaration.type = this.copyDims(type, dimension);
+//             }
+//     }
+//     variablesCounter[nestedType]++;
+//     nestedMethod[nestedType]++;
+//     pushOnAstStack(declaration);
+//
+//     int[] javadocPositions = intArrayStack[intArrayPtr];
+//     if (!isLocalDeclaration) {
+//             requestor
+//                     .enterField(
+//                             declaration.declarationSourceStart, 
+//                             javadocPositions, 
+//                             declaration.modifiers, 
+//                             declaration.modifiersSourceStart, 
+//                             returnTypeName(declaration.type), 
+//                             type.sourceStart, 
+//                             type.sourceEnd, 
+//                             typeDims, 
+//                             name, 
+//                             (int) (namePosition >>> 32), 
+//                             (int) namePosition, 
+//                             extendedTypeDimension, 
+//                             extendedTypeDimension == 0 ? -1 : endPosition); 
+//     }
+//}
+///**
+// *
+// * INTERNAL USE-ONLY
+// */
+//protected void consumeExitVariableWithInitialization() {
+//     // ExitVariableWithInitialization ::= $empty
+//     // the scanner is located after the comma or the semi-colon.
+//     // we want to include the comma or the semi-colon
+//     super.consumeExitVariableWithInitialization();
+//     nestedMethod[nestedType]--;     
+//     lastFieldEndPosition = scanner.currentPosition - 1;
+//     lastFieldBodyEndPosition =      ((AbstractVariableDeclaration) astStack[astPtr]).initialization.sourceEnd;
+//}
+//protected void consumeExitVariableWithoutInitialization() {
+//     // ExitVariableWithoutInitialization ::= $empty
+//     // do nothing by default
+//     super.consumeExitVariableWithoutInitialization();
+//     nestedMethod[nestedType]--;     
+//     lastFieldEndPosition = scanner.currentPosition - 1;
+//     lastFieldBodyEndPosition = scanner.startPosition - 1;
+//}
+///**
+// *
+// * INTERNAL USE-ONLY
+// */
+//protected void consumeFieldDeclaration() {
+//     // See consumeLocalVariableDeclarationDefaultModifier() in case of change: duplicated code
+//     // FieldDeclaration ::= Modifiersopt Type VariableDeclarators ';'
+//     // the super.consumeFieldDeclaration will reinitialize the variableCounter[nestedType]  
+//     int variableIndex = variablesCounter[nestedType];
+//     super.consumeFieldDeclaration();
+//     intArrayPtr--;
+//     if (isLocalDeclaration())
+//             return;
+//     if (variableIndex != 0) {
+//             requestor.exitField(lastFieldBodyEndPosition, lastFieldEndPosition);
+//     }
+//}
+//protected void consumeFormalParameter() {
+//     // FormalParameter ::= Type VariableDeclaratorId ==> false
+//     // FormalParameter ::= Modifiers Type VariableDeclaratorId ==> true
+//     /*
+//     astStack : 
+//     identifierStack : type identifier
+//     intStack : dim dim
+//      ==>
+//     astStack : Argument
+//     identifierStack :  
+//     intStack :  
+//     */
+//
+//     identifierLengthPtr--;
+//     char[] name = identifierStack[identifierPtr];
+//     long namePositions = identifierPositionStack[identifierPtr--];
+//     TypeReference type = getTypeReference(intStack[intPtr--] + intStack[intPtr--]);
+//     intPtr -= 3;
+//     Argument arg = 
+//             new Argument(
+//                     name, 
+//                     namePositions, 
+//                     type, 
+//                     intStack[intPtr + 1]); // modifiers
+//     pushOnAstStack(arg);
+//     intArrayPtr--;
+//}
+///**
+// *
+// * INTERNAL USE-ONLY
+// */
+//protected void consumeInterfaceDeclaration() {
+//     super.consumeInterfaceDeclaration();
+//     // we know that we have a TypeDeclaration on the top of the astStack
+//     if (isLocalDeclaration()) {
+//             // we ignore the local variable declarations
+//             return;
+//     }
+//     requestor.exitInterface(endStatementPosition, // the '}' is the end of the body
+//      ((TypeDeclaration) astStack[astPtr]).declarationSourceEnd);
+//}
+///**
+// *
+// * INTERNAL USE-ONLY
+// */
+//protected void consumeInterfaceHeader() {
+//     //InterfaceHeader ::= $empty
+//     super.consumeInterfaceHeader();
+//     if (isLocalDeclaration()) {
+//             // we ignore the local variable declarations
+//             intArrayPtr--;
+//             return;
+//     }
+//     TypeDeclaration typeDecl = (TypeDeclaration) astStack[astPtr];
+//     TypeReference[] superInterfaces = typeDecl.superInterfaces;
+//     char[][] interfaceNames = null;
+//     int[] interfaceNameStarts = null;
+//     int[] interfacenameEnds = null;
+//     int superInterfacesLength = 0;
+//     if (superInterfaces != null) {
+//             superInterfacesLength = superInterfaces.length;
+//             interfaceNames = new char[superInterfacesLength][];
+//             interfaceNameStarts = new int[superInterfacesLength];
+//             interfacenameEnds = new int[superInterfacesLength];
+//     }
+//     if (superInterfaces != null) {
+//             for (int i = 0; i < superInterfacesLength; i++) {
+//                     TypeReference superInterface = superInterfaces[i];
+//                     interfaceNames[i] = CharOperation.concatWith(superInterface.getTypeName(), '.'); 
+//                     interfaceNameStarts[i] = superInterface.sourceStart;
+//                     interfacenameEnds[i] = superInterface.sourceEnd;
+//             }
+//     }
+//     // flush the comments related to the interface header
+//     scanner.commentPtr = -1;
+//     requestor.enterInterface(
+//             typeDecl.declarationSourceStart, 
+//             intArrayStack[intArrayPtr--], 
+//             typeDecl.modifiers, 
+//             typeDecl.modifiersSourceStart, 
+//             typeStartPosition, 
+//             typeDecl.name, 
+//             typeDecl.sourceStart, 
+//             typeDecl.sourceEnd, 
+//             interfaceNames, 
+//             interfaceNameStarts, 
+//             interfacenameEnds, 
+//             scanner.currentPosition - 1); 
+//}
+//protected void consumeInterfaceHeaderName() {
+//     // InterfaceHeaderName ::= Modifiersopt 'interface' 'Identifier'
+//     TypeDeclaration typeDecl;
+//     if (nestedMethod[nestedType] == 0) {
+//             if (nestedType != 0) {
+//                     typeDecl = new MemberTypeDeclaration(this.compilationUnit.compilationResult);
+//             } else {
+//                     typeDecl = new TypeDeclaration(this.compilationUnit.compilationResult);
+//             }
+//     } else {
+//             // Record that the block has a declaration for local types
+//             typeDecl = new LocalTypeDeclaration(this.compilationUnit.compilationResult);
+//             markEnclosingMemberWithLocalType();
+//             blockReal();
+//     }
+//
+//     //highlight the name of the type
+//     long pos = identifierPositionStack[identifierPtr];
+//     typeDecl.sourceEnd = (int) pos;
+//     typeDecl.sourceStart = (int) (pos >>> 32);
+//     typeDecl.name = identifierStack[identifierPtr--];
+//     identifierLengthPtr--;
+//
+//     //compute the declaration source too
+//     // 'class' and 'interface' push an int position
+//     typeStartPosition = typeDecl.declarationSourceStart = intStack[intPtr--];
+//     intPtr--;
+//     int declarationSourceStart = intStack[intPtr--];
+//     typeDecl.modifiersSourceStart = intStack[intPtr--];
+//     typeDecl.modifiers = intStack[intPtr--];
+//     if (typeDecl.declarationSourceStart > declarationSourceStart) {
+//             typeDecl.declarationSourceStart = declarationSourceStart;
+//     }
+//     typeDecl.bodyStart = typeDecl.sourceEnd + 1;
+//     pushOnAstStack(typeDecl);
+//}
+///**
+// *
+// * INTERNAL USE-ONLY
+// */
+//protected void consumeLocalVariableDeclaration() {
+//     // See consumeLocalVariableDeclarationDefaultModifier() in case of change: duplicated code
+//     // FieldDeclaration ::= Modifiersopt Type VariableDeclarators ';'
+//
+//     super.consumeLocalVariableDeclaration();
+//     intArrayPtr--;
+//}
+///**
+// *
+// * INTERNAL USE-ONLY
+// */
+//protected void consumeMethodDeclaration(boolean isNotAbstract) {
+//     // MethodDeclaration ::= MethodHeader MethodBody
+//     // AbstractMethodDeclaration ::= MethodHeader ';'
+//     super.consumeMethodDeclaration(isNotAbstract);
+//     if (isLocalDeclaration()) {
+//             // we ignore the local variable declarations
+//             return;
+//     }
+//     MethodDeclaration md = (MethodDeclaration) astStack[astPtr];
+//     requestor.exitMethod(endStatementPosition, md.declarationSourceEnd);
+//}
+///**
+// *
+// * INTERNAL USE-ONLY
+// */
+//protected void consumeMethodHeader() {
+//     // MethodHeader ::= MethodHeaderName MethodHeaderParameters MethodHeaderExtendedDims ThrowsClauseopt
+//     super.consumeMethodHeader();
+//     if (isLocalDeclaration()) {
+//             // we ignore the local variable declarations
+//             intArrayPtr--;
+//             return;
+//     }
+//     MethodDeclaration md = (MethodDeclaration) astStack[astPtr];
+//
+//     TypeReference returnType = md.returnType;
+//     char[] returnTypeName = returnTypeName(returnType);
+//     Argument[] arguments = md.arguments;
+//     char[][] argumentTypes = null;
+//     char[][] argumentNames = null;
+//     int[] argumentTypeStarts = null;
+//     int[] argumentTypeEnds = null;
+//     int[] argumentNameStarts = null;
+//     int[] argumentNameEnds = null;
+//     if (arguments != null) {
+//             int argumentLength = arguments.length;
+//             argumentTypes = new char[argumentLength][];
+//             argumentNames = new char[argumentLength][];
+//             argumentNameStarts = new int[argumentLength];
+//             argumentNameEnds = new int[argumentLength];
+//             argumentTypeStarts = new int[argumentLength];
+//             argumentTypeEnds = new int[argumentLength];
+//             for (int i = 0; i < argumentLength; i++) {
+//                     Argument argument = arguments[i];
+//                     TypeReference argumentType = argument.type;
+//                     argumentTypes[i] = returnTypeName(argumentType);
+//                     argumentNames[i] = argument.name;
+//                     argumentNameStarts[i] = argument.sourceStart;
+//                     argumentNameEnds[i] = argument.sourceEnd;
+//                     argumentTypeStarts[i] = argumentType.sourceStart;
+//                     argumentTypeEnds[i] = argumentType.sourceEnd;
+//             }
+//     }
+//     TypeReference[] thrownExceptions = md.thrownExceptions;
+//     char[][] exceptionTypes = null;
+//     int[] exceptionTypeStarts = null;
+//     int[] exceptionTypeEnds = null;
+//     if (thrownExceptions != null) {
+//             int thrownExceptionLength = thrownExceptions.length;
+//             exceptionTypeStarts = new int[thrownExceptionLength];
+//             exceptionTypeEnds = new int[thrownExceptionLength];
+//             exceptionTypes = new char[thrownExceptionLength][];
+//             for (int i = 0; i < thrownExceptionLength; i++) {
+//                     TypeReference exception = thrownExceptions[i];
+//                     exceptionTypes[i] = CharOperation.concatWith(exception.getTypeName(), '.');
+//                     exceptionTypeStarts[i] = exception.sourceStart;
+//                     exceptionTypeEnds[i] = exception.sourceEnd;
+//             }
+//     }
+//     requestor
+//             .enterMethod(
+//                     md.declarationSourceStart, 
+//                     intArrayStack[intArrayPtr--], 
+//                     md.modifiers, 
+//                     md.modifiersSourceStart, 
+//                     returnTypeName, 
+//                     returnType.sourceStart, 
+//                     returnType.sourceEnd, 
+//                     typeDims, 
+//                     md.selector, 
+//                     md.sourceStart, 
+//                     (int) (selectorSourcePositions & 0xFFFFFFFFL), 
+//                     argumentTypes, 
+//                     argumentTypeStarts, 
+//                     argumentTypeEnds, 
+//                     argumentNames, 
+//                     argumentNameStarts, 
+//                     argumentNameEnds, 
+//                     rParenPos, 
+//                     extendsDim, 
+//                     extendsDim == 0 ? -1 : endPosition, 
+//                     exceptionTypes, 
+//                     exceptionTypeStarts, 
+//                     exceptionTypeEnds, 
+//                     scanner.currentPosition - 1); 
+//}
+//protected void consumeMethodHeaderExtendedDims() {
+//     // MethodHeaderExtendedDims ::= Dimsopt
+//     // now we update the returnType of the method
+//     MethodDeclaration md = (MethodDeclaration) astStack[astPtr];
+//     int extendedDims = intStack[intPtr--];
+//     extendsDim = extendedDims;
+//     if (extendedDims != 0) {
+//             TypeReference returnType = md.returnType;
+//             md.sourceEnd = endPosition;
+//             int dims = returnType.dimensions() + extendedDims;
+//             int baseType;
+//             if ((baseType = identifierLengthStack[identifierLengthPtr + 1]) < 0) {
+//                     //it was a baseType
+//                     int sourceStart = returnType.sourceStart;
+//                     int sourceEnd = returnType.sourceEnd;
+//                     returnType = TypeReference.baseTypeReference(-baseType, dims);
+//                     returnType.sourceStart = sourceStart;
+//                     returnType.sourceEnd = sourceEnd;
+//                     md.returnType = returnType;
+//             } else {
+//                     md.returnType = this.copyDims(md.returnType, dims);
+//             }
+//             if (currentToken == TokenNameLBRACE) {
+//                     md.bodyStart = endPosition + 1;
+//             }
+//     }
+//}
+//protected void consumeMethodHeaderName() {
+//     // MethodHeaderName ::= Modifiersopt Type 'Identifier' '('
+//     MethodDeclaration md = new MethodDeclaration(this.compilationUnit.compilationResult);
+//
+//     //name
+//     md.selector = identifierStack[identifierPtr];
+//     selectorSourcePositions = identifierPositionStack[identifierPtr--];
+//     identifierLengthPtr--;
+//     //type
+//     md.returnType = getTypeReference(typeDims = intStack[intPtr--]);
+//     //modifiers
+//     md.declarationSourceStart = intStack[intPtr--];
+//     md.modifiersSourceStart = intStack[intPtr--];
+//     md.modifiers = intStack[intPtr--];
+//
+//     //highlight starts at selector start
+//     md.sourceStart = (int) (selectorSourcePositions >>> 32);
+//     pushOnAstStack(md);
+//     md.bodyStart = scanner.currentPosition-1;
+//}
+//protected void consumeModifiers() {
+//     checkAnnotation(); // might update modifiers with AccDeprecated
+//     pushOnIntStack(modifiers); // modifiers
+//     pushOnIntStack(modifiersSourceStart);
+//     pushOnIntStack(
+//             declarationSourceStart >= 0 ? declarationSourceStart : modifiersSourceStart); 
+//     resetModifiers();
+//}
 /**
  *
  * INTERNAL USE-ONLY
  */
-protected void consumeEnterVariable() {
-       // EnterVariable ::= $empty
-       boolean isLocalDeclaration = isLocalDeclaration();
-       if (!isLocalDeclaration && (variablesCounter[nestedType] != 0)) {
-               requestor.exitField(lastFieldBodyEndPosition, lastFieldEndPosition);
-       }
-       char[] name = identifierStack[identifierPtr];
-       long namePosition = identifierPositionStack[identifierPtr--];
-       int extendedTypeDimension = intStack[intPtr--];
-
-       AbstractVariableDeclaration declaration;
-       if (nestedMethod[nestedType] != 0) {
-               // create the local variable declarations
-               declaration = 
-                       new LocalDeclaration(null, name, (int) (namePosition >>> 32), (int) namePosition); 
-       } else {
-               // create the field declaration
-               declaration = 
-                       new FieldDeclaration(null, name, (int) (namePosition >>> 32), (int) namePosition); 
-       }
-       identifierLengthPtr--;
-       TypeReference type;
-       int variableIndex = variablesCounter[nestedType];
-       int typeDim = 0;
-       if (variableIndex == 0) {
-               // first variable of the declaration (FieldDeclaration or LocalDeclaration)
-               if (nestedMethod[nestedType] != 0) {
-                       // local declaration
-                       declaration.declarationSourceStart = intStack[intPtr--];
-                       declaration.modifiersSourceStart = intStack[intPtr--];
-                       declaration.modifiers = intStack[intPtr--];
-                       type = getTypeReference(typeDim = intStack[intPtr--]); // type dimension
-                       pushOnAstStack(type);
-               } else {
-                       // field declaration
-                       type = getTypeReference(typeDim = intStack[intPtr--]); // type dimension
-                       pushOnAstStack(type);
-                       declaration.declarationSourceStart = intStack[intPtr--];
-                       declaration.modifiersSourceStart = intStack[intPtr--];
-                       declaration.modifiers = intStack[intPtr--];
-               }
-       } else {
-               type = (TypeReference) astStack[astPtr - variableIndex];
-               typeDim = type.dimensions();
-               AbstractVariableDeclaration previousVariable = 
-                       (AbstractVariableDeclaration) astStack[astPtr]; 
-               declaration.declarationSourceStart = previousVariable.declarationSourceStart;
-               declaration.modifiers = previousVariable.modifiers;
-               declaration.modifiersSourceStart = previousVariable.modifiersSourceStart;
-       }
-
-       localIntPtr = intPtr;
-
-       if (extendedTypeDimension == 0) {
-               declaration.type = type;
-       } else {
-               int dimension = typeDim + extendedTypeDimension;
-               //on the identifierLengthStack there is the information about the type....
-               int baseType;
-               if ((baseType = identifierLengthStack[identifierLengthPtr + 1]) < 0) {
-                       //it was a baseType
-                       declaration.type = TypeReference.baseTypeReference(-baseType, dimension);
-                       declaration.type.sourceStart = type.sourceStart;
-                       declaration.type.sourceEnd = type.sourceEnd;
-               } else {
-                       declaration.type = this.copyDims(type, dimension);
-               }
-       }
-       variablesCounter[nestedType]++;
-       nestedMethod[nestedType]++;
-       pushOnAstStack(declaration);
-
-       int[] javadocPositions = intArrayStack[intArrayPtr];
-       if (!isLocalDeclaration) {
-               requestor
-                       .enterField(
-                               declaration.declarationSourceStart, 
-                               javadocPositions, 
-                               declaration.modifiers, 
-                               declaration.modifiersSourceStart, 
-                               returnTypeName(declaration.type), 
-                               type.sourceStart, 
-                               type.sourceEnd, 
-                               typeDims, 
-                               name, 
-                               (int) (namePosition >>> 32), 
-                               (int) namePosition, 
-                               extendedTypeDimension, 
-                               extendedTypeDimension == 0 ? -1 : endPosition); 
-       }
-}
-/**
- *
- * INTERNAL USE-ONLY
- */
-protected void consumeExitVariableWithInitialization() {
-       // ExitVariableWithInitialization ::= $empty
-       // the scanner is located after the comma or the semi-colon.
-       // we want to include the comma or the semi-colon
-       super.consumeExitVariableWithInitialization();
-       nestedMethod[nestedType]--;     
-       lastFieldEndPosition = scanner.currentPosition - 1;
-       lastFieldBodyEndPosition =      ((AbstractVariableDeclaration) astStack[astPtr]).initialization.sourceEnd;
-}
-protected void consumeExitVariableWithoutInitialization() {
-       // ExitVariableWithoutInitialization ::= $empty
-       // do nothing by default
-       super.consumeExitVariableWithoutInitialization();
-       nestedMethod[nestedType]--;     
-       lastFieldEndPosition = scanner.currentPosition - 1;
-       lastFieldBodyEndPosition = scanner.startPosition - 1;
-}
-/**
- *
- * INTERNAL USE-ONLY
- */
-protected void consumeFieldDeclaration() {
-       // See consumeLocalVariableDeclarationDefaultModifier() in case of change: duplicated code
-       // FieldDeclaration ::= Modifiersopt Type VariableDeclarators ';'
-       // the super.consumeFieldDeclaration will reinitialize the variableCounter[nestedType]  
-       int variableIndex = variablesCounter[nestedType];
-       super.consumeFieldDeclaration();
-       intArrayPtr--;
-       if (isLocalDeclaration())
-               return;
-       if (variableIndex != 0) {
-               requestor.exitField(lastFieldBodyEndPosition, lastFieldEndPosition);
-       }
-}
-protected void consumeFormalParameter() {
-       // FormalParameter ::= Type VariableDeclaratorId ==> false
-       // FormalParameter ::= Modifiers Type VariableDeclaratorId ==> true
-       /*
-       astStack : 
-       identifierStack : type identifier
-       intStack : dim dim
-        ==>
-       astStack : Argument
-       identifierStack :  
-       intStack :  
-       */
-
-       identifierLengthPtr--;
-       char[] name = identifierStack[identifierPtr];
-       long namePositions = identifierPositionStack[identifierPtr--];
-       TypeReference type = getTypeReference(intStack[intPtr--] + intStack[intPtr--]);
-       intPtr -= 3;
-       Argument arg = 
-               new Argument(
-                       name, 
-                       namePositions, 
-                       type, 
-                       intStack[intPtr + 1]); // modifiers
-       pushOnAstStack(arg);
-       intArrayPtr--;
-}
-/**
- *
- * INTERNAL USE-ONLY
- */
-protected void consumeInterfaceDeclaration() {
-       super.consumeInterfaceDeclaration();
-       // we know that we have a TypeDeclaration on the top of the astStack
-       if (isLocalDeclaration()) {
-               // we ignore the local variable declarations
-               return;
-       }
-       requestor.exitInterface(endStatementPosition, // the '}' is the end of the body
-        ((TypeDeclaration) astStack[astPtr]).declarationSourceEnd);
-}
-/**
- *
- * INTERNAL USE-ONLY
- */
-protected void consumeInterfaceHeader() {
-       //InterfaceHeader ::= $empty
-       super.consumeInterfaceHeader();
-       if (isLocalDeclaration()) {
-               // we ignore the local variable declarations
-               intArrayPtr--;
-               return;
-       }
-       TypeDeclaration typeDecl = (TypeDeclaration) astStack[astPtr];
-       TypeReference[] superInterfaces = typeDecl.superInterfaces;
-       char[][] interfaceNames = null;
-       int[] interfaceNameStarts = null;
-       int[] interfacenameEnds = null;
-       int superInterfacesLength = 0;
-       if (superInterfaces != null) {
-               superInterfacesLength = superInterfaces.length;
-               interfaceNames = new char[superInterfacesLength][];
-               interfaceNameStarts = new int[superInterfacesLength];
-               interfacenameEnds = new int[superInterfacesLength];
-       }
-       if (superInterfaces != null) {
-               for (int i = 0; i < superInterfacesLength; i++) {
-                       TypeReference superInterface = superInterfaces[i];
-                       interfaceNames[i] = CharOperation.concatWith(superInterface.getTypeName(), '.'); 
-                       interfaceNameStarts[i] = superInterface.sourceStart;
-                       interfacenameEnds[i] = superInterface.sourceEnd;
-               }
-       }
-       // flush the comments related to the interface header
-       scanner.commentPtr = -1;
-       requestor.enterInterface(
-               typeDecl.declarationSourceStart, 
-               intArrayStack[intArrayPtr--], 
-               typeDecl.modifiers, 
-               typeDecl.modifiersSourceStart, 
-               typeStartPosition, 
-               typeDecl.name, 
-               typeDecl.sourceStart, 
-               typeDecl.sourceEnd, 
-               interfaceNames, 
-               interfaceNameStarts, 
-               interfacenameEnds, 
-               scanner.currentPosition - 1); 
-}
-protected void consumeInterfaceHeaderName() {
-       // InterfaceHeaderName ::= Modifiersopt 'interface' 'Identifier'
-       TypeDeclaration typeDecl;
-       if (nestedMethod[nestedType] == 0) {
-               if (nestedType != 0) {
-                       typeDecl = new MemberTypeDeclaration(this.compilationUnit.compilationResult);
-               } else {
-                       typeDecl = new TypeDeclaration(this.compilationUnit.compilationResult);
-               }
-       } else {
-               // Record that the block has a declaration for local types
-               typeDecl = new LocalTypeDeclaration(this.compilationUnit.compilationResult);
-               markCurrentMethodWithLocalType();
-               blockReal();
-       }
-
-       //highlight the name of the type
-       long pos = identifierPositionStack[identifierPtr];
-       typeDecl.sourceEnd = (int) pos;
-       typeDecl.sourceStart = (int) (pos >>> 32);
-       typeDecl.name = identifierStack[identifierPtr--];
-       identifierLengthPtr--;
-
-       //compute the declaration source too
-       // 'class' and 'interface' push an int position
-       typeStartPosition = typeDecl.declarationSourceStart = intStack[intPtr--];
-       intPtr--;
-       int declarationSourceStart = intStack[intPtr--];
-       typeDecl.modifiersSourceStart = intStack[intPtr--];
-       typeDecl.modifiers = intStack[intPtr--];
-       if (typeDecl.declarationSourceStart > declarationSourceStart) {
-               typeDecl.declarationSourceStart = declarationSourceStart;
-       }
-       typeDecl.bodyStart = typeDecl.sourceEnd + 1;
-       pushOnAstStack(typeDecl);
-}
-/**
- *
- * INTERNAL USE-ONLY
- */
-protected void consumeLocalVariableDeclaration() {
-       // See consumeLocalVariableDeclarationDefaultModifier() in case of change: duplicated code
-       // FieldDeclaration ::= Modifiersopt Type VariableDeclarators ';'
-
-       super.consumeLocalVariableDeclaration();
-       intArrayPtr--;
-}
-/**
- *
- * INTERNAL USE-ONLY
- */
-protected void consumeMethodDeclaration(boolean isNotAbstract) {
-       // MethodDeclaration ::= MethodHeader MethodBody
-       // AbstractMethodDeclaration ::= MethodHeader ';'
-       super.consumeMethodDeclaration(isNotAbstract);
-       if (isLocalDeclaration()) {
-               // we ignore the local variable declarations
-               return;
-       }
-       MethodDeclaration md = (MethodDeclaration) astStack[astPtr];
-       requestor.exitMethod(endStatementPosition, md.declarationSourceEnd);
-}
-/**
- *
- * INTERNAL USE-ONLY
- */
-protected void consumeMethodHeader() {
-       // MethodHeader ::= MethodHeaderName MethodHeaderParameters MethodHeaderExtendedDims ThrowsClauseopt
-       super.consumeMethodHeader();
-       if (isLocalDeclaration()) {
-               // we ignore the local variable declarations
-               intArrayPtr--;
-               return;
-       }
-       MethodDeclaration md = (MethodDeclaration) astStack[astPtr];
-
-       TypeReference returnType = md.returnType;
-       char[] returnTypeName = returnTypeName(returnType);
-       Argument[] arguments = md.arguments;
-       char[][] argumentTypes = null;
-       char[][] argumentNames = null;
-       int[] argumentTypeStarts = null;
-       int[] argumentTypeEnds = null;
-       int[] argumentNameStarts = null;
-       int[] argumentNameEnds = null;
-       if (arguments != null) {
-               int argumentLength = arguments.length;
-               argumentTypes = new char[argumentLength][];
-               argumentNames = new char[argumentLength][];
-               argumentNameStarts = new int[argumentLength];
-               argumentNameEnds = new int[argumentLength];
-               argumentTypeStarts = new int[argumentLength];
-               argumentTypeEnds = new int[argumentLength];
-               for (int i = 0; i < argumentLength; i++) {
-                       Argument argument = arguments[i];
-                       TypeReference argumentType = argument.type;
-                       argumentTypes[i] = returnTypeName(argumentType);
-                       argumentNames[i] = argument.name;
-                       argumentNameStarts[i] = argument.sourceStart;
-                       argumentNameEnds[i] = argument.sourceEnd;
-                       argumentTypeStarts[i] = argumentType.sourceStart;
-                       argumentTypeEnds[i] = argumentType.sourceEnd;
-               }
-       }
-       TypeReference[] thrownExceptions = md.thrownExceptions;
-       char[][] exceptionTypes = null;
-       int[] exceptionTypeStarts = null;
-       int[] exceptionTypeEnds = null;
-       if (thrownExceptions != null) {
-               int thrownExceptionLength = thrownExceptions.length;
-               exceptionTypeStarts = new int[thrownExceptionLength];
-               exceptionTypeEnds = new int[thrownExceptionLength];
-               exceptionTypes = new char[thrownExceptionLength][];
-               for (int i = 0; i < thrownExceptionLength; i++) {
-                       TypeReference exception = thrownExceptions[i];
-                       exceptionTypes[i] = CharOperation.concatWith(exception.getTypeName(), '.');
-                       exceptionTypeStarts[i] = exception.sourceStart;
-                       exceptionTypeEnds[i] = exception.sourceEnd;
-               }
-       }
-       requestor
-               .enterMethod(
-                       md.declarationSourceStart, 
-                       intArrayStack[intArrayPtr--], 
-                       md.modifiers, 
-                       md.modifiersSourceStart, 
-                       returnTypeName, 
-                       returnType.sourceStart, 
-                       returnType.sourceEnd, 
-                       typeDims, 
-                       md.selector, 
-                       md.sourceStart, 
-                       (int) (selectorSourcePositions & 0xFFFFFFFFL), 
-                       argumentTypes, 
-                       argumentTypeStarts, 
-                       argumentTypeEnds, 
-                       argumentNames, 
-                       argumentNameStarts, 
-                       argumentNameEnds, 
-                       rParenPos, 
-                       extendsDim, 
-                       extendsDim == 0 ? -1 : endPosition, 
-                       exceptionTypes, 
-                       exceptionTypeStarts, 
-                       exceptionTypeEnds, 
-                       scanner.currentPosition - 1); 
-}
-protected void consumeMethodHeaderExtendedDims() {
-       // MethodHeaderExtendedDims ::= Dimsopt
-       // now we update the returnType of the method
-       MethodDeclaration md = (MethodDeclaration) astStack[astPtr];
-       int extendedDims = intStack[intPtr--];
-       extendsDim = extendedDims;
-       if (extendedDims != 0) {
-               TypeReference returnType = md.returnType;
-               md.sourceEnd = endPosition;
-               int dims = returnType.dimensions() + extendedDims;
-               int baseType;
-               if ((baseType = identifierLengthStack[identifierLengthPtr + 1]) < 0) {
-                       //it was a baseType
-                       int sourceStart = returnType.sourceStart;
-                       int sourceEnd = returnType.sourceEnd;
-                       returnType = TypeReference.baseTypeReference(-baseType, dims);
-                       returnType.sourceStart = sourceStart;
-                       returnType.sourceEnd = sourceEnd;
-                       md.returnType = returnType;
-               } else {
-                       md.returnType = this.copyDims(md.returnType, dims);
-               }
-               if (currentToken == TokenNameLBRACE) {
-                       md.bodyStart = endPosition + 1;
-               }
-       }
-}
-protected void consumeMethodHeaderName() {
-       // MethodHeaderName ::= Modifiersopt Type 'Identifier' '('
-       MethodDeclaration md = new MethodDeclaration(this.compilationUnit.compilationResult);
-
-       //name
-       md.selector = identifierStack[identifierPtr];
-       selectorSourcePositions = identifierPositionStack[identifierPtr--];
-       identifierLengthPtr--;
-       //type
-       md.returnType = getTypeReference(typeDims = intStack[intPtr--]);
-       //modifiers
-       md.declarationSourceStart = intStack[intPtr--];
-       md.modifiersSourceStart = intStack[intPtr--];
-       md.modifiers = intStack[intPtr--];
-
-       //highlight starts at selector start
-       md.sourceStart = (int) (selectorSourcePositions >>> 32);
-       pushOnAstStack(md);
-       md.bodyStart = scanner.currentPosition-1;
-}
-protected void consumeModifiers() {
-       checkAnnotation(); // might update modifiers with AccDeprecated
-       pushOnIntStack(modifiers); // modifiers
-       pushOnIntStack(modifiersSourceStart);
-       pushOnIntStack(
-               declarationSourceStart >= 0 ? declarationSourceStart : modifiersSourceStart); 
-       resetModifiers();
-}
-/**
- *
- * INTERNAL USE-ONLY
- */
-protected void consumePackageDeclarationName() {
-       /* persisting javadoc positions */
-       pushOnIntArrayStack(this.getJavaDocPositions());
-
-       super.consumePackageDeclarationName();
-       ImportReference importReference = compilationUnit.currentPackage;
-
-       requestor.acceptPackage(
-               importReference.declarationSourceStart, 
-               importReference.declarationSourceEnd, 
-               intArrayStack[intArrayPtr--], 
-               CharOperation.concatWith(importReference.getImportName(), '.'),
-               importReference.sourceStart);
-}
-protected void consumePushModifiers() {
-       checkAnnotation(); // might update modifiers with AccDeprecated
-       pushOnIntStack(modifiers); // modifiers
-       if (modifiersSourceStart < 0) {
-               pushOnIntStack(-1);
-               pushOnIntStack(
-                       declarationSourceStart >= 0 ? declarationSourceStart : scanner.startPosition); 
-       } else {
-               pushOnIntStack(modifiersSourceStart);
-               pushOnIntStack(
-                       declarationSourceStart >= 0 ? declarationSourceStart : modifiersSourceStart); 
-       }
-       resetModifiers();
-}
-/**
- *
- * INTERNAL USE-ONLY
- */
-protected void consumeSingleTypeImportDeclarationName() {
-       // SingleTypeImportDeclarationName ::= 'import' Name
-
-       /* persisting javadoc positions */
-       pushOnIntArrayStack(this.getJavaDocPositions());
-
-       super.consumeSingleTypeImportDeclarationName();
-       ImportReference importReference = (ImportReference) astStack[astPtr];
-       requestor.acceptImport(
-               importReference.declarationSourceStart, 
-               importReference.declarationSourceEnd,
-               intArrayStack[intArrayPtr--],
-               CharOperation.concatWith(importReference.getImportName(), '.'),
-               importReference.sourceStart,
-               false);
-}
-/**
- *
- * INTERNAL USE-ONLY
- */
-protected void consumeStaticInitializer() {
-       // StaticInitializer ::=  StaticOnly Block
-       //push an Initializer
-       //optimize the push/pop
-       super.consumeStaticInitializer();
-       Initializer initializer = (Initializer) astStack[astPtr];
-       requestor.acceptInitializer(
-               initializer.declarationSourceStart,
-               initializer.declarationSourceEnd,
-               intArrayStack[intArrayPtr--],
-               AccStatic, 
-               intStack[intPtr--], 
-               initializer.block.sourceStart,
-               initializer.declarationSourceEnd);
-}
-protected void consumeStaticOnly() {
-       // StaticOnly ::= 'static'
-       checkAnnotation(); // might update declaration source start
-       pushOnIntStack(modifiersSourceStart);
-       pushOnIntStack(
-               declarationSourceStart >= 0 ? declarationSourceStart : modifiersSourceStart); 
-       jumpOverMethodBody();
-       nestedMethod[nestedType]++;
-       resetModifiers();
-}
-/**
- *
- * INTERNAL USE-ONLY
- */
-protected void consumeTypeImportOnDemandDeclarationName() {
-       // TypeImportOnDemandDeclarationName ::= 'import' Name '.' '*'
-
-       /* persisting javadoc positions */
-       pushOnIntArrayStack(this.getJavaDocPositions());
-
-       super.consumeTypeImportOnDemandDeclarationName();
-       ImportReference importReference = (ImportReference) astStack[astPtr];
-       requestor.acceptImport(
-               importReference.declarationSourceStart, 
-               importReference.declarationSourceEnd,
-               intArrayStack[intArrayPtr--],
-               CharOperation.concatWith(importReference.getImportName(), '.'), 
-               importReference.sourceStart,
-               true);
-}
+//protected void consumePackageDeclarationName() {
+//     /* persisting javadoc positions */
+//     pushOnIntArrayStack(this.getJavaDocPositions());
+//
+//     super.consumePackageDeclarationName();
+//     ImportReference importReference = compilationUnit.currentPackage;
+//
+//     requestor.acceptPackage(
+//             importReference.declarationSourceStart, 
+//             importReference.declarationSourceEnd, 
+//             intArrayStack[intArrayPtr--], 
+//             CharOperation.concatWith(importReference.getImportName(), '.'),
+//             importReference.sourceStart);
+//}
+//protected void consumePushModifiers() {
+//     checkAnnotation(); // might update modifiers with AccDeprecated
+//     pushOnIntStack(modifiers); // modifiers
+//     if (modifiersSourceStart < 0) {
+//             pushOnIntStack(-1);
+//             pushOnIntStack(
+//                     declarationSourceStart >= 0 ? declarationSourceStart : scanner.startPosition); 
+//     } else {
+//             pushOnIntStack(modifiersSourceStart);
+//             pushOnIntStack(
+//                     declarationSourceStart >= 0 ? declarationSourceStart : modifiersSourceStart); 
+//     }
+//     resetModifiers();
+//}
+///**
+// *
+// * INTERNAL USE-ONLY
+// */
+//protected void consumeSingleTypeImportDeclarationName() {
+//     // SingleTypeImportDeclarationName ::= 'import' Name
+//
+//     /* persisting javadoc positions */
+//     pushOnIntArrayStack(this.getJavaDocPositions());
+//
+//     super.consumeSingleTypeImportDeclarationName();
+//     ImportReference importReference = (ImportReference) astStack[astPtr];
+//     requestor.acceptImport(
+//             importReference.declarationSourceStart, 
+//             importReference.declarationSourceEnd,
+//             intArrayStack[intArrayPtr--],
+//             CharOperation.concatWith(importReference.getImportName(), '.'),
+//             importReference.sourceStart,
+//             false);
+//}
+///**
+// *
+// * INTERNAL USE-ONLY
+// */
+//protected void consumeStaticInitializer() {
+//     // StaticInitializer ::=  StaticOnly Block
+//     //push an Initializer
+//     //optimize the push/pop
+//     super.consumeStaticInitializer();
+//     Initializer initializer = (Initializer) astStack[astPtr];
+//     requestor.acceptInitializer(
+//             initializer.declarationSourceStart,
+//             initializer.declarationSourceEnd,
+//             intArrayStack[intArrayPtr--],
+//             AccStatic, 
+//             intStack[intPtr--], 
+//             initializer.block.sourceStart,
+//             initializer.declarationSourceEnd);
+//}
+//protected void consumeStaticOnly() {
+//     // StaticOnly ::= 'static'
+//     checkAnnotation(); // might update declaration source start
+//     pushOnIntStack(modifiersSourceStart);
+//     pushOnIntStack(
+//             declarationSourceStart >= 0 ? declarationSourceStart : modifiersSourceStart); 
+//     jumpOverMethodBody();
+//     nestedMethod[nestedType]++;
+//     resetModifiers();
+//}
+///**
+// *
+// * INTERNAL USE-ONLY
+// */
+//protected void consumeTypeImportOnDemandDeclarationName() {
+//     // TypeImportOnDemandDeclarationName ::= 'import' Name '.' '*'
+//
+//     /* persisting javadoc positions */
+//     pushOnIntArrayStack(this.getJavaDocPositions());
+//
+//     super.consumeTypeImportOnDemandDeclarationName();
+//     ImportReference importReference = (ImportReference) astStack[astPtr];
+//     requestor.acceptImport(
+//             importReference.declarationSourceStart, 
+//             importReference.declarationSourceEnd,
+//             intArrayStack[intArrayPtr--],
+//             CharOperation.concatWith(importReference.getImportName(), '.'), 
+//             importReference.sourceStart,
+//             true);
+//}
 public CompilationUnitDeclaration endParse(int act) {
        if (scanner.recordLineSeparator) {
                requestor.acceptLineSeparatorPositions(scanner.getLineEnds());
@@ -962,81 +949,81 @@ public CompilationUnitDeclaration endParse(int act) {
  * } // end of method foo
  */
  
-public int flushAnnotationsDefinedPriorTo(int position) {
-
-       return lastFieldEndPosition = super.flushAnnotationsDefinedPriorTo(position);
-}
-protected TypeReference getTypeReference(int dim) { /* build a Reference on a variable that may be qualified or not
-This variable is a type reference and dim will be its dimensions*/
-
-       int length;
-       TypeReference ref;
-       if ((length = identifierLengthStack[identifierLengthPtr--]) == 1) {
-               // single variable reference
-               if (dim == 0) {
-                       ref = 
-                               new SingleTypeReference(
-                                       identifierStack[identifierPtr], 
-                                       identifierPositionStack[identifierPtr--]); 
-               } else {
-                       ref = 
-                               new ArrayTypeReference(
-                                       identifierStack[identifierPtr], 
-                                       dim, 
-                                       identifierPositionStack[identifierPtr--]); 
-                       ref.sourceEnd = endPosition;
-               }
-       } else {
-               if (length < 0) { //flag for precompiled type reference on base types
-                       ref = TypeReference.baseTypeReference(-length, dim);
-                       ref.sourceStart = intStack[intPtr--];
-                       if (dim == 0) {
-                               ref.sourceEnd = intStack[intPtr--];
-                       } else {
-                               intPtr--;
-                               ref.sourceEnd = endPosition;
-                       }
-               } else { //Qualified variable reference
-                       char[][] tokens = new char[length][];
-                       identifierPtr -= length;
-                       long[] positions = new long[length];
-                       System.arraycopy(identifierStack, identifierPtr + 1, tokens, 0, length);
-                       System.arraycopy(
-                               identifierPositionStack, 
-                               identifierPtr + 1, 
-                               positions, 
-                               0, 
-                               length); 
-                       if (dim == 0) {
-                               ref = new QualifiedTypeReference(tokens, positions);
-                       } else {
-                               ref = new ArrayQualifiedTypeReference(tokens, dim, positions);
-                               ref.sourceEnd = endPosition;
-                       }
-               }
-       };
-       return ref;
-}
+//public int flushAnnotationsDefinedPriorTo(int position) {
+//
+//     return lastFieldEndPosition = super.flushAnnotationsDefinedPriorTo(position);
+//}
+//protected TypeReference getTypeReference(int dim) { /* build a Reference on a variable that may be qualified or not
+//This variable is a type reference and dim will be its dimensions*/
+//
+//     int length;
+//     TypeReference ref;
+//     if ((length = identifierLengthStack[identifierLengthPtr--]) == 1) {
+//             // single variable reference
+//             if (dim == 0) {
+//                     ref = 
+//                             new SingleTypeReference(
+//                                     identifierStack[identifierPtr], 
+//                                     identifierPositionStack[identifierPtr--]); 
+//             } else {
+//                     ref = 
+//                             new ArrayTypeReference(
+//                                     identifierStack[identifierPtr], 
+//                                     dim, 
+//                                     identifierPositionStack[identifierPtr--]); 
+//                     ref.sourceEnd = endPosition;
+//             }
+//     } else {
+//             if (length < 0) { //flag for precompiled type reference on base types
+//                     ref = TypeReference.baseTypeReference(-length, dim);
+//                     ref.sourceStart = intStack[intPtr--];
+//                     if (dim == 0) {
+//                             ref.sourceEnd = intStack[intPtr--];
+//                     } else {
+//                             intPtr--;
+//                             ref.sourceEnd = endPosition;
+//                     }
+//             } else { //Qualified variable reference
+//                     char[][] tokens = new char[length][];
+//                     identifierPtr -= length;
+//                     long[] positions = new long[length];
+//                     System.arraycopy(identifierStack, identifierPtr + 1, tokens, 0, length);
+//                     System.arraycopy(
+//                             identifierPositionStack, 
+//                             identifierPtr + 1, 
+//                             positions, 
+//                             0, 
+//                             length); 
+//                     if (dim == 0) {
+//                             ref = new QualifiedTypeReference(tokens, positions);
+//                     } else {
+//                             ref = new ArrayQualifiedTypeReference(tokens, dim, positions);
+//                             ref.sourceEnd = endPosition;
+//                     }
+//             }
+//     };
+//     return ref;
+//}
 public void initialize() {
        //positionning the parser for a new compilation unit
        //avoiding stack reallocation and all that....
-       super.initialize();
+       super.initialize(false);
        intArrayPtr = -1;
 }
 /**
  *
  * INTERNAL USE-ONLY
  */
-private boolean isLocalDeclaration() {
-       int nestedDepth = nestedType;
-       while (nestedDepth >= 0) {
-               if (nestedMethod[nestedDepth] != 0) {
-                       return true;
-               }
-               nestedDepth--;
-       }
-       return false;
-}
+//private boolean isLocalDeclaration() {
+//     int nestedDepth = nestedType;
+//     while (nestedDepth >= 0) {
+//             if (nestedMethod[nestedDepth] != 0) {
+//                     return true;
+//             }
+//             nestedDepth--;
+//     }
+//     return false;
+//}
 /*
  * Investigate one entire unit.
  */
@@ -1050,7 +1037,7 @@ public void parseCompilationUnit(ICompilationUnit unit) {
                                compilationUnit = 
                                        new CompilationUnitDeclaration(
                                                problemReporter(), 
-                                               new CompilationResult(unit, 0, 0, this.options.maxProblemsPerUnit), 
+                                               new CompilationResult(unit, 0, 0, 10), //this.options.maxProblemsPerUnit), 
                                                regionSource.length); 
                scanner.resetTo(0, regionSource.length);
                scanner.setSource(regionSource);
@@ -1061,152 +1048,152 @@ public void parseCompilationUnit(ICompilationUnit unit) {
 /*
  * Investigate one constructor declaration.
  */
-public void parseConstructor(char[] regionSource) {
-       try {
-               initialize();
-               goForClassBodyDeclarations();
-               referenceContext = 
-                       compilationUnit = 
-                               compilationUnit = 
-                                       new CompilationUnitDeclaration(
-                                               problemReporter(), 
-                                               new CompilationResult(regionSource, 0, 0, this.options.maxProblemsPerUnit), 
-                                               regionSource.length); 
-               scanner.resetTo(0, regionSource.length);
-               scanner.setSource(regionSource);
-               parse();
-       } catch (AbortCompilation ex) {
-       }
-}
+//public void parseConstructor(char[] regionSource) {
+//     try {
+//             initialize();
+//             goForClassBodyDeclarations();
+//             referenceContext = 
+//                     compilationUnit = 
+//                             compilationUnit = 
+//                                     new CompilationUnitDeclaration(
+//                                             problemReporter(), 
+//                                             new CompilationResult(regionSource, 0, 0, 10), //this.options.maxProblemsPerUnit), 
+//                                             regionSource.length); 
+//             scanner.resetTo(0, regionSource.length);
+//             scanner.setSource(regionSource);
+//             parse();
+//     } catch (AbortCompilation ex) {
+//     }
+//}
 /*
  * Investigate one field declaration statement (might have multiple declarations in it).
  */
-public void parseField(char[] regionSource) {
-       try {
-               initialize();
-               goForFieldDeclaration();
-               referenceContext = 
-                       compilationUnit = 
-                               compilationUnit = 
-                                       new CompilationUnitDeclaration(
-                                               problemReporter(), 
-                                               new CompilationResult(regionSource, 0, 0, this.options.maxProblemsPerUnit), 
-                                               regionSource.length); 
-               scanner.resetTo(0, regionSource.length);
-               scanner.setSource(regionSource);
-               parse();
-       } catch (AbortCompilation ex) {
-       }
-
-}
-/*
- * Investigate one import statement declaration.
- */
-public void parseImport(char[] regionSource) {
-       try {
-               initialize();
-               goForImportDeclaration();
-               referenceContext = 
-                       compilationUnit = 
-                               compilationUnit = 
-                                       new CompilationUnitDeclaration(
-                                               problemReporter(), 
-                                               new CompilationResult(regionSource, 0, 0, this.options.maxProblemsPerUnit), 
-                                               regionSource.length); 
-               scanner.resetTo(0, regionSource.length);
-               scanner.setSource(regionSource);
-               parse();
-       } catch (AbortCompilation ex) {
-       }
-
-}
-/*
- * Investigate one initializer declaration.
- * regionSource need to content exactly an initializer declaration.
- * e.g: static { i = 4; }
- * { name = "test"; }
- */
-public void parseInitializer(char[] regionSource) {
-       try {
-               initialize();
-               goForInitializer();
-               referenceContext = 
-                       compilationUnit = 
-                               compilationUnit = 
-                                       new CompilationUnitDeclaration(
-                                               problemReporter(), 
-                                               new CompilationResult(regionSource, 0, 0, this.options.maxProblemsPerUnit), 
-                                               regionSource.length); 
-               scanner.resetTo(0, regionSource.length);
-               scanner.setSource(regionSource);
-               parse();
-       } catch (AbortCompilation ex) {
-       }
-
-}
-/*
- * Investigate one method declaration.
- */
-public void parseMethod(char[] regionSource) {
-       try {
-               initialize();
-               goForGenericMethodDeclaration();
-               referenceContext = 
-                       compilationUnit = 
-                               compilationUnit = 
-                                       new CompilationUnitDeclaration(
-                                               problemReporter(), 
-                                               new CompilationResult(regionSource, 0, 0, this.options.maxProblemsPerUnit), 
-                                               regionSource.length); 
-               scanner.resetTo(0, regionSource.length);
-               scanner.setSource(regionSource);
-               parse();
-       } catch (AbortCompilation ex) {
-       }
-
-}
-/*
- * Investigate one package statement declaration.
- */
-public void parsePackage(char[] regionSource) {
-       try {
-               initialize();
-               goForPackageDeclaration();
-               referenceContext = 
-                       compilationUnit = 
-                               compilationUnit = 
-                                       new CompilationUnitDeclaration(
-                                               problemReporter(), 
-                                               new CompilationResult(regionSource, 0, 0, this.options.maxProblemsPerUnit), 
-                                               regionSource.length); 
-               scanner.resetTo(0, regionSource.length);
-               scanner.setSource(regionSource);
-               parse();
-       } catch (AbortCompilation ex) {
-       }
-
-}
-/*
- * Investigate one type declaration, its fields, methods and member types.
- */
-public void parseType(char[] regionSource) {
-       try {
-               initialize();
-               goForTypeDeclaration();
-               referenceContext = 
-                       compilationUnit = 
-                               compilationUnit = 
-                                       new CompilationUnitDeclaration(
-                                               problemReporter(), 
-                                               new CompilationResult(regionSource, 0, 0, this.options.maxProblemsPerUnit), 
-                                               regionSource.length); 
-               scanner.resetTo(0, regionSource.length);
-               scanner.setSource(regionSource);
-               parse();
-       } catch (AbortCompilation ex) {
-       }
-
-}
+//public void parseField(char[] regionSource) {
+//     try {
+//             initialize();
+//             goForFieldDeclaration();
+//             referenceContext = 
+//                     compilationUnit = 
+//                             compilationUnit = 
+//                                     new CompilationUnitDeclaration(
+//                                             problemReporter(), 
+//                                             new CompilationResult(regionSource, 0, 0, this.options.maxProblemsPerUnit), 
+//                                             regionSource.length); 
+//             scanner.resetTo(0, regionSource.length);
+//             scanner.setSource(regionSource);
+//             parse();
+//     } catch (AbortCompilation ex) {
+//     }
+//
+//}
+///*
+// * Investigate one import statement declaration.
+// */
+//public void parseImport(char[] regionSource) {
+//     try {
+//             initialize();
+//             goForImportDeclaration();
+//             referenceContext = 
+//                     compilationUnit = 
+//                             compilationUnit = 
+//                                     new CompilationUnitDeclaration(
+//                                             problemReporter(), 
+//                                             new CompilationResult(regionSource, 0, 0, this.options.maxProblemsPerUnit), 
+//                                             regionSource.length); 
+//             scanner.resetTo(0, regionSource.length);
+//             scanner.setSource(regionSource);
+//             parse();
+//     } catch (AbortCompilation ex) {
+//     }
+//
+//}
+///*
+// * Investigate one initializer declaration.
+// * regionSource need to content exactly an initializer declaration.
+// * e.g: static { i = 4; }
+// * { name = "test"; }
+// */
+//public void parseInitializer(char[] regionSource) {
+//     try {
+//             initialize();
+//             goForInitializer();
+//             referenceContext = 
+//                     compilationUnit = 
+//                             compilationUnit = 
+//                                     new CompilationUnitDeclaration(
+//                                             problemReporter(), 
+//                                             new CompilationResult(regionSource, 0, 0, this.options.maxProblemsPerUnit), 
+//                                             regionSource.length); 
+//             scanner.resetTo(0, regionSource.length);
+//             scanner.setSource(regionSource);
+//             parse();
+//     } catch (AbortCompilation ex) {
+//     }
+//
+//}
+///*
+// * Investigate one method declaration.
+// */
+//public void parseMethod(char[] regionSource) {
+//     try {
+//             initialize();
+//             goForGenericMethodDeclaration();
+//             referenceContext = 
+//                     compilationUnit = 
+//                             compilationUnit = 
+//                                     new CompilationUnitDeclaration(
+//                                             problemReporter(), 
+//                                             new CompilationResult(regionSource, 0, 0, this.options.maxProblemsPerUnit), 
+//                                             regionSource.length); 
+//             scanner.resetTo(0, regionSource.length);
+//             scanner.setSource(regionSource);
+//             parse();
+//     } catch (AbortCompilation ex) {
+//     }
+//
+//}
+///*
+// * Investigate one package statement declaration.
+// */
+//public void parsePackage(char[] regionSource) {
+//     try {
+//             initialize();
+//             goForPackageDeclaration();
+//             referenceContext = 
+//                     compilationUnit = 
+//                             compilationUnit = 
+//                                     new CompilationUnitDeclaration(
+//                                             problemReporter(), 
+//                                             new CompilationResult(regionSource, 0, 0, this.options.maxProblemsPerUnit), 
+//                                             regionSource.length); 
+//             scanner.resetTo(0, regionSource.length);
+//             scanner.setSource(regionSource);
+//             parse();
+//     } catch (AbortCompilation ex) {
+//     }
+//
+//}
+///*
+// * Investigate one type declaration, its fields, methods and member types.
+// */
+//public void parseType(char[] regionSource) {
+//     try {
+//             initialize();
+//             goForTypeDeclaration();
+//             referenceContext = 
+//                     compilationUnit = 
+//                             compilationUnit = 
+//                                     new CompilationUnitDeclaration(
+//                                             problemReporter(), 
+//                                             new CompilationResult(regionSource, 0, 0, this.options.maxProblemsPerUnit), 
+//                                             regionSource.length); 
+//             scanner.resetTo(0, regionSource.length);
+//             scanner.setSource(regionSource);
+//             parse();
+//     } catch (AbortCompilation ex) {
+//     }
+//
+//}
 /**
  * Returns this parser's problem reporter initialized with its reference context.
  * Also it is assumed that a problem is going to be reported, so initializes
@@ -1229,10 +1216,10 @@ protected void pushOnIntArrayStack(int[] positions) {
                intArrayStack[intArrayPtr] = positions;
        }
 }
-protected void resetModifiers() {
-       super.resetModifiers();
-       declarationSourceStart = -1;
-}
+//protected void resetModifiers() {
+//     super.resetModifiers();
+//     declarationSourceStart = -1;
+//}
 /*
  * Syntax error was detected. Will attempt to perform some recovery action in order
  * to resume to the regular parse loop.
@@ -1247,82 +1234,82 @@ protected boolean resumeOnSyntaxError() {
  * "A[][]".toCharArray()
  * "java.lang.String".toCharArray()
  */
-private char[] returnTypeName(TypeReference type) {
-       int dimension = type.dimensions();
-       if (dimension != 0) {
-               char[] dimensionsArray = new char[dimension * 2];
-               for (int i = 0; i < dimension; i++) {
-                       dimensionsArray[i*2] = '[';
-                       dimensionsArray[(i*2) + 1] = ']';
-               }
-               return CharOperation.concat(
-                       CharOperation.concatWith(type.getTypeName(), '.'), 
-                       dimensionsArray); 
-       }
-       return CharOperation.concatWith(type.getTypeName(), '.');
-}
-public String toString() {
-       StringBuffer buffer = new StringBuffer();
-       buffer.append("intArrayPtr = " + intArrayPtr + "\n"); //$NON-NLS-1$ //$NON-NLS-2$
-       buffer.append(super.toString());
-       return buffer.toString();
-}
-/**
- * INTERNAL USE ONLY
- */
-protected TypeReference typeReference(
-       int dim,
-       int localIdentifierPtr, 
-       int localIdentifierLengthPtr) {
-       /* build a Reference on a variable that may be qualified or not
-        * This variable is a type reference and dim will be its dimensions.
-        * We don't have any side effect on the stacks' pointers.
-        */
-
-       int length;
-       TypeReference ref;
-       if ((length = identifierLengthStack[localIdentifierLengthPtr]) == 1) {
-               // single variable reference
-               if (dim == 0) {
-                       ref = 
-                               new SingleTypeReference(
-                                       identifierStack[localIdentifierPtr], 
-                                       identifierPositionStack[localIdentifierPtr--]); 
-               } else {
-                       ref = 
-                               new ArrayTypeReference(
-                                       identifierStack[localIdentifierPtr], 
-                                       dim, 
-                                       identifierPositionStack[localIdentifierPtr--]); 
-                       ref.sourceEnd = endPosition;                            
-               }
-       } else {
-               if (length < 0) { //flag for precompiled type reference on base types
-                       ref = TypeReference.baseTypeReference(-length, dim);
-                       ref.sourceStart = intStack[localIntPtr--];
-                       if (dim == 0) {
-                               ref.sourceEnd = intStack[localIntPtr--];
-                       } else {
-                               localIntPtr--;
-                               ref.sourceEnd = endPosition;
-                       }
-               } else { //Qualified variable reference
-                       char[][] tokens = new char[length][];
-                       localIdentifierPtr -= length;
-                       long[] positions = new long[length];
-                       System.arraycopy(identifierStack, localIdentifierPtr + 1, tokens, 0, length);
-                       System.arraycopy(
-                               identifierPositionStack, 
-                               localIdentifierPtr + 1, 
-                               positions, 
-                               0, 
-                               length); 
-                       if (dim == 0)
-                               ref = new QualifiedTypeReference(tokens, positions);
-                       else
-                               ref = new ArrayQualifiedTypeReference(tokens, dim, positions);
-               }
-       };
-       return ref;
-}
+//private char[] returnTypeName(TypeReference type) {
+//     int dimension = type.dimensions();
+//     if (dimension != 0) {
+//             char[] dimensionsArray = new char[dimension * 2];
+//             for (int i = 0; i < dimension; i++) {
+//                     dimensionsArray[i*2] = '[';
+//                     dimensionsArray[(i*2) + 1] = ']';
+//             }
+//             return CharOperation.concat(
+//                     CharOperation.concatWith(type.getTypeName(), '.'), 
+//                     dimensionsArray); 
+//     }
+//     return CharOperation.concatWith(type.getTypeName(), '.');
+//}
+//public String toString() {
+//     StringBuffer buffer = new StringBuffer();
+//     buffer.append("intArrayPtr = " + intArrayPtr + "\n"); //$NON-NLS-1$ //$NON-NLS-2$
+//     buffer.append(super.toString());
+//     return buffer.toString();
+//}
+///**
+// * INTERNAL USE ONLY
+// */
+//protected TypeReference typeReference(
+//     int dim,
+//     int localIdentifierPtr, 
+//     int localIdentifierLengthPtr) {
+//     /* build a Reference on a variable that may be qualified or not
+//      * This variable is a type reference and dim will be its dimensions.
+//      * We don't have any side effect on the stacks' pointers.
+//      */
+//
+//     int length;
+//     TypeReference ref;
+//     if ((length = identifierLengthStack[localIdentifierLengthPtr]) == 1) {
+//             // single variable reference
+//             if (dim == 0) {
+//                     ref = 
+//                             new SingleTypeReference(
+//                                     identifierStack[localIdentifierPtr], 
+//                                     identifierPositionStack[localIdentifierPtr--]); 
+//             } else {
+//                     ref = 
+//                             new ArrayTypeReference(
+//                                     identifierStack[localIdentifierPtr], 
+//                                     dim, 
+//                                     identifierPositionStack[localIdentifierPtr--]); 
+//                     ref.sourceEnd = endPosition;                            
+//             }
+//     } else {
+//             if (length < 0) { //flag for precompiled type reference on base types
+//                     ref = TypeReference.baseTypeReference(-length, dim);
+//                     ref.sourceStart = intStack[localIntPtr--];
+//                     if (dim == 0) {
+//                             ref.sourceEnd = intStack[localIntPtr--];
+//                     } else {
+//                             localIntPtr--;
+//                             ref.sourceEnd = endPosition;
+//                     }
+//             } else { //Qualified variable reference
+//                     char[][] tokens = new char[length][];
+//                     localIdentifierPtr -= length;
+//                     long[] positions = new long[length];
+//                     System.arraycopy(identifierStack, localIdentifierPtr + 1, tokens, 0, length);
+//                     System.arraycopy(
+//                             identifierPositionStack, 
+//                             localIdentifierPtr + 1, 
+//                             positions, 
+//                             0, 
+//                             length); 
+//                     if (dim == 0)
+//                             ref = new QualifiedTypeReference(tokens, positions);
+//                     else
+//                             ref = new ArrayQualifiedTypeReference(tokens, dim, positions);
+//             }
+//     };
+//     return ref;
+//}
 }