X-Git-Url: http://git.phpeclipse.com diff --git a/net.sourceforge.phpeclipse/src/net/sourceforge/phpdt/internal/compiler/SourceElementParser.java b/net.sourceforge.phpeclipse/src/net/sourceforge/phpdt/internal/compiler/SourceElementParser.java index 7902369..2f98945 100644 --- a/net.sourceforge.phpeclipse/src/net/sourceforge/phpdt/internal/compiler/SourceElementParser.java +++ b/net.sourceforge.phpeclipse/src/net/sourceforge/phpdt/internal/compiler/SourceElementParser.java @@ -1,15 +1,48 @@ /******************************************************************************* - * 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 java.util.ArrayList; + +import net.sourceforge.phpdt.internal.compiler.CompilationResult; + +import net.sourceforge.phpdt.core.compiler.CharOperation; +import net.sourceforge.phpdt.core.compiler.IProblem; +import net.sourceforge.phpdt.internal.compiler.env.ICompilationUnit; +import net.sourceforge.phpdt.internal.compiler.env.ISourceType; +import net.sourceforge.phpdt.internal.compiler.impl.CompilerOptions; +import net.sourceforge.phpdt.internal.compiler.impl.ReferenceContext; +import net.sourceforge.phpdt.internal.compiler.lookup.BlockScope; +import net.sourceforge.phpdt.internal.compiler.lookup.ClassScope; +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.AbstractMethodDeclaration; +import net.sourceforge.phpeclipse.internal.compiler.ast.AnonymousLocalTypeDeclaration; +import net.sourceforge.phpeclipse.internal.compiler.ast.Argument; +import net.sourceforge.phpeclipse.internal.compiler.ast.AstNode; +import net.sourceforge.phpeclipse.internal.compiler.ast.CompilationUnitDeclaration; +import net.sourceforge.phpeclipse.internal.compiler.ast.ConstructorDeclaration; +import net.sourceforge.phpeclipse.internal.compiler.ast.ExplicitConstructorCall; +import net.sourceforge.phpeclipse.internal.compiler.ast.FieldDeclaration; +import net.sourceforge.phpeclipse.internal.compiler.ast.LocalTypeDeclaration; +import net.sourceforge.phpeclipse.internal.compiler.ast.MemberTypeDeclaration; +import net.sourceforge.phpeclipse.internal.compiler.ast.MethodDeclaration; +import net.sourceforge.phpeclipse.internal.compiler.ast.NameReference; +import net.sourceforge.phpeclipse.internal.compiler.ast.QualifiedAllocationExpression; +import net.sourceforge.phpeclipse.internal.compiler.ast.TypeDeclaration; +import net.sourceforge.phpeclipse.internal.compiler.ast.TypeReference; + + + /** * A source element parser extracts structural and reference information * from a piece of source. @@ -29,78 +62,33 @@ package net.sourceforge.phpdt.internal.compiler; * Any (parsing) problem encountered is also provided. */ -import net.sourceforge.phpdt.core.compiler.IProblem; -import net.sourceforge.phpdt.internal.compiler.ast.AbstractMethodDeclaration; -import net.sourceforge.phpdt.internal.compiler.ast.AllocationExpression; -import net.sourceforge.phpdt.internal.compiler.ast.AnonymousLocalTypeDeclaration; -import net.sourceforge.phpdt.internal.compiler.ast.Argument; -import net.sourceforge.phpdt.internal.compiler.ast.ArrayQualifiedTypeReference; -import net.sourceforge.phpdt.internal.compiler.ast.ArrayTypeReference; -import net.sourceforge.phpdt.internal.compiler.ast.AstNode; -import net.sourceforge.phpdt.internal.compiler.ast.CompilationUnitDeclaration; -import net.sourceforge.phpdt.internal.compiler.ast.ConstructorDeclaration; -import net.sourceforge.phpdt.internal.compiler.ast.ExplicitConstructorCall; -import net.sourceforge.phpdt.internal.compiler.ast.Expression; -import net.sourceforge.phpdt.internal.compiler.ast.FieldDeclaration; -import net.sourceforge.phpdt.internal.compiler.ast.FieldReference; -import net.sourceforge.phpdt.internal.compiler.ast.ImportReference; -import net.sourceforge.phpdt.internal.compiler.ast.Initializer; -import net.sourceforge.phpdt.internal.compiler.ast.LocalTypeDeclaration; -import net.sourceforge.phpdt.internal.compiler.ast.MemberTypeDeclaration; -import net.sourceforge.phpdt.internal.compiler.ast.MessageSend; -import net.sourceforge.phpdt.internal.compiler.ast.MethodDeclaration; -import net.sourceforge.phpdt.internal.compiler.ast.NameReference; -import net.sourceforge.phpdt.internal.compiler.ast.QualifiedAllocationExpression; -import net.sourceforge.phpdt.internal.compiler.ast.QualifiedNameReference; -import net.sourceforge.phpdt.internal.compiler.ast.QualifiedTypeReference; -import net.sourceforge.phpdt.internal.compiler.ast.SingleNameReference; -import net.sourceforge.phpdt.internal.compiler.ast.SingleTypeReference; -import net.sourceforge.phpdt.internal.compiler.ast.TypeDeclaration; -import net.sourceforge.phpdt.internal.compiler.ast.TypeReference; -import net.sourceforge.phpdt.internal.compiler.env.ICompilationUnit; -import net.sourceforge.phpdt.internal.compiler.env.ISourceType; -import net.sourceforge.phpdt.internal.compiler.impl.CompilerOptions; -import net.sourceforge.phpdt.internal.compiler.impl.ReferenceContext; -import net.sourceforge.phpdt.internal.compiler.lookup.BindingIds; -import net.sourceforge.phpdt.internal.compiler.lookup.BlockScope; -import net.sourceforge.phpdt.internal.compiler.lookup.ClassScope; -import net.sourceforge.phpdt.internal.compiler.parser.Parser; -import net.sourceforge.phpdt.internal.compiler.parser.RecoveredType; -import net.sourceforge.phpdt.internal.compiler.parser.SourceConstructorDeclaration; -import net.sourceforge.phpdt.internal.compiler.parser.SourceFieldDeclaration; -import net.sourceforge.phpdt.internal.compiler.parser.SourceMethodDeclaration; -import net.sourceforge.phpdt.internal.compiler.parser.SourceTypeConverter; -import net.sourceforge.phpdt.internal.compiler.problem.AbortCompilation; -import net.sourceforge.phpdt.internal.compiler.problem.ProblemReporter; -import net.sourceforge.phpdt.internal.compiler.util.CharOperation; - -public class SourceElementParser extends Parser { +public class SourceElementParser extends UnitParser { ISourceElementRequestor requestor; - private int fieldCount; - private int localIntPtr; - private int lastFieldEndPosition; - private ISourceType sourceType; - private boolean reportReferenceInfo; - private char[][] typeNames; - private char[][] superTypeNames; - private int nestedTypeIndex; - private static final char[] JAVA_LANG_OBJECT = "java.lang.Object".toCharArray(); //$NON-NLS-1$ - private NameReference[] unknownRefs; - private int unknownRefsCounter; - private LocalDeclarationVisitor localDeclarationVisitor = null; - private CompilerOptions options; + int fieldCount; + int localIntPtr; + int lastFieldEndPosition; + ISourceType sourceType; + boolean reportReferenceInfo; + char[][] typeNames; + char[][] superTypeNames; + int nestedTypeIndex; + static final char[] JAVA_LANG_OBJECT = "java.lang.Object".toCharArray(); //$NON-NLS-1$ + NameReference[] unknownRefs; + int unknownRefsCounter; + LocalDeclarationVisitor localDeclarationVisitor = null; +// CompilerOptions options; /** * An ast visitor that visits local type declarations. */ public class LocalDeclarationVisitor extends AbstractSyntaxTreeVisitorAdapter { - public boolean visit( - AnonymousLocalTypeDeclaration anonymousTypeDeclaration, - BlockScope scope) { - notifySourceElementRequestor(anonymousTypeDeclaration, sourceType == null); - return false; // don't visit members as this was done during notifySourceElementRequestor(...) - } +// public boolean visit( +// AnonymousLocalTypeDeclaration anonymousTypeDeclaration, +// BlockScope scope) { +// notifySourceElementRequestor(anonymousTypeDeclaration, sourceType == null); +// return false; // don't visit members as this was done during notifySourceElementRequestor(...) +// } public boolean visit(LocalTypeDeclaration typeDeclaration, BlockScope scope) { notifySourceElementRequestor(typeDeclaration, sourceType == null); return false; // don't visit members as this was done during notifySourceElementRequestor(...) @@ -115,20 +103,21 @@ public class LocalDeclarationVisitor extends AbstractSyntaxTreeVisitorAdapter { public SourceElementParser( final ISourceElementRequestor requestor, IProblemFactory problemFactory, - CompilerOptions options) { + CompilerOptions options) { // we want to notify all syntax error with the acceptProblem API // To do so, we define the record method of the ProblemReporter - super(new ProblemReporter( + super( + new ProblemReporter( DefaultErrorHandlingPolicies.exitAfterAllProblems(), - options, + options, problemFactory) { public void record(IProblem problem, CompilationResult unitResult, ReferenceContext referenceContext) { unitResult.record(problem, referenceContext); requestor.acceptProblem(problem); } - }, - true, - options.assertMode); + }); +// true); +// options.sourceLevel >= CompilerOptions.JDK1_4); this.requestor = requestor; typeNames = new char[4][]; superTypeNames = new char[4][]; @@ -137,251 +126,252 @@ public SourceElementParser( } /** @deprecated use SourceElementParser(ISourceElementRequestor, IProblemFactory, CompilerOptions) */ -public SourceElementParser( - final ISourceElementRequestor requestor, - IProblemFactory problemFactory) { - this(requestor, problemFactory, new CompilerOptions()); -} - -public SourceElementParser( - final ISourceElementRequestor requestor, - IProblemFactory problemFactory, - CompilerOptions options, - boolean reportLocalDeclarations) { - this(requestor, problemFactory, options); - if (reportLocalDeclarations) { - this.localDeclarationVisitor = new LocalDeclarationVisitor(); - } -} - -public void checkAnnotation() { - int firstCommentIndex = scanner.commentPtr; - - super.checkAnnotation(); - - // modify the modifier source start to point at the first comment - if (firstCommentIndex >= 0) { - modifiersSourceStart = scanner.commentStarts[0]; - } -} - -protected void classInstanceCreation(boolean alwaysQualified) { - - boolean previousFlag = reportReferenceInfo; - reportReferenceInfo = false; // not to see the type reference reported in super call to getTypeReference(...) - super.classInstanceCreation(alwaysQualified); - reportReferenceInfo = previousFlag; - if (reportReferenceInfo){ - AllocationExpression alloc = (AllocationExpression)expressionStack[expressionPtr]; - TypeReference typeRef = alloc.type; - requestor.acceptConstructorReference( - typeRef instanceof SingleTypeReference - ? ((SingleTypeReference) typeRef).token - : CharOperation.concatWith(alloc.type.getTypeName(), '.'), - alloc.arguments == null ? 0 : alloc.arguments.length, - alloc.sourceStart); - } -} -protected void consumeConstructorHeaderName() { - // ConstructorHeaderName ::= Modifiersopt 'Identifier' '(' - - /* recovering - might be an empty message send */ - if (currentElement != null){ - if (lastIgnoredToken == TokenNamenew){ // was an allocation expression - lastCheckPoint = scanner.startPosition; // force to restart at this exact position - restartRecovery = true; - return; - } - } - SourceConstructorDeclaration cd = new SourceConstructorDeclaration(this.compilationUnit.compilationResult); - - //name -- this is not really revelant but we do ..... - cd.selector = identifierStack[identifierPtr]; - long selectorSourcePositions = identifierPositionStack[identifierPtr--]; - identifierLengthPtr--; +//public SourceElementParser( +// final ISourceElementRequestor requestor, +// IProblemFactory problemFactory) { +// this(requestor, problemFactory, new CompilerOptions()); +//} - //modifiers - cd.declarationSourceStart = intStack[intPtr--]; - cd.modifiers = intStack[intPtr--]; +//public SourceElementParser( +// final ISourceElementRequestor requestor, +// IProblemFactory problemFactory, +// CompilerOptions options, +// boolean reportLocalDeclarations) { +// this(requestor, problemFactory, options); +// if (reportLocalDeclarations) { +// this.localDeclarationVisitor = new LocalDeclarationVisitor(); +// } +//} - //highlight starts at the selector starts - cd.sourceStart = (int) (selectorSourcePositions >>> 32); - cd.selectorSourceEnd = (int) selectorSourcePositions; - pushOnAstStack(cd); +//public void checkAnnotation() { +// int firstCommentIndex = scanner.commentPtr; +// +// super.checkAnnotation(); +// +// // modify the modifier source start to point at the first comment +// if (firstCommentIndex >= 0) { +// modifiersSourceStart = scanner.commentStarts[0]; +// } +//} - cd.sourceEnd = lParenPos; - cd.bodyStart = lParenPos+1; - listLength = 0; // initialize listLength before reading parameters/throws - - // recovery - if (currentElement != null){ - lastCheckPoint = cd.bodyStart; - if ((currentElement instanceof RecoveredType && lastIgnoredToken != TokenNameDOT) - || cd.modifiers != 0){ - currentElement = currentElement.add(cd, 0); - lastIgnoredToken = -1; - } - } -} -/** - * - * 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(); - if (isLocalDeclaration() || ((currentToken != TokenNameCOMMA) && (currentToken != TokenNameSEMICOLON))) - return; - ((SourceFieldDeclaration) astStack[astPtr]).fieldEndPosition = scanner.currentPosition - 1; -} -protected void consumeExitVariableWithoutInitialization() { - // ExitVariableWithoutInitialization ::= $empty - // do nothing by default - if (isLocalDeclaration() || ((currentToken != TokenNameCOMMA) && (currentToken != TokenNameSEMICOLON))) - return; - ((SourceFieldDeclaration) astStack[astPtr]).fieldEndPosition = scanner.currentPosition - 1; -} -/** - * - * INTERNAL USE-ONLY - */ -protected void consumeFieldAccess(boolean isSuperAccess) { - // FieldAccess ::= Primary '.' 'Identifier' - // FieldAccess ::= 'super' '.' 'Identifier' - super.consumeFieldAccess(isSuperAccess); - FieldReference fr = (FieldReference) expressionStack[expressionPtr]; - if (reportReferenceInfo) { - requestor.acceptFieldReference(fr.token, fr.sourceStart); - } -} -protected void consumeMethodHeaderName() { - // MethodHeaderName ::= Modifiersopt Type 'Identifier' '(' - SourceMethodDeclaration md = new SourceMethodDeclaration(this.compilationUnit.compilationResult); - - //name - md.selector = identifierStack[identifierPtr]; - long selectorSourcePositions = identifierPositionStack[identifierPtr--]; - identifierLengthPtr--; - //type - md.returnType = getTypeReference(intStack[intPtr--]); - //modifiers - md.declarationSourceStart = intStack[intPtr--]; - md.modifiers = intStack[intPtr--]; - - //highlight starts at selector start - md.sourceStart = (int) (selectorSourcePositions >>> 32); - md.selectorSourceEnd = (int) selectorSourcePositions; - pushOnAstStack(md); - md.sourceEnd = lParenPos; - md.bodyStart = lParenPos+1; - listLength = 0; // initialize listLength before reading parameters/throws - - // recovery - if (currentElement != null){ - if (currentElement instanceof RecoveredType - //|| md.modifiers != 0 - || (scanner.getLineNumber(md.returnType.sourceStart) - == scanner.getLineNumber(md.sourceStart))){ - lastCheckPoint = md.bodyStart; - currentElement = currentElement.add(md, 0); - lastIgnoredToken = -1; - } else { - lastCheckPoint = md.sourceStart; - restartRecovery = true; - } - } -} -/** - * - * INTERNAL USE-ONLY - */ -protected void consumeMethodInvocationName() { - // MethodInvocation ::= Name '(' ArgumentListopt ')' - - // when the name is only an identifier...we have a message send to "this" (implicit) - super.consumeMethodInvocationName(); - MessageSend messageSend = (MessageSend) expressionStack[expressionPtr]; - Expression[] args = messageSend.arguments; - if (reportReferenceInfo) { - requestor.acceptMethodReference( - messageSend.selector, - args == null ? 0 : args.length, - (int)(messageSend.nameSourcePosition >>> 32)); - } -} -/** - * - * INTERNAL USE-ONLY - */ -protected void consumeMethodInvocationPrimary() { - super.consumeMethodInvocationPrimary(); - MessageSend messageSend = (MessageSend) expressionStack[expressionPtr]; - Expression[] args = messageSend.arguments; - if (reportReferenceInfo) { - requestor.acceptMethodReference( - messageSend.selector, - args == null ? 0 : args.length, - (int)(messageSend.nameSourcePosition >>> 32)); - } -} -/** - * - * INTERNAL USE-ONLY - */ -protected void consumeMethodInvocationSuper() { - // MethodInvocation ::= 'super' '.' 'Identifier' '(' ArgumentListopt ')' - super.consumeMethodInvocationSuper(); - MessageSend messageSend = (MessageSend) expressionStack[expressionPtr]; - Expression[] args = messageSend.arguments; - if (reportReferenceInfo) { - requestor.acceptMethodReference( - messageSend.selector, - args == null ? 0 : args.length, - (int)(messageSend.nameSourcePosition >>> 32)); - } -} -protected void consumeSingleTypeImportDeclarationName() { - // SingleTypeImportDeclarationName ::= 'import' Name - /* push an ImportRef build from the last name - stored in the identifier stack. */ - - super.consumeSingleTypeImportDeclarationName(); - ImportReference impt = (ImportReference)astStack[astPtr]; - if (reportReferenceInfo) { - requestor.acceptTypeReference(impt.tokens, impt.sourceStart, impt.sourceEnd); - } -} -protected void consumeTypeImportOnDemandDeclarationName() { - // TypeImportOnDemandDeclarationName ::= 'import' Name '.' '*' - /* push an ImportRef build from the last name - stored in the identifier stack. */ - - super.consumeTypeImportOnDemandDeclarationName(); - ImportReference impt = (ImportReference)astStack[astPtr]; - if (reportReferenceInfo) { - requestor.acceptUnknownReference(impt.tokens, impt.sourceStart, impt.sourceEnd); - } -} -protected FieldDeclaration createFieldDeclaration(Expression initialization, char[] name, int sourceStart, int sourceEnd) { - return new SourceFieldDeclaration(null, name, sourceStart, sourceEnd); -} -protected CompilationUnitDeclaration endParse(int act) { - if (sourceType != null) { - if (sourceType.isInterface()) { - consumeInterfaceDeclaration(); - } else { - consumeClassDeclaration(); - } - } - if (compilationUnit != null) { - CompilationUnitDeclaration result = super.endParse(act); - return result; - } else { - return null; - } -} +//protected void classInstanceCreation(boolean alwaysQualified) { +// +// boolean previousFlag = reportReferenceInfo; +// reportReferenceInfo = false; // not to see the type reference reported in super call to getTypeReference(...) +// super.classInstanceCreation(alwaysQualified); +// reportReferenceInfo = previousFlag; +// if (reportReferenceInfo){ +// AllocationExpression alloc = (AllocationExpression)expressionStack[expressionPtr]; +// TypeReference typeRef = alloc.type; +// requestor.acceptConstructorReference( +// typeRef instanceof SingleTypeReference +// ? ((SingleTypeReference) typeRef).token +// : CharOperation.concatWith(alloc.type.getTypeName(), '.'), +// alloc.arguments == null ? 0 : alloc.arguments.length, +// alloc.sourceStart); +// } +//} +//protected void consumeConstructorHeaderName() { +// // ConstructorHeaderName ::= Modifiersopt 'Identifier' '(' +// +// /* recovering - might be an empty message send */ +// if (currentElement != null){ +// if (lastIgnoredToken == TokenNamenew){ // was an allocation expression +// lastCheckPoint = scanner.startPosition; // force to restart at this exact position +// restartRecovery = true; +// return; +// } +// } +// SourceConstructorDeclaration cd = new SourceConstructorDeclaration(this.compilationUnit.compilationResult); +// +// //name -- this is not really revelant but we do ..... +// cd.selector = identifierStack[identifierPtr]; +// long selectorSourcePositions = identifierPositionStack[identifierPtr--]; +// identifierLengthPtr--; +// +// //modifiers +// cd.declarationSourceStart = intStack[intPtr--]; +// cd.modifiers = intStack[intPtr--]; +// +// //highlight starts at the selector starts +// cd.sourceStart = (int) (selectorSourcePositions >>> 32); +// cd.selectorSourceEnd = (int) selectorSourcePositions; +// pushOnAstStack(cd); +// +// cd.sourceEnd = lParenPos; +// cd.bodyStart = lParenPos+1; +// listLength = 0; // initialize listLength before reading parameters/throws +// +// // recovery +// if (currentElement != null){ +// lastCheckPoint = cd.bodyStart; +// if ((currentElement instanceof RecoveredType && lastIgnoredToken != TokenNameDOT) +// || cd.modifiers != 0){ +// currentElement = currentElement.add(cd, 0); +// lastIgnoredToken = -1; +// } +// } +//} +///** +// * +// * 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(); +// if (isLocalDeclaration() || ((currentToken != TokenNameCOMMA) && (currentToken != TokenNameSEMICOLON))) +// return; +// ((SourceFieldDeclaration) astStack[astPtr]).fieldEndPosition = scanner.currentPosition - 1; +//} +//protected void consumeExitVariableWithoutInitialization() { +// // ExitVariableWithoutInitialization ::= $empty +// // do nothing by default +// super.consumeExitVariableWithoutInitialization(); +// if (isLocalDeclaration() || ((currentToken != TokenNameCOMMA) && (currentToken != TokenNameSEMICOLON))) +// return; +// ((SourceFieldDeclaration) astStack[astPtr]).fieldEndPosition = scanner.currentPosition - 1; +//} +///** +// * +// * INTERNAL USE-ONLY +// */ +//protected void consumeFieldAccess(boolean isSuperAccess) { +// // FieldAccess ::= Primary '.' 'Identifier' +// // FieldAccess ::= 'super' '.' 'Identifier' +// super.consumeFieldAccess(isSuperAccess); +// FieldReference fr = (FieldReference) expressionStack[expressionPtr]; +// if (reportReferenceInfo) { +// requestor.acceptFieldReference(fr.token, fr.sourceStart); +// } +//} +//protected void consumeMethodHeaderName() { +// // MethodHeaderName ::= Modifiersopt Type 'Identifier' '(' +// SourceMethodDeclaration md = new SourceMethodDeclaration(this.compilationUnit.compilationResult); +// +// //name +// md.selector = identifierStack[identifierPtr]; +// long selectorSourcePositions = identifierPositionStack[identifierPtr--]; +// identifierLengthPtr--; +// //type +// md.returnType = getTypeReference(intStack[intPtr--]); +// //modifiers +// md.declarationSourceStart = intStack[intPtr--]; +// md.modifiers = intStack[intPtr--]; +// +// //highlight starts at selector start +// md.sourceStart = (int) (selectorSourcePositions >>> 32); +// md.selectorSourceEnd = (int) selectorSourcePositions; +// pushOnAstStack(md); +// md.sourceEnd = lParenPos; +// md.bodyStart = lParenPos+1; +// listLength = 0; // initialize listLength before reading parameters/throws +// +// // recovery +// if (currentElement != null){ +// if (currentElement instanceof RecoveredType +// //|| md.modifiers != 0 +// || (scanner.getLineNumber(md.returnType.sourceStart) +// == scanner.getLineNumber(md.sourceStart))){ +// lastCheckPoint = md.bodyStart; +// currentElement = currentElement.add(md, 0); +// lastIgnoredToken = -1; +// } else { +// lastCheckPoint = md.sourceStart; +// restartRecovery = true; +// } +// } +//} +///** +// * +// * INTERNAL USE-ONLY +// */ +//protected void consumeMethodInvocationName() { +// // MethodInvocation ::= Name '(' ArgumentListopt ')' +// +// // when the name is only an identifier...we have a message send to "this" (implicit) +// super.consumeMethodInvocationName(); +// MessageSend messageSend = (MessageSend) expressionStack[expressionPtr]; +// Expression[] args = messageSend.arguments; +// if (reportReferenceInfo) { +// requestor.acceptMethodReference( +// messageSend.selector, +// args == null ? 0 : args.length, +// (int)(messageSend.nameSourcePosition >>> 32)); +// } +//} +///** +// * +// * INTERNAL USE-ONLY +// */ +//protected void consumeMethodInvocationPrimary() { +// super.consumeMethodInvocationPrimary(); +// MessageSend messageSend = (MessageSend) expressionStack[expressionPtr]; +// Expression[] args = messageSend.arguments; +// if (reportReferenceInfo) { +// requestor.acceptMethodReference( +// messageSend.selector, +// args == null ? 0 : args.length, +// (int)(messageSend.nameSourcePosition >>> 32)); +// } +//} +///** +// * +// * INTERNAL USE-ONLY +// */ +//protected void consumeMethodInvocationSuper() { +// // MethodInvocation ::= 'super' '.' 'Identifier' '(' ArgumentListopt ')' +// super.consumeMethodInvocationSuper(); +// MessageSend messageSend = (MessageSend) expressionStack[expressionPtr]; +// Expression[] args = messageSend.arguments; +// if (reportReferenceInfo) { +// requestor.acceptMethodReference( +// messageSend.selector, +// args == null ? 0 : args.length, +// (int)(messageSend.nameSourcePosition >>> 32)); +// } +//} +//protected void consumeSingleTypeImportDeclarationName() { +// // SingleTypeImportDeclarationName ::= 'import' Name +// /* push an ImportRef build from the last name +// stored in the identifier stack. */ +// +// super.consumeSingleTypeImportDeclarationName(); +// ImportReference impt = (ImportReference)astStack[astPtr]; +// if (reportReferenceInfo) { +// requestor.acceptTypeReference(impt.tokens, impt.sourceStart, impt.sourceEnd); +// } +//} +//protected void consumeTypeImportOnDemandDeclarationName() { +// // TypeImportOnDemandDeclarationName ::= 'import' Name '.' '*' +// /* push an ImportRef build from the last name +// stored in the identifier stack. */ +// +// super.consumeTypeImportOnDemandDeclarationName(); +// ImportReference impt = (ImportReference)astStack[astPtr]; +// if (reportReferenceInfo) { +// requestor.acceptUnknownReference(impt.tokens, impt.sourceStart, impt.sourceEnd); +// } +//} +//protected FieldDeclaration createFieldDeclaration(Expression initialization, char[] name, int sourceStart, int sourceEnd) { +// return new SourceFieldDeclaration(null, name, sourceStart, sourceEnd); +//} +//protected CompilationUnitDeclaration endParse(int act) { +// if (sourceType != null) { +// if (sourceType.isInterface()) { +// consumeInterfaceDeclaration(); +// } else { +// consumeClassDeclaration(); +// } +// } +// if (compilationUnit != null) { +// CompilationUnitDeclaration result = super.endParse(act); +// return result; +// } else { +// return null; +// } +//} /* * Flush annotations defined prior to a given positions. * @@ -394,171 +384,171 @@ protected CompilationUnitDeclaration endParse(int act) { * void foo(){ * } // end of method foo */ - -public int flushAnnotationsDefinedPriorTo(int position) { - - return lastFieldEndPosition = super.flushAnnotationsDefinedPriorTo(position); -} -public 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; - if ((length = identifierLengthStack[identifierLengthPtr--]) == 1) { - // single variable reference - if (dim == 0) { - SingleTypeReference ref = - new SingleTypeReference( - identifierStack[identifierPtr], - identifierPositionStack[identifierPtr--]); - if (reportReferenceInfo) { - requestor.acceptTypeReference(ref.token, ref.sourceStart); - } - return ref; - } else { - ArrayTypeReference ref = - new ArrayTypeReference( - identifierStack[identifierPtr], - dim, - identifierPositionStack[identifierPtr--]); - ref.sourceEnd = endPosition; - if (reportReferenceInfo) { - requestor.acceptTypeReference(ref.token, ref.sourceStart); - } - return ref; - } - } else { - if (length < 0) { //flag for precompiled type reference on base types - TypeReference ref = TypeReference.baseTypeReference(-length, dim); - ref.sourceStart = intStack[intPtr--]; - if (dim == 0) { - ref.sourceEnd = intStack[intPtr--]; - } else { - intPtr--; // no need to use this position as it is an array - ref.sourceEnd = endPosition; - } - if (reportReferenceInfo){ - requestor.acceptTypeReference(ref.getTypeName(), ref.sourceStart, ref.sourceEnd); - } - return ref; - } 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) { - QualifiedTypeReference ref = new QualifiedTypeReference(tokens, positions); - if (reportReferenceInfo) { - requestor.acceptTypeReference(ref.tokens, ref.sourceStart, ref.sourceEnd); - } - return ref; - } else { - ArrayQualifiedTypeReference ref = - new ArrayQualifiedTypeReference(tokens, dim, positions); - ref.sourceEnd = endPosition; - if (reportReferenceInfo) { - requestor.acceptTypeReference(ref.tokens, ref.sourceStart, ref.sourceEnd); - } - return ref; - } - } - } -} -public NameReference getUnspecifiedReference() { - /* build a (unspecified) NameReference which may be qualified*/ - - int length; - if ((length = identifierLengthStack[identifierLengthPtr--]) == 1) { - // single variable reference - SingleNameReference ref = - new SingleNameReference( - identifierStack[identifierPtr], - identifierPositionStack[identifierPtr--]); - if (reportReferenceInfo) { - this.addUnknownRef(ref); - } - return ref; - } else { - //Qualified variable reference - char[][] tokens = new char[length][]; - identifierPtr -= length; - System.arraycopy(identifierStack, identifierPtr + 1, tokens, 0, length); - QualifiedNameReference ref = - new QualifiedNameReference( - tokens, - (int) (identifierPositionStack[identifierPtr + 1] >> 32), // sourceStart - (int) identifierPositionStack[identifierPtr + length]); // sourceEnd - if (reportReferenceInfo) { - this.addUnknownRef(ref); - } - return ref; - } -} -public NameReference getUnspecifiedReferenceOptimized() { - /* build a (unspecified) NameReference which may be qualified - The optimization occurs for qualified reference while we are - certain in this case the last item of the qualified name is - a field access. This optimization is IMPORTANT while it results - that when a NameReference is build, the type checker should always - look for that it is not a type reference */ - - int length; - if ((length = identifierLengthStack[identifierLengthPtr--]) == 1) { - // single variable reference - SingleNameReference ref = - new SingleNameReference( - identifierStack[identifierPtr], - identifierPositionStack[identifierPtr--]); - ref.bits &= ~AstNode.RestrictiveFlagMASK; - ref.bits |= LOCAL | FIELD; - if (reportReferenceInfo) { - this.addUnknownRef(ref); - } - return ref; - } - - //Qualified-variable-reference - //In fact it is variable-reference DOT field-ref , but it would result in a type - //conflict tha can be only reduce by making a superclass (or inetrface ) between - //nameReference and FiledReference or putting FieldReference under NameReference - //or else..........This optimisation is not really relevant so just leave as it is - - char[][] tokens = new char[length][]; - identifierPtr -= length; - System.arraycopy(identifierStack, identifierPtr + 1, tokens, 0, length); - QualifiedNameReference ref = - new QualifiedNameReference( - tokens, - (int) (identifierPositionStack[identifierPtr + 1] >> 32), - // sourceStart - (int) identifierPositionStack[identifierPtr + length]); // sourceEnd - ref.bits &= ~AstNode.RestrictiveFlagMASK; - ref.bits |= LOCAL | FIELD; - if (reportReferenceInfo) { - this.addUnknownRef(ref); - } - return ref; -} -/** - * - * INTERNAL USE-ONLY - */ -private boolean isLocalDeclaration() { - int nestedDepth = nestedType; - while (nestedDepth >= 0) { - if (nestedMethod[nestedDepth] != 0) { - return true; - } - nestedDepth--; - } - return false; -} +// +//public int flushAnnotationsDefinedPriorTo(int position) { +// +// return lastFieldEndPosition = super.flushAnnotationsDefinedPriorTo(position); +//} +//public 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; +// if ((length = identifierLengthStack[identifierLengthPtr--]) == 1) { +// // single variable reference +// if (dim == 0) { +// SingleTypeReference ref = +// new SingleTypeReference( +// identifierStack[identifierPtr], +// identifierPositionStack[identifierPtr--]); +// if (reportReferenceInfo) { +// requestor.acceptTypeReference(ref.token, ref.sourceStart); +// } +// return ref; +// } else { +// ArrayTypeReference ref = +// new ArrayTypeReference( +// identifierStack[identifierPtr], +// dim, +// identifierPositionStack[identifierPtr--]); +// ref.sourceEnd = endPosition; +// if (reportReferenceInfo) { +// requestor.acceptTypeReference(ref.token, ref.sourceStart); +// } +// return ref; +// } +// } else { +// if (length < 0) { //flag for precompiled type reference on base types +// TypeReference ref = TypeReference.baseTypeReference(-length, dim); +// ref.sourceStart = intStack[intPtr--]; +// if (dim == 0) { +// ref.sourceEnd = intStack[intPtr--]; +// } else { +// intPtr--; // no need to use this position as it is an array +// ref.sourceEnd = endPosition; +// } +// if (reportReferenceInfo){ +// requestor.acceptTypeReference(ref.getTypeName(), ref.sourceStart, ref.sourceEnd); +// } +// return ref; +// } 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) { +// QualifiedTypeReference ref = new QualifiedTypeReference(tokens, positions); +// if (reportReferenceInfo) { +// requestor.acceptTypeReference(ref.tokens, ref.sourceStart, ref.sourceEnd); +// } +// return ref; +// } else { +// ArrayQualifiedTypeReference ref = +// new ArrayQualifiedTypeReference(tokens, dim, positions); +// ref.sourceEnd = endPosition; +// if (reportReferenceInfo) { +// requestor.acceptTypeReference(ref.tokens, ref.sourceStart, ref.sourceEnd); +// } +// return ref; +// } +// } +// } +//} +//public NameReference getUnspecifiedReference() { +// /* build a (unspecified) NameReference which may be qualified*/ +// +// int length; +// if ((length = identifierLengthStack[identifierLengthPtr--]) == 1) { +// // single variable reference +// SingleNameReference ref = +// new SingleNameReference( +// identifierStack[identifierPtr], +// identifierPositionStack[identifierPtr--]); +// if (reportReferenceInfo) { +// this.addUnknownRef(ref); +// } +// return ref; +// } else { +// //Qualified variable reference +// char[][] tokens = new char[length][]; +// identifierPtr -= length; +// System.arraycopy(identifierStack, identifierPtr + 1, tokens, 0, length); +// QualifiedNameReference ref = +// new QualifiedNameReference( +// tokens, +// (int) (identifierPositionStack[identifierPtr + 1] >> 32), // sourceStart +// (int) identifierPositionStack[identifierPtr + length]); // sourceEnd +// if (reportReferenceInfo) { +// this.addUnknownRef(ref); +// } +// return ref; +// } +//} +//public NameReference getUnspecifiedReferenceOptimized() { +// /* build a (unspecified) NameReference which may be qualified +// The optimization occurs for qualified reference while we are +// certain in this case the last item of the qualified name is +// a field access. This optimization is IMPORTANT while it results +// that when a NameReference is build, the type checker should always +// look for that it is not a type reference */ +// +// int length; +// if ((length = identifierLengthStack[identifierLengthPtr--]) == 1) { +// // single variable reference +// SingleNameReference ref = +// new SingleNameReference( +// identifierStack[identifierPtr], +// identifierPositionStack[identifierPtr--]); +// ref.bits &= ~AstNode.RestrictiveFlagMASK; +// ref.bits |= LOCAL | FIELD; +// if (reportReferenceInfo) { +// this.addUnknownRef(ref); +// } +// return ref; +// } +// +// //Qualified-variable-reference +// //In fact it is variable-reference DOT field-ref , but it would result in a type +// //conflict tha can be only reduce by making a superclass (or inetrface ) between +// //nameReference and FiledReference or putting FieldReference under NameReference +// //or else..........This optimisation is not really relevant so just leave as it is +// +// char[][] tokens = new char[length][]; +// identifierPtr -= length; +// System.arraycopy(identifierStack, identifierPtr + 1, tokens, 0, length); +// QualifiedNameReference ref = +// new QualifiedNameReference( +// tokens, +// (int) (identifierPositionStack[identifierPtr + 1] >> 32), +// // sourceStart +// (int) identifierPositionStack[identifierPtr + length]); // sourceEnd +// ref.bits &= ~AstNode.RestrictiveFlagMASK; +// ref.bits |= LOCAL | FIELD; +// if (reportReferenceInfo) { +// this.addUnknownRef(ref); +// } +// return ref; +//} +///** +// * +// * INTERNAL USE-ONLY +// */ +//private boolean isLocalDeclaration() { +// int nestedDepth = nestedType; +// while (nestedDepth >= 0) { +// if (nestedMethod[nestedDepth] != 0) { +// return true; +// } +// nestedDepth--; +// } +// return false; +//} /* * Update the bodyStart of the corresponding parse node */ @@ -577,9 +567,9 @@ public void notifySourceElementRequestor(CompilationUnitDeclaration parsedUnit) scanner.initialPosition <= parsedUnit.sourceStart && scanner.eofPosition >= parsedUnit.sourceEnd; - if (reportReferenceInfo) { - notifyAllUnknownReferences(); - } +// if (reportReferenceInfo) { +// notifyAllUnknownReferences(); +// } // collect the top level ast nodes int length = 0; AstNode[] nodes = null; @@ -587,35 +577,40 @@ public void notifySourceElementRequestor(CompilationUnitDeclaration parsedUnit) if (isInRange) { requestor.enterCompilationUnit(); } - ImportReference currentPackage = parsedUnit.currentPackage; - ImportReference[] imports = parsedUnit.imports; - TypeDeclaration[] types = parsedUnit.types; - length = - (currentPackage == null ? 0 : 1) - + (imports == null ? 0 : imports.length) - + (types == null ? 0 : types.length); +// ImportReference currentPackage = parsedUnit.currentPackage; +// ImportReference[] imports = parsedUnit.imports; +// TypeDeclaration[] types = parsedUnit.types; + ArrayList types = parsedUnit.types; + if (types != null) { +// length = +// (currentPackage == null ? 0 : 1) +// + (imports == null ? 0 : imports.length) +// + (types == null ? 0 : types.length); +// nodes = new AstNode[length]; + length = types.size(); nodes = new AstNode[length]; int index = 0; - if (currentPackage != null) { - nodes[index++] = currentPackage; - } - if (imports != null) { - for (int i = 0, max = imports.length; i < max; i++) { - nodes[index++] = imports[i]; - } - } - if (types != null) { - for (int i = 0, max = types.length; i < max; i++) { - nodes[index++] = types[i]; +// if (currentPackage != null) { +// nodes[index++] = currentPackage; +// } +// if (imports != null) { +// for (int i = 0, max = imports.length; i < max; i++) { +// nodes[index++] = imports[i]; +// } +// } + + for (int i = 0, max = types.size(); i < max; i++) { + nodes[index++] = (AstNode)types.get(i); } } } else { - TypeDeclaration[] types = parsedUnit.types; +// TypeDeclaration[] types = parsedUnit.types; + ArrayList types = parsedUnit.types; if (types != null) { - length = types.length; + length = types.size(); nodes = new AstNode[length]; - for (int i = 0, max = types.length; i < max; i++) { - nodes[i] = types[i]; + for (int i = 0, max = types.size(); i < max; i++) { + nodes[i] = (AstNode)types.get(i); } } } @@ -625,16 +620,23 @@ public void notifySourceElementRequestor(CompilationUnitDeclaration parsedUnit) quickSort(nodes, 0, length-1); for (int i=0;i= fieldDeclaration.declarationSourceEnd; - - if (fieldDeclaration.isField()) { - int fieldEndPosition = fieldDeclaration.declarationSourceEnd; - if (fieldDeclaration instanceof SourceFieldDeclaration) { - fieldEndPosition = ((SourceFieldDeclaration) fieldDeclaration).fieldEndPosition; - if (fieldEndPosition == 0) { - // use the declaration source end by default - fieldEndPosition = fieldDeclaration.declarationSourceEnd; - } - } - if (isInRange) { - requestor.enterField( - fieldDeclaration.declarationSourceStart, - fieldDeclaration.modifiers & AccJustFlag, - returnTypeName(fieldDeclaration.type), - fieldDeclaration.name, - fieldDeclaration.sourceStart, - fieldDeclaration.sourceEnd); - } - this.visitIfNeeded(fieldDeclaration); - if (isInRange){ - requestor.exitField(fieldEndPosition); - } - - } else { - if (isInRange){ - requestor.enterInitializer( - fieldDeclaration.declarationSourceStart, - fieldDeclaration.modifiers); - } - this.visitIfNeeded((Initializer)fieldDeclaration); - if (isInRange){ - requestor.exitInitializer(fieldDeclaration.declarationSourceEnd); - } - } -} -public void notifySourceElementRequestor( - ImportReference importReference, - boolean isPackage) { - if (isPackage) { - requestor.acceptPackage( - importReference.declarationSourceStart, - importReference.declarationSourceEnd, - CharOperation.concatWith(importReference.getImportName(), '.')); - } else { - requestor.acceptImport( - importReference.declarationSourceStart, - importReference.declarationSourceEnd, - CharOperation.concatWith(importReference.getImportName(), '.'), - importReference.onDemand); - } -} +///* +//* Update the bodyStart of the corresponding parse node +//*/ +//public void notifySourceElementRequestor(FieldDeclaration fieldDeclaration) { +// +// // range check +// boolean isInRange = +// scanner.initialPosition <= fieldDeclaration.declarationSourceStart +// && scanner.eofPosition >= fieldDeclaration.declarationSourceEnd; +// +// if (fieldDeclaration.isField()) { +// int fieldEndPosition = fieldDeclaration.declarationSourceEnd; +// if (fieldDeclaration instanceof SourceFieldDeclaration) { +// fieldEndPosition = ((SourceFieldDeclaration) fieldDeclaration).fieldEndPosition; +// if (fieldEndPosition == 0) { +// // use the declaration source end by default +// fieldEndPosition = fieldDeclaration.declarationSourceEnd; +// } +// } +// if (isInRange) { +// int modifiers = fieldDeclaration.modifiers; +// boolean deprecated = (modifiers & AccDeprecated) != 0; // remember deprecation so as to not lose it below +// requestor.enterField( +// fieldDeclaration.declarationSourceStart, +// deprecated ? (modifiers & AccJustFlag) | AccDeprecated : modifiers & AccJustFlag, +// returnTypeName(fieldDeclaration.type), +// fieldDeclaration.name, +// fieldDeclaration.sourceStart, +// fieldDeclaration.sourceEnd); +// } +// this.visitIfNeeded(fieldDeclaration); +// if (isInRange){ +// requestor.exitField( +// // filter out initializations that are not a constant (simple check) +// (fieldDeclaration.initialization == null +// || fieldDeclaration.initialization instanceof ArrayInitializer +// || fieldDeclaration.initialization instanceof AllocationExpression +// || fieldDeclaration.initialization instanceof ArrayAllocationExpression +// || fieldDeclaration.initialization instanceof Assignment +// || fieldDeclaration.initialization instanceof ClassLiteralAccess +// || fieldDeclaration.initialization instanceof MessageSend +// || fieldDeclaration.initialization instanceof ArrayReference +// || fieldDeclaration.initialization instanceof ThisReference) ? +// -1 : +// fieldDeclaration.initialization.sourceStart, +// fieldEndPosition, +// fieldDeclaration.declarationSourceEnd); +// } +// +// } else { +// if (isInRange){ +// requestor.enterInitializer( +// fieldDeclaration.declarationSourceStart, +// fieldDeclaration.modifiers); +// } +// this.visitIfNeeded((Initializer)fieldDeclaration); +// if (isInRange){ +// requestor.exitInitializer(fieldDeclaration.declarationSourceEnd); +// } +// } +//} +//public void notifySourceElementRequestor( +// ImportReference importReference, +// boolean isPackage) { +// if (isPackage) { +// requestor.acceptPackage( +// importReference.declarationSourceStart, +// importReference.declarationSourceEnd, +// CharOperation.concatWith(importReference.getImportName(), '.')); +// } else { +// requestor.acceptImport( +// importReference.declarationSourceStart, +// importReference.declarationSourceEnd, +// CharOperation.concatWith(importReference.getImportName(), '.'), +// importReference.onDemand); +// } +//} public void notifySourceElementRequestor(TypeDeclaration typeDeclaration, boolean notifyTypePresence) { +//// public void notifySourceElementRequestor(AstNode typeDeclaration, boolean notifyTypePresence) { // range check boolean isInRange = @@ -916,9 +937,11 @@ public void notifySourceElementRequestor(TypeDeclaration typeDeclaration, boolea } if (isInterface) { if (isInRange){ + int modifiers = typeDeclaration.modifiers; + boolean deprecated = false; //(modifiers & AccDeprecated) != 0; // remember deprecation so as to not lose it below requestor.enterInterface( typeDeclaration.declarationSourceStart, - typeDeclaration.modifiers & AccJustFlag, + modifiers, //deprecated ? (modifiers & AccJustFlag) | AccDeprecated : modifiers & AccJustFlag, typeDeclaration.name, typeDeclaration.sourceStart, typeDeclaration.sourceEnd, @@ -998,7 +1021,7 @@ public void notifySourceElementRequestor(TypeDeclaration typeDeclaration, boolea switch (nextDeclarationType) { case 0 : fieldIndex++; - notifySourceElementRequestor(nextFieldDeclaration); +// notifySourceElementRequestor(nextFieldDeclaration); break; case 1 : methodIndex++; @@ -1020,156 +1043,161 @@ public void notifySourceElementRequestor(TypeDeclaration typeDeclaration, boolea nestedTypeIndex--; } } -public void parseCompilationUnit( +public void parseCompilationUnit ( ICompilationUnit unit, int start, - int end, - boolean needReferenceInfo) { + int end ) { +// boolean needReferenceInfo) { - reportReferenceInfo = needReferenceInfo; - boolean old = diet; - if (needReferenceInfo) { - unknownRefs = new NameReference[10]; - unknownRefsCounter = 0; - } +// reportReferenceInfo = needReferenceInfo; +// boolean old = diet; +// if (needReferenceInfo) { +// unknownRefs = new NameReference[10]; +// unknownRefsCounter = 0; +// } + try { - diet = true; - CompilationResult compilationUnitResult = new CompilationResult(unit, 0, 0, this.options.maxProblemsPerUnit); +// diet = true; + CompilationResult compilationUnitResult = new CompilationResult(unit, 0, 0, 10); //this.options.maxProblemsPerUnit); CompilationUnitDeclaration parsedUnit = parse(unit, compilationUnitResult, start, end); - if (needReferenceInfo){ - diet = false; - this.getMethodBodies(parsedUnit); - } - this.scanner.resetTo(start, end); - notifySourceElementRequestor(parsedUnit); - } catch (AbortCompilation e) { - } finally { - if (scanner.recordLineSeparator) { - requestor.acceptLineSeparatorPositions(scanner.getLineEnds()); - } - diet = old; - } -} -public void parseCompilationUnit( - ICompilationUnit unit, - boolean needReferenceInfo) { - boolean old = diet; - if (needReferenceInfo) { - unknownRefs = new NameReference[10]; - unknownRefsCounter = 0; - } - - try { -/* diet = !needReferenceInfo; - reportReferenceInfo = needReferenceInfo; - CompilationResult compilationUnitResult = new CompilationResult(unit, 0, 0); - parse(unit, compilationUnitResult); -*/ diet = true; - reportReferenceInfo = needReferenceInfo; - CompilationResult compilationUnitResult = new CompilationResult(unit, 0, 0, this.options.maxProblemsPerUnit); - CompilationUnitDeclaration parsedUnit = parse(unit, compilationUnitResult); - int initialStart = this.scanner.initialPosition; - int initialEnd = this.scanner.eofPosition; - if (needReferenceInfo){ - diet = false; - this.getMethodBodies(parsedUnit); - } - this.scanner.resetTo(initialStart, initialEnd); - notifySourceElementRequestor(parsedUnit); +// if (scanner.recordLineSeparator) { +// requestor.acceptLineSeparatorPositions(scanner.getLineEnds()); +// } +// if (this.localDeclarationVisitor != null || needReferenceInfo){ +// diet = false; +// this.getMethodBodies(parsedUnit); +// } +// this.scanner.resetTo(start, end); +// notifySourceElementRequestor(parsedUnit); } catch (AbortCompilation e) { } finally { - if (scanner.recordLineSeparator) { - requestor.acceptLineSeparatorPositions(scanner.getLineEnds()); - } - diet = old; +// diet = old; } } -public void parseTypeMemberDeclarations( - ISourceType sourceType, - ICompilationUnit sourceUnit, - int start, - int end, - boolean needReferenceInfo) { - boolean old = diet; - if (needReferenceInfo) { - unknownRefs = new NameReference[10]; - unknownRefsCounter = 0; - } - - try { - diet = !needReferenceInfo; - reportReferenceInfo = needReferenceInfo; - CompilationResult compilationUnitResult = - new CompilationResult(sourceUnit, 0, 0, this.options.maxProblemsPerUnit); - CompilationUnitDeclaration unit = - SourceTypeConverter.buildCompilationUnit( - new ISourceType[]{sourceType}, - false, - false, - problemReporter(), - compilationUnitResult); - if ((unit == null) || (unit.types == null) || (unit.types.length != 1)) - return; - this.sourceType = sourceType; +public CompilationUnitDeclaration parseCompilationUnit( + ICompilationUnit unit, + boolean fullParse) { + +// boolean old = diet; +// if (fullParse) { +// unknownRefs = new NameReference[10]; +// unknownRefsCounter = 0; +// } + try { - /* automaton initialization */ - initialize(); - goForClassBodyDeclarations(); - /* scanner initialization */ - scanner.setSource(sourceUnit.getContents()); - scanner.resetTo(start, end); - /* unit creation */ - referenceContext = compilationUnit = unit; - /* initialize the astStacl */ - // the compilationUnitDeclaration should contain exactly one type - pushOnAstStack(unit.types[0]); - /* run automaton */ - parse(); - notifySourceElementRequestor(unit); +// diet = true; + this.reportReferenceInfo = fullParse; + CompilationResult compilationUnitResult = new CompilationResult(unit, 0, 0, this.options.maxProblemsPerUnit); + CompilationUnitDeclaration parsedUnit = parse(unit, compilationUnitResult, false); + if (scanner.recordLineSeparator) { + requestor.acceptLineSeparatorPositions(scanner.getLineEnds()); + } + int initialStart = this.scanner.initialPosition; + int initialEnd = this.scanner.eofPosition; +// if (this.localDeclarationVisitor != null || fullParse){ +// diet = false; +// this.getMethodBodies(parsedUnit); +// } + this.scanner.resetTo(initialStart, initialEnd); + notifySourceElementRequestor(parsedUnit); + return parsedUnit; + } catch (AbortCompilation e) { + // ignore this exception } finally { - unit = compilationUnit; - compilationUnit = null; // reset parser +// diet = old; } - } catch (AbortCompilation e) { - } finally { - if (scanner.recordLineSeparator) { - requestor.acceptLineSeparatorPositions(scanner.getLineEnds()); - } - diet = old; + return null; } -} - -public void parseTypeMemberDeclarations( - char[] contents, - int start, - int end) { - boolean old = diet; - - try { - diet = true; - - /* automaton initialization */ - initialize(); - goForClassBodyDeclarations(); - /* scanner initialization */ - scanner.setSource(contents); - scanner.recordLineSeparator = false; - scanner.resetTo(start, end); - - /* unit creation */ - referenceContext = null; - - /* initialize the astStacl */ - // the compilationUnitDeclaration should contain exactly one type - /* run automaton */ - parse(); - notifySourceElementRequestor((CompilationUnitDeclaration)null); - } catch (AbortCompilation e) { - } finally { - diet = old; - } -} +//public void parseTypeMemberDeclarations( +// ISourceType sourceType, +// ICompilationUnit sourceUnit, +// int start, +// int end, +// boolean needReferenceInfo) { +// boolean old = diet; +// if (needReferenceInfo) { +// unknownRefs = new NameReference[10]; +// unknownRefsCounter = 0; +// } +// +// try { +// diet = !needReferenceInfo; +// reportReferenceInfo = needReferenceInfo; +// CompilationResult compilationUnitResult = +// new CompilationResult(sourceUnit, 0, 0, this.options.maxProblemsPerUnit); +// CompilationUnitDeclaration unit = +// SourceTypeConverter.buildCompilationUnit( +// new ISourceType[]{sourceType}, +// false, // no need for field and methods +// false, // no need for member types +// false, // no need for field initialization +// problemReporter(), +// compilationUnitResult); +// if ((unit == null) || (unit.types == null) || (unit.types.length != 1)) +// return; +// this.sourceType = sourceType; +// try { +// /* automaton initialization */ +// initialize(); +// goForClassBodyDeclarations(); +// /* scanner initialization */ +// scanner.setSource(sourceUnit.getContents()); +// scanner.resetTo(start, end); +// /* unit creation */ +// referenceContext = compilationUnit = unit; +// /* initialize the astStacl */ +// // the compilationUnitDeclaration should contain exactly one type +// pushOnAstStack(unit.types[0]); +// /* run automaton */ +// parse(); +// notifySourceElementRequestor(unit); +// } finally { +// unit = compilationUnit; +// compilationUnit = null; // reset parser +// } +// } catch (AbortCompilation e) { +// } finally { +// if (scanner.recordLineSeparator) { +// requestor.acceptLineSeparatorPositions(scanner.getLineEnds()); +// } +// diet = old; +// } +//} +// +//public void parseTypeMemberDeclarations( +// char[] contents, +// int start, +// int end) { +// +// boolean old = diet; +// +// try { +// diet = true; +// +// /* automaton initialization */ +// initialize(); +// goForClassBodyDeclarations(); +// /* scanner initialization */ +// scanner.setSource(contents); +// scanner.recordLineSeparator = false; +// scanner.taskTags = null; +// scanner.taskPriorities = null; +// scanner.resetTo(start, end); +// +// /* unit creation */ +// referenceContext = null; +// +// /* initialize the astStacl */ +// // the compilationUnitDeclaration should contain exactly one type +// /* run automaton */ +// parse(); +// notifySourceElementRequestor((CompilationUnitDeclaration)null); +// } catch (AbortCompilation e) { +// } finally { +// diet = old; +// } +//} /** * Sort the given ast nodes by their positions. */ @@ -1235,63 +1263,6 @@ public void addUnknownRef(NameReference nameRef) { } this.unknownRefs[this.unknownRefsCounter++] = nameRef; } -private 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); - ref.sourceEnd = endPosition; - } - } - }; - return ref; -} private void visitIfNeeded(AbstractMethodDeclaration method) { if (this.localDeclarationVisitor != null @@ -1304,27 +1275,27 @@ private void visitIfNeeded(AbstractMethodDeclaration method) { } } -private void visitIfNeeded(FieldDeclaration field) { - if (this.localDeclarationVisitor != null - && (field.bits & AstNode.HasLocalTypeMASK) != 0) { - if (field.initialization != null) { - field.initialization.traverse(this.localDeclarationVisitor, null); - } - } -} - -private void visitIfNeeded(Initializer initializer) { - if (this.localDeclarationVisitor != null - && (initializer.bits & AstNode.HasLocalTypeMASK) != 0) { - if (initializer.block != null) { - initializer.block.traverse(this.localDeclarationVisitor, null); - } - } -} - -protected void reportSyntaxError(int act, int currentKind, int stateStackTop) { - if (compilationUnit == null) return; - super.reportSyntaxError(act, currentKind,stateStackTop); -} +//private void visitIfNeeded(FieldDeclaration field) { +// if (this.localDeclarationVisitor != null +// && (field.bits & AstNode.HasLocalTypeMASK) != 0) { +// if (field.initialization != null) { +// field.initialization.traverse(this.localDeclarationVisitor, null); +// } +// } +//} +// +//private void visitIfNeeded(Initializer initializer) { +// if (this.localDeclarationVisitor != null +// && (initializer.bits & AstNode.HasLocalTypeMASK) != 0) { +// if (initializer.block != null) { +// initializer.block.traverse(this.localDeclarationVisitor, null); +// } +// } +//} +// +//protected void reportSyntaxError(int act, int currentKind, int stateStackTop) { +// if (compilationUnit == null) return; +// super.reportSyntaxError(act, currentKind,stateStackTop); +//} }