X-Git-Url: http://secure.phpeclipse.com

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