syntax.xml update from hudson build on Thu 28 Aug 2008 09:25:08 PM CDT
[phpeclipse.git] / net.sourceforge.phpeclipse / src / net / sourceforge / phpdt / internal / compiler / DocumentElementParser.java
index 2d6c723..d68c7a2 100644 (file)
-/*******************************************************************************
- * 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 v1.0
- * which accompanies this distribution, and is available at
+/***********************************************************************************************************************************
+ * 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 v1.0 which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/cpl-v10.html
  * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
+ * 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.ast.CompilationUnitDeclaration;
 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.
- *
+ * A document element parser extracts structural information from a piece of
+ * source, providing detailed source positions info.
+ * 
  * also see @IDocumentElementRequestor
- *
- * The structural investigation includes:
- * - the package statement
- * - import statements
- * - top-level types: package member, member types (member types of member types...)
- * - fields
- * - methods
- *
+ * 
+ * The structural investigation includes: - the package statement - import
+ * statements - top-level types: package member, member types (member types of
+ * member types...) - fields - methods
+ * 
  * Any (parsing) problem encountered is also provided.
  */
 public class DocumentElementParser extends UnitParser {
        IDocumentElementRequestor requestor;
+
        private int localIntPtr;
+
        private int lastFieldEndPosition;
-       private int lastFieldBodyEndPosition;   
+
+       private int lastFieldBodyEndPosition;
+
        private int typeStartPosition;
+
        private long selectorSourcePositions;
+
        private int typeDims;
+
        private int extendsDim;
+
        private int declarationSourceStart;
 
        /* int[] stack for storing javadoc positions */
        int[][] intArrayStack;
+
        int intArrayPtr;
-       
-//     CompilerOptions options;
-       
-public DocumentElementParser(
-       final IDocumentElementRequestor requestor, 
-       IProblemFactory problemFactory) {
-//     CompilerOptions options) {
-       super(new ProblemReporter(
-               DefaultErrorHandlingPolicies.exitAfterAllProblems(), 
-//             options, 
-               problemFactory) {
-               public void record(IProblem problem, CompilationResult unitResult) {
-                       requestor.acceptProblem(problem);
+
+       // CompilerOptions options;
+
+       public DocumentElementParser(final IDocumentElementRequestor requestor,
+                       IProblemFactory problemFactory, CompilerOptions options) {
+               super(new ProblemReporter(DefaultErrorHandlingPolicies
+                               .exitAfterAllProblems(), options, problemFactory) {
+                       public void record(IProblem problem, CompilationResult unitResult) {
+                               requestor.acceptProblem(problem);
+                       }
+               });
+               // false,
+               // options.sourceLevel >= CompilerOptions.JDK1_4);
+               this.requestor = requestor;
+               intArrayStack = new int[30][];
+               this.options = options;
+       }
+
+       /**
+        * 
+        * INTERNAL USE-ONLY
+        */
+       // protected void adjustInterfaceModifiers() {
+       // intStack[intPtr - 2] |= AccInterface;
+       // }
+       /*
+        * Will clear the comment stack when looking for a potential JavaDoc which
+        * might contain @deprecated.
+        * 
+        * 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;
+       // 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 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 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 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());
                }
-       });
-//     false,
-//     options.sourceLevel >= CompilerOptions.JDK1_4);
-       this.requestor = requestor;
-       intArrayStack = new int[30][];
-//     this.options = options;
-}
+               return super.endParse(act);
+       }
 
-/**
- *
- * INTERNAL USE-ONLY
- */
-//protected void adjustInterfaceModifiers() {
-//     intStack[intPtr - 2] |= AccInterface;
-//}
-/*
- * Will clear the comment stack when looking
- * for a potential JavaDoc which might contain @deprecated.
- *
- * 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;
-//     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 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 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 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());
+       /*
+        * Flush annotations defined prior to a given positions.
+        * 
+        * Note: annotations are stacked in syntactical order
+        * 
+        * Either answer given <position>, or the end position of a comment line
+        * immediately following the <position> (same line)
+        * 
+        * e.g. void foo(){ } // 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 void initialize() {
+               // positionning the parser for a new compilation unit
+               // avoiding stack reallocation and all that....
+               super.initialize(false);
+               intArrayPtr = -1;
        }
-       return super.endParse(act);
-}
-/*
- * Flush annotations defined prior to a given positions.
- *
- * Note: annotations are stacked in syntactical order
- *
- * Either answer given <position>, or the end position of a comment line 
- * immediately following the <position> (same line)
- *
- * e.g.
- * void foo(){
- * } // 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 void initialize() {
-       //positionning the parser for a new compilation unit
-       //avoiding stack reallocation and all that....
-       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;
-//}
-/*
- * Investigate one entire unit.
- */
-public void parseCompilationUnit(ICompilationUnit unit) {
-       char[] regionSource = unit.getContents();
-       try {
-               initialize();
-               goForCompilationUnit();
-               referenceContext =
-                       compilationUnit = 
-                               compilationUnit = 
-                                       new CompilationUnitDeclaration(
-                                               problemReporter(), 
-                                               new CompilationResult(unit, 0, 0, 10), //this.options.maxProblemsPerUnit), 
-                                               regionSource.length); 
-               scanner.resetTo(0, regionSource.length);
-               scanner.setSource(regionSource);
-               parse();
-       } catch (AbortCompilation ex) {
+
+       /**
+        * 
+        * INTERNAL USE-ONLY
+        */
+       // private boolean isLocalDeclaration() {
+       // int nestedDepth = nestedType;
+       // while (nestedDepth >= 0) {
+       // if (nestedMethod[nestedDepth] != 0) {
+       // return true;
+       // }
+       // nestedDepth--;
+       // }
+       // return false;
+       // }
+       /*
+        * Investigate one entire unit.
+        */
+       public void parseCompilationUnit(ICompilationUnit unit) {
+               char[] regionSource = unit.getContents();
+               try {
+                       initialize();
+                       goForCompilationUnit();
+                       referenceContext = compilationUnit = new CompilationUnitDeclaration(
+                                       problemReporter(), new CompilationResult(unit, 0, 0, 10), // this.options.maxProblemsPerUnit),
+                                       regionSource.length);
+                       scanner.resetTo(0, regionSource.length);
+                       scanner.setSource(regionSource);
+                       parse();
+               } catch (AbortCompilation ex) {
+               }
        }
-}
-/*
- * Investigate one constructor declaration.
- */
-//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) {
-//     }
-//
-//}
-/**
- * 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
- * the compilation result's line positions.
- */
-public ProblemReporter problemReporter() {
-       problemReporter.referenceContext = referenceContext;
-       return problemReporter;
-}
-protected void pushOnIntArrayStack(int[] positions) {
 
-       try {
-               intArrayStack[++intArrayPtr] = positions;
-       } catch (IndexOutOfBoundsException e) {
-               //intPtr is correct 
-               int oldStackLength = intArrayStack.length;
-               int oldStack[][] = intArrayStack;
-               intArrayStack = new int[oldStackLength + StackIncrement][];
-               System.arraycopy(oldStack, 0, intArrayStack, 0, oldStackLength);
-               intArrayStack[intArrayPtr] = positions;
+       /*
+        * Investigate one constructor declaration.
+        */
+       // 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) {
+       // }
+       //
+       // }
+       /**
+        * 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 the compilation result's line positions.
+        */
+       public ProblemReporter problemReporter() {
+               problemReporter.referenceContext = referenceContext;
+               return problemReporter;
        }
-}
-//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.
- */
-protected boolean resumeOnSyntaxError() {
-       return false;
-}
-/*
- * Answer a char array representation of the type name formatted like:
- * - type name + dimensions
- * Example:
- * "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;
-//}
-}
+
+       protected void pushOnIntArrayStack(int[] positions) {
+
+               try {
+                       intArrayStack[++intArrayPtr] = positions;
+               } catch (IndexOutOfBoundsException e) {
+                       // intPtr is correct
+                       int oldStackLength = intArrayStack.length;
+                       int oldStack[][] = intArrayStack;
+                       intArrayStack = new int[oldStackLength + StackIncrement][];
+                       System.arraycopy(oldStack, 0, intArrayStack, 0, oldStackLength);
+                       intArrayStack[intArrayPtr] = positions;
+               }
+       }
+
+       // 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.
+        */
+       protected boolean resumeOnSyntaxError() {
+               return false;
+       }
+       /*
+        * Answer a char array representation of the type name formatted like: -
+        * type name + dimensions Example: "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;
+       // }
+}
\ No newline at end of file