package org.eclipse.jdt.internal.core.jdom; | |
/* | |
* (c) Copyright IBM Corp. 2000, 2001. | |
* All Rights Reserved. | |
*/ | |
import org.eclipse.jdt.internal.compiler.*; | |
import org.eclipse.jdt.internal.compiler.env.ICompilationUnit; | |
import org.eclipse.jdt.internal.compiler.impl.CompilerOptions; | |
import org.eclipse.jdt.internal.compiler.problem.DefaultProblemFactory; | |
import org.eclipse.jdt.core.JavaCore; | |
import org.eclipse.jdt.core.compiler.IProblem; | |
import org.eclipse.jdt.core.jdom.*; | |
import org.eclipse.jdt.internal.core.util.*; | |
import java.lang.reflect.Modifier; | |
import java.util.ArrayList; | |
import java.util.Enumeration; | |
import java.util.Stack; | |
/** | |
* The DOMBuilder constructs each type of JDOM document fragment, | |
* for the DOMFactory. The DOMBuilder has been separated from the | |
* DOMFactory to hide the implmentation of node creation and the | |
* public Requestor API methods. | |
* | |
*/ | |
public class DOMBuilder extends AbstractDOMBuilder implements IDocumentElementRequestor { | |
/** | |
* True when parsing a single member - ignore any problems | |
* encountered after the member. | |
*/ | |
protected boolean fBuildingSingleMember= false; | |
/** | |
* True when the single member being built has been | |
* exited. | |
*/ | |
protected boolean fFinishedSingleMember = false; | |
/** | |
* Collection of multiple fields in one declaration | |
*/ | |
protected ArrayList fFields; | |
/** | |
* Creates a new DOMBuilder | |
*/ | |
public DOMBuilder() {} | |
/** | |
* @see IDocumentElementRequestor#acceptImport(int declarationStart, int declarationEnd, int[] javaDocPositions, char[] name, int nameStartPosition, boolean onDemand) | |
*/ | |
public void acceptImport(int declarationStart, int declarationEnd, int[] javaDocPositions, char[] name, | |
int nameStart, boolean onDemand) { | |
int[] sourceRange = {declarationStart, declarationEnd}; | |
int[] nameRange = {nameStart, declarationEnd - 1}; | |
/* See 1FVII1P */ | |
String importName = CharArrayOps.substring(fDocument, nameRange[0], nameRange[1] + 1 - nameRange[0]); | |
fNode= new DOMImport(fDocument, sourceRange, importName, nameRange, onDemand); | |
addChild(fNode); | |
if (fBuildingSingleMember) { | |
fFinishedSingleMember= true; | |
} | |
} | |
/** | |
* @see IDocumentElementRequestor#acceptInitializer(int declarationStart, int declarationEnd, int[] javaDocPositions, int modifiers, int modifiersStart, int bodyStart, int bodyEnd) | |
*/ | |
public void acceptInitializer(int declarationStart, int declarationEnd, int[] javaDocPositions, int modifiers, | |
int modifiersStart, int bodyStart, int bodyEnd) { | |
int[] sourceRange = {declarationStart, declarationEnd}; | |
int[] commentRange = {-1, -1}; | |
if (javaDocPositions != null) { | |
int length = javaDocPositions.length; | |
commentRange[0] = javaDocPositions[length - 2]; | |
commentRange[1] = javaDocPositions[length - 1]; | |
} | |
int[] modifiersRange = {-1, -1}; | |
if (modifiersStart > declarationStart) { | |
modifiersRange[0] = modifiersStart; | |
modifiersRange[1] = bodyStart - 1; | |
} | |
fNode = new DOMInitializer(fDocument, sourceRange, commentRange, modifiers, | |
modifiersRange, bodyStart); | |
addChild(fNode); | |
if (fBuildingSingleMember) { | |
fFinishedSingleMember= true; | |
} | |
} | |
/** | |
* @see IDocumentElementRequestor#acceptPackage(int declarationStart, int declarationEnd, int[] javaDocPositions, char[] name, int nameStartPosition) | |
*/ | |
public void acceptPackage(int declarationStart, int declarationEnd, int[] javaDocPositions, char[] name, | |
int nameStartPosition) { | |
int[] sourceRange = {declarationStart, declarationEnd}; | |
int[] nameRange = {nameStartPosition, declarationEnd - 1}; | |
fNode= new DOMPackage(fDocument, sourceRange, CharArrayOps.charToString(name), nameRange); | |
addChild(fNode); | |
if (fBuildingSingleMember) { | |
fFinishedSingleMember= true; | |
} | |
} | |
/** | |
* Sets the abort flag to true. The parser has encountered an error | |
* in the current document. If we are only building a single member, and | |
* we are done with the member - don't worry about the error. | |
* | |
* @see IDocumentElementRequestor | |
*/ | |
public void acceptProblem(IProblem problem){ | |
if (fBuildingSingleMember && fFinishedSingleMember) { | |
return; | |
} | |
fAbort= true; | |
} | |
/** | |
* Adds the given node to the current enclosing scope, building the JDOM | |
* tree. Nodes are only added to an enclosing scope when a compilation unit or type | |
* is being built (since those are the only nodes that have children). | |
* | |
* <p>NOTE: nodes are added to the JDOM via the method #basicAddChild such that | |
* the nodes in the newly created JDOM are not fragmented. | |
*/ | |
protected void addChild(IDOMNode child) { | |
super.addChild(child); | |
if (fStack.isEmpty() && fFields != null) { | |
fFields.add(child); | |
} | |
} | |
/** | |
* @see IDOMFactory#createCompilationUnit() | |
*/ | |
public IDOMCompilationUnit createCompilationUnit() { | |
return new DOMCompilationUnit(); | |
} | |
/** | |
* @see IDOMFactory#createCompilationUnit(String, String) | |
*/ | |
public IDOMCompilationUnit createCompilationUnit(ICompilationUnit compilationUnit) { | |
initializeBuild(compilationUnit.getContents(), true, true, false); | |
getParser().parseCompilationUnit(compilationUnit); | |
return super.createCompilationUnit(compilationUnit); | |
} | |
/** | |
* @see IDOMFactory#createField(String) | |
*/ | |
public IDOMField createField(char[] sourceCode) { | |
initializeBuild(sourceCode, false, false, true); | |
getParser().parseField(sourceCode); | |
if (fAbort) { | |
return null; | |
} | |
// we only accept field declarations with one field | |
if (fFieldCount > 1) { | |
return null; | |
} | |
fNode.normalize(this); | |
return (IDOMField)fNode; | |
} | |
/** | |
* | |
*/ | |
public IDOMField[] createFields(char[] sourceCode) { | |
initializeBuild(sourceCode, false, false, false); | |
fFields= new ArrayList(); | |
getParser().parseField(sourceCode); | |
if (fAbort) { | |
return null; | |
} | |
IDOMField[] fields= new IDOMField[fFields.size()]; | |
fFields.toArray(fields); | |
for (int i= 0; i < fields.length; i++) { | |
DOMNode node= (DOMNode)fields[i]; | |
if (i < (fields.length - 1)) { | |
DOMNode next= (DOMNode)fields[i + 1]; | |
node.fNextNode= next; | |
next.fPreviousNode= node; | |
} | |
((DOMNode)fields[i]).normalize(this); | |
} | |
return fields; | |
} | |
/** | |
* @see IDOMFactory#createImport() | |
*/ | |
public IDOMImport createImport() { | |
return new DOMImport(); | |
} | |
/** | |
* @see IDOMFactory#createImport(String) | |
*/ | |
public IDOMImport createImport(char[] sourceCode) { | |
initializeBuild(sourceCode, false, false, true); | |
getParser().parseImport(sourceCode); | |
if (fAbort || fNode == null) { | |
return null; | |
} | |
fNode.normalize(this); | |
return (IDOMImport)fNode; | |
} | |
/** | |
* Creates an INITIALIZER document fragment from the given source. | |
* | |
* @see IDOMFactory#createInitializer(String) | |
*/ | |
public IDOMInitializer createInitializer(char[] sourceCode) { | |
initializeBuild(sourceCode, false, false, true); | |
getParser().parseInitializer(sourceCode); | |
if (fAbort || fNode == null || !(fNode instanceof IDOMInitializer)) { | |
return null; | |
} | |
fNode.normalize(this); | |
return (IDOMInitializer)fNode; | |
} | |
/** | |
* @see IDOMFactory#createMethod(String) | |
*/ | |
public IDOMMethod createMethod(char[] sourceCode) { | |
initializeBuild(sourceCode, false, false, true); | |
getParser().parseMethod(sourceCode); | |
if (fAbort) { | |
return null; | |
} | |
fNode.normalize(this); | |
return (IDOMMethod)fNode; | |
} | |
/** | |
* @see IDOMFactory#createPackage() | |
*/ | |
public IDOMPackage createPackage() { | |
return new DOMPackage(); | |
} | |
/** | |
* @see IDOMFactory#createPackage(String) | |
*/ | |
public IDOMPackage createPackage(char[] sourceCode) { | |
initializeBuild(sourceCode, false, false, true); | |
getParser().parsePackage(sourceCode); | |
if (fAbort || fNode == null) { | |
return null; | |
} | |
fNode.normalize(this); | |
return (IDOMPackage)fNode; | |
} | |
/** | |
* @see IDOMFactory#createType(String) | |
*/ | |
public IDOMType createType(char[] sourceCode) { | |
initializeBuild(sourceCode, false, true, false); | |
getParser().parseType(sourceCode); | |
if (fAbort) { | |
return null; | |
} | |
fNode.normalize(this); | |
return (IDOMType)fNode; | |
} | |
/** | |
* Creates a new DOMMethod and inizializes. | |
* | |
* @param declarationStart - a source position corresponding to the first character | |
* of this constructor declaration | |
* @param modifiers - the modifiers for this constructor converted to a flag | |
* @param modifiersStart - a source position corresponding to the first character of the | |
* textual modifiers | |
* @param returnType - the name of the return type | |
* @param returnTypeStart - a source position corresponding to the first character | |
* of the return type | |
* @param returnTypeEnd - a source position corresponding to the last character | |
* of the return type | |
* @param returnTypeDimensionCount - the array dimension count as supplied on the | |
* return type, i.e. public int[] foo() {} | |
* @param name - the name of this constructor | |
* @param nameStart - a source position corresponding to the first character of the name | |
* @param nameEnd - a source position corresponding to the last character of the name | |
* @param parameterTypes - a list of parameter type names | |
* @param parameterTypeStarts - a list of source positions corresponding to the | |
* first character of each parameter type name | |
* @param parameterTypeEnds - a list of source positions corresponding to the | |
* last character of each parameter type name | |
* @param parameterNames - a list of the names of the parameters | |
* @param parametersEnd - a source position corresponding to the last character of the | |
* parameter list | |
* @extendedReturnTypeDimensionCount - the array dimension count as supplied on the | |
* end of the parameter list, i.e. public int foo()[] {} | |
* @extendedReturnTypeDimensionEnd - a source position corresponding to the last character | |
* of the extended return type dimension | |
* @param exceptionTypes - a list of the exception types | |
* @param exceptionTypeStarts - a list of source positions corresponding to the first | |
* character of the respective exception types | |
* @param exceptionTypeEnds - a list of source positions corresponding to the last | |
* character of the respective exception types | |
* @param bodyStart - a source position corresponding to the start of this | |
* constructor's body | |
*/ | |
protected void enterAbstractMethod(int declarationStart, int[] javaDocPositions, int modifiers, int modifiersStart, | |
char[] returnType, int returnTypeStart, int returnTypeEnd, int returnTypeDimensionCount, | |
char[] name, int nameStart, int nameEnd, char[][] parameterTypes, int[] parameterTypeStarts, | |
int[] parameterTypeEnds, char[][] parameterNames, int[] parameterNameStarts, | |
int[] parameterNameEnds, int parametersEnd, int extendedReturnTypeDimensionCount, | |
int extendedReturnTypeDimensionEnd, char[][] exceptionTypes, int[] exceptionTypeStarts, | |
int[] exceptionTypeEnds, int bodyStart, boolean isConstructor) { | |
int[] sourceRange = {declarationStart, -1}; // will be fixed up on exit | |
int[] nameRange = {nameStart, nameEnd}; | |
int[] commentRange = {-1, -1}; | |
if (javaDocPositions != null) { | |
int length = javaDocPositions.length; | |
commentRange[0] = javaDocPositions[0]; | |
commentRange[1] = javaDocPositions[length - 1]; | |
} | |
int[] modifiersRange = {-1, -1}; | |
if (modifiersStart > -1) { | |
modifiersRange[0] = modifiersStart; | |
if (isConstructor) { | |
modifiersRange[1] = nameStart - 1; | |
} else { | |
modifiersRange[1] = returnTypeStart - 1; | |
} | |
} | |
int[] returnTypeRange = null; | |
if (extendedReturnTypeDimensionCount > 0) | |
returnTypeRange = new int[] {returnTypeStart, returnTypeEnd, | |
parametersEnd + 1, extendedReturnTypeDimensionEnd}; | |
else | |
returnTypeRange = new int[] {returnTypeStart, returnTypeEnd}; | |
int[] parameterRange = {nameEnd + 1, parametersEnd}; | |
int[] exceptionRange = {-1, -1}; | |
if (exceptionTypes != null && exceptionTypes.length > 0) { | |
int exceptionCount = exceptionTypes.length; | |
exceptionRange[0] = exceptionTypeStarts[0]; | |
exceptionRange[1] = exceptionTypeEnds[exceptionCount - 1]; | |
} | |
int[] bodyRange = null; | |
if (exceptionRange[1] > -1) { | |
bodyRange = new int[] {exceptionRange[1] + 1, -1}; // will be fixed up on exit | |
} else { | |
bodyRange = new int[] {parametersEnd + 1, -1}; | |
} | |
fNode = new DOMMethod(fDocument, sourceRange, CharArrayOps.charToString(name), nameRange, commentRange, modifiers, | |
modifiersRange, isConstructor, CharArrayOps.charToString(returnType), returnTypeRange, | |
CharArrayOps.charcharToString(parameterTypes), | |
CharArrayOps.charcharToString(parameterNames), | |
parameterRange, CharArrayOps.charcharToString(exceptionTypes), exceptionRange, bodyRange); | |
addChild(fNode); | |
fStack.push(fNode); | |
} | |
/** | |
* @see IDocumentElementRequestor#enterClass( | |
int declarationStart, | |
int[] javaDocPositions, | |
int modifiers, | |
int modifiersStart, | |
int classStart, | |
char[] name, | |
int nameStart, | |
int nameEnd, | |
char[] superclass, | |
int superclassStart, | |
int superclassEnd, | |
char[][] superinterfaces, | |
int[] superinterfaceStarts, | |
int[] superinterfaceEnds, | |
int bodyStart) | |
*/ | |
public void enterClass(int declarationStart, int[] javaDocPositions, int modifiers, int modifiersStart, int keywordStart, | |
char[] name, int nameStart, int nameEnd, char[] superclass, int superclassStart, | |
int superclassEnd, char[][] superinterfaces, int[] superinterfaceStarts, | |
int[] superinterfaceEnds, int bodyStart) { | |
enterType(declarationStart, javaDocPositions, modifiers, modifiersStart, keywordStart, | |
name, nameStart, nameEnd, superclass, superclassStart, | |
superclassEnd, superinterfaces, superinterfaceStarts, | |
superinterfaceEnds, bodyStart, true); | |
} | |
/** | |
* @see IDocumentElementRequestor#enterConstructor( | |
int declarationStart, | |
int[] javaDocPositions, | |
int modifiers, | |
int modifiersStart, | |
char[] name, | |
int nameStart, | |
int nameEnd, | |
char[][] parameterTypes, | |
int [] parameterTypeStarts, | |
int [] parameterTypeEnds, | |
char[][] parameterNames, | |
int [] parameterNameStarts, | |
int [] parameterNameEnds, | |
int parametersEnd, | |
char[][] exceptionTypes, | |
int [] exceptionTypeStarts, | |
int [] exceptionTypeEnds, | |
int bodyStart) | |
*/ | |
public void enterConstructor(int declarationStart, int[] javaDocPositions, int modifiers, int modifiersStart, | |
char[] name, int nameStart, int nameEnd, char[][] parameterTypes, | |
int[] parameterTypeStarts, int[] parameterTypeEnds, char[][] parameterNames, | |
int[] parameterNameStarts, int[] parameterNameEnds, int parametersEnd, | |
char[][] exceptionTypes, int[] exceptionTypeStarts, int[] exceptionTypeEnds, | |
int bodyStart) { | |
/* see 1FVIIQZ */ | |
String nameString = new String(fDocument, nameStart, nameEnd - nameStart); | |
int openParenPosition = nameString.indexOf('('); | |
if (openParenPosition > -1) | |
nameEnd = nameStart + openParenPosition - 1; | |
enterAbstractMethod(declarationStart, javaDocPositions, modifiers, modifiersStart, | |
null, -1, -1, 0, | |
name, nameStart, nameEnd, parameterTypes, parameterTypeStarts, | |
parameterTypeEnds, parameterNames, parameterNameStarts, | |
parameterNameEnds, parametersEnd, 0, | |
-1, exceptionTypes, exceptionTypeStarts, | |
exceptionTypeEnds, bodyStart,true); | |
} | |
/** | |
* @see IDocumentElementRequestor#enterField( | |
int declarationStart, | |
int[] javaDocPositions, | |
int modifiers, | |
int modifiersStart, | |
char[] type, | |
int typeStart, | |
int typeEnd, | |
int typeDimensionCount, | |
char[] name, | |
int nameStart, | |
int nameEnd, | |
int extendedTypeDimensionCount, | |
int extendedTypeDimensionEnd) | |
*/ | |
public void enterField(int declarationStart, int[] javaDocPositions, int modifiers, int modifiersStart, | |
char[] type, int typeStart, int typeEnd, int typeDimensionCount, char[] name, | |
int nameStart, int nameEnd, int extendedTypeDimensionCount, | |
int extendedTypeDimensionEnd) { | |
int[] sourceRange = {declarationStart, | |
(extendedTypeDimensionEnd > nameEnd) ? extendedTypeDimensionEnd : nameEnd}; | |
int[] nameRange = {nameStart, nameEnd}; | |
int[] commentRange = {-1, -1}; | |
if (javaDocPositions != null) { | |
int length = javaDocPositions.length; | |
commentRange[0] = javaDocPositions[0]; | |
commentRange[1] = javaDocPositions[length - 1]; | |
} | |
int[] modifiersRange = {-1, -1}; | |
if (modifiersStart > -1) { | |
modifiersRange[0] = modifiersStart; | |
modifiersRange[1] = typeStart - 1; | |
} | |
int[] typeRange = {typeStart, typeEnd}; | |
boolean hasInitializer = false; // fixed on exitField | |
int[] initializerRange = {-1, -1}; // fixed on exitField | |
boolean isVariableDeclarator = false; | |
if (fNode instanceof DOMField) { | |
DOMField field = (DOMField)fNode; | |
if (field.fTypeRange[0] == typeStart) | |
isVariableDeclarator = true; | |
} | |
fNode = new DOMField(fDocument, sourceRange, CharArrayOps.charToString(name), nameRange, commentRange, | |
modifiers, modifiersRange, typeRange, CharArrayOps.charToString(type), hasInitializer, | |
initializerRange, isVariableDeclarator); | |
addChild(fNode); | |
fStack.push(fNode); | |
} | |
/** | |
* @see IDocumentElementRequestor#enterInterface( | |
int declarationStart, | |
int[] javaDocPositions, | |
int modifiers, | |
int modifiersStart, | |
int interfaceStart, | |
char[] name, | |
int nameStart, | |
int nameEnd, | |
char[][] superinterfaces, | |
int[] superinterfaceStarts, | |
int[] superinterfaceEnds, | |
int bodyStart) | |
*/ | |
public void enterInterface(int declarationStart, int[] javaDocPositions, int modifiers, int modifiersStart, int keywordStart, | |
char[] name, int nameStart, int nameEnd, char[][] superinterfaces, | |
int[] superinterfaceStarts, int[] superinterfaceEnds, int bodyStart) { | |
enterType(declarationStart, javaDocPositions, modifiers, modifiersStart, keywordStart, | |
name, nameStart, nameEnd, null, -1, -1, superinterfaces, | |
superinterfaceStarts, superinterfaceEnds, bodyStart, false); | |
} | |
/** | |
* @see IDocumentElementRequestor#enterMethod( | |
int declarationStart, | |
int[] javaDocPositions, | |
int modifiers, | |
int modifiersStart, | |
char[] returnType, | |
int returnTypeStart, | |
int returnTypeEnd, | |
int returnTypeDimensionCount, | |
char[] name, | |
int nameStart, | |
int nameEnd, | |
char[][] parameterTypes, | |
int [] parameterTypeStarts, | |
int [] parameterTypeEnds, | |
char[][] parameterNames, | |
int [] parameterNameStarts, | |
int [] parameterNameEnds, | |
int parametersEnd, | |
int extendedReturnTypeDimensionCount, | |
int extendedReturnTypeDimensionEnd, | |
char[][] exceptionTypes, | |
int [] exceptionTypeStarts, | |
int [] exceptionTypeEnds, | |
int bodyStart) | |
*/ | |
public void enterMethod(int declarationStart, int[] javaDocPositions, int modifiers, int modifiersStart, | |
char[] returnType, int returnTypeStart, int returnTypeEnd, int returnTypeDimensionCount, | |
char[] name, int nameStart, int nameEnd, char[][] parameterTypes, int[] parameterTypeStarts, | |
int[] parameterTypeEnds, char[][] parameterNames, int[] parameterNameStarts, | |
int[] parameterNameEnds, int parametersEnd, int extendedReturnTypeDimensionCount, | |
int extendedReturnTypeDimensionEnd, char[][] exceptionTypes, int[] exceptionTypeStarts, | |
int[] exceptionTypeEnds, int bodyStart) { | |
enterAbstractMethod(declarationStart, javaDocPositions, modifiers, modifiersStart, | |
returnType, returnTypeStart, returnTypeEnd, returnTypeDimensionCount, | |
name, nameStart, nameEnd, parameterTypes, parameterTypeStarts, | |
parameterTypeEnds, parameterNames, parameterNameStarts, | |
parameterNameEnds, parametersEnd, extendedReturnTypeDimensionCount, | |
extendedReturnTypeDimensionEnd, exceptionTypes, exceptionTypeStarts, | |
exceptionTypeEnds, bodyStart,false); | |
} | |
protected void enterType(int declarationStart, int[] javaDocPositions, | |
int modifiers, int modifiersStart, int keywordStart, char[] name, | |
int nameStart, int nameEnd, char[] superclass, int superclassStart, | |
int superclassEnd, char[][] superinterfaces, int[] superinterfaceStarts, | |
int[] superinterfaceEnds, int bodyStart, boolean isClass) { | |
if (fBuildingType) { | |
int[] sourceRange = {declarationStart, -1}; // will be fixed in the exit | |
int[] commentRange = {-1, -1}; | |
if (javaDocPositions != null) { | |
int length = javaDocPositions.length; | |
commentRange[0] = javaDocPositions[0]; | |
commentRange[1] = javaDocPositions[length - 1]; | |
} | |
int[] modifiersRange = {-1, -1}; | |
if (modifiersStart > -1) { | |
modifiersRange[0] = modifiersStart; | |
modifiersRange[1] = (modifiersStart > -1) ? keywordStart - 1 : -1; | |
} | |
int[] typeKeywordRange = {keywordStart, nameStart - 1}; | |
int[] nameRange = new int[] {nameStart, nameEnd}; | |
int[] extendsKeywordRange = {-1, -1}; | |
int[] superclassRange = {-1, -1}; | |
int[] implementsKeywordRange = {-1, -1}; | |
int[] interfacesRange = {-1, -1}; | |
if (isClass) { | |
if (superclass != null) { | |
extendsKeywordRange[0] = nameEnd + 1; | |
extendsKeywordRange[1] = superclassStart - 1; | |
superclassRange[0] = superclassStart; | |
superclassRange[1] = bodyStart - 1; | |
} | |
if (superinterfaces != null && superinterfaces.length > 0) { | |
superclassRange[1] = superclassEnd; | |
if (superclassEnd > -1) { | |
implementsKeywordRange[0] = superclassEnd + 1; | |
} else { | |
implementsKeywordRange[0] = nameEnd + 1; | |
} | |
implementsKeywordRange[1] = superinterfaceStarts[0] - 1; | |
interfacesRange[0] = superinterfaceStarts[0]; | |
interfacesRange[1] = superinterfaceEnds[superinterfaces.length - 1]; | |
} | |
} else { | |
if (superinterfaces != null && superinterfaces.length > 0) { | |
extendsKeywordRange[0] = nameEnd + 1; | |
extendsKeywordRange[1] = superinterfaceStarts[0] - 1; | |
interfacesRange[0] = superinterfaceStarts[0]; | |
interfacesRange[1] = superinterfaceEnds[superinterfaces.length - 1]; | |
} | |
} | |
int[] openBodyRange = {bodyStart, -1}; // fixed by setTypeRanges(DOMNode) | |
int[] closeBodyRange = {-1, -1}; // will be fixed in exit | |
fNode = new DOMType(fDocument, sourceRange, new String(name), nameRange, commentRange, | |
modifiers, modifiersRange, typeKeywordRange, superclassRange, extendsKeywordRange, | |
CharArrayOps.charcharToString(superinterfaces), interfacesRange, | |
implementsKeywordRange, openBodyRange, | |
closeBodyRange, isClass); | |
addChild(fNode); | |
fStack.push(fNode); | |
} | |
} | |
/** | |
* Finishes the configuration of the constructors and methods. | |
* | |
* @param bodyEnd - a source position corresponding to the closing bracket of the method | |
* @param declarationEnd - a source position corresponding to the end of the method | |
* declaration. This can include whitespace and comments following the closing bracket. | |
*/ | |
protected void exitAbstractMethod(int bodyEnd, int declarationEnd) { | |
DOMMethod method = (DOMMethod) fStack.pop(); | |
method.setSourceRangeEnd(declarationEnd); | |
method.setBodyRangeEnd(bodyEnd + 1); | |
fNode = method; | |
if (fBuildingSingleMember) { | |
fFinishedSingleMember= true; | |
} | |
} | |
/** | |
* Finishes the configuration of the class DOM object which | |
* was created by a previous enterClass call. | |
* | |
* @see IDocumentElementRequestor#exitClass(int, int) | |
*/ | |
public void exitClass(int bodyEnd, int declarationEnd) { | |
exitType(bodyEnd, declarationEnd); | |
} | |
/** | |
* Finishes the configuration of the method DOM object which | |
* was created by a previous enterConstructor call. | |
* | |
* @see IDocumentElementRequestor#exitConstructor(int, int) | |
*/ | |
public void exitConstructor(int bodyEnd, int declarationEnd) { | |
exitAbstractMethod(bodyEnd, declarationEnd); | |
} | |
/** | |
* Finishes the configuration of the field DOM object which | |
* was created by a previous enterField call. | |
* | |
* @see IDocumentElementRequestor#exitField(int, int) | |
*/ | |
public void exitField(int bodyEnd, int declarationEnd) { | |
DOMField field = (DOMField)fStack.pop(); | |
if (field.getEndPosition() < declarationEnd) { | |
field.setSourceRangeEnd(declarationEnd); | |
int nameEnd = field.fNameRange[1]; | |
if (nameEnd < bodyEnd) { | |
/* see 1FVIIV8 - obtain initializer range */ | |
String initializer = new String(fDocument, nameEnd + 1, bodyEnd - nameEnd); | |
int index = initializer.indexOf('='); | |
if (index > -1) { | |
field.setHasInitializer(true); | |
field.setInitializerRange(nameEnd + index + 2, bodyEnd); | |
} | |
} | |
} | |
fFieldCount++; | |
fNode = field; | |
if (fBuildingSingleMember) { | |
fFinishedSingleMember= true; | |
} | |
} | |
/** | |
* Finishes the configuration of the interface DOM object which | |
* was created by a previous enterInterface call. | |
* | |
* @see IDocumentElementRequestor#exitInterface(int, int) | |
*/ | |
public void exitInterface(int bodyEnd, int declarationEnd) { | |
exitType(bodyEnd, declarationEnd); | |
} | |
/** | |
* Finishes the configuration of the method DOM object which | |
* was created by a previous enterMethod call. | |
* | |
* @see IDocumentElementRequestor#exitMethod(int, int) | |
*/ | |
public void exitMethod(int bodyEnd, int declarationEnd) { | |
exitAbstractMethod(bodyEnd, declarationEnd); | |
} | |
/** | |
* Creates a new parser. | |
*/ | |
protected DocumentElementParser getParser() { | |
return new DocumentElementParser(this, new DefaultProblemFactory(), new CompilerOptions(JavaCore.getOptions())); | |
} | |
/** | |
* Initializes the builder to create a document fragment. | |
* | |
* @param sourceCode - the document containing the source code to be analyzed | |
* @param buildingCompilationUnit - true if a the document is being analyzed to | |
* create a compilation unit, otherwise false | |
* @param buildingType - true if the document is being analyzed to create a | |
* type or compilation unit | |
* @param singleMember - true if building a single member | |
*/ | |
protected void initializeBuild(char[] sourceCode, boolean buildingCompilationUnit, boolean buildingType, boolean singleMember) { | |
super.initializeBuild(sourceCode, buildingCompilationUnit, buildingType); | |
fBuildingSingleMember= singleMember; | |
fFinishedSingleMember= false; | |
} | |
} |