Attachment #11197 for bug #64332

View | Details | Raw Unified | Return to bug 64332
Collapse All | Expand All

Lines 331-337 Link Here

(-)antadapter/org/eclipse/jdt/core/JDTCompilerAdapter.java (-1 / +1 lines)
331	* This method adds all files in the given	331	* This method adds all files in the given
332	* directories (but not in sub-directories!) to the classpath,	332	* directories (but not in sub-directories!) to the classpath,
333	* so that you don't have to specify them all one by one.	333	* so that you don't have to specify them all one by one.
334	* @param extdirs - Path to append files to	334	* @param extDirs - Path to append files to
335	*/	335	*/
336	private void addExtdirs(Path extDirs, Path classpath) {	336	private void addExtdirs(Path extDirs, Path classpath) {
337	if (extDirs == null) {	337	if (extDirs == null) {

Lines 871-877 Link Here

(-)codeassist/org/eclipse/jdt/internal/codeassist/CompletionEngine.java (-1 / +1 lines)
871	* Ask the engine to compute a completion at the specified position	871	* Ask the engine to compute a completion at the specified position
872	* of the given compilation unit.	872	* of the given compilation unit.
873	*	873	*
874	* @return void	874	* No return
875	* completion results are answered through a requestor.	875	* completion results are answered through a requestor.
876	*	876	*
877	* @param sourceUnit org.eclipse.jdt.internal.compiler.env.ICompilationUnit	877	* @param sourceUnit org.eclipse.jdt.internal.compiler.env.ICompilationUnit




	 * INTERNAL USE-ONLY
	 * This methods stores the bindings for each inner class. They will be used to know which entries
	 * have to be generated for the inner classes attributes.
	 * @param refBinding org.eclipse.jdt.internal.compiler.lookup.ReferenceBinding 
	 */
	public void addInnerClasses(ReferenceBinding refBinding) {
		// check first if that reference binding is there

	 * INTERNAL USE-ONLY
	 * Generate the byte for a problem clinit method info that correspond to a boggus method.
	 *
	 * @param problems org.eclipse.jdt.internal.compiler.problem.Problem[]
	 */
	public void addProblemClinit(IProblem[] problems) {
		generateMethodInfoHeaderForClinit();

	 *
	 * @param method org.eclipse.jdt.internal.compiler.ast.AbstractMethodDeclaration
	 * @param methodBinding org.eclipse.jdt.internal.compiler.nameloopkup.MethodBinding
	 * @param problems org.eclipse.jdt.internal.compiler.problem.Problem[]
	 */
	public void addProblemConstructor(
		AbstractMethodDeclaration method,

	 *
	 * @param method org.eclipse.jdt.internal.compiler.ast.AbstractMethodDeclaration
	 * @param methodBinding org.eclipse.jdt.internal.compiler.nameloopkup.MethodBinding
	 * @param problems org.eclipse.jdt.internal.compiler.problem.Problem[]
	 * @param savedOffset <CODE>int</CODE>
	 */
	public void addProblemConstructor(

	 *
	 * @param method org.eclipse.jdt.internal.compiler.ast.AbstractMethodDeclaration
	 * @param methodBinding org.eclipse.jdt.internal.compiler.nameloopkup.MethodBinding
	 * @param problems org.eclipse.jdt.internal.compiler.problem.Problem[]
	 */
	public void addProblemMethod(
		AbstractMethodDeclaration method,

	 *
	 * @param method org.eclipse.jdt.internal.compiler.ast.AbstractMethodDeclaration
	 * @param methodBinding org.eclipse.jdt.internal.compiler.nameloopkup.MethodBinding
	 * @param problems org.eclipse.jdt.internal.compiler.problem.Problem[]
	 * @param savedOffset <CODE>int</CODE>
	 */
	public void addProblemMethod(

	 * - exception table
	 * - and debug attributes if necessary.
	 *
	 * @param codeStream org.eclipse.jdt.internal.compiler.codegen.CodeStream
	 * @param codeAttributeOffset <CODE>int</CODE>
	 */
	public void completeCodeAttribute(int codeAttributeOffset) {

	 * - exception table
	 * - and debug attributes if necessary.
	 *
	 * @param codeStream org.eclipse.jdt.internal.compiler.codegen.CodeStream
	 * @param codeAttributeOffset <CODE>int</CODE>
	 */
	public void completeCodeAttributeForClinit(int codeAttributeOffset) {

	 * - exception table
	 * - and debug attributes if necessary.
	 *
	 * @param codeStream org.eclipse.jdt.internal.compiler.codegen.CodeStream
	 * @param codeAttributeOffset <CODE>int</CODE>
	 * @param startLineIndexes int[]
	 * @param startIndexes int[]
	 */
	public void completeCodeAttributeForClinit(
		int codeAttributeOffset,

	 * - exception table
	 * - and debug attributes if necessary.
	 *
	 * @param codeStream org.eclipse.jdt.internal.compiler.codegen.CodeStream
	 * @param codeAttributeOffset <CODE>int</CODE>
	 * @param exceptionHandler int[] 
	 */
	public void completeCodeAttributeForProblemMethod(
		AbstractMethodDeclaration method,

	 * - and debug attributes if necessary.
	 *
	 * @param binding org.eclipse.jdt.internal.compiler.lookup.SyntheticAccessMethodBinding
	 * @param codeStream org.eclipse.jdt.internal.compiler.codegen.CodeStream
	 * @param codeAttributeOffset <CODE>int</CODE>
	 */
	public void completeCodeAttributeForSyntheticAccessMethod(

	 * - the access flags (always default access + static)
	 * - the name index of the method name (always <clinit>) inside the constant pool 
	 * - the descriptor index of the signature (always ()V) of the method inside the constant pool.
	 *
	 * @param methodBinding org.eclipse.jdt.internal.compiler.lookup.MethodBinding
	 */
	public void generateMethodInfoHeaderForClinit() {
		// check that there is enough space to write all the bytes for the method info corresponding

Lines 184-191 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/ConfigurableOption.java (-2 lines)
184	*	184	*
185	* In case the set of possibleValues is NoDiscreteValue, then this index is the	185	* In case the set of possibleValues is NoDiscreteValue, then this index is the
186	* actual value (e.g. max line lenght set to 80).	186	* actual value (e.g. max line lenght set to 80).
187	*
188	* @return int
189	*/	187	*/
190	public void setValueIndex(int newIndex) {	188	public void setValueIndex(int newIndex) {
191	currentValueIndex = newIndex;	189	currentValueIndex = newIndex;

Lines 19-25 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/ast/ArrayTypeReference.java (-1 / +1 lines)
19	/**	19	/**
20	* ArrayTypeReference constructor comment.	20	* ArrayTypeReference constructor comment.
21	* @param source char[]	21	* @param source char[]
22	* @param dim int	22	* @param dimensions int
23	* @param pos int	23	* @param pos int
24	*/	24	*/
25	public ArrayTypeReference(char[] source, int dimensions, long pos) {	25	public ArrayTypeReference(char[] source, int dimensions, long pos) {

Lines 18-24 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/ast/PrefixExpression.java (-1 / +1 lines)
18	/**	18	/**
19	* PrefixExpression constructor comment.	19	* PrefixExpression constructor comment.
20	* @param l org.eclipse.jdt.internal.compiler.ast.Expression	20	* @param l org.eclipse.jdt.internal.compiler.ast.Expression
21	* @param r org.eclipse.jdt.internal.compiler.ast.Expression	21	* @param e org.eclipse.jdt.internal.compiler.ast.Expression
22	* @param op int	22	* @param op int
23	*/	23	*/
24	public PrefixExpression(Expression l, Expression e, int op, int pos) {	24	public PrefixExpression(Expression l, Expression e, int op, int pos) {

Lines 242-248 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/classfmt/ClassFileReader.java (-2 / +2 lines)
242	* Answer the char array that corresponds to the class name of the constant class.	242	* Answer the char array that corresponds to the class name of the constant class.
243	* constantPoolIndex is the index in the constant pool that is a constant class entry.	243	* constantPoolIndex is the index in the constant pool that is a constant class entry.
244	*	244	*
245	* @param int constantPoolIndex	245	* @param constantPoolIndex int
246	* @return char[]	246	* @return char[]
247	*/	247	*/
248	private char[] getConstantClassNameAt(int constantPoolIndex) {	248	private char[] getConstantClassNameAt(int constantPoolIndex) {
Lines 575-581 Link Here
575	* If any of these changes occurs, the method returns true. false otherwise.	575	* If any of these changes occurs, the method returns true. false otherwise.
576	* @param newBytes the bytes of the .class file we want to compare the receiver to	576	* @param newBytes the bytes of the .class file we want to compare the receiver to
577	* @param orderRequired a boolean indicating whether the members should be sorted or not	577	* @param orderRequired a boolean indicating whether the members should be sorted or not
578	* @param excludesSynthetics a boolean indicating whether the synthetic members should be used in the comparison	578	* @param excludesSynthetic a boolean indicating whether the synthetic members should be used in the comparison
579	* @return boolean Returns true is there is a structural change between the two .class files, false otherwise	579	* @return boolean Returns true is there is a structural change between the two .class files, false otherwise
580	*/	580	*/
581	public boolean hasStructuralChanges(byte[] newBytes, boolean orderRequired, boolean excludesSynthetic) {	581	public boolean hasStructuralChanges(byte[] newBytes, boolean orderRequired, boolean excludesSynthetic) {

Lines 41-47 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/classfmt/MethodInfo.java (-1 / +1 lines)
41	attributeBytes = readOffset;	41	attributeBytes = readOffset;
42	}	42	}
43	/**	43	/**
44	* @see IGenericMethod#getArgumentNames()	44	* @see org.eclipse.jdt.internal.compiler.env.IGenericMethod#getArgumentNames()
45	*/	45	*/
46	public char[][] getArgumentNames() {	46	public char[][] getArgumentNames() {
47	return null;	47	return null;

Lines 49-55 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/codegen/CharArrayCache.java (-1 / +1 lines)
49	}	49	}
50	/** Returns true if the collection contains an element for the key.	50	/** Returns true if the collection contains an element for the key.
51	*	51	*
52	* @param char[] key the key that we are looking for	52	* @param key char[] the key that we are looking for
53	* @return boolean	53	* @return boolean
54	*/	54	*/
55	public boolean containsKey(char[] key) {	55	public boolean containsKey(char[] key) {




/**
 * The equivalent code performs a string conversion:
 *
 * @param blockScope org.eclipse.jdt.internal.compiler.lookup.BlockScope
 * @param oper1 org.eclipse.jdt.internal.compiler.ast.Expression
 * @param oper2 org.eclipse.jdt.internal.compiler.ast.Expression
 */

}

/**
 * @param accessBinding org.eclipse.jdt.internal.compiler.lookup.SyntheticAccessMethodBinding
 * @param constructorBinding org.eclipse.jdt.internal.compiler.lookup.MethodBinding
 */
public void generateSyntheticBodyForConstructorAccess(SyntheticAccessMethodBinding accessBinding) {


	position = 0;
}
/**
 * @param methodBinding org.eclipse.jdt.internal.compiler.ast.MethodBinding
 * @param classFile org.eclipse.jdt.internal.compiler.codegen.ClassFile
 */
public void initializeMaxLocals(MethodBinding methodBinding) {


 * Otherwise it returns the index where the entry for the pc has to be inserted.
 * This is based on the fact that the pcToSourceMap table is sorted according to the pc.
 *
 * @param pcToSourceMap int[]
 * @param length int
 * @param pc int
 * @return int
 */
public static int insertionIndex(int[] pcToSourceMap, int length, int pc) {

	}
}
/**
 * @param referenceMethod org.eclipse.jdt.internal.compiler.ast.AbstractMethodDeclaration
 * @param targetClassFile org.eclipse.jdt.internal.compiler.codegen.ClassFile
 */
public void reset(AbstractMethodDeclaration referenceMethod, ClassFile targetClassFile) {
	init(targetClassFile);

	initializeMaxLocals(referenceMethod.binding);
}
/**
 * @param targetClassFile org.eclipse.jdt.internal.compiler.codegen.ClassFile
 * @param classFile org.eclipse.jdt.internal.compiler.codegen.ClassFile
 */
public void resetForProblemClinit(ClassFile targetClassFile) {
	init(targetClassFile);

}
/**
 * Write a unsigned 8 bits value into the byte array
 * @param value the signed byte
 */
public final void writeSignedByte(int value) {
	try {

}
/**
 * Write a unsigned 8 bits value into the byte array
 * @param value the unsigned byte
 */
public final void writeUnsignedByte(int value) {
	try {

}
/**
 * Write a unsigned 16 bits value into the byte array
 * @param value the unsigned short
 */
public final void writeUnsignedShort(int value) {
	try {




/**
 * This method returns the index into the constantPool corresponding to the type descriptor.
 *
 * @param utf8Constant char[]
 * @return <CODE>int</CODE>
 */
public int literalIndex(char[] utf8Constant) {

 * value. If the double is not already present into the pool, it is added. The 
 * double cache is updated and it returns the right index.
 *
 * @param key <CODE>double</CODE>
 * @return <CODE>int</CODE>
 */
public int literalIndex(double key) {

 * value. If the float is not already present into the pool, it is added. The 
 * int cache is updated and it returns the right index.
 *
 * @param key <CODE>float</CODE>
 * @return <CODE>int</CODE>
 */
public int literalIndex(float key) {

 * value. If the int is not already present into the pool, it is added. The 
 * int cache is updated and it returns the right index.
 *
 * @param key <CODE>int</CODE>
 * @return <CODE>int</CODE>
 */
public int literalIndex(int key) {

 * value. If the long is not already present into the pool, it is added. The 
 * long cache is updated and it returns the right index.
 *
 * @param key <CODE>long</CODE>
 * @return <CODE>int</CODE>
 */
public int literalIndex(long key) {

 * This method returns the index into the constantPool 
 * corresponding to the field binding aFieldBinding.
 *
 * @param aFieldBinding FieldBinding
 * @return <CODE>int</CODE>
 */
public int literalIndex(FieldBinding aFieldBinding) {

 * or a method reference constant.
 * Note: uses the method binding #constantPoolDeclaringClass which could be an array type
 * for the array clone method (see UpdatedMethodDeclaration).
 * @param aMethodBinding MethodBinding
 * @return <CODE>int</CODE>
 */
public int literalIndex(MethodBinding aMethodBinding) {

/**
 * This method returns the index into the constantPool corresponding to the type descriptor.
 *
 * @param aTypeBinding TypeBinding
 * @return <CODE>int</CODE>
 */
public int literalIndex(TypeBinding aTypeBinding) {

 * This method returns the index into the constantPool corresponding 
 * nameAndType constant with nameIndex, typeIndex.
 *
 * @param nameIndex int
 * @param typeIndex int
 * @param key org.eclipse.jdt.internal.compiler.lookup.FieldBinding
 * @return <CODE>int</CODE>
 */
public int literalIndexForFields(int nameIndex, int typeIndex, FieldBinding key) {

/**
 * This method returns the index into the constantPool corresponding to the type descriptor.
 *
 * @param TypeBinding aTypeBinding
 * @return <CODE>int</CODE>
 */
public int literalIndexForJavaLangBoolean() {

/**
 * This method returns the index into the constantPool corresponding to the type descriptor.
 *
 * @param TypeBinding aTypeBinding
 * @return <CODE>int</CODE>
 */
public int literalIndexForJavaLangByte() {

/**
 * This method returns the index into the constantPool corresponding to the type descriptor.
 *
 * @param TypeBinding aTypeBinding
 * @return <CODE>int</CODE>
 */
public int literalIndexForJavaLangCharacter() {

/**
 * This method returns the index into the constantPool corresponding to the type descriptor.
 *
 * @param TypeBinding aTypeBinding
 * @return <CODE>int</CODE>
 */
public int literalIndexForJavaLangClass() {

/**
 * This method returns the index into the constantPool corresponding to the type descriptor.
 *
 * @param TypeBinding aTypeBinding
 * @return <CODE>int</CODE>
 */
public int literalIndexForJavaLangClassNotFoundException() {

/**
 * This method returns the index into the constantPool corresponding to the type descriptor.
 *
 * @param TypeBinding aTypeBinding
 * @return <CODE>int</CODE>
 */
public int literalIndexForJavaLangDouble() {

/**
 * This method returns the index into the constantPool corresponding to the type descriptor.
 *
 * @param TypeBinding aTypeBinding
 * @return <CODE>int</CODE>
 */
public int literalIndexForJavaLangError() {

/**
 * This method returns the index into the constantPool corresponding to the type descriptor.
 *
 * @param TypeBinding aTypeBinding
 * @return <CODE>int</CODE>
 */
public int literalIndexForJavaLangFloat() {

/**
 * This method returns the index into the constantPool corresponding to the type descriptor.
 *
 * @param TypeBinding aTypeBinding
 * @return <CODE>int</CODE>
 */
public int literalIndexForJavaLangInteger() {

/**
 * This method returns the index into the constantPool corresponding to the type descriptor.
 *
 * @param TypeBinding aTypeBinding
 * @return <CODE>int</CODE>
 */
public int literalIndexForJavaLangLong() {

/**
 * This method returns the index into the constantPool corresponding to the type descriptor.
 *
 * @param TypeBinding aTypeBinding
 * @return <CODE>int</CODE>
 */
public int literalIndexForJavaLangNoClassDefFoundError() {

/**
 * This method returns the index into the constantPool corresponding to the type descriptor.
 *
 * @param TypeBinding aTypeBinding
 * @return <CODE>int</CODE>
 */
public int literalIndexForJavaLangAssertionError() {

/**
 * This method returns the index into the constantPool corresponding to the type descriptor.
 *
 * @param typeBindingID int
 * @return <CODE>int</CODE>
 */
public int literalIndexForJavaLangAssertionErrorConstructor(int typeBindingID) {

/**
 * This method returns the index into the constantPool corresponding to the type descriptor.
 *
 * @param TypeBinding aTypeBinding
 * @return <CODE>int</CODE>
 */
public int literalIndexForJavaLangObject() {

/**
 * This method returns the index into the constantPool corresponding to the type descriptor.
 *
 * @param TypeBinding aTypeBinding
 * @return <CODE>int</CODE>
 */
public int literalIndexForJavaLangReflectConstructor() {

/**
 * This method returns the index into the constantPool corresponding to the type descriptor.
 *
 * @param TypeBinding aTypeBinding
 * @return <CODE>int</CODE>
 */
public int literalIndexForJavaLangShort() {

/**
 * This method returns the index into the constantPool corresponding to the type descriptor.
 *
 * @param TypeBinding aTypeBinding
 * @return <CODE>int</CODE>
 */
public int literalIndexForJavaLangString() {

/**
 * This method returns the index into the constantPool corresponding to the type descriptor.
 *
 * @param TypeBinding aTypeBinding
 * @return <CODE>int</CODE>
 */
public int literalIndexForJavaLangStringBuffer() {

/**
 * This method returns the index into the constantPool corresponding to the type descriptor.
 *
 * @param TypeBinding aTypeBinding
 * @return <CODE>int</CODE>
 */
public int literalIndexForJavaLangSystem() {

/**
 * This method returns the index into the constantPool corresponding to the type descriptor.
 *
 * @param TypeBinding aTypeBinding
 * @return <CODE>int</CODE>
 */
public int literalIndexForJavaLangThrowable() {

/**
 * This method returns the index into the constantPool corresponding to the type descriptor.
 *
 * @param TypeBinding aTypeBinding
 * @return <CODE>int</CODE>
 */
public int literalIndexForJavaLangVoid() {

/**
 * This method returns the index into the constantPool corresponding to the type descriptor.
 *
 * @param stringCharArray char[]
 * @return <CODE>int</CODE>
 */
public int literalIndexForLdc(char[] stringCharArray) {

 * This method returns the index into the constantPool corresponding 
 * nameAndType constant with nameIndex, typeIndex.
 *
 * @param nameIndex int
 * @param typeIndex int
 * @param key org.eclipse.jdt.internal.compiler.lookup.MethodBinding
 * @return <CODE>int</CODE>
 */
public int literalIndexForMethods(int nameIndex, int typeIndex, MethodBinding key) {

/**
 * Write a unsigned byte into the byte array
 * 
 * @param value <CODE>int</CODE> The value to write into the byte array
 */
protected final void writeU1(int value) {
	try {

/**
 * Write a unsigned byte into the byte array
 * 
 * @param value <CODE>int</CODE> The value to write into the byte array
 */
protected final void writeU2(int value) {
	//first byte

Lines 49-55 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/codegen/FieldNameAndTypeCache.java (-1 / +1 lines)
49	}	49	}
50	/** Returns true if the collection contains an element for the key.	50	/** Returns true if the collection contains an element for the key.
51	*	51	*
52	* @param char[] key the key that we are looking for	52	* @param key char[] the key that we are looking for
53	* @return boolean	53	* @return boolean
54	*/	54	*/
55	public boolean containsKey(FieldBinding key) {	55	public boolean containsKey(FieldBinding key) {

Lines 49-55 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/codegen/MethodNameAndTypeCache.java (-1 / +1 lines)
49	}	49	}
50	/** Returns true if the collection contains an element for the key.	50	/** Returns true if the collection contains an element for the key.
51	*	51	*
52	* @param char[] key the key that we are looking for	52	* @param key char[] the key that we are looking for
53	* @return boolean	53	* @return boolean
54	*/	54	*/
55	public boolean containsKey(MethodBinding key) {	55	public boolean containsKey(MethodBinding key) {

Lines 46-52 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/codegen/ObjectCache.java (-1 / +1 lines)
46	}	46	}
47	/** Returns true if the collection contains an element for the key.	47	/** Returns true if the collection contains an element for the key.
48	*	48	*
49	* @param char[] key the key that we are looking for	49	* @param key char[] the key that we are looking for
50	* @return boolean	50	* @return boolean
51	*/	51	*/
52	public boolean containsKey(Object key) {	52	public boolean containsKey(Object key) {




	 * receiver represents a compilation unit or source type.
	 */
	public IBinaryType getBinaryType() {
		return this.binaryType;
	}

	/**

	 * receiver represents a binary or source type.
	 */
	public ICompilationUnit getCompilationUnit() {
		return this.compilationUnit;
	}

	/**

	 * several type at once. Then the first type is guaranteed to be the requested type.
	 */
	public ISourceType[] getSourceTypes() {
		return this.sourceTypes;
	}

	/**
	 * Answer whether the receiver contains the resolved binary form of the type.
	 */
	public boolean isBinaryType() {
		return this.binaryType != null;
	}

	/**
	 * Answer whether the receiver contains the compilation unit which defines the type.
	 */
	public boolean isCompilationUnit() {
		return this.compilationUnit != null;
	}

	/**
	 * Answer whether the receiver contains the unresolved source form of the type.
	 */
	public boolean isSourceType() {
		return this.sourceTypes != null;
	}
}

Lines 993-999 Link Here

(-)dom/org/eclipse/jdt/core/dom/AST.java (-2 / +2 lines)
993	/**	993	/**
994	* Sets the event handler for this AST.	994	* Sets the event handler for this AST.
995	*	995	*
996	* @param resolver the event handler for this AST	996	* @param eventHandler the event handler for this AST
997	* @since 3.0	997	* @since 3.0
998	*/	998	*/
999	void setEventHandler(NodeEventHandler eventHandler) {	999	void setEventHandler(NodeEventHandler eventHandler) {
Lines 1142-1148 Link Here
1142	try {	1142	try {
1143	// invoke constructor with signature Foo(AST)	1143	// invoke constructor with signature Foo(AST)
1144	Constructor c = nodeClass.getDeclaredConstructor(AST_CLASS);	1144	Constructor c = nodeClass.getDeclaredConstructor(AST_CLASS);
1145	Object result = c.newInstance(THIS_AST);	1145	Object result = c.newInstance(this.THIS_AST);
1146	return (ASTNode) result;	1146	return (ASTNode) result;
1147	} catch (NoSuchMethodException e) {	1147	} catch (NoSuchMethodException e) {
1148	// all AST node classes have a Foo(AST) constructor	1148	// all AST node classes have a Foo(AST) constructor

Lines 1172-1179 Link Here

(-)dom/org/eclipse/jdt/core/dom/ASTNode.java (-3 / +1 lines)
1172	* This node will be the common parent of all nodes added to	1172	* This node will be the common parent of all nodes added to
1173	* this list.	1173	* this list.
1174	*	1174	*
1175	* @param cycleCheck <code>true</code> if cycles should be
1176	* checked, and <code>false</code> if cycles are not a risk
1177	* @param property the property descriptor	1175	* @param property the property descriptor
1178	* @since 3.0	1176	* @since 3.0
1179	*/	1177	*/
Lines 2004-2010 Link Here
2004	/**	2002	/**
2005	* Postlude portion of the "3 step program" for replacing the	2003	* Postlude portion of the "3 step program" for replacing the
2006	* old child of this node with another node.	2004	* old child of this node with another node.
2007	* See {@link #preChange(SimplePropertyDescriptor)} for details.	2005	* See {@link #preValueChange(SimplePropertyDescriptor)} for details.
2008	* @since 3.0	2006	* @since 3.0
2009	*/	2007	*/
2010	final void postValueChange(SimplePropertyDescriptor property) {	2008	final void postValueChange(SimplePropertyDescriptor property) {

Lines 51-57 Link Here

(-)dom/org/eclipse/jdt/core/dom/BindingResolver.java (-2 / +2 lines)
51	* </p>	51	* </p>
52	*	52	*
53	* @param newNode the new AST node	53	* @param newNode the new AST node
54	* @param oldNode the old AST node	54	* @param oldASTNode the old AST node
55	*/	55	*/
56	void store(ASTNode newNode, org.eclipse.jdt.internal.compiler.ast.ASTNode oldASTNode) {	56	void store(ASTNode newNode, org.eclipse.jdt.internal.compiler.ast.ASTNode oldASTNode) {
57	// default implementation: do nothing	57	// default implementation: do nothing
Lines 674-680 Link Here
674	* Subclasses may reimplement.	674	* Subclasses may reimplement.
675	* </p>	675	* </p>
676	*	676	*
677	* @param variableBinding the old variable binding	677	* @param binding the old variable binding
678	* @return the new variable binding	678	* @return the new variable binding
679	*/	679	*/
680	IVariableBinding getVariableBinding(org.eclipse.jdt.internal.compiler.lookup.VariableBinding binding) {	680	IVariableBinding getVariableBinding(org.eclipse.jdt.internal.compiler.lookup.VariableBinding binding) {




	 * For example, the source string <code>A\nB\nC</code> has
	 * line end table {1, 3, 4}.
	 * 
	 * @param lineEndTable the line end table
	 */
	void setLineEndTable(int[] lineEndTable) {
		if (lineEndTable == null) {


	/**
	 * Returns the extended start position of the given node. Unlike
	 * {@link ASTNode#getStartPosition()} and {@link ASTNode#getLength()},
	 * the extended source range may include comments and whitespace
	 * immediately before or after the normal source range for the node.
	 * 


	/**
	 * Returns the extended source length of the given node. Unlike
	 * {@link ASTNode#getStartPosition()} and {@link ASTNode#getLength()},
	 * the extended source range may include comments and whitespace
	 * immediately before or after the normal source range for the node.
	 * 

Lines 140-146 Link Here

(-)dom/org/eclipse/jdt/core/dom/DefaultCommentMapper.java (-2 / +2 lines)
140		140
141	/**	141	/**
142	* Returns the extended start position of the given node. Unlike	142	* Returns the extended start position of the given node. Unlike
143	* {@link ASTNode#getStartPosition()} and {@link ASTNode#getLength()()},	143	* {@link ASTNode#getStartPosition()} and {@link ASTNode#getLength()},
144	* the extended source range may include comments and whitespace	144	* the extended source range may include comments and whitespace
145	* immediately before or after the normal source range for the node.	145	* immediately before or after the normal source range for the node.
146	*	146	*
Lines 177-183 Link Here
177		177
178	/**	178	/**
179	* Returns the extended source length of the given node. Unlike	179	* Returns the extended source length of the given node. Unlike
180	* {@link ASTNode#getStartPosition()} and {@link ASTNode#getLength()()},	180	* {@link ASTNode#getStartPosition()} and {@link ASTNode#getLength()},
181	* the extended source range may include comments and whitespace	181	* the extended source range may include comments and whitespace
182	* immediately before or after the normal source range for the node.	182	* immediately before or after the normal source range for the node.
183	*	183	*

Lines 18-24 Link Here

(-)dom/org/eclipse/jdt/core/dom/NodeEventHandler.java (-1 / +1 lines)
18	* that does nothing. Internal subclasses do all the real work.	18	* that does nothing. Internal subclasses do all the real work.
19	* </p>	19	* </p>
20	*	20	*
21	* @see AST#getNodeEventHandler()	21	* @see AST#getEventHandler()
22	*/	22	*/
23	class NodeEventHandler {	23	class NodeEventHandler {
24		24




 * Returns -1 if the @methodBinding is not a predefined methodBinding, 
 * the right index otherwise.
 *
 * @param methodBinding org.eclipse.jdt.internal.compiler.lookup.MethodBinding
 * @return <CODE>int</CODE>
 */
public int indexOfWellKnownMethods(MethodBinding methodBinding) {

 * method descriptor. It can be either an interface method reference constant
 * or a method reference constant.
 *
 * @param aMethodBinding MethodBinding
 * @return <CODE>int</CODE>
 */
public int literalIndex(MethodBinding aMethodBinding) {

/**
 * This method returns the index into the constantPool corresponding to the type descriptor.
 *
 * @param aTypeBinding TypeBinding
 * @return <CODE>int</CODE>
 */
public int literalIndex(TypeBinding aTypeBinding) {

 * This method returns the index into the constantPool corresponding 
 * nameAndType constant with nameIndex, typeIndex.
 *
 * @param nameIndex int
 * @param typeIndex int
 * @param key org.eclipse.jdt.internal.compiler.lookup.MethodBinding
 * @return <CODE>int</CODE>
 */
public int literalIndexForMethods(int nameIndex, int typeIndex, MethodBinding key) {

Lines 107-113 Link Here

(-)eval/org/eclipse/jdt/internal/eval/CodeSnippetEvaluator.java (-1 / +1 lines)
107	return CharOperation.concat(CODE_SNIPPET_CLASS_NAME_PREFIX, Integer.toString(EvaluationContext.CODE_SNIPPET_COUNTER + 1).toCharArray());	107	return CharOperation.concat(CODE_SNIPPET_CLASS_NAME_PREFIX, Integer.toString(EvaluationContext.CODE_SNIPPET_COUNTER + 1).toCharArray());
108	}	108	}
109	/**	109	/**
110	* @see Evaluator.	110	* @see Evaluator
111	*/	111	*/
112	Compiler getCompiler(ICompilerRequestor compilerRequestor) {	112	Compiler getCompiler(ICompilerRequestor compilerRequestor) {
113	Compiler compiler = null;	113	Compiler compiler = null;

Lines 83-89 Link Here

(-)eval/org/eclipse/jdt/internal/eval/CodeSnippetSkeleton.java (-1 / +1 lines)
83	return this.isConstructor;	83	return this.isConstructor;
84	}	84	}
85	/**	85	/**
86	* @see IGenericMethod#getArgumentNames()	86	* @see org.eclipse.jdt.internal.compiler.env.IGenericMethod#getArgumentNames()
87	*/	87	*/
88	public char[][] getArgumentNames() {	88	public char[][] getArgumentNames() {
89	return null;	89	return null;




	 * @param block
	 * @param scope
	 * @param block_brace_position
	 * @return
	 */
	private void formatBlock(Block block, BlockScope scope, String block_brace_position, boolean insertSpaceBeforeOpeningBrace) {
		formatOpeningBrace(block_brace_position, insertSpaceBeforeOpeningBrace);

	}
	
	/**
	 * @see org.eclipse.jdt.core.formatter.CodeFormatter#format(int, String, int, int, int, String)
	 */
	public TextEdit format(String string, ASTNode[] nodes) {
		// reset the scribe

	}

	/**
	 * @see org.eclipse.jdt.core.formatter.CodeFormatter#format(int, String, int, int, int, String)
	 */
	public TextEdit format(String string, CompilationUnitDeclaration compilationUnitDeclaration) {
		// reset the scribe

	}

	/**
	 * @see org.eclipse.jdt.core.formatter.CodeFormatter#format(int, String, int, int, int, String)
	 */
	public TextEdit format(String string, ConstructorDeclaration constructorDeclaration) {
		// reset the scribe

	}

	/**
	 * @see org.eclipse.jdt.core.formatter.CodeFormatter#format(int, String, int, int, int, String)
	 */
	public TextEdit format(String string, Expression expression) {
		// reset the scribe

         * Print comments to get proper line number
         */
        this.scribe.printComment();
        final int line = this.scribe.line; 
        
        this.scribe.printModifiers();
		/*

         */
        this.scribe.printComment();
        if (DefaultCodeFormatterConstants.NEXT_LINE_ON_WRAP.equals(bracePosition)
                && (this.scribe.line > line || this.scribe.column >= this.preferences.page_width)) 
        {
            this.scribe.printNewLine();
        }
    }
    

	}

	/**
	 * @see org.eclipse.jdt.internal.compiler.ASTVisitor#visit(org.eclipse.jdt.internal.compiler.ast.BreakStatement, org.eclipse.jdt.internal.compiler.lookup.BlockScope)
	 */
	public boolean visit(BreakStatement breakStatement, BlockScope scope) {
		

	}

	/**
	 * @see org.eclipse.jdt.internal.compiler.ASTVisitor#visit(org.eclipse.jdt.internal.compiler.ast.CaseStatement, org.eclipse.jdt.internal.compiler.lookup.BlockScope)
	 */
	public boolean visit(CaseStatement caseStatement, BlockScope scope) {		
		if (caseStatement.constantExpression == null) {

         * Print comments to get proper line number
         */
        this.scribe.printComment();
        final int line = this.scribe.line;
		this.scribe.printModifiers();
		this.scribe.space();
		/*

	}

	/**
	 * @see org.eclipse.jdt.internal.compiler.ASTVisitor#visit(org.eclipse.jdt.internal.compiler.ast.ContinueStatement, org.eclipse.jdt.internal.compiler.lookup.BlockScope)
	 */
	public boolean visit(ContinueStatement continueStatement, BlockScope scope) {


	public boolean visit(ForStatement forStatement, BlockScope scope) {
	
		this.scribe.printNextToken(TerminalTokens.TokenNamefor);
	    final int line = this.scribe.line;
	    this.scribe.printNextToken(TerminalTokens.TokenNameLPAREN, this.preferences.insert_space_before_opening_paren_in_for);
		
		if (this.preferences.insert_space_after_opening_paren_in_for) {

	public boolean visit(IfStatement ifStatement, BlockScope scope) {

		this.scribe.printNextToken(TerminalTokens.TokenNameif);
        final int line = this.scribe.line;
        this.scribe.printNextToken(TerminalTokens.TokenNameLPAREN, this.preferences.insert_space_before_opening_paren_in_if);
		if (this.preferences.insert_space_after_opening_paren_in_if) {
			this.scribe.space();

	}

	/**
	 * @see org.eclipse.jdt.internal.compiler.ASTVisitor#visit(org.eclipse.jdt.internal.compiler.ast.IntLiteral, org.eclipse.jdt.internal.compiler.lookup.BlockScope)
	 */
	public boolean visit(IntLiteral intLiteral, BlockScope scope) {


	}

	/**
	 * @see org.eclipse.jdt.internal.compiler.ASTVisitor#visit(org.eclipse.jdt.internal.compiler.ast.TypeDeclaration, org.eclipse.jdt.internal.compiler.lookup.ClassScope)
	 */
	public boolean visit(TypeDeclaration memberTypeDeclaration, ClassScope scope) {
		format(memberTypeDeclaration);	

         * Print comments to get proper line number
         */
        this.scribe.printComment();
        final int line = this.scribe.line;
        
        this.scribe.printModifiers();
		this.scribe.space();

	}

	/**
	 * @see org.eclipse.jdt.internal.compiler.ASTVisitor#visit(org.eclipse.jdt.internal.compiler.ast.SingleNameReference, org.eclipse.jdt.internal.compiler.lookup.BlockScope)
	 */
	public boolean visit(SingleNameReference singleNameReference, BlockScope scope) {


		formatOpeningBrace(switch_brace, this.preferences.insert_space_before_opening_brace_in_switch);
		this.scribe.printNewLine();

		if (this.preferences.indent_switchstatements_compare_to_switch) {
			this.scribe.indent();
		}
		final Statement[] statements = switchStatement.statements;

		if ((wasACase || wasAStatement) && this.preferences.indent_switchstatements_compare_to_cases) {
			this.scribe.unIndent();
		}
		if (this.preferences.indent_switchstatements_compare_to_switch) {
			this.scribe.unIndent();
		}
		this.scribe.printNewLine();

	public boolean visit(WhileStatement whileStatement, BlockScope scope) {

		this.scribe.printNextToken(TerminalTokens.TokenNamewhile);
		final int line = this.scribe.line;
		this.scribe.printNextToken(TerminalTokens.TokenNameLPAREN, this.preferences.insert_space_before_opening_paren_in_while);
		
		if (this.preferences.insert_space_after_opening_paren_in_while) {

Lines 62-68 Link Here

(-)formatter/org/eclipse/jdt/internal/formatter/DefaultCodeFormatter.java (-1 / +1 lines)
62	}	62	}
63		63
64	/**	64	/**
65	* @see CodeFormatter#format(int, String, int, int[], String, Map)	65	* @see org.eclipse.jdt.core.formatter.CodeFormatter#format(int, java.lang.String, int, int, int, java.lang.String)
66	*/	66	*/
67	public TextEdit format(	67	public TextEdit format(
68	int kind,	68	int kind,




 * The proposal is as follows: insert
 * the {@linkplain #getCompletion() completion string} into the
 * source file buffer, replacing the characters between 
 * {@linkplain #getReplaceStart() the start}
 * and {@linkplain #getReplaceEnd() end}. The string
 * can be arbitrary; for example, it might include not only the 
 * name of a method but a set of parentheses. Moreover, the source
 * range may include source positions before or after the source

				|| (kind > CompletionProposal.VARIABLE_DECLARATION)) {
			throw new IllegalArgumentException();
		}
		if (this.completion == null || completionLocation < 0) {
			throw new IllegalArgumentException();
		}
		this.completionKind = kind;

	 * or not available or not relevant
	 */
	public char[][] findParameterNames(IProgressMonitor monitor) {
		if (!this.parameterNamesComputed) {
			this.parameterNamesComputed = true;
			// TODO (jerome) - Missing implementation
		}

Lines 239-245 Link Here

(-)model/org/eclipse/jdt/internal/compiler/IDocumentElementRequestor.java (-1 / +1 lines)
239	* @param nameEnd - a source position corresponding to the last character of the name	239	* @param nameEnd - a source position corresponding to the last character of the name
240	* @param extendedTypeDimensionCount - the array dimension indicated on the variable,	240	* @param extendedTypeDimensionCount - the array dimension indicated on the variable,
241	* (for example, 'int v[]')	241	* (for example, 'int v[]')
242	* @param extendedTypeDimnesionEnd - a source position corresponding to the end of	242	* @param extendedTypeDimensionEnd - a source position corresponding to the end of
243	* the extened type dimension. This position should be -1 in case there is no extended	243	* the extened type dimension. This position should be -1 in case there is no extended
244	* dimension for the type.	244	* dimension for the type.
245	*/	245	*/




	}

	/**
	 * @see IWorkingCopy#getSharedWorkingCopy(IProgressMonitor, IBufferFactory, IProblemRequestor)
	 * @deprecated
	 */
	public IJavaElement getSharedWorkingCopy(

		throw new JavaModelException(new JavaModelStatus(IJavaModelStatusConstants.ELEMENT_DOES_NOT_EXIST, this));
	}

	/* (non-Javadoc)
	 * @see org.eclipse.jdt.core.ICompilationUnit#getWorkingCopy(org.eclipse.jdt.core.WorkingCopyOwner, org.eclipse.jdt.core.IProblemRequestor, org.eclipse.core.runtime.IProgressMonitor)
	 */
	public ICompilationUnit getWorkingCopy(WorkingCopyOwner owner, IProblemRequestor problemRequestor, IProgressMonitor monitor) throws JavaModelException {
		throw new JavaModelException(new JavaModelStatus(IJavaModelStatusConstants.ELEMENT_DOES_NOT_EXIST, this));

		throw new JavaModelException(new JavaModelStatus(IJavaModelStatusConstants.ELEMENT_DOES_NOT_EXIST, this));
	}
	
	/* (non-Javadoc)
	 * @see org.eclipse.jdt.core.IWorkingCopy#reconcile(boolean, org.eclipse.core.runtime.IProgressMonitor)
	 */
	public void reconcile(
		boolean forceProblemDetection,

		throw new JavaModelException(new JavaModelStatus(IJavaModelStatusConstants.ELEMENT_DOES_NOT_EXIST, this));
	}

	/* (non-Javadoc)
	 * @see org.eclipse.jdt.core.IWorkingCopy#restore()
	 */
	public void restore() throws JavaModelException {

Lines 718-725 Link Here

(-)model/org/eclipse/jdt/internal/core/ClasspathEntry.java (-2 / +2 lines)
718	* be performed during the classpath setting operation (if validation fails, the classpath setting will not complete).	718	* be performed during the classpath setting operation (if validation fails, the classpath setting will not complete).
719	* <p>	719	* <p>
720	* @param javaProject the given java project	720	* @param javaProject the given java project
721	* @param classpath a given classpath	721	* @param rawClasspath a given classpath
722	* @param outputLocation a given output location	722	* @param projectOutputLocation a given output location
723	* @return a status object with code <code>IStatus.OK</code> if	723	* @return a status object with code <code>IStatus.OK</code> if
724	* the given classpath and output location are compatible, otherwise a status	724	* the given classpath and output location are compatible, otherwise a status
725	* object indicating what is wrong with the classpath or output location	725	* object indicating what is wrong with the classpath or output location

Lines 57-63 Link Here

(-)model/org/eclipse/jdt/internal/core/CompilationUnitProblemFinder.java (-2 / +2 lines)
57	* specify the rules for handling problems (stop on first error or accumulate	57	* specify the rules for handling problems (stop on first error or accumulate
58	* them all) and at the same time perform some actions such as opening a dialog	58	* them all) and at the same time perform some actions such as opening a dialog
59	* in UI when compiling interactively.	59	* in UI when compiling interactively.
60	* @see org.eclipse.jdt.internal.compiler.api.problem.DefaultErrorHandlingPolicies	60	* @see org.eclipse.jdt.internal.compiler.DefaultErrorHandlingPolicies
61	*	61	*
62	* @param settings The settings to use for the resolution.	62	* @param settings The settings to use for the resolution.
63	*	63	*
Lines 65-71 Link Here
65	* Component which will receive and persist all compilation results and is intended	65	* Component which will receive and persist all compilation results and is intended
66	* to consume them as they are produced. Typically, in a batch compiler, it is	66	* to consume them as they are produced. Typically, in a batch compiler, it is
67	* responsible for writing out the actual .class files to the file system.	67	* responsible for writing out the actual .class files to the file system.
68	* @see org.eclipse.jdt.internal.compiler.api.CompilationResult	68	* @see org.eclipse.jdt.internal.compiler.CompilationResult
69	*	69	*
70	* @param problemFactory org.eclipse.jdt.internal.compiler.api.problem.IProblemFactory	70	* @param problemFactory org.eclipse.jdt.internal.compiler.api.problem.IProblemFactory
71	* Factory used inside the compiler to create problem descriptors. It allows the	71	* Factory used inside the compiler to create problem descriptors. It allows the

Lines 202-208 Link Here

(-)model/org/eclipse/jdt/internal/core/CompilationUnitStructureRequestor.java (-1 / +1 lines)
202	}	202	}
203	/**	203	/**
204	* Convert these type names to signatures.	204	* Convert these type names to signatures.
205	* @see Signature.	205	* @see Signature
206	*/	206	*/
207	/* default */ static String[] convertTypeNamesToSigs(char[][] typeNames) {	207	/* default */ static String[] convertTypeNamesToSigs(char[][] typeNames) {
208	if (typeNames == null)	208	if (typeNames == null)

Lines 259-266 Link Here

(-)model/org/eclipse/jdt/internal/core/CreateElementInCUOperation.java (-3 / +3 lines)
259	* Inserts the given child into the given JDOM,	259	* Inserts the given child into the given JDOM,
260	* based on the position settings of this operation.	260	* based on the position settings of this operation.
261	*	261	*
262	* @see createAfter(IJavaElement)	262	* @see #createAfter(IJavaElement)
263	* @see createBefore(IJavaElement)	263	* @see #createBefore(IJavaElement)
264	* @deprecated JDOM is obsolete	264	* @deprecated JDOM is obsolete
265	*/	265	*/
266	// TODO - JDOM - remove once model ported off of JDOM	266	// TODO - JDOM - remove once model ported off of JDOM
Lines 318-324 Link Here
318	* <li>INVALID_SIBLING - the sibling provided for positioning is not valid.	318	* <li>INVALID_SIBLING - the sibling provided for positioning is not valid.
319	* </ul>	319	* </ul>
320	* @see IJavaModelStatus	320	* @see IJavaModelStatus
321	* @see JavaConventions	321	* @see org.eclipse.jdt.core.JavaConventions
322	*/	322	*/
323	public IJavaModelStatus verify() {	323	public IJavaModelStatus verify() {
324	if (getParentElement() == null) {	324	if (getParentElement() == null) {

Lines 40-46 Link Here

(-)model/org/eclipse/jdt/internal/core/CreateFieldOperation.java (-1 / +1 lines)
40	super(parentElement, source, force);	40	super(parentElement, source, force);
41	}	41	}
42	/**	42	/**
43	* @see CreateTypeMemberOperation#generateElementDOM	43	* @see CreateTypeMemberOperation#generateSyntaxIncorrectDOM()
44	* @deprecated JDOM is obsolete	44	* @deprecated JDOM is obsolete
45	*/	45	*/
46	// TODO - JDOM - remove once model ported off of JDOM	46	// TODO - JDOM - remove once model ported off of JDOM

Lines 54-60 Link Here

(-)model/org/eclipse/jdt/internal/core/CreateImportOperation.java (-1 / +1 lines)
54	fImportName = importName;	54	fImportName = importName;
55	}	55	}
56	/**	56	/**
57	* @see CreateTypeMemberOperation#generateElementDOM	57	* @see CreateTypeMemberOperation
58	* @deprecated JDOM is obsolete	58	* @deprecated JDOM is obsolete
59	*/	59	*/
60	// TODO - JDOM - remove once model ported off of JDOM	60	// TODO - JDOM - remove once model ported off of JDOM

Lines 44-50 Link Here

(-)model/org/eclipse/jdt/internal/core/CreateInitializerOperation.java (-1 / +1 lines)
44	super(parentElement, source, false);	44	super(parentElement, source, false);
45	}	45	}
46	/**	46	/**
47	* @see CreateTypeMemberOperation#generateElementDOM	47	* @see CreateTypeMemberOperation#generateSyntaxIncorrectDOM()
48	* @deprecated JDOM is obsolete	48	* @deprecated JDOM is obsolete
49	*/	49	*/
50	// TODO - JDOM - remove once model ported off of JDOM	50	// TODO - JDOM - remove once model ported off of JDOM

Lines 60-66 Link Here

(-)model/org/eclipse/jdt/internal/core/CreateMethodOperation.java (-1 / +1 lines)
60	return fParameterTypes;	60	return fParameterTypes;
61	}	61	}
62	/**	62	/**
63	* @see CreateTypeMemberOperation#generateElementDOM	63	* @see CreateTypeMemberOperation#generateSyntaxIncorrectDOM()
64	* @deprecated JDOM is obsolete	64	* @deprecated JDOM is obsolete
65	*/	65	*/
66	// TODO - JDOM - remove once model ported off of JDOM	66	// TODO - JDOM - remove once model ported off of JDOM

Lines 47-53 Link Here

(-)model/org/eclipse/jdt/internal/core/CreatePackageDeclarationOperation.java (-1 / +1 lines)
47	fName= name;	47	fName= name;
48	}	48	}
49	/**	49	/**
50	* @see CreateTypeMemberOperation#generateElementDOM	50	* @see CreateTypeMemberOperation#generateSyntaxIncorrectDOM()
51	* @deprecated JDOM is obsolete	51	* @deprecated JDOM is obsolete
52	*/	52	*/
53	// TODO - JDOM - remove once model ported off of JDOM	53	// TODO - JDOM - remove once model ported off of JDOM

Lines 37-43 Link Here

(-)model/org/eclipse/jdt/internal/core/DeleteElementsOperation.java (-1 / +1 lines)
37	public class DeleteElementsOperation extends MultiOperation {	37	public class DeleteElementsOperation extends MultiOperation {
38	/**	38	/**
39	* The elements this operation processes grouped by compilation unit	39	* The elements this operation processes grouped by compilation unit
40	* @see processElements(). Keys are compilation units,	40	* @see #processElements() Keys are compilation units,
41	* values are <code>IRegion</code>s of elements to be processed in each	41	* values are <code>IRegion</code>s of elements to be processed in each
42	* compilation unit.	42	* compilation unit.
43	*/	43	*/

Lines 100-106 Link Here

(-)model/org/eclipse/jdt/internal/core/DeleteResourceElementsOperation.java (-1 / +1 lines)
100	return Util.bind("operation.deleteResourceProgress"); //$NON-NLS-1$	100	return Util.bind("operation.deleteResourceProgress"); //$NON-NLS-1$
101	}	101	}
102	/**	102	/**
103	* @see MultiOperation. This method delegate to <code>deleteResource</code> or	103	* @see MultiOperation This method delegate to <code>deleteResource</code> or
104	* <code>deletePackageFragment</code> depending on the type of <code>element</code>.	104	* <code>deletePackageFragment</code> depending on the type of <code>element</code>.
105	*/	105	*/
106	protected void processElement(IJavaElement element) throws JavaModelException {	106	protected void processElement(IJavaElement element) throws JavaModelException {

Lines 14-20 Link Here

(-)model/org/eclipse/jdt/internal/core/ImportDeclarationElementInfo.java (-1 / +1 lines)
14		14
15	/**	15	/**
16	* Element info for IImportDeclaration elements.	16	* Element info for IImportDeclaration elements.
17	* @see IImportDeclaration	17	* @see org.eclipse.jdt.core.IImportDeclaration
18	*/	18	*/
19	public class ImportDeclarationElementInfo extends MemberElementInfo implements ISourceImport{	19	public class ImportDeclarationElementInfo extends MemberElementInfo implements ISourceImport{
20		20




/**
 * A package fragment that represents a package fragment found in a JAR.
 *
 * @see org.eclipse.jdt.core.IPackageFragment
 */
class JarPackageFragment extends PackageFragment implements SuffixConstants {
/**

	return ((JarPackageFragmentInfo) getElementInfo()).containsJavaResources();
}
/**
 * @see org.eclipse.jdt.core.IPackageFragment
 */
public ICompilationUnit createCompilationUnit(String cuName, String contents, boolean force, IProgressMonitor monitor) throws JavaModelException {
	throw new JavaModelException(new JavaModelStatus(IJavaModelStatusConstants.READ_ONLY, this));

	}
}
/**
 * @see org.eclipse.jdt.core.IPackageFragment
 */
public IClassFile[] getClassFiles() throws JavaModelException {
	ArrayList list = getChildrenOfType(CLASS_FILE);

}
/**
 * A jar package fragment never contains compilation units.
 * @see org.eclipse.jdt.core.IPackageFragment
 */
public ICompilationUnit[] getCompilationUnits() {
	return NO_COMPILATION_UNITS;

Lines 40-50 Link Here

(-)model/org/eclipse/jdt/internal/core/JavaElementDelta.java (-2 / +2 lines)
40	*/	40	*/
41	protected int resourceDeltasCounter;	41	protected int resourceDeltasCounter;
42	/**	42	/**
43	* @see #getMovedFromHandle()	43	* @see #getMovedFromElement()
44	*/	44	*/
45	protected IJavaElement fMovedFromHandle = null;	45	protected IJavaElement fMovedFromHandle = null;
46	/**	46	/**
47	* @see #getMovedToHandle()	47	* @see #getMovedToElement()
48	*/	48	*/
49	protected IJavaElement fMovedToHandle = null;	49	protected IJavaElement fMovedToHandle = null;
50	/**	50	/**

Lines 17-23 Link Here

(-)model/org/eclipse/jdt/internal/core/JavaModelInfo.java (-1 / +1 lines)
17	* Implementation of IJavaModel. A Java Model is specific to a	17	* Implementation of IJavaModel. A Java Model is specific to a
18	* workspace.	18	* workspace.
19	*	19	*
20	* @see IJavaModel	20	* @see org.eclipse.jdt.core.IJavaModel
21	*/	21	*/
22	public class JavaModelInfo extends OpenableElementInfo {	22	public class JavaModelInfo extends OpenableElementInfo {
23		23

Lines 635-641 Link Here

(-)model/org/eclipse/jdt/internal/core/JavaModelManager.java (-1 / +1 lines)
635	*/	635	*/
636	public static class PluginPreferencesListener implements Preferences.IPropertyChangeListener {	636	public static class PluginPreferencesListener implements Preferences.IPropertyChangeListener {
637	/**	637	/**
638	* @see org.eclipse.core.runtime.Preferences.IPropertyChangeListener#propertyChange(PropertyChangeEvent)	638	* @see org.eclipse.core.runtime.Preferences.IPropertyChangeListener#propertyChange(Preferences.PropertyChangeEvent)
639	*/	639	*/
640	public void propertyChange(Preferences.PropertyChangeEvent event) {	640	public void propertyChange(Preferences.PropertyChangeEvent event) {
641		641

Lines 17-23 Link Here

(-)model/org/eclipse/jdt/internal/core/MemberElementInfo.java (-1 / +1 lines)
17	/**	17	/**
18	* The modifiers associated with this member.	18	* The modifiers associated with this member.
19	*	19	*
20	* @see IConstants	20	* @see org.eclipse.jdt.internal.compiler.env.IConstants
21	*/	21	*/
22	protected int flags;	22	protected int flags;
23		23




	 * Table specifying insertion positions for elements being 
	 * copied/moved/renamed. Keyed by elements being processed, and
	 * values are the corresponding insertion point.
	 * @see #processElements()
	 */
	protected Map insertBeforeElements = new HashMap(1);
	/**

	 * values are the new name.
	 */
	private void initializeRenamings() {
		if (this.renamingsList != null && this.renamingsList.length == this.elementsToProcess.length) {
			this.renamings = new HashMap(this.renamingsList.length);
			for (int i = 0; i < this.renamingsList.length; i++) {
				if (this.renamingsList[i] != null) {
					this.renamings.put(this.elementsToProcess[i], this.renamingsList[i]);
				}
			}
		}

	 * be completed.
	 */
	protected void processElements() throws JavaModelException {
		beginTask(getMainTaskName(), this.elementsToProcess.length);
		IJavaModelStatus[] errors = new IJavaModelStatus[3];
		int errorsCounter = 0;
		for (int i = 0; i < this.elementsToProcess.length; i++) {
			try {
				verify(this.elementsToProcess[i]);
				processElement(this.elementsToProcess[i]);
			} catch (JavaModelException jme) {
				if (errorsCounter == errors.length) {
					// resize

Lines 166-172 Link Here

(-)model/org/eclipse/jdt/internal/core/PackageFragment.java (-2 / +2 lines)
166	}	166	}
167	/**	167	/**
168	* @see IPackageFragment#getClassFile(String)	168	* @see IPackageFragment#getClassFile(String)
169	* @exception IllegalArgumentExcpetion if the name does not end with ".class"	169	* @exception IllegalArgumentException if the name does not end with ".class"
170	*/	170	*/
171	public IClassFile getClassFile(String classFileName) {	171	public IClassFile getClassFile(String classFileName) {
172	if (!org.eclipse.jdt.internal.compiler.util.Util.isClassFileName(classFileName)) {	172	if (!org.eclipse.jdt.internal.compiler.util.Util.isClassFileName(classFileName)) {
Lines 193-199 Link Here
193	}	193	}
194	/**	194	/**
195	* @see IPackageFragment#getCompilationUnit(String)	195	* @see IPackageFragment#getCompilationUnit(String)
196	* @exception IllegalArgumentExcpetion if the name does not end with ".java"	196	* @exception IllegalArgumentException if the name does not end with ".java"
197	*/	197	*/
198	public ICompilationUnit getCompilationUnit(String cuName) {	198	public ICompilationUnit getCompilationUnit(String cuName) {
199	if (!org.eclipse.jdt.internal.compiler.util.Util.isJavaFileName(cuName)) {	199	if (!org.eclipse.jdt.internal.compiler.util.Util.isJavaFileName(cuName)) {

Lines 318-324 Link Here

(-)model/org/eclipse/jdt/internal/core/PackageFragmentRoot.java (-1 / +1 lines)
318	* Returns the root's kind - K_SOURCE or K_BINARY, defaults	318	* Returns the root's kind - K_SOURCE or K_BINARY, defaults
319	* to K_SOURCE if it is not on the classpath.	319	* to K_SOURCE if it is not on the classpath.
320	*	320	*
321	* @exception NotPresentException if the project and root do	321	* @exception JavaModelException if the project and root do
322	* not exist.	322	* not exist.
323	*/	323	*/
324	protected int determineKind(IResource underlyingResource) throws JavaModelException {	324	protected int determineKind(IResource underlyingResource) throws JavaModelException {




 * Create and initialize a new instance of the receiver
 */
public PackageFragmentRootInfo() {
	this.fNonJavaResources = null;
}
/**
 * Starting at this folder, create non-java resources for this package fragment root 

}
/**
 * Compute the non-package resources of this package fragment root.
 * 
 * @exception JavaModelException  The resource associated with this package fragment root does not exist
 */
private Object[] computeNonJavaResources(IJavaProject project, IResource underlyingResource, PackageFragmentRoot handle) {
	Object[] nonJavaResources = NO_NON_JAVA_RESOURCES;

 * Returns an array of non-java resources contained in the receiver.
 */
synchronized Object[] getNonJavaResources(IJavaProject project, IResource underlyingResource, PackageFragmentRoot handle) {
	Object[] nonJavaResources = this.fNonJavaResources;
	if (nonJavaResources == null) {
		nonJavaResources = this.computeNonJavaResources(project, underlyingResource, handle);
		this.fNonJavaResources = nonJavaResources;
	}
	return nonJavaResources;
}

 * Returns the kind of this root.
 */
public int getRootKind() {
	return this.fRootKind;
}
/**
 * Retuns the SourceMapper for this root, or <code>null</code>

 * Set the fNonJavaResources to res value
 */
void setNonJavaResources(Object[] resources) {
	this.fNonJavaResources = resources;
}
/**
 * Sets the kind of this root.
 */
protected void setRootKind(int newRootKind) {
	this.fRootKind = newRootKind;
}
/**
 * Sets the SourceMapper for this root.

Lines 150-156 Link Here

(-)model/org/eclipse/jdt/internal/core/SearchableEnvironment.java (-1 / +1 lines)
150	}	150	}
151		151
152	/**	152	/**
153	* @see INameEnvironment#findType(char[], char[][])	153	* @see org.eclipse.jdt.internal.compiler.env.INameEnvironment#findType(char[], char[][])
154	*/	154	*/
155	public NameEnvironmentAnswer findType(char[] name, char[][] packageName) {	155	public NameEnvironmentAnswer findType(char[] name, char[][] packageName) {
156	if (name == null) return null;	156	if (name == null) return null;




	}
	
	void sort() {
		this.compilationUnit.sort();
	}

	void mapNextPosition(SortJavaElement node, int start, int end) {

		this.positionsToMapIndex = i;
	}
	/**
	 * @see org.eclipse.jdt.internal.compiler.ISourceElementRequestor#enterClass(int, int, char[], int, int, char[], char[][])
	 */
	public void enterClass(
		int declarationStart,

	 */
	public void enterCompilationUnit() {
		this.stack = new Stack();
		push(this.compilationUnit = new SortCompilationUnit(0));
	}

	/**
	 * @see org.eclipse.jdt.internal.compiler.ISourceElementRequestor#enterConstructor(int, int, char[], int, int, char[][], char[][], char[][])
	 */
	public void enterConstructor(
		int declarationStart,

	}

	/**
	 * @see org.eclipse.jdt.internal.compiler.ISourceElementRequestor#enterField(int, int, char[], char[], int, int)
	 */
	public void enterField(
		int declarationStart,

	}

	/**
	 * @see org.eclipse.jdt.internal.compiler.ISourceElementRequestor#enterInterface(int, int, char[], int, int, char[][])
	 */
	public void enterInterface(
		int declarationStart,

	}

	/**
	 * @see org.eclipse.jdt.internal.compiler.ISourceElementRequestor#enterMethod(int, int, char[], char[], int, int, char[][], char[][], char[][])
	 */
	public void enterMethod(
		int declarationStart,

	}

	/**
	 * @see org.eclipse.jdt.internal.compiler.ISourceElementRequestor#exitField(int, int, int)
	 */
	public void exitField(int initializationStart, int declarationEnd, int declarationSourceEnd) {
		int normalizedDeclarationSourceEnd = this.normalizeSourceEnd(declarationSourceEnd);




	 * Converts these type names to unqualified signatures. This needs to be done in order to be consistent
	 * with the way the source range is retrieved.
	 * @see SourceMapper#getUnqualifiedMethodHandle
	 * @see Signature
	 */
	private String[] convertTypeNamesToSigs(char[][] typeNames) {
		if (typeNames == null)

	/** 
	 * Sets the mapping for this method to its parameter names.
	 *
	 * @see #fParameterNames
	 */
	protected void setMethodParameterNames(
		IMethod method,

	 * Sets the mapping for this element to its source ranges for its source range
	 * and name range.
	 *
	 * @see #fSourceRanges
	 */
	protected void setSourceRange(
		IJavaElement element,




	return getAllSubtypesForType(type);
}
/**
 * @see #getAllSubtypes(IType)
 */
private IType[] getAllSubtypesForType(IType type) {
	ArrayList subTypes = new ArrayList();

}
/**
 * Assumes that the type is an interface
 * @see #getExtendingInterfaces
 */
private IType[] getExtendingInterfaces0(IType extendedInterface) {
	Iterator iter = this.typeToSuperInterfaces.keySet().iterator();

}
/**
 * Assumes that the type is an interface
 * @see #getImplementingClasses
 */
private IType[] getImplementingClasses0(IType interfce) {
	

		this.progressMonitor = monitor;
		if (monitor != null) {
			if (this.focusType != null) {
				monitor.beginTask(Util.bind("hierarchy.creatingOnType", this.focusType.getFullyQualifiedName()), 100); //$NON-NLS-1$
			} else {
				monitor.beginTask(Util.bind("hierarchy.creating"), 100); //$NON-NLS-1$
			}

		Hashtable hashtable2 = new Hashtable();
		int count = 0;
		
		if(this.focusType != null) {
			Integer index = new Integer(count++);
			hashtable.put(this.focusType, index);
			hashtable2.put(index, this.focusType);
		}
		Object[] types = this.classToSuperclass.keySet().toArray();
		for (int i = 0; i < types.length; i++) {
			Object t = types[i];
			if(hashtable.get(t) == null) {

				hashtable.put(t, index);
				hashtable2.put(index, t);
			}
			Object superClass = this.classToSuperclass.get(t);
			if(superClass != null && hashtable.get(superClass) == null) {
				Integer index = new Integer(count++);
				hashtable.put(superClass, index);
				hashtable2.put(index, superClass);
			}
		}
		types = this.typeToSuperInterfaces.keySet().toArray();
		for (int i = 0; i < types.length; i++) {
			Object t = types[i];
			if(hashtable.get(t) == null) {

				hashtable.put(t, index);
				hashtable2.put(index, t);
			}
			Object[] sp = (Object[])this.typeToSuperInterfaces.get(t);
			if(sp != null) {
				for (int j = 0; j < sp.length; j++) {
					Object superInterface = sp[j];

		
		// save general info
		byte generalInfo = 0;
		if(this.computeSubtypes) {
			generalInfo |= COMPUTE_SUBTYPES;
		}
		output.write(generalInfo);
		
		// save project
		if(this.project != null) {
			output.write(this.project.getHandleIdentifier().getBytes());
		}
		output.write(SEPARATOR1);
		
		// save missing types
		for (int i = 0; i < this.missingTypes.size(); i++) {
			if(i != 0) {
				output.write(SEPARATOR2);
			}
			output.write(((String)this.missingTypes.get(i)).getBytes());
			
		}
		output.write(SEPARATOR1);

			// n bytes
			output.write(t.getHandleIdentifier().getBytes());
			output.write(SEPARATOR4);
			output.write(flagsToBytes((Integer)this.typeFlags.get(t)));
			output.write(SEPARATOR4);
			byte info = CLASS;
			if(this.focusType != null && this.focusType.equals(t)) {
				info |= COMPUTED_FOR;
			}
			if(this.interfaces.contains(t)) {
				info |= INTERFACE;
			}
			if(this.rootClasses.contains(t)) {
				info |= ROOT;
			}
			output.write(info);

		output.write(SEPARATOR1);
		
		// save superclasses
		types = this.classToSuperclass.keySet().toArray();
		for (int i = 0; i < types.length; i++) {
			IJavaElement key = (IJavaElement)types[i];
			IJavaElement value = (IJavaElement)this.classToSuperclass.get(key);
			
			output.write(((Integer)hashtable.get(key)).toString().getBytes());
			output.write('>');

		output.write(SEPARATOR1);
		
		// save superinterfaces
		types = this.typeToSuperInterfaces.keySet().toArray();
		for (int i = 0; i < types.length; i++) {
			IJavaElement key = (IJavaElement)types[i];
			IJavaElement[] values = (IJavaElement[])this.typeToSuperInterfaces.get(key);
			
			if(values.length > 0) {
				output.write(((Integer)hashtable.get(key)).toString().getBytes());




 *
 * <p>A line separator might corresponds to several characters in the source.
 *
 * @see org.eclipse.jdt.internal.compiler.IDocumentElementRequestor#acceptLineSeparatorPositions(int[])
 */
public void acceptLineSeparatorPositions(int[] positions) {
	if (positions != null) {

	return (IDOMCompilationUnit)fNode;
}
/**
 * @see org.eclipse.jdt.internal.compiler.IDocumentElementRequestor#enterClass(int, int[], int, int, int, char[], int, int, char[], int, int, char[][], int[], int[], int)
 */
public void enterCompilationUnit() {
 	if (fBuildingCU) {

 * Finishes the configuration of the compilation unit DOM object which
 * was created by a previous enterCompilationUnit call.
 *
 * @see org.eclipse.jdt.internal.compiler.IDocumentElementRequestor#exitCompilationUnit(int)
 */
public void exitCompilationUnit(int declarationEnd) {
	DOMCompilationUnit cu = (DOMCompilationUnit) fStack.pop();




	setMask(MASK_FIELD_HAS_INITIALIZER, hasInitializer);
}
/**
 * @see IDOMField#setInitializer(String)
 */
public void setInitializer(String initializer) {
	becomeDetailed();

	setMask(MASK_FIELD_IS_VARIABLE_DECLARATOR, isVariableDeclarator);
}
/**
 * @see IDOMField#setName(String)
 */
public void setName(String name) throws IllegalArgumentException {
	if (name == null) {

	}
}
/**
 * @see IDOMField#setType(String)
 */
public void setType(String typeName) throws IllegalArgumentException {
	if (typeName == null) {

Lines 150-156 Link Here

(-)model/org/eclipse/jdt/internal/core/jdom/DOMImport.java (-1 / +1 lines)
150	return new DOMImport();	150	return new DOMImport();
151	}	151	}
152	/**	152	/**
153	* @see IDOMNode#setName(char[])	153	* @see IDOMNode#setName(String)
154	*/	154	*/
155	public void setName(String name) {	155	public void setName(String name) {
156	if (name == null) {	156	if (name == null) {




	// nothing to do
}
/**
 * @see DOMMember#appendSimpleContents(CharArrayBuffer)
 */
protected void appendSimpleContents(CharArrayBuffer buffer) {
	// append eveything before my name

	return IDOMNode.INITIALIZER;
}
/**
 * @see IDOMNode#isSignatureEqual(IDOMNode)
 *
 * <p>This method always answers false since an initializer
 * does not have a signature.

	offsetRange(fBodyRange, offset);
}
/**
 * @see IDOMInitializer#setBody(String)
 */
public void setBody(String body) {
	becomeDetailed();

Lines 235-243 Link Here

(-)model/org/eclipse/jdt/internal/core/jdom/DOMMember.java (-3 lines)
235	/**	235	/**
236	* Returns the location of the first character in the member's declaration	236	* Returns the location of the first character in the member's declaration
237	* section.	237	* section.
238	*
239	* @see DOMMember#getMemberDeclarationContents()
240	* @see DOMMember#getFragmentedContents()
241	*/	238	*/
242	protected abstract int getMemberDeclarationStartPosition();	239	protected abstract int getMemberDeclarationStartPosition();
243	/**	240	/**




	
}
/**
 * @see DOMMember#appendSimpleContents(CharArrayBuffer)
 */
protected void appendSimpleContents(CharArrayBuffer buffer) {
	// append eveything before my name

	return getMask(MASK_RETURN_TYPE_ALTERED);
}
/**
 * @see IDOMNode#isSignatureEqual(IDOMNode)
 *
 * <p>Two methods have equal signatures if there names are the same
 * and their parameter types are the same.

	fragment();
}
/**
 * @see IDOMMethod#setExceptions(String[])
 */
public void setExceptions(String[] names) {
	becomeDetailed();

	}
}
/**
 * @see IDOMMethod#setParameters(String[], String[])
 */
public void setParameters(String[] types, String[] names) throws IllegalArgumentException {
	becomeDetailed();

	fragment();
}
/**
 * @see IDOMMethod#setReturnType(String)
 */
public void setReturnType(String name) throws IllegalArgumentException {
	if (name == null) {

Lines 751-757 Link Here

(-)model/org/eclipse/jdt/internal/core/jdom/DOMNode.java (-1 / +1 lines)
751	return getMask(MASK_NAME_ALTERED);	751	return getMask(MASK_NAME_ALTERED);
752	}	752	}
753	/**	753	/**
754	* @see IDOMNode#isSignatureEqual(IDOMNode).	754	* @see IDOMNode#isSignatureEqual(IDOMNode)
755	*	755	*
756	* <p>By default, the signatures of two nodes are equal if their	756	* <p>By default, the signatures of two nodes are equal if their
757	* type and names are equal. Node types that have other requirements	757	* type and names are equal. Node types that have other requirements




	
}
/**
 * @see DOMMember#appendSimpleContents(CharArrayBuffer)
 */
protected void appendSimpleContents(CharArrayBuffer buffer) {
	// append eveything before my name

 * as fragmented, since the names of the constructors must reflect the name
 * of this type.
 *
 * @see IDOMNode#setName(String)
 */
public void setName(String name) throws IllegalArgumentException {
	if (name == null) {

	fOpenBodyRange[0] = start;
}
/**
 * @see IDOMType#setSuperclass(String)
 */
public void setSuperclass(String superclassName) {
	becomeDetailed();

Lines 136-142 Link Here

(-)model/org/eclipse/jdt/internal/core/util/CharArrayBuffer.java (-1 / +1 lines)
136	/**	136	/**
137	* Appends the given char. Given for convenience.	137	* Appends the given char. Given for convenience.
138	*	138	*
139	* @param src - a char which is appended to the end of the buffer.	139	* @param c - a char which is appended to the end of the buffer.
140	*/	140	*/
141	public CharArrayBuffer append(char c) {	141	public CharArrayBuffer append(char c) {
142	append(new char[] {c}, 0, 1);	142	append(new char[] {c}, 0, 1);




	}

	/**
	 * @see #disassemble(org.eclipse.jdt.core.util.IClassFileReader, java.lang.String, int)
	 */
	public String disassemble(IClassFileReader classFileReader, String lineSeparator) {
		return disassemble(classFileReader, lineSeparator, ClassFileBytesDisassembler.DEFAULT);
	}

	/**
	 * Answers back the disassembled string of the IClassFileReader according to the
	 * mode.
	 * This is an output quite similar to the javap tool.
	 * 
	 * @param classFileReader The classFileReader to be disassembled
	 * @param lineSeparator the line separator to use.
	 * @param mode the mode used to disassemble the IClassFileReader
	 * 
	 * @return the disassembled string of the IClassFileReader according to the mode
	 */
	public String disassemble(IClassFileReader classFileReader, String lineSeparator, int mode) {
		if (classFileReader == null) return EMPTY_OUTPUT;




	
	/**
	 * @param classFileBytes byte[]
	 * @param constantPool IConstantPool
	 * @param offset int
	 */
	public FieldInfo(byte classFileBytes[], IConstantPool constantPool, int offset)

			this.attributes = new IClassFileAttribute[this.attributesCount];
		}
		int attributesIndex = 0;
		for (int i = 0; i < this.attributesCount; i++) {
			constantPoolEntry = constantPool.decodeEntry(u2At(classFileBytes, readOffset, offset));
			if (constantPoolEntry.getKind() != IConstantPoolConstant.CONSTANT_Utf8) {
				throw new ClassFormatException(ClassFormatException.INVALID_CONSTANT_POOL_ENTRY);

			readOffset += (6 + u4At(classFileBytes, readOffset + 2, offset));
		}

		this.attributeBytes = readOffset;
	}
	/**
	 * @see IFieldInfo#getAccessFlags()

	}

	int sizeInBytes() {
		return this.attributeBytes;
	}
	/**
	 * @see IFieldInfo#getAttributeCount()




	
	/**
	 * @param classFileBytes byte[]
	 * @param constantPool IConstantPool
	 * @param offset int
	 * @param decodingFlags int
	 */

		throws ClassFormatException {
			
		boolean no_code_attribute = (decodingFlags & IClassFileReader.METHOD_BODIES) == 0;
		this.accessFlags = u2At(classFileBytes, 0, offset);
		
		this.nameIndex = u2At(classFileBytes, 2, offset);
		IConstantPoolEntry constantPoolEntry = constantPool.decodeEntry(this.nameIndex);

			}
			readOffset += (6 + u4At(classFileBytes, readOffset + 2, offset));
		}
		this.attributeBytes = readOffset;
	}
	/**
	 * @see IMethodInfo#getAccessFlags()

	 * @see IMethodInfo#isClinit()
	 */
	public boolean isClinit() {
		return this.name[0] == '<' && this.name.length == 8; // Can only match <clinit>
	}

	/**
	 * @see IMethodInfo#isConstructor()
	 */
	public boolean isConstructor() {
		return this.name[0] == '<' && this.name.length == 6; // Can only match <init>
	}

	/**

	}

	int sizeInBytes() {
		return this.attributeBytes;
	}
	/**
	 * @see IMethodInfo#getAttributes()

Lines 430-436 Link Here

(-)search/org/eclipse/jdt/core/search/SearchEngine.java (-1 / +1 lines)
430	* being searched (for example, search method declarations in a case sensitive way).	430	* being searched (for example, search method declarations in a case sensitive way).
431	*	431	*
432	* @param scope the search result has to be limited to the given scope	432	* @param scope the search result has to be limited to the given scope
433	* @param resultCollector a callback object to which each match is reported	433	* @param requestor a callback object to which each match is reported
434	*/	434	*/
435	private void findMatches(SearchPattern pattern, SearchParticipant[] participants, IJavaSearchScope scope, SearchRequestor requestor, IProgressMonitor monitor) throws CoreException {	435	private void findMatches(SearchPattern pattern, SearchParticipant[] participants, IJavaSearchScope scope, SearchRequestor requestor, IProgressMonitor monitor) throws CoreException {
436	if (monitor != null && monitor.isCanceled()) throw new OperationCanceledException();	436	if (monitor != null && monitor.isCanceled()) throw new OperationCanceledException();

Lines 130-136 Link Here

(-)search/org/eclipse/jdt/internal/core/search/matching/MethodLocator.java (-1 / +1 lines)
130	return level;	130	return level;
131	}	131	}
132	/**	132	/**
133	* @see SearchPattern#matchReportReference	133	* @see org.eclipse.jdt.internal.core.search.matching.PatternLocator#matchReportReference(org.eclipse.jdt.internal.compiler.ast.ASTNode, org.eclipse.jdt.core.IJavaElement, int, org.eclipse.jdt.internal.core.search.matching.MatchLocator)
134	*/	134	*/
135	protected void matchReportReference(ASTNode reference, IJavaElement element, int accuracy, MatchLocator locator) throws CoreException {	135	protected void matchReportReference(ASTNode reference, IJavaElement element, int accuracy, MatchLocator locator) throws CoreException {
136	if (this.isDeclarationOfReferencedMethodsPattern) {	136	if (this.isDeclarationOfReferencedMethodsPattern) {

Lines 68-74 Link Here

(-)search/org/eclipse/jdt/internal/core/search/matching/PossibleMatch.java (-1 / +1 lines)
68	/**	68	/**
69	* The exact openable file name. In particular, will be the originating .class file for binary openable with attached	69	* The exact openable file name. In particular, will be the originating .class file for binary openable with attached
70	* source.	70	* source.
71	* @see PackageReferenceLocator#isDeclaringPackageFragment(IPackageFragment, ReferenceBinding)	71	* @see PackageReferenceLocator#isDeclaringPackageFragment(IPackageFragment, org.eclipse.jdt.internal.compiler.lookup.ReferenceBinding)
72	*/	72	*/
73	public char[] getFileName() {	73	public char[] getFileName() {
74	return this.openable.getElementName().toCharArray();	74	return this.openable.getElementName().toCharArray();

Return to bug 64332

Lines 1843-1849 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/codegen/CodeStream.java (-13 / +12 lines)
1843	/**	1843	/**
1844	* The equivalent code performs a string conversion:	1844	* The equivalent code performs a string conversion:
1845	*	1845	*
1846	* @param oper1 org.eclipse.jdt.internal.compiler.lookup.BlockScope	1846	* @param blockScope org.eclipse.jdt.internal.compiler.lookup.BlockScope
1847	* @param oper1 org.eclipse.jdt.internal.compiler.ast.Expression	1847	* @param oper1 org.eclipse.jdt.internal.compiler.ast.Expression
1848	* @param oper2 org.eclipse.jdt.internal.compiler.ast.Expression	1848	* @param oper2 org.eclipse.jdt.internal.compiler.ast.Expression
1849	*/	1849	*/
Lines 1941-1948 Link Here
1941	}	1941	}
1942		1942
1943	/**	1943	/**
1944	* @param parameters org.eclipse.jdt.internal.compiler.lookup.TypeBinding[]	1944	* @param accessBinding org.eclipse.jdt.internal.compiler.lookup.SyntheticAccessMethodBinding
1945	* @param constructorBinding org.eclipse.jdt.internal.compiler.lookup.MethodBinding
1946	*/	1945	*/
1947	public void generateSyntheticBodyForConstructorAccess(SyntheticAccessMethodBinding accessBinding) {	1946	public void generateSyntheticBodyForConstructorAccess(SyntheticAccessMethodBinding accessBinding) {
1948		1947
Lines 2919-2926 Link Here
2919	position = 0;	2918	position = 0;
2920	}	2919	}
2921	/**	2920	/**
2922	* @param methodDeclaration org.eclipse.jdt.internal.compiler.ast.AbstractMethodDeclaration	2921	* @param methodBinding org.eclipse.jdt.internal.compiler.ast.MethodBinding
2923	* @param classFile org.eclipse.jdt.internal.compiler.codegen.ClassFile
2924	*/	2922	*/
2925	public void initializeMaxLocals(MethodBinding methodBinding) {	2923	public void initializeMaxLocals(MethodBinding methodBinding) {
2926		2924
Lines 2966-2972 Link Here
2966	* Otherwise it returns the index where the entry for the pc has to be inserted.	2964	* Otherwise it returns the index where the entry for the pc has to be inserted.
2967	* This is based on the fact that the pcToSourceMap table is sorted according to the pc.	2965	* This is based on the fact that the pcToSourceMap table is sorted according to the pc.
2968	*	2966	*
2969	* @param int pc	2967	* @param pcToSourceMap int[]
		2968	* @param length int
		2969	* @param pc int
2970	* @return int	2970	* @return int
2971	*/	2971	*/
2972	public static int insertionIndex(int[] pcToSourceMap, int length, int pc) {	2972	public static int insertionIndex(int[] pcToSourceMap, int length, int pc) {
Lines 5005-5012 Link Here
5005	}	5005	}
5006	}	5006	}
5007	/**	5007	/**
5008	* @param methodDeclaration org.eclipse.jdt.internal.compiler.ast.AbstractMethodDeclaration	5008	* @param referenceMethod org.eclipse.jdt.internal.compiler.ast.AbstractMethodDeclaration
5009	* @param classFile org.eclipse.jdt.internal.compiler.codegen.ClassFile	5009	* @param targetClassFile org.eclipse.jdt.internal.compiler.codegen.ClassFile
5010	*/	5010	*/
5011	public void reset(AbstractMethodDeclaration referenceMethod, ClassFile targetClassFile) {	5011	public void reset(AbstractMethodDeclaration referenceMethod, ClassFile targetClassFile) {
5012	init(targetClassFile);	5012	init(targetClassFile);
Lines 5015-5022 Link Here
5015	initializeMaxLocals(referenceMethod.binding);	5015	initializeMaxLocals(referenceMethod.binding);
5016	}	5016	}
5017	/**	5017	/**
5018	* @param methodDeclaration org.eclipse.jdt.internal.compiler.ast.AbstractMethodDeclaration	5018	* @param targetClassFile org.eclipse.jdt.internal.compiler.codegen.ClassFile
5019	* @param classFile org.eclipse.jdt.internal.compiler.codegen.ClassFile
5020	*/	5019	*/
5021	public void resetForProblemClinit(ClassFile targetClassFile) {	5020	public void resetForProblemClinit(ClassFile targetClassFile) {
5022	init(targetClassFile);	5021	init(targetClassFile);
Lines 5662-5668 Link Here
5662	}	5661	}
5663	/**	5662	/**
5664	* Write a unsigned 8 bits value into the byte array	5663	* Write a unsigned 8 bits value into the byte array
5665	* @param b the signed byte	5664	* @param value the signed byte
5666	*/	5665	*/
5667	public final void writeSignedByte(int value) {	5666	public final void writeSignedByte(int value) {
5668	try {	5667	try {
Lines 5760-5766 Link Here
5760	}	5759	}
5761	/**	5760	/**
5762	* Write a unsigned 8 bits value into the byte array	5761	* Write a unsigned 8 bits value into the byte array
5763	* @param b the unsigned byte	5762	* @param value the unsigned byte
5764	*/	5763	*/
5765	public final void writeUnsignedByte(int value) {	5764	public final void writeUnsignedByte(int value) {
5766	try {	5765	try {
Lines 5772-5778 Link Here
5772	}	5771	}
5773	/**	5772	/**
5774	* Write a unsigned 16 bits value into the byte array	5773	* Write a unsigned 16 bits value into the byte array
5775	* @param b the unsigned short	5774	* @param value the unsigned short
5776	*/	5775	*/
5777	public final void writeUnsignedShort(int value) {	5776	public final void writeUnsignedShort(int value) {
5778	try {	5777	try {

Lines 505-511 Link Here

(-)formatter/org/eclipse/jdt/internal/formatter/CodeFormatterVisitor.java (-21 / +20 lines)
505	* @param block	505	* @param block
506	* @param scope	506	* @param scope
507	* @param block_brace_position	507	* @param block_brace_position
508	* @return
509	*/	508	*/
510	private void formatBlock(Block block, BlockScope scope, String block_brace_position, boolean insertSpaceBeforeOpeningBrace) {	509	private void formatBlock(Block block, BlockScope scope, String block_brace_position, boolean insertSpaceBeforeOpeningBrace) {
511	formatOpeningBrace(block_brace_position, insertSpaceBeforeOpeningBrace);	510	formatOpeningBrace(block_brace_position, insertSpaceBeforeOpeningBrace);
Lines 739-745 Link Here
739	}	738	}
740		739
741	/**	740	/**
742	* @see org.eclipse.jdt.core.ICodeFormatter#format(java.lang.String, int, int, java.lang.String)	741	* @see org.eclipse.jdt.core.formatter.CodeFormatter#format(int, String, int, int, int, String)
743	*/	742	*/
744	public TextEdit format(String string, ASTNode[] nodes) {	743	public TextEdit format(String string, ASTNode[] nodes) {
745	// reset the scribe	744	// reset the scribe
Lines 769-775 Link Here
769	}	768	}
770		769
771	/**	770	/**
772	* @see org.eclipse.jdt.core.ICodeFormatter#format(java.lang.String, int, int, java.lang.String)	771	* @see org.eclipse.jdt.core.formatter.CodeFormatter#format(int, String, int, int, int, String)
773	*/	772	*/
774	public TextEdit format(String string, CompilationUnitDeclaration compilationUnitDeclaration) {	773	public TextEdit format(String string, CompilationUnitDeclaration compilationUnitDeclaration) {
775	// reset the scribe	774	// reset the scribe
Lines 799-805 Link Here
799	}	798	}
800		799
801	/**	800	/**
802	* @see org.eclipse.jdt.core.ICodeFormatter#format(java.lang.String, int, int, java.lang.String)	801	* @see org.eclipse.jdt.core.formatter.CodeFormatter#format(int, String, int, int, int, String)
803	*/	802	*/
804	public TextEdit format(String string, ConstructorDeclaration constructorDeclaration) {	803	public TextEdit format(String string, ConstructorDeclaration constructorDeclaration) {
805	// reset the scribe	804	// reset the scribe
Lines 840-846 Link Here
840	}	839	}
841		840
842	/**	841	/**
843	* @see org.eclipse.jdt.core.ICodeFormatter#format(java.lang.String, int, int, java.lang.String)	842	* @see org.eclipse.jdt.core.formatter.CodeFormatter#format(int, String, int, int, int, String)
844	*/	843	*/
845	public TextEdit format(String string, Expression expression) {	844	public TextEdit format(String string, Expression expression) {
846	// reset the scribe	845	// reset the scribe
Lines 875-881 Link Here
875	* Print comments to get proper line number	874	* Print comments to get proper line number
876	*/	875	*/
877	this.scribe.printComment();	876	this.scribe.printComment();
878	final int line = scribe.line;	877	final int line = this.scribe.line;
879		878
880	this.scribe.printModifiers();	879	this.scribe.printModifiers();
881	/*	880	/*
Lines 1248-1256 Link Here
1248	*/	1247	*/
1249	this.scribe.printComment();	1248	this.scribe.printComment();
1250	if (DefaultCodeFormatterConstants.NEXT_LINE_ON_WRAP.equals(bracePosition)	1249	if (DefaultCodeFormatterConstants.NEXT_LINE_ON_WRAP.equals(bracePosition)
1251	&& (scribe.line > line \|\| scribe.column >= this.preferences.page_width))	1250	&& (this.scribe.line > line \|\| this.scribe.column >= this.preferences.page_width))
1252	{	1251	{
1253	scribe.printNewLine();	1252	this.scribe.printNewLine();
1254	}	1253	}
1255	}	1254	}
1256		1255
Lines 2307-2313 Link Here
2307	}	2306	}
2308		2307
2309	/**	2308	/**
2310	* @see org.eclipse.jdt.internal.compiler.ASTVisitor#visit(org.eclipse.jdt.internal.compiler.ast.Break, org.eclipse.jdt.internal.compiler.lookup.BlockScope)	2309	* @see org.eclipse.jdt.internal.compiler.ASTVisitor#visit(org.eclipse.jdt.internal.compiler.ast.BreakStatement, org.eclipse.jdt.internal.compiler.lookup.BlockScope)
2311	*/	2310	*/
2312	public boolean visit(BreakStatement breakStatement, BlockScope scope) {	2311	public boolean visit(BreakStatement breakStatement, BlockScope scope) {
2313		2312
Lines 2321-2327 Link Here
2321	}	2320	}
2322		2321
2323	/**	2322	/**
2324	* @see org.eclipse.jdt.internal.compiler.ASTVisitor#visit(org.eclipse.jdt.internal.compiler.ast.Case, org.eclipse.jdt.internal.compiler.lookup.BlockScope)	2323	* @see org.eclipse.jdt.internal.compiler.ASTVisitor#visit(org.eclipse.jdt.internal.compiler.ast.CaseStatement, org.eclipse.jdt.internal.compiler.lookup.BlockScope)
2325	*/	2324	*/
2326	public boolean visit(CaseStatement caseStatement, BlockScope scope) {	2325	public boolean visit(CaseStatement caseStatement, BlockScope scope) {
2327	if (caseStatement.constantExpression == null) {	2326	if (caseStatement.constantExpression == null) {
Lines 2627-2633 Link Here
2627	* Print comments to get proper line number	2626	* Print comments to get proper line number
2628	*/	2627	*/
2629	this.scribe.printComment();	2628	this.scribe.printComment();
2630	final int line = scribe.line;	2629	final int line = this.scribe.line;
2631	this.scribe.printModifiers();	2630	this.scribe.printModifiers();
2632	this.scribe.space();	2631	this.scribe.space();
2633	/*	2632	/*
Lines 2707-2713 Link Here
2707	}	2706	}
2708		2707
2709	/**	2708	/**
2710	* @see org.eclipse.jdt.internal.compiler.ASTVisitor#visit(org.eclipse.jdt.internal.compiler.ast.Continue, org.eclipse.jdt.internal.compiler.lookup.BlockScope)	2709	* @see org.eclipse.jdt.internal.compiler.ASTVisitor#visit(org.eclipse.jdt.internal.compiler.ast.ContinueStatement, org.eclipse.jdt.internal.compiler.lookup.BlockScope)
2711	*/	2710	*/
2712	public boolean visit(ContinueStatement continueStatement, BlockScope scope) {	2711	public boolean visit(ContinueStatement continueStatement, BlockScope scope) {
2713		2712
Lines 2944-2950 Link Here
2944	public boolean visit(ForStatement forStatement, BlockScope scope) {	2943	public boolean visit(ForStatement forStatement, BlockScope scope) {
2945		2944
2946	this.scribe.printNextToken(TerminalTokens.TokenNamefor);	2945	this.scribe.printNextToken(TerminalTokens.TokenNamefor);
2947	final int line = scribe.line;	2946	final int line = this.scribe.line;
2948	this.scribe.printNextToken(TerminalTokens.TokenNameLPAREN, this.preferences.insert_space_before_opening_paren_in_for);	2947	this.scribe.printNextToken(TerminalTokens.TokenNameLPAREN, this.preferences.insert_space_before_opening_paren_in_for);
2949		2948
2950	if (this.preferences.insert_space_after_opening_paren_in_for) {	2949	if (this.preferences.insert_space_after_opening_paren_in_for) {
Lines 3031-3037 Link Here
3031	public boolean visit(IfStatement ifStatement, BlockScope scope) {	3030	public boolean visit(IfStatement ifStatement, BlockScope scope) {
3032		3031
3033	this.scribe.printNextToken(TerminalTokens.TokenNameif);	3032	this.scribe.printNextToken(TerminalTokens.TokenNameif);
3034	final int line = scribe.line;	3033	final int line = this.scribe.line;
3035	this.scribe.printNextToken(TerminalTokens.TokenNameLPAREN, this.preferences.insert_space_before_opening_paren_in_if);	3034	this.scribe.printNextToken(TerminalTokens.TokenNameLPAREN, this.preferences.insert_space_before_opening_paren_in_if);
3036	if (this.preferences.insert_space_after_opening_paren_in_if) {	3035	if (this.preferences.insert_space_after_opening_paren_in_if) {
3037	this.scribe.space();	3036	this.scribe.space();
Lines 3207-3213 Link Here
3207	}	3206	}
3208		3207
3209	/**	3208	/**
3210	* @see org.eclipse.jdt.internal.compiler.AbstractSyntaxTreeVisitorAdapter#visit(org.eclipse.jdt.internal.compiler.ast.IntLiteral, org.eclipse.jdt.internal.compiler.lookup.BlockScope)	3209	* @see org.eclipse.jdt.internal.compiler.ASTVisitor#visit(org.eclipse.jdt.internal.compiler.ast.IntLiteral, org.eclipse.jdt.internal.compiler.lookup.BlockScope)
3211	*/	3210	*/
3212	public boolean visit(IntLiteral intLiteral, BlockScope scope) {	3211	public boolean visit(IntLiteral intLiteral, BlockScope scope) {
3213		3212
Lines 3272-3278 Link Here
3272	}	3271	}
3273		3272
3274	/**	3273	/**
3275	* @see org.eclipse.jdt.internal.compiler.AbstractSyntaxTreeVisitorAdapter#visit(org.eclipse.jdt.internal.compiler.ast.TypeDeclaration, org.eclipse.jdt.internal.compiler.lookup.ClassScope)	3274	* @see org.eclipse.jdt.internal.compiler.ASTVisitor#visit(org.eclipse.jdt.internal.compiler.ast.TypeDeclaration, org.eclipse.jdt.internal.compiler.lookup.ClassScope)
3276	*/	3275	*/
3277	public boolean visit(TypeDeclaration memberTypeDeclaration, ClassScope scope) {	3276	public boolean visit(TypeDeclaration memberTypeDeclaration, ClassScope scope) {
3278	format(memberTypeDeclaration);	3277	format(memberTypeDeclaration);
Lines 3340-3346 Link Here
3340	* Print comments to get proper line number	3339	* Print comments to get proper line number
3341	*/	3340	*/
3342	this.scribe.printComment();	3341	this.scribe.printComment();
3343	final int line = scribe.line;	3342	final int line = this.scribe.line;
3344		3343
3345	this.scribe.printModifiers();	3344	this.scribe.printModifiers();
3346	this.scribe.space();	3345	this.scribe.space();
Lines 3741-3747 Link Here
3741	}	3740	}
3742		3741
3743	/**	3742	/**
3744	* @see org.eclipse.jdt.internal.compiler.AbstractSyntaxTreeVisitorAdapter#visit(org.eclipse.jdt.internal.compiler.ast.SingleNameReference, org.eclipse.jdt.internal.compiler.lookup.BlockScope)	3743	* @see org.eclipse.jdt.internal.compiler.ASTVisitor#visit(org.eclipse.jdt.internal.compiler.ast.SingleNameReference, org.eclipse.jdt.internal.compiler.lookup.BlockScope)
3745	*/	3744	*/
3746	public boolean visit(SingleNameReference singleNameReference, BlockScope scope) {	3745	public boolean visit(SingleNameReference singleNameReference, BlockScope scope) {
3747		3746
Lines 3849-3855 Link Here
3849	formatOpeningBrace(switch_brace, this.preferences.insert_space_before_opening_brace_in_switch);	3848	formatOpeningBrace(switch_brace, this.preferences.insert_space_before_opening_brace_in_switch);
3850	this.scribe.printNewLine();	3849	this.scribe.printNewLine();
3851		3850
3852	if (preferences.indent_switchstatements_compare_to_switch) {	3851	if (this.preferences.indent_switchstatements_compare_to_switch) {
3853	this.scribe.indent();	3852	this.scribe.indent();
3854	}	3853	}
3855	final Statement[] statements = switchStatement.statements;	3854	final Statement[] statements = switchStatement.statements;
Lines 3969-3975 Link Here
3969	if ((wasACase \|\| wasAStatement) && this.preferences.indent_switchstatements_compare_to_cases) {	3968	if ((wasACase \|\| wasAStatement) && this.preferences.indent_switchstatements_compare_to_cases) {
3970	this.scribe.unIndent();	3969	this.scribe.unIndent();
3971	}	3970	}
3972	if (preferences.indent_switchstatements_compare_to_switch) {	3971	if (this.preferences.indent_switchstatements_compare_to_switch) {
3973	this.scribe.unIndent();	3972	this.scribe.unIndent();
3974	}	3973	}
3975	this.scribe.printNewLine();	3974	this.scribe.printNewLine();
Lines 4163-4169 Link Here
4163	public boolean visit(WhileStatement whileStatement, BlockScope scope) {	4162	public boolean visit(WhileStatement whileStatement, BlockScope scope) {
4164		4163
4165	this.scribe.printNextToken(TerminalTokens.TokenNamewhile);	4164	this.scribe.printNextToken(TerminalTokens.TokenNamewhile);
4166	final int line = scribe.line;	4165	final int line = this.scribe.line;
4167	this.scribe.printNextToken(TerminalTokens.TokenNameLPAREN, this.preferences.insert_space_before_opening_paren_in_while);	4166	this.scribe.printNextToken(TerminalTokens.TokenNameLPAREN, this.preferences.insert_space_before_opening_paren_in_while);
4168		4167
4169	if (this.preferences.insert_space_after_opening_paren_in_while) {	4168	if (this.preferences.insert_space_after_opening_paren_in_while) {

Lines 453-459 Link Here

(-)model/org/eclipse/jdt/internal/core/ClassFileWorkingCopy.java (-6 / +6 lines)
453	}	453	}
454		454
455	/**	455	/**
456	* @see IWorkingCopy#getSharedWorkingCopy(IProgressMonitor, IBufferFactory)	456	* @see IWorkingCopy#getSharedWorkingCopy(IProgressMonitor, IBufferFactory, IProblemRequestor)
457	* @deprecated	457	* @deprecated
458	*/	458	*/
459	public IJavaElement getSharedWorkingCopy(	459	public IJavaElement getSharedWorkingCopy(
Lines 487-494 Link Here
487	throw new JavaModelException(new JavaModelStatus(IJavaModelStatusConstants.ELEMENT_DOES_NOT_EXIST, this));	487	throw new JavaModelException(new JavaModelStatus(IJavaModelStatusConstants.ELEMENT_DOES_NOT_EXIST, this));
488	}	488	}
489		489
490	/**	490	/* (non-Javadoc)
491	* @see IWorkingCopy#getWorkingCopy(WorkingCopyOwner, IProblemRequestor, IProgressMonitor)	491	* @see org.eclipse.jdt.core.ICompilationUnit#getWorkingCopy(org.eclipse.jdt.core.WorkingCopyOwner, org.eclipse.jdt.core.IProblemRequestor, org.eclipse.core.runtime.IProgressMonitor)
492	*/	492	*/
493	public ICompilationUnit getWorkingCopy(WorkingCopyOwner owner, IProblemRequestor problemRequestor, IProgressMonitor monitor) throws JavaModelException {	493	public ICompilationUnit getWorkingCopy(WorkingCopyOwner owner, IProblemRequestor problemRequestor, IProgressMonitor monitor) throws JavaModelException {
494	throw new JavaModelException(new JavaModelStatus(IJavaModelStatusConstants.ELEMENT_DOES_NOT_EXIST, this));	494	throw new JavaModelException(new JavaModelStatus(IJavaModelStatusConstants.ELEMENT_DOES_NOT_EXIST, this));
Lines 530-537 Link Here
530	throw new JavaModelException(new JavaModelStatus(IJavaModelStatusConstants.ELEMENT_DOES_NOT_EXIST, this));	530	throw new JavaModelException(new JavaModelStatus(IJavaModelStatusConstants.ELEMENT_DOES_NOT_EXIST, this));
531	}	531	}
532		532
533	/**	533	/* (non-Javadoc)
534	* @see IWorkingCopy#reconcile(boolean, IProgressMonitor)	534	* @see org.eclipse.jdt.core.IWorkingCopy#reconcile(boolean, org.eclipse.core.runtime.IProgressMonitor)
535	*/	535	*/
536	public void reconcile(	536	public void reconcile(
537	boolean forceProblemDetection,	537	boolean forceProblemDetection,
Lines 540-546 Link Here
540	throw new JavaModelException(new JavaModelStatus(IJavaModelStatusConstants.ELEMENT_DOES_NOT_EXIST, this));	540	throw new JavaModelException(new JavaModelStatus(IJavaModelStatusConstants.ELEMENT_DOES_NOT_EXIST, this));
541	}	541	}
542		542
543	/**	543	/* (non-Javadoc)
544	* @see org.eclipse.jdt.core.IWorkingCopy#restore()	544	* @see org.eclipse.jdt.core.IWorkingCopy#restore()
545	*/	545	*/
546	public void restore() throws JavaModelException {	546	public void restore() throws JavaModelException {

Lines 552-558 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/ClassFile.java (-16 / +7 lines)
552	* INTERNAL USE-ONLY	552	* INTERNAL USE-ONLY
553	* This methods stores the bindings for each inner class. They will be used to know which entries	553	* This methods stores the bindings for each inner class. They will be used to know which entries
554	* have to be generated for the inner classes attributes.	554	* have to be generated for the inner classes attributes.
555	* @param referenceBinding org.eclipse.jdt.internal.compiler.lookup.ReferenceBinding	555	* @param refBinding org.eclipse.jdt.internal.compiler.lookup.ReferenceBinding
556	*/	556	*/
557	public void addInnerClasses(ReferenceBinding refBinding) {	557	public void addInnerClasses(ReferenceBinding refBinding) {
558	// check first if that reference binding is there	558	// check first if that reference binding is there
Lines 576-582 Link Here
576	* INTERNAL USE-ONLY	576	* INTERNAL USE-ONLY
577	* Generate the byte for a problem clinit method info that correspond to a boggus method.	577	* Generate the byte for a problem clinit method info that correspond to a boggus method.
578	*	578	*
579	* @param problem org.eclipse.jdt.internal.compiler.problem.Problem[]	579	* @param problems org.eclipse.jdt.internal.compiler.problem.Problem[]
580	*/	580	*/
581	public void addProblemClinit(IProblem[] problems) {	581	public void addProblemClinit(IProblem[] problems) {
582	generateMethodInfoHeaderForClinit();	582	generateMethodInfoHeaderForClinit();
Lines 633-639 Link Here
633	*	633	*
634	* @param method org.eclipse.jdt.internal.compiler.ast.AbstractMethodDeclaration	634	* @param method org.eclipse.jdt.internal.compiler.ast.AbstractMethodDeclaration
635	* @param methodBinding org.eclipse.jdt.internal.compiler.nameloopkup.MethodBinding	635	* @param methodBinding org.eclipse.jdt.internal.compiler.nameloopkup.MethodBinding
636	* @param problem org.eclipse.jdt.internal.compiler.problem.Problem[]	636	* @param problems org.eclipse.jdt.internal.compiler.problem.Problem[]
637	*/	637	*/
638	public void addProblemConstructor(	638	public void addProblemConstructor(
639	AbstractMethodDeclaration method,	639	AbstractMethodDeclaration method,
Lines 694-700 Link Here
694	*	694	*
695	* @param method org.eclipse.jdt.internal.compiler.ast.AbstractMethodDeclaration	695	* @param method org.eclipse.jdt.internal.compiler.ast.AbstractMethodDeclaration
696	* @param methodBinding org.eclipse.jdt.internal.compiler.nameloopkup.MethodBinding	696	* @param methodBinding org.eclipse.jdt.internal.compiler.nameloopkup.MethodBinding
697	* @param problem org.eclipse.jdt.internal.compiler.problem.Problem[]	697	* @param problems org.eclipse.jdt.internal.compiler.problem.Problem[]
698	* @param savedOffset <CODE>int</CODE>	698	* @param savedOffset <CODE>int</CODE>
699	*/	699	*/
700	public void addProblemConstructor(	700	public void addProblemConstructor(
Lines 714-720 Link Here
714	*	714	*
715	* @param method org.eclipse.jdt.internal.compiler.ast.AbstractMethodDeclaration	715	* @param method org.eclipse.jdt.internal.compiler.ast.AbstractMethodDeclaration
716	* @param methodBinding org.eclipse.jdt.internal.compiler.nameloopkup.MethodBinding	716	* @param methodBinding org.eclipse.jdt.internal.compiler.nameloopkup.MethodBinding
717	* @param problem org.eclipse.jdt.internal.compiler.problem.Problem[]	717	* @param problems org.eclipse.jdt.internal.compiler.problem.Problem[]
718	*/	718	*/
719	public void addProblemMethod(	719	public void addProblemMethod(
720	AbstractMethodDeclaration method,	720	AbstractMethodDeclaration method,
Lines 782-788 Link Here
782	*	782	*
783	* @param method org.eclipse.jdt.internal.compiler.ast.AbstractMethodDeclaration	783	* @param method org.eclipse.jdt.internal.compiler.ast.AbstractMethodDeclaration
784	* @param methodBinding org.eclipse.jdt.internal.compiler.nameloopkup.MethodBinding	784	* @param methodBinding org.eclipse.jdt.internal.compiler.nameloopkup.MethodBinding
785	* @param problem org.eclipse.jdt.internal.compiler.problem.Problem[]	785	* @param problems org.eclipse.jdt.internal.compiler.problem.Problem[]
786	* @param savedOffset <CODE>int</CODE>	786	* @param savedOffset <CODE>int</CODE>
787	*/	787	*/
788	public void addProblemMethod(	788	public void addProblemMethod(
Lines 1218-1224 Link Here
1218	* - exception table	1218	* - exception table
1219	* - and debug attributes if necessary.	1219	* - and debug attributes if necessary.
1220	*	1220	*
1221	* @param codeStream org.eclipse.jdt.internal.compiler.codegen.CodeStream
1222	* @param codeAttributeOffset <CODE>int</CODE>	1221	* @param codeAttributeOffset <CODE>int</CODE>
1223	*/	1222	*/
1224	public void completeCodeAttribute(int codeAttributeOffset) {	1223	public void completeCodeAttribute(int codeAttributeOffset) {
Lines 1489-1495 Link Here
1489	* - exception table	1488	* - exception table
1490	* - and debug attributes if necessary.	1489	* - and debug attributes if necessary.
1491	*	1490	*
1492	* @param codeStream org.eclipse.jdt.internal.compiler.codegen.CodeStream
1493	* @param codeAttributeOffset <CODE>int</CODE>	1491	* @param codeAttributeOffset <CODE>int</CODE>
1494	*/	1492	*/
1495	public void completeCodeAttributeForClinit(int codeAttributeOffset) {	1493	public void completeCodeAttributeForClinit(int codeAttributeOffset) {
Lines 1738-1747 Link Here
1738	* - exception table	1736	* - exception table
1739	* - and debug attributes if necessary.	1737	* - and debug attributes if necessary.
1740	*	1738	*
1741	* @param codeStream org.eclipse.jdt.internal.compiler.codegen.CodeStream
1742	* @param codeAttributeOffset <CODE>int</CODE>	1739	* @param codeAttributeOffset <CODE>int</CODE>
1743	* @param exceptionHandler int[]	1740	* @param startLineIndexes int[]
1744	* @param startIndexes int[]
1745	*/	1741	*/
1746	public void completeCodeAttributeForClinit(	1742	public void completeCodeAttributeForClinit(
1747	int codeAttributeOffset,	1743	int codeAttributeOffset,
Lines 1875-1883 Link Here
1875	* - exception table	1871	* - exception table
1876	* - and debug attributes if necessary.	1872	* - and debug attributes if necessary.
1877	*	1873	*
1878	* @param codeStream org.eclipse.jdt.internal.compiler.codegen.CodeStream
1879	* @param codeAttributeOffset <CODE>int</CODE>	1874	* @param codeAttributeOffset <CODE>int</CODE>
1880	* @param exceptionHandler int[]
1881	*/	1875	*/
1882	public void completeCodeAttributeForProblemMethod(	1876	public void completeCodeAttributeForProblemMethod(
1883	AbstractMethodDeclaration method,	1877	AbstractMethodDeclaration method,
Lines 2122-2128 Link Here
2122	* - and debug attributes if necessary.	2116	* - and debug attributes if necessary.
2123	*	2117	*
2124	* @param binding org.eclipse.jdt.internal.compiler.lookup.SyntheticAccessMethodBinding	2118	* @param binding org.eclipse.jdt.internal.compiler.lookup.SyntheticAccessMethodBinding
2125	* @param codeStream org.eclipse.jdt.internal.compiler.codegen.CodeStream
2126	* @param codeAttributeOffset <CODE>int</CODE>	2119	* @param codeAttributeOffset <CODE>int</CODE>
2127	*/	2120	*/
2128	public void completeCodeAttributeForSyntheticAccessMethod(	2121	public void completeCodeAttributeForSyntheticAccessMethod(
Lines 2602-2609 Link Here
2602	* - the access flags (always default access + static)	2595	* - the access flags (always default access + static)
2603	* - the name index of the method name (always <clinit>) inside the constant pool	2596	* - the name index of the method name (always <clinit>) inside the constant pool
2604	* - the descriptor index of the signature (always ()V) of the method inside the constant pool.	2597	* - the descriptor index of the signature (always ()V) of the method inside the constant pool.
2605	*
2606	* @param methodBinding org.eclipse.jdt.internal.compiler.lookup.MethodBinding
2607	*/	2598	*/
2608	public void generateMethodInfoHeaderForClinit() {	2599	public void generateMethodInfoHeaderForClinit() {
2609	// check that there is enough space to write all the bytes for the method info corresponding	2600	// check that there is enough space to write all the bytes for the method info corresponding

Lines 664-670 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/codegen/ConstantPool.java (-38 / +18 lines)
664	/**	664	/**
665	* This method returns the index into the constantPool corresponding to the type descriptor.	665	* This method returns the index into the constantPool corresponding to the type descriptor.
666	*	666	*
667	* @param char[] stringName	667	* @param utf8Constant char[]
668	* @return <CODE>int</CODE>	668	* @return <CODE>int</CODE>
669	*/	669	*/
670	public int literalIndex(char[] utf8Constant) {	670	public int literalIndex(char[] utf8Constant) {
Lines 742-748 Link Here
742	* value. If the double is not already present into the pool, it is added. The	742	* value. If the double is not already present into the pool, it is added. The
743	* double cache is updated and it returns the right index.	743	* double cache is updated and it returns the right index.
744	*	744	*
745	* @param <CODE>double</CODE> key	745	* @param key <CODE>double</CODE>
746	* @return <CODE>int</CODE>	746	* @return <CODE>int</CODE>
747	*/	747	*/
748	public int literalIndex(double key) {	748	public int literalIndex(double key) {
Lines 783-789 Link Here
783	* value. If the float is not already present into the pool, it is added. The	783	* value. If the float is not already present into the pool, it is added. The
784	* int cache is updated and it returns the right index.	784	* int cache is updated and it returns the right index.
785	*	785	*
786	* @param <CODE>float</CODE> key	786	* @param key <CODE>float</CODE>
787	* @return <CODE>int</CODE>	787	* @return <CODE>int</CODE>
788	*/	788	*/
789	public int literalIndex(float key) {	789	public int literalIndex(float key) {
Lines 821-827 Link Here
821	* value. If the int is not already present into the pool, it is added. The	821	* value. If the int is not already present into the pool, it is added. The
822	* int cache is updated and it returns the right index.	822	* int cache is updated and it returns the right index.
823	*	823	*
824	* @param <CODE>int</CODE> key	824	* @param key <CODE>int</CODE>
825	* @return <CODE>int</CODE>	825	* @return <CODE>int</CODE>
826	*/	826	*/
827	public int literalIndex(int key) {	827	public int literalIndex(int key) {
Lines 858-864 Link Here
858	* value. If the long is not already present into the pool, it is added. The	858	* value. If the long is not already present into the pool, it is added. The
859	* long cache is updated and it returns the right index.	859	* long cache is updated and it returns the right index.
860	*	860	*
861	* @param <CODE>long</CODE> key	861	* @param key <CODE>long</CODE>
862	* @return <CODE>int</CODE>	862	* @return <CODE>int</CODE>
863	*/	863	*/
864	public int literalIndex(long key) {	864	public int literalIndex(long key) {
Lines 920-926 Link Here
920	* This method returns the index into the constantPool	920	* This method returns the index into the constantPool
921	* corresponding to the field binding aFieldBinding.	921	* corresponding to the field binding aFieldBinding.
922	*	922	*
923	* @param FieldBinding aFieldBinding	923	* @param aFieldBinding FieldBinding
924	* @return <CODE>int</CODE>	924	* @return <CODE>int</CODE>
925	*/	925	*/
926	public int literalIndex(FieldBinding aFieldBinding) {	926	public int literalIndex(FieldBinding aFieldBinding) {
Lines 963-969 Link Here
963	* or a method reference constant.	963	* or a method reference constant.
964	* Note: uses the method binding #constantPoolDeclaringClass which could be an array type	964	* Note: uses the method binding #constantPoolDeclaringClass which could be an array type
965	* for the array clone method (see UpdatedMethodDeclaration).	965	* for the array clone method (see UpdatedMethodDeclaration).
966	* @param MethodBinding aMethodBinding	966	* @param aMethodBinding MethodBinding
967	* @return <CODE>int</CODE>	967	* @return <CODE>int</CODE>
968	*/	968	*/
969	public int literalIndex(MethodBinding aMethodBinding) {	969	public int literalIndex(MethodBinding aMethodBinding) {
Lines 1049-1055 Link Here
1049	/**	1049	/**
1050	* This method returns the index into the constantPool corresponding to the type descriptor.	1050	* This method returns the index into the constantPool corresponding to the type descriptor.
1051	*	1051	*
1052	* @param TypeBinding aTypeBinding	1052	* @param aTypeBinding TypeBinding
1053	* @return <CODE>int</CODE>	1053	* @return <CODE>int</CODE>
1054	*/	1054	*/
1055	public int literalIndex(TypeBinding aTypeBinding) {	1055	public int literalIndex(TypeBinding aTypeBinding) {
Lines 1087-1095 Link Here
1087	* This method returns the index into the constantPool corresponding	1087	* This method returns the index into the constantPool corresponding
1088	* nameAndType constant with nameIndex, typeIndex.	1088	* nameAndType constant with nameIndex, typeIndex.
1089	*	1089	*
1090	* @param int nameIndex	1090	* @param nameIndex int
1091	* @param int nameIndex	1091	* @param typeIndex int
1092	* @param org.eclipse.jdt.internal.compiler.lookup.FieldBinding a FieldBinding	1092	* @param key org.eclipse.jdt.internal.compiler.lookup.FieldBinding
1093	* @return <CODE>int</CODE>	1093	* @return <CODE>int</CODE>
1094	*/	1094	*/
1095	public int literalIndexForFields(int nameIndex, int typeIndex, FieldBinding key) {	1095	public int literalIndexForFields(int nameIndex, int typeIndex, FieldBinding key) {
Lines 1123-1129 Link Here
1123	/**	1123	/**
1124	* This method returns the index into the constantPool corresponding to the type descriptor.	1124	* This method returns the index into the constantPool corresponding to the type descriptor.
1125	*	1125	*
1126	* @param TypeBinding aTypeBinding
1127	* @return <CODE>int</CODE>	1126	* @return <CODE>int</CODE>
1128	*/	1127	*/
1129	public int literalIndexForJavaLangBoolean() {	1128	public int literalIndexForJavaLangBoolean() {
Lines 1176-1182 Link Here
1176	/**	1175	/**
1177	* This method returns the index into the constantPool corresponding to the type descriptor.	1176	* This method returns the index into the constantPool corresponding to the type descriptor.
1178	*	1177	*
1179	* @param TypeBinding aTypeBinding
1180	* @return <CODE>int</CODE>	1178	* @return <CODE>int</CODE>
1181	*/	1179	*/
1182	public int literalIndexForJavaLangByte() {	1180	public int literalIndexForJavaLangByte() {
Lines 1229-1235 Link Here
1229	/**	1227	/**
1230	* This method returns the index into the constantPool corresponding to the type descriptor.	1228	* This method returns the index into the constantPool corresponding to the type descriptor.
1231	*	1229	*
1232	* @param TypeBinding aTypeBinding
1233	* @return <CODE>int</CODE>	1230	* @return <CODE>int</CODE>
1234	*/	1231	*/
1235	public int literalIndexForJavaLangCharacter() {	1232	public int literalIndexForJavaLangCharacter() {
Lines 1282-1288 Link Here
1282	/**	1279	/**
1283	* This method returns the index into the constantPool corresponding to the type descriptor.	1280	* This method returns the index into the constantPool corresponding to the type descriptor.
1284	*	1281	*
1285	* @param TypeBinding aTypeBinding
1286	* @return <CODE>int</CODE>	1282	* @return <CODE>int</CODE>
1287	*/	1283	*/
1288	public int literalIndexForJavaLangClass() {	1284	public int literalIndexForJavaLangClass() {
Lines 1412-1418 Link Here
1412	/**	1408	/**
1413	* This method returns the index into the constantPool corresponding to the type descriptor.	1409	* This method returns the index into the constantPool corresponding to the type descriptor.
1414	*	1410	*
1415	* @param TypeBinding aTypeBinding
1416	* @return <CODE>int</CODE>	1411	* @return <CODE>int</CODE>
1417	*/	1412	*/
1418	public int literalIndexForJavaLangClassNotFoundException() {	1413	public int literalIndexForJavaLangClassNotFoundException() {
Lines 1434-1440 Link Here
1434	/**	1429	/**
1435	* This method returns the index into the constantPool corresponding to the type descriptor.	1430	* This method returns the index into the constantPool corresponding to the type descriptor.
1436	*	1431	*
1437	* @param TypeBinding aTypeBinding
1438	* @return <CODE>int</CODE>	1432	* @return <CODE>int</CODE>
1439	*/	1433	*/
1440	public int literalIndexForJavaLangDouble() {	1434	public int literalIndexForJavaLangDouble() {
Lines 1487-1493 Link Here
1487	/**	1481	/**
1488	* This method returns the index into the constantPool corresponding to the type descriptor.	1482	* This method returns the index into the constantPool corresponding to the type descriptor.
1489	*	1483	*
1490	* @param TypeBinding aTypeBinding
1491	* @return <CODE>int</CODE>	1484	* @return <CODE>int</CODE>
1492	*/	1485	*/
1493	public int literalIndexForJavaLangError() {	1486	public int literalIndexForJavaLangError() {
Lines 1560-1566 Link Here
1560	/**	1553	/**
1561	* This method returns the index into the constantPool corresponding to the type descriptor.	1554	* This method returns the index into the constantPool corresponding to the type descriptor.
1562	*	1555	*
1563	* @param TypeBinding aTypeBinding
1564	* @return <CODE>int</CODE>	1556	* @return <CODE>int</CODE>
1565	*/	1557	*/
1566	public int literalIndexForJavaLangFloat() {	1558	public int literalIndexForJavaLangFloat() {
Lines 1613-1619 Link Here
1613	/**	1605	/**
1614	* This method returns the index into the constantPool corresponding to the type descriptor.	1606	* This method returns the index into the constantPool corresponding to the type descriptor.
1615	*	1607	*
1616	* @param TypeBinding aTypeBinding
1617	* @return <CODE>int</CODE>	1608	* @return <CODE>int</CODE>
1618	*/	1609	*/
1619	public int literalIndexForJavaLangInteger() {	1610	public int literalIndexForJavaLangInteger() {
Lines 1666-1672 Link Here
1666	/**	1657	/**
1667	* This method returns the index into the constantPool corresponding to the type descriptor.	1658	* This method returns the index into the constantPool corresponding to the type descriptor.
1668	*	1659	*
1669	* @param TypeBinding aTypeBinding
1670	* @return <CODE>int</CODE>	1660	* @return <CODE>int</CODE>
1671	*/	1661	*/
1672	public int literalIndexForJavaLangLong() {	1662	public int literalIndexForJavaLangLong() {
Lines 1719-1725 Link Here
1719	/**	1709	/**
1720	* This method returns the index into the constantPool corresponding to the type descriptor.	1710	* This method returns the index into the constantPool corresponding to the type descriptor.
1721	*	1711	*
1722	* @param TypeBinding aTypeBinding
1723	* @return <CODE>int</CODE>	1712	* @return <CODE>int</CODE>
1724	*/	1713	*/
1725	public int literalIndexForJavaLangNoClassDefFoundError() {	1714	public int literalIndexForJavaLangNoClassDefFoundError() {
Lines 1742-1748 Link Here
1742	/**	1731	/**
1743	* This method returns the index into the constantPool corresponding to the type descriptor.	1732	* This method returns the index into the constantPool corresponding to the type descriptor.
1744	*	1733	*
1745	* @param TypeBinding aTypeBinding
1746	* @return <CODE>int</CODE>	1734	* @return <CODE>int</CODE>
1747	*/	1735	*/
1748	public int literalIndexForJavaLangAssertionError() {	1736	public int literalIndexForJavaLangAssertionError() {
Lines 1765-1771 Link Here
1765	/**	1753	/**
1766	* This method returns the index into the constantPool corresponding to the type descriptor.	1754	* This method returns the index into the constantPool corresponding to the type descriptor.
1767	*	1755	*
1768	* @param TypeBinding aTypeBinding	1756	* @param typeBindingID int
1769	* @return <CODE>int</CODE>	1757	* @return <CODE>int</CODE>
1770	*/	1758	*/
1771	public int literalIndexForJavaLangAssertionErrorConstructor(int typeBindingID) {	1759	public int literalIndexForJavaLangAssertionErrorConstructor(int typeBindingID) {
Lines 2026-2032 Link Here
2026	/**	2014	/**
2027	* This method returns the index into the constantPool corresponding to the type descriptor.	2015	* This method returns the index into the constantPool corresponding to the type descriptor.
2028	*	2016	*
2029	* @param TypeBinding aTypeBinding
2030	* @return <CODE>int</CODE>	2017	* @return <CODE>int</CODE>
2031	*/	2018	*/
2032	public int literalIndexForJavaLangObject() {	2019	public int literalIndexForJavaLangObject() {
Lines 2048-2054 Link Here
2048	/**	2035	/**
2049	* This method returns the index into the constantPool corresponding to the type descriptor.	2036	* This method returns the index into the constantPool corresponding to the type descriptor.
2050	*	2037	*
2051	* @param TypeBinding aTypeBinding
2052	* @return <CODE>int</CODE>	2038	* @return <CODE>int</CODE>
2053	*/	2039	*/
2054	public int literalIndexForJavaLangReflectConstructor() {	2040	public int literalIndexForJavaLangReflectConstructor() {
Lines 2099-2105 Link Here
2099	/**	2085	/**
2100	* This method returns the index into the constantPool corresponding to the type descriptor.	2086	* This method returns the index into the constantPool corresponding to the type descriptor.
2101	*	2087	*
2102	* @param TypeBinding aTypeBinding
2103	* @return <CODE>int</CODE>	2088	* @return <CODE>int</CODE>
2104	*/	2089	*/
2105	public int literalIndexForJavaLangShort() {	2090	public int literalIndexForJavaLangShort() {
Lines 2152-2158 Link Here
2152	/**	2137	/**
2153	* This method returns the index into the constantPool corresponding to the type descriptor.	2138	* This method returns the index into the constantPool corresponding to the type descriptor.
2154	*	2139	*
2155	* @param TypeBinding aTypeBinding
2156	* @return <CODE>int</CODE>	2140	* @return <CODE>int</CODE>
2157	*/	2141	*/
2158	public int literalIndexForJavaLangString() {	2142	public int literalIndexForJavaLangString() {
Lines 2174-2180 Link Here
2174	/**	2158	/**
2175	* This method returns the index into the constantPool corresponding to the type descriptor.	2159	* This method returns the index into the constantPool corresponding to the type descriptor.
2176	*	2160	*
2177	* @param TypeBinding aTypeBinding
2178	* @return <CODE>int</CODE>	2161	* @return <CODE>int</CODE>
2179	*/	2162	*/
2180	public int literalIndexForJavaLangStringBuffer() {	2163	public int literalIndexForJavaLangStringBuffer() {
Lines 2728-2734 Link Here
2728	/**	2711	/**
2729	* This method returns the index into the constantPool corresponding to the type descriptor.	2712	* This method returns the index into the constantPool corresponding to the type descriptor.
2730	*	2713	*
2731	* @param TypeBinding aTypeBinding
2732	* @return <CODE>int</CODE>	2714	* @return <CODE>int</CODE>
2733	*/	2715	*/
2734	public int literalIndexForJavaLangSystem() {	2716	public int literalIndexForJavaLangSystem() {
Lines 2817-2823 Link Here
2817	/**	2799	/**
2818	* This method returns the index into the constantPool corresponding to the type descriptor.	2800	* This method returns the index into the constantPool corresponding to the type descriptor.
2819	*	2801	*
2820	* @param TypeBinding aTypeBinding
2821	* @return <CODE>int</CODE>	2802	* @return <CODE>int</CODE>
2822	*/	2803	*/
2823	public int literalIndexForJavaLangThrowable() {	2804	public int literalIndexForJavaLangThrowable() {
Lines 2875-2881 Link Here
2875	/**	2856	/**
2876	* This method returns the index into the constantPool corresponding to the type descriptor.	2857	* This method returns the index into the constantPool corresponding to the type descriptor.
2877	*	2858	*
2878	* @param TypeBinding aTypeBinding
2879	* @return <CODE>int</CODE>	2859	* @return <CODE>int</CODE>
2880	*/	2860	*/
2881	public int literalIndexForJavaLangVoid() {	2861	public int literalIndexForJavaLangVoid() {
Lines 2928-2934 Link Here
2928	/**	2908	/**
2929	* This method returns the index into the constantPool corresponding to the type descriptor.	2909	* This method returns the index into the constantPool corresponding to the type descriptor.
2930	*	2910	*
2931	* @param char[] stringName	2911	* @param stringCharArray char[]
2932	* @return <CODE>int</CODE>	2912	* @return <CODE>int</CODE>
2933	*/	2913	*/
2934	public int literalIndexForLdc(char[] stringCharArray) {	2914	public int literalIndexForLdc(char[] stringCharArray) {
Lines 2999-3007 Link Here
2999	* This method returns the index into the constantPool corresponding	2979	* This method returns the index into the constantPool corresponding
3000	* nameAndType constant with nameIndex, typeIndex.	2980	* nameAndType constant with nameIndex, typeIndex.
3001	*	2981	*
3002	* @param int nameIndex	2982	* @param nameIndex int
3003	* @param int nameIndex	2983	* @param typeIndex int
3004	* @param org.eclipse.jdt.internal.compiler.lookup.MethodBinding a methodBinding	2984	* @param key org.eclipse.jdt.internal.compiler.lookup.MethodBinding
3005	* @return <CODE>int</CODE>	2985	* @return <CODE>int</CODE>
3006	*/	2986	*/
3007	public int literalIndexForMethods(int nameIndex, int typeIndex, MethodBinding key) {	2987	public int literalIndexForMethods(int nameIndex, int typeIndex, MethodBinding key) {
Lines 3087-3093 Link Here
3087	/**	3067	/**
3088	* Write a unsigned byte into the byte array	3068	* Write a unsigned byte into the byte array
3089	*	3069	*
3090	* @param <CODE>int</CODE> The value to write into the byte array	3070	* @param value <CODE>int</CODE> The value to write into the byte array
3091	*/	3071	*/
3092	protected final void writeU1(int value) {	3072	protected final void writeU1(int value) {
3093	try {	3073	try {
Lines 3102-3108 Link Here
3102	/**	3082	/**
3103	* Write a unsigned byte into the byte array	3083	* Write a unsigned byte into the byte array
3104	*	3084	*
3105	* @param <CODE>int</CODE> The value to write into the byte array	3085	* @param value <CODE>int</CODE> The value to write into the byte array
3106	*/	3086	*/
3107	protected final void writeU2(int value) {	3087	protected final void writeU2(int value) {
3108	//first byte	3088	//first byte

Lines 34-40 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/env/NameEnvironmentAnswer.java (-6 / +6 lines)
34	* receiver represents a compilation unit or source type.	34	* receiver represents a compilation unit or source type.
35	*/	35	*/
36	public IBinaryType getBinaryType() {	36	public IBinaryType getBinaryType() {
37	return binaryType;	37	return this.binaryType;
38	}	38	}
39		39
40	/**	40	/**
Lines 42-48 Link Here
42	* receiver represents a binary or source type.	42	* receiver represents a binary or source type.
43	*/	43	*/
44	public ICompilationUnit getCompilationUnit() {	44	public ICompilationUnit getCompilationUnit() {
45	return compilationUnit;	45	return this.compilationUnit;
46	}	46	}
47		47
48	/**	48	/**
Lines 53-79 Link Here
53	* several type at once. Then the first type is guaranteed to be the requested type.	53	* several type at once. Then the first type is guaranteed to be the requested type.
54	*/	54	*/
55	public ISourceType[] getSourceTypes() {	55	public ISourceType[] getSourceTypes() {
56	return sourceTypes;	56	return this.sourceTypes;
57	}	57	}
58		58
59	/**	59	/**
60	* Answer whether the receiver contains the resolved binary form of the type.	60	* Answer whether the receiver contains the resolved binary form of the type.
61	*/	61	*/
62	public boolean isBinaryType() {	62	public boolean isBinaryType() {
63	return binaryType != null;	63	return this.binaryType != null;
64	}	64	}
65		65
66	/**	66	/**
67	* Answer whether the receiver contains the compilation unit which defines the type.	67	* Answer whether the receiver contains the compilation unit which defines the type.
68	*/	68	*/
69	public boolean isCompilationUnit() {	69	public boolean isCompilationUnit() {
70	return compilationUnit != null;	70	return this.compilationUnit != null;
71	}	71	}
72		72
73	/**	73	/**
74	* Answer whether the receiver contains the unresolved source form of the type.	74	* Answer whether the receiver contains the unresolved source form of the type.
75	*/	75	*/
76	public boolean isSourceType() {	76	public boolean isSourceType() {
77	return sourceTypes != null;	77	return this.sourceTypes != null;
78	}	78	}
79	}	79	}

Lines 183-189 Link Here

(-)dom/org/eclipse/jdt/core/dom/CompilationUnit.java (-3 / +3 lines)
183	* For example, the source string <code>A\nB\nC</code> has	183	* For example, the source string <code>A\nB\nC</code> has
184	* line end table {1, 3, 4}.	184	* line end table {1, 3, 4}.
185	*	185	*
186	* @param lineEndtable the line end table	186	* @param lineEndTable the line end table
187	*/	187	*/
188	void setLineEndTable(int[] lineEndTable) {	188	void setLineEndTable(int[] lineEndTable) {
189	if (lineEndTable == null) {	189	if (lineEndTable == null) {
Lines 470-476 Link Here
470		470
471	/**	471	/**
472	* Returns the extended start position of the given node. Unlike	472	* Returns the extended start position of the given node. Unlike
473	* {@link ASTNode#getStartPosition()} and {@link ASTNode#getLength()()},	473	* {@link ASTNode#getStartPosition()} and {@link ASTNode#getLength()},
474	* the extended source range may include comments and whitespace	474	* the extended source range may include comments and whitespace
475	* immediately before or after the normal source range for the node.	475	* immediately before or after the normal source range for the node.
476	*	476	*
Lines 490-496 Link Here
490		490
491	/**	491	/**
492	* Returns the extended source length of the given node. Unlike	492	* Returns the extended source length of the given node. Unlike
493	* {@link ASTNode#getStartPosition()} and {@link ASTNode#getLength()()},	493	* {@link ASTNode#getStartPosition()} and {@link ASTNode#getLength()},
494	* the extended source range may include comments and whitespace	494	* the extended source range may include comments and whitespace
495	* immediately before or after the normal source range for the node.	495	* immediately before or after the normal source range for the node.
496	*	496	*

Lines 431-437 Link Here

(-)eval/org/eclipse/jdt/internal/eval/CodeSnippetConstantPool.java (-6 / +6 lines)
431	* Returns -1 if the @methodBinding is not a predefined methodBinding,	431	* Returns -1 if the @methodBinding is not a predefined methodBinding,
432	* the right index otherwise.	432	* the right index otherwise.
433	*	433	*
434	* @param methodBindingorg.eclipse.jdt.internal.compiler.lookup.MethodBinding	434	* @param methodBinding org.eclipse.jdt.internal.compiler.lookup.MethodBinding
435	* @return <CODE>int</CODE>	435	* @return <CODE>int</CODE>
436	*/	436	*/
437	public int indexOfWellKnownMethods(MethodBinding methodBinding) {	437	public int indexOfWellKnownMethods(MethodBinding methodBinding) {
Lines 683-689 Link Here
683	* method descriptor. It can be either an interface method reference constant	683	* method descriptor. It can be either an interface method reference constant
684	* or a method reference constant.	684	* or a method reference constant.
685	*	685	*
686	* @param MethodBinding aMethodBinding	686	* @param aMethodBinding MethodBinding
687	* @return <CODE>int</CODE>	687	* @return <CODE>int</CODE>
688	*/	688	*/
689	public int literalIndex(MethodBinding aMethodBinding) {	689	public int literalIndex(MethodBinding aMethodBinding) {
Lines 777-783 Link Here
777	/**	777	/**
778	* This method returns the index into the constantPool corresponding to the type descriptor.	778	* This method returns the index into the constantPool corresponding to the type descriptor.
779	*	779	*
780	* @param TypeBinding aTypeBinding	780	* @param aTypeBinding TypeBinding
781	* @return <CODE>int</CODE>	781	* @return <CODE>int</CODE>
782	*/	782	*/
783	public int literalIndex(TypeBinding aTypeBinding) {	783	public int literalIndex(TypeBinding aTypeBinding) {
Lines 1355-1363 Link Here
1355	* This method returns the index into the constantPool corresponding	1355	* This method returns the index into the constantPool corresponding
1356	* nameAndType constant with nameIndex, typeIndex.	1356	* nameAndType constant with nameIndex, typeIndex.
1357	*	1357	*
1358	* @param int nameIndex	1358	* @param nameIndex int
1359	* @param int nameIndex	1359	* @param typeIndex int
1360	* @param org.eclipse.jdt.internal.compiler.lookup.MethodBinding a methodBinding	1360	* @param key org.eclipse.jdt.internal.compiler.lookup.MethodBinding
1361	* @return <CODE>int</CODE>	1361	* @return <CODE>int</CODE>
1362	*/	1362	*/
1363	public int literalIndexForMethods(int nameIndex, int typeIndex, MethodBinding key) {	1363	public int literalIndexForMethods(int nameIndex, int typeIndex, MethodBinding key) {

Lines 31-38 Link Here

(-)model/org/eclipse/jdt/core/CompletionProposal.java (-4 / +4 lines)
31	* The proposal is as follows: insert	31	* The proposal is as follows: insert
32	* the {@linkplain #getCompletion() completion string} into the	32	* the {@linkplain #getCompletion() completion string} into the
33	* source file buffer, replacing the characters between	33	* source file buffer, replacing the characters between
34	* {@linkplain #getReplaceStart()() the start}	34	* {@linkplain #getReplaceStart() the start}
35	* and {@linkplain #getReplaceEnd()() end}. The string	35	* and {@linkplain #getReplaceEnd() end}. The string
36	* can be arbitrary; for example, it might include not only the	36	* can be arbitrary; for example, it might include not only the
37	* name of a method but a set of parentheses. Moreover, the source	37	* name of a method but a set of parentheses. Moreover, the source
38	* range may include source positions before or after the source	38	* range may include source positions before or after the source
Lines 429-435 Link Here
429	\|\| (kind > CompletionProposal.VARIABLE_DECLARATION)) {	429	\|\| (kind > CompletionProposal.VARIABLE_DECLARATION)) {
430	throw new IllegalArgumentException();	430	throw new IllegalArgumentException();
431	}	431	}
432	if (completion == null \|\| completionLocation < 0) {	432	if (this.completion == null \|\| completionLocation < 0) {
433	throw new IllegalArgumentException();	433	throw new IllegalArgumentException();
434	}	434	}
435	this.completionKind = kind;	435	this.completionKind = kind;
Lines 880-886 Link Here
880	* or not available or not relevant	880	* or not available or not relevant
881	*/	881	*/
882	public char[][] findParameterNames(IProgressMonitor monitor) {	882	public char[][] findParameterNames(IProgressMonitor monitor) {
883	if (!parameterNamesComputed) {	883	if (!this.parameterNamesComputed) {
884	this.parameterNamesComputed = true;	884	this.parameterNamesComputed = true;
885	// TODO (jerome) - Missing implementation	885	// TODO (jerome) - Missing implementation
886	}	886	}

Lines 26-32 Link Here

(-)model/org/eclipse/jdt/internal/core/JarPackageFragment.java (-4 / +4 lines)
26	/**	26	/**
27	* A package fragment that represents a package fragment found in a JAR.	27	* A package fragment that represents a package fragment found in a JAR.
28	*	28	*
29	* @see IPackageFragment	29	* @see org.eclipse.jdt.core.IPackageFragment
30	*/	30	*/
31	class JarPackageFragment extends PackageFragment implements SuffixConstants {	31	class JarPackageFragment extends PackageFragment implements SuffixConstants {
32	/**	32	/**
Lines 90-96 Link Here
90	return ((JarPackageFragmentInfo) getElementInfo()).containsJavaResources();	90	return ((JarPackageFragmentInfo) getElementInfo()).containsJavaResources();
91	}	91	}
92	/**	92	/**
93	* @see IPackageFragment	93	* @see org.eclipse.jdt.core.IPackageFragment
94	*/	94	*/
95	public ICompilationUnit createCompilationUnit(String cuName, String contents, boolean force, IProgressMonitor monitor) throws JavaModelException {	95	public ICompilationUnit createCompilationUnit(String cuName, String contents, boolean force, IProgressMonitor monitor) throws JavaModelException {
96	throw new JavaModelException(new JavaModelStatus(IJavaModelStatusConstants.READ_ONLY, this));	96	throw new JavaModelException(new JavaModelStatus(IJavaModelStatusConstants.READ_ONLY, this));
Lines 112-118 Link Here
112	}	112	}
113	}	113	}
114	/**	114	/**
115	* @see IPackageFragment	115	* @see org.eclipse.jdt.core.IPackageFragment
116	*/	116	*/
117	public IClassFile[] getClassFiles() throws JavaModelException {	117	public IClassFile[] getClassFiles() throws JavaModelException {
118	ArrayList list = getChildrenOfType(CLASS_FILE);	118	ArrayList list = getChildrenOfType(CLASS_FILE);
Lines 122-128 Link Here
122	}	122	}
123	/**	123	/**
124	* A jar package fragment never contains compilation units.	124	* A jar package fragment never contains compilation units.
125	* @see IPackageFragment	125	* @see org.eclipse.jdt.core.IPackageFragment
126	*/	126	*/
127	public ICompilationUnit[] getCompilationUnits() {	127	public ICompilationUnit[] getCompilationUnits() {
128	return NO_COMPILATION_UNITS;	128	return NO_COMPILATION_UNITS;

Lines 30-36 Link Here

(-)model/org/eclipse/jdt/internal/core/MultiOperation.java (-7 / +7 lines)
30	* Table specifying insertion positions for elements being	30	* Table specifying insertion positions for elements being
31	* copied/moved/renamed. Keyed by elements being processed, and	31	* copied/moved/renamed. Keyed by elements being processed, and
32	* values are the corresponding insertion point.	32	* values are the corresponding insertion point.
33	* @see processElements(IProgressMonitor)	33	* @see #processElements()
34	*/	34	*/
35	protected Map insertBeforeElements = new HashMap(1);	35	protected Map insertBeforeElements = new HashMap(1);
36	/**	36	/**
Lines 114-124 Link Here
114	* values are the new name.	114	* values are the new name.
115	*/	115	*/
116	private void initializeRenamings() {	116	private void initializeRenamings() {
117	if (this.renamingsList != null && this.renamingsList.length == elementsToProcess.length) {	117	if (this.renamingsList != null && this.renamingsList.length == this.elementsToProcess.length) {
118	this.renamings = new HashMap(this.renamingsList.length);	118	this.renamings = new HashMap(this.renamingsList.length);
119	for (int i = 0; i < this.renamingsList.length; i++) {	119	for (int i = 0; i < this.renamingsList.length; i++) {
120	if (this.renamingsList[i] != null) {	120	if (this.renamingsList[i] != null) {
121	this.renamings.put(elementsToProcess[i], this.renamingsList[i]);	121	this.renamings.put(this.elementsToProcess[i], this.renamingsList[i]);
122	}	122	}
123	}	123	}
124	}	124	}
Lines 151-163 Link Here
151	* be completed.	151	* be completed.
152	*/	152	*/
153	protected void processElements() throws JavaModelException {	153	protected void processElements() throws JavaModelException {
154	beginTask(getMainTaskName(), elementsToProcess.length);	154	beginTask(getMainTaskName(), this.elementsToProcess.length);
155	IJavaModelStatus[] errors = new IJavaModelStatus[3];	155	IJavaModelStatus[] errors = new IJavaModelStatus[3];
156	int errorsCounter = 0;	156	int errorsCounter = 0;
157	for (int i = 0; i < elementsToProcess.length; i++) {	157	for (int i = 0; i < this.elementsToProcess.length; i++) {
158	try {	158	try {
159	verify(elementsToProcess[i]);	159	verify(this.elementsToProcess[i]);
160	processElement(elementsToProcess[i]);	160	processElement(this.elementsToProcess[i]);
161	} catch (JavaModelException jme) {	161	} catch (JavaModelException jme) {
162	if (errorsCounter == errors.length) {	162	if (errorsCounter == errors.length) {
163	// resize	163	// resize

Lines 48-54 Link Here

(-)model/org/eclipse/jdt/internal/core/PackageFragmentRootInfo.java (-8 / +6 lines)
48	* Create and initialize a new instance of the receiver	48	* Create and initialize a new instance of the receiver
49	*/	49	*/
50	public PackageFragmentRootInfo() {	50	public PackageFragmentRootInfo() {
51	fNonJavaResources = null;	51	this.fNonJavaResources = null;
52	}	52	}
53	/**	53	/**
54	* Starting at this folder, create non-java resources for this package fragment root	54	* Starting at this folder, create non-java resources for this package fragment root
Lines 104-111 Link Here
104	}	104	}
105	/**	105	/**
106	* Compute the non-package resources of this package fragment root.	106	* Compute the non-package resources of this package fragment root.
107	*
108	* @exception JavaModelException The resource associated with this package fragment root does not exist
109	*/	107	*/
110	private Object[] computeNonJavaResources(IJavaProject project, IResource underlyingResource, PackageFragmentRoot handle) {	108	private Object[] computeNonJavaResources(IJavaProject project, IResource underlyingResource, PackageFragmentRoot handle) {
111	Object[] nonJavaResources = NO_NON_JAVA_RESOURCES;	109	Object[] nonJavaResources = NO_NON_JAVA_RESOURCES;
Lines 129-138 Link Here
129	* Returns an array of non-java resources contained in the receiver.	127	* Returns an array of non-java resources contained in the receiver.
130	*/	128	*/
131	synchronized Object[] getNonJavaResources(IJavaProject project, IResource underlyingResource, PackageFragmentRoot handle) {	129	synchronized Object[] getNonJavaResources(IJavaProject project, IResource underlyingResource, PackageFragmentRoot handle) {
132	Object[] nonJavaResources = fNonJavaResources;	130	Object[] nonJavaResources = this.fNonJavaResources;
133	if (nonJavaResources == null) {	131	if (nonJavaResources == null) {
134	nonJavaResources = this.computeNonJavaResources(project, underlyingResource, handle);	132	nonJavaResources = this.computeNonJavaResources(project, underlyingResource, handle);
135	fNonJavaResources = nonJavaResources;	133	this.fNonJavaResources = nonJavaResources;
136	}	134	}
137	return nonJavaResources;	135	return nonJavaResources;
138	}	136	}
Lines 140-146 Link Here
140	* Returns the kind of this root.	138	* Returns the kind of this root.
141	*/	139	*/
142	public int getRootKind() {	140	public int getRootKind() {
143	return fRootKind;	141	return this.fRootKind;
144	}	142	}
145	/**	143	/**
146	* Retuns the SourceMapper for this root, or <code>null</code>	144	* Retuns the SourceMapper for this root, or <code>null</code>
Lines 162-174 Link Here
162	* Set the fNonJavaResources to res value	160	* Set the fNonJavaResources to res value
163	*/	161	*/
164	void setNonJavaResources(Object[] resources) {	162	void setNonJavaResources(Object[] resources) {
165	fNonJavaResources = resources;	163	this.fNonJavaResources = resources;
166	}	164	}
167	/**	165	/**
168	* Sets the kind of this root.	166	* Sets the kind of this root.
169	*/	167	*/
170	protected void setRootKind(int newRootKind) {	168	protected void setRootKind(int newRootKind) {
171	fRootKind = newRootKind;	169	this.fRootKind = newRootKind;
172	}	170	}
173	/**	171	/**
174	* Sets the SourceMapper for this root.	172	* Sets the SourceMapper for this root.

Lines 982-988 Link Here

(-)model/org/eclipse/jdt/internal/core/SortElementBuilder.java (-8 / +8 lines)
982	}	982	}
983		983
984	void sort() {	984	void sort() {
985	compilationUnit.sort();	985	this.compilationUnit.sort();
986	}	986	}
987		987
988	void mapNextPosition(SortJavaElement node, int start, int end) {	988	void mapNextPosition(SortJavaElement node, int start, int end) {
Lines 999-1005 Link Here
999	this.positionsToMapIndex = i;	999	this.positionsToMapIndex = i;
1000	}	1000	}
1001	/**	1001	/**
1002	* @see org.eclipse.jdt.internal.compiler.ISourceElementRequestor#enterClass(int, int, char, int, int, char, char)	1002	* @see org.eclipse.jdt.internal.compiler.ISourceElementRequestor#enterClass(int, int, char[], int, int, char[], char[][])
1003	*/	1003	*/
1004	public void enterClass(	1004	public void enterClass(
1005	int declarationStart,	1005	int declarationStart,
Lines 1019-1029 Link Here
1019	*/	1019	*/
1020	public void enterCompilationUnit() {	1020	public void enterCompilationUnit() {
1021	this.stack = new Stack();	1021	this.stack = new Stack();
1022	push(compilationUnit = new SortCompilationUnit(0));	1022	push(this.compilationUnit = new SortCompilationUnit(0));
1023	}	1023	}
1024		1024
1025	/**	1025	/**
1026	* @see org.eclipse.jdt.internal.compiler.ISourceElementRequestor#enterConstructor(int, int, char, int, int, char, char, char)	1026	* @see org.eclipse.jdt.internal.compiler.ISourceElementRequestor#enterConstructor(int, int, char[], int, int, char[][], char[][], char[][])
1027	*/	1027	*/
1028	public void enterConstructor(	1028	public void enterConstructor(
1029	int declarationStart,	1029	int declarationStart,
Lines 1042-1048 Link Here
1042	}	1042	}
1043		1043
1044	/**	1044	/**
1045	* @see org.eclipse.jdt.internal.compiler.ISourceElementRequestor#enterField(int, int, char, char, int, int)	1045	* @see org.eclipse.jdt.internal.compiler.ISourceElementRequestor#enterField(int, int, char[], char[], int, int)
1046	*/	1046	*/
1047	public void enterField(	1047	public void enterField(
1048	int declarationStart,	1048	int declarationStart,
Lines 1084-1090 Link Here
1084	}	1084	}
1085		1085
1086	/**	1086	/**
1087	* @see org.eclipse.jdt.internal.compiler.ISourceElementRequestor#enterInterface(int, int, char, int, int, char)	1087	* @see org.eclipse.jdt.internal.compiler.ISourceElementRequestor#enterInterface(int, int, char[], int, int, char[][])
1088	*/	1088	*/
1089	public void enterInterface(	1089	public void enterInterface(
1090	int declarationStart,	1090	int declarationStart,
Lines 1099-1105 Link Here
1099	}	1099	}
1100		1100
1101	/**	1101	/**
1102	* @see org.eclipse.jdt.internal.compiler.ISourceElementRequestor#enterMethod(int, int, char, char, int, int, char, char, char)	1102	* @see org.eclipse.jdt.internal.compiler.ISourceElementRequestor#enterMethod(int, int, char[], char[], int, int, char[][], char[][], char[][])
1103	*/	1103	*/
1104	public void enterMethod(	1104	public void enterMethod(
1105	int declarationStart,	1105	int declarationStart,
Lines 1141-1147 Link Here
1141	}	1141	}
1142		1142
1143	/**	1143	/**
1144	* @see org.eclipse.jdt.internal.compiler.ISourceElementRequestor#exitField(int, int)	1144	* @see org.eclipse.jdt.internal.compiler.ISourceElementRequestor#exitField(int, int, int)
1145	*/	1145	*/
1146	public void exitField(int initializationStart, int declarationEnd, int declarationSourceEnd) {	1146	public void exitField(int initializationStart, int declarationEnd, int declarationSourceEnd) {
1147	int normalizedDeclarationSourceEnd = this.normalizeSourceEnd(declarationSourceEnd);	1147	int normalizedDeclarationSourceEnd = this.normalizeSourceEnd(declarationSourceEnd);

Lines 283-289 Link Here

(-)model/org/eclipse/jdt/internal/core/SourceMapper.java (-3 / +3 lines)
283	* Converts these type names to unqualified signatures. This needs to be done in order to be consistent	283	* Converts these type names to unqualified signatures. This needs to be done in order to be consistent
284	* with the way the source range is retrieved.	284	* with the way the source range is retrieved.
285	* @see SourceMapper#getUnqualifiedMethodHandle	285	* @see SourceMapper#getUnqualifiedMethodHandle
286	* @see Signature.	286	* @see Signature
287	*/	287	*/
288	private String[] convertTypeNamesToSigs(char[][] typeNames) {	288	private String[] convertTypeNamesToSigs(char[][] typeNames) {
289	if (typeNames == null)	289	if (typeNames == null)
Lines 1152-1158 Link Here
1152	/**	1152	/**
1153	* Sets the mapping for this method to its parameter names.	1153	* Sets the mapping for this method to its parameter names.
1154	*	1154	*
1155	* @see fParameterNames	1155	* @see #fParameterNames
1156	*/	1156	*/
1157	protected void setMethodParameterNames(	1157	protected void setMethodParameterNames(
1158	IMethod method,	1158	IMethod method,
Lines 1167-1173 Link Here
1167	* Sets the mapping for this element to its source ranges for its source range	1167	* Sets the mapping for this element to its source ranges for its source range
1168	* and name range.	1168	* and name range.
1169	*	1169	*
1170	* @see fSourceRanges	1170	* @see #fSourceRanges
1171	*/	1171	*/
1172	protected void setSourceRange(	1172	protected void setSourceRange(
1173	IJavaElement element,	1173	IJavaElement element,

Lines 420-426 Link Here

(-)model/org/eclipse/jdt/internal/core/hierarchy/TypeHierarchy.java (-24 / +24 lines)
420	return getAllSubtypesForType(type);	420	return getAllSubtypesForType(type);
421	}	421	}
422	/**	422	/**
423	* @see getAllSubtypes(IType)	423	* @see #getAllSubtypes(IType)
424	*/	424	*/
425	private IType[] getAllSubtypesForType(IType type) {	425	private IType[] getAllSubtypesForType(IType type) {
426	ArrayList subTypes = new ArrayList();	426	ArrayList subTypes = new ArrayList();
Lines 540-546 Link Here
540	}	540	}
541	/**	541	/**
542	* Assumes that the type is an interface	542	* Assumes that the type is an interface
543	* @see getExtendingInterfaces	543	* @see #getExtendingInterfaces
544	*/	544	*/
545	private IType[] getExtendingInterfaces0(IType extendedInterface) {	545	private IType[] getExtendingInterfaces0(IType extendedInterface) {
546	Iterator iter = this.typeToSuperInterfaces.keySet().iterator();	546	Iterator iter = this.typeToSuperInterfaces.keySet().iterator();
Lines 575-581 Link Here
575	}	575	}
576	/**	576	/**
577	* Assumes that the type is an interface	577	* Assumes that the type is an interface
578	* @see getImplementingClasses	578	* @see #getImplementingClasses
579	*/	579	*/
580	private IType[] getImplementingClasses0(IType interfce) {	580	private IType[] getImplementingClasses0(IType interfce) {
581		581
Lines 1213-1219 Link Here
1213	this.progressMonitor = monitor;	1213	this.progressMonitor = monitor;
1214	if (monitor != null) {	1214	if (monitor != null) {
1215	if (this.focusType != null) {	1215	if (this.focusType != null) {
1216	monitor.beginTask(Util.bind("hierarchy.creatingOnType", focusType.getFullyQualifiedName()), 100); //$NON-NLS-1$	1216	monitor.beginTask(Util.bind("hierarchy.creatingOnType", this.focusType.getFullyQualifiedName()), 100); //$NON-NLS-1$
1217	} else {	1217	} else {
1218	monitor.beginTask(Util.bind("hierarchy.creating"), 100); //$NON-NLS-1$	1218	monitor.beginTask(Util.bind("hierarchy.creating"), 100); //$NON-NLS-1$
1219	}	1219	}
Lines 1281-1292 Link Here
1281	Hashtable hashtable2 = new Hashtable();	1281	Hashtable hashtable2 = new Hashtable();
1282	int count = 0;	1282	int count = 0;
1283		1283
1284	if(focusType != null) {	1284	if(this.focusType != null) {
1285	Integer index = new Integer(count++);	1285	Integer index = new Integer(count++);
1286	hashtable.put(focusType, index);	1286	hashtable.put(this.focusType, index);
1287	hashtable2.put(index, focusType);	1287	hashtable2.put(index, this.focusType);
1288	}	1288	}
1289	Object[] types = classToSuperclass.keySet().toArray();	1289	Object[] types = this.classToSuperclass.keySet().toArray();
1290	for (int i = 0; i < types.length; i++) {	1290	for (int i = 0; i < types.length; i++) {
1291	Object t = types[i];	1291	Object t = types[i];
1292	if(hashtable.get(t) == null) {	1292	if(hashtable.get(t) == null) {
Lines 1294-1307 Link Here
1294	hashtable.put(t, index);	1294	hashtable.put(t, index);
1295	hashtable2.put(index, t);	1295	hashtable2.put(index, t);
1296	}	1296	}
1297	Object superClass = classToSuperclass.get(t);	1297	Object superClass = this.classToSuperclass.get(t);
1298	if(superClass != null && hashtable.get(superClass) == null) {	1298	if(superClass != null && hashtable.get(superClass) == null) {
1299	Integer index = new Integer(count++);	1299	Integer index = new Integer(count++);
1300	hashtable.put(superClass, index);	1300	hashtable.put(superClass, index);
1301	hashtable2.put(index, superClass);	1301	hashtable2.put(index, superClass);
1302	}	1302	}
1303	}	1303	}
1304	types = typeToSuperInterfaces.keySet().toArray();	1304	types = this.typeToSuperInterfaces.keySet().toArray();
1305	for (int i = 0; i < types.length; i++) {	1305	for (int i = 0; i < types.length; i++) {
1306	Object t = types[i];	1306	Object t = types[i];
1307	if(hashtable.get(t) == null) {	1307	if(hashtable.get(t) == null) {
Lines 1309-1315 Link Here
1309	hashtable.put(t, index);	1309	hashtable.put(t, index);
1310	hashtable2.put(index, t);	1310	hashtable2.put(index, t);
1311	}	1311	}
1312	Object[] sp = (Object[])typeToSuperInterfaces.get(t);	1312	Object[] sp = (Object[])this.typeToSuperInterfaces.get(t);
1313	if(sp != null) {	1313	if(sp != null) {
1314	for (int j = 0; j < sp.length; j++) {	1314	for (int j = 0; j < sp.length; j++) {
1315	Object superInterface = sp[j];	1315	Object superInterface = sp[j];
Lines 1326-1348 Link Here
1326		1326
1327	// save general info	1327	// save general info
1328	byte generalInfo = 0;	1328	byte generalInfo = 0;
1329	if(computeSubtypes) {	1329	if(this.computeSubtypes) {
1330	generalInfo \|= COMPUTE_SUBTYPES;	1330	generalInfo \|= COMPUTE_SUBTYPES;
1331	}	1331	}
1332	output.write(generalInfo);	1332	output.write(generalInfo);
1333		1333
1334	// save project	1334	// save project
1335	if(project != null) {	1335	if(this.project != null) {
1336	output.write(project.getHandleIdentifier().getBytes());	1336	output.write(this.project.getHandleIdentifier().getBytes());
1337	}	1337	}
1338	output.write(SEPARATOR1);	1338	output.write(SEPARATOR1);
1339		1339
1340	// save missing types	1340	// save missing types
1341	for (int i = 0; i < missingTypes.size(); i++) {	1341	for (int i = 0; i < this.missingTypes.size(); i++) {
1342	if(i != 0) {	1342	if(i != 0) {
1343	output.write(SEPARATOR2);	1343	output.write(SEPARATOR2);
1344	}	1344	}
1345	output.write(((String)missingTypes.get(i)).getBytes());	1345	output.write(((String)this.missingTypes.get(i)).getBytes());
1346		1346
1347	}	1347	}
1348	output.write(SEPARATOR1);	1348	output.write(SEPARATOR1);
Lines 1354-1369 Link Here
1354	// n bytes	1354	// n bytes
1355	output.write(t.getHandleIdentifier().getBytes());	1355	output.write(t.getHandleIdentifier().getBytes());
1356	output.write(SEPARATOR4);	1356	output.write(SEPARATOR4);
1357	output.write(flagsToBytes((Integer)typeFlags.get(t)));	1357	output.write(flagsToBytes((Integer)this.typeFlags.get(t)));
1358	output.write(SEPARATOR4);	1358	output.write(SEPARATOR4);
1359	byte info = CLASS;	1359	byte info = CLASS;
1360	if(focusType != null && focusType.equals(t)) {	1360	if(this.focusType != null && this.focusType.equals(t)) {
1361	info \|= COMPUTED_FOR;	1361	info \|= COMPUTED_FOR;
1362	}	1362	}
1363	if(interfaces.contains(t)) {	1363	if(this.interfaces.contains(t)) {
1364	info \|= INTERFACE;	1364	info \|= INTERFACE;
1365	}	1365	}
1366	if(rootClasses.contains(t)) {	1366	if(this.rootClasses.contains(t)) {
1367	info \|= ROOT;	1367	info \|= ROOT;
1368	}	1368	}
1369	output.write(info);	1369	output.write(info);
Lines 1371-1380 Link Here
1371	output.write(SEPARATOR1);	1371	output.write(SEPARATOR1);
1372		1372
1373	// save superclasses	1373	// save superclasses
1374	types = classToSuperclass.keySet().toArray();	1374	types = this.classToSuperclass.keySet().toArray();
1375	for (int i = 0; i < types.length; i++) {	1375	for (int i = 0; i < types.length; i++) {
1376	IJavaElement key = (IJavaElement)types[i];	1376	IJavaElement key = (IJavaElement)types[i];
1377	IJavaElement value = (IJavaElement)classToSuperclass.get(key);	1377	IJavaElement value = (IJavaElement)this.classToSuperclass.get(key);
1378		1378
1379	output.write(((Integer)hashtable.get(key)).toString().getBytes());	1379	output.write(((Integer)hashtable.get(key)).toString().getBytes());
1380	output.write('>');	1380	output.write('>');
Lines 1384-1393 Link Here
1384	output.write(SEPARATOR1);	1384	output.write(SEPARATOR1);
1385		1385
1386	// save superinterfaces	1386	// save superinterfaces
1387	types = typeToSuperInterfaces.keySet().toArray();	1387	types = this.typeToSuperInterfaces.keySet().toArray();
1388	for (int i = 0; i < types.length; i++) {	1388	for (int i = 0; i < types.length; i++) {
1389	IJavaElement key = (IJavaElement)types[i];	1389	IJavaElement key = (IJavaElement)types[i];
1390	IJavaElement[] values = (IJavaElement[])typeToSuperInterfaces.get(key);	1390	IJavaElement[] values = (IJavaElement[])this.typeToSuperInterfaces.get(key);
1391		1391
1392	if(values.length > 0) {	1392	if(values.length > 0) {
1393	output.write(((Integer)hashtable.get(key)).toString().getBytes());	1393	output.write(((Integer)hashtable.get(key)).toString().getBytes());

Lines 83-89 Link Here

(-)model/org/eclipse/jdt/internal/core/jdom/AbstractDOMBuilder.java (-3 / +3 lines)
83	*	83	*
84	* <p>A line separator might corresponds to several characters in the source.	84	* <p>A line separator might corresponds to several characters in the source.
85	*	85	*
86	* @see IDocumentElementRequestor#acceptLineSeparatorPositions(int[])	86	* @see org.eclipse.jdt.internal.compiler.IDocumentElementRequestor#acceptLineSeparatorPositions(int[])
87	*/	87	*/
88	public void acceptLineSeparatorPositions(int[] positions) {	88	public void acceptLineSeparatorPositions(int[] positions) {
89	if (positions != null) {	89	if (positions != null) {
Lines 147-153 Link Here
147	return (IDOMCompilationUnit)fNode;	147	return (IDOMCompilationUnit)fNode;
148	}	148	}
149	/**	149	/**
150	* @see IDocumentElementRequestor#enterClass(int, int[], int, int, int, char[], int, int, char[], int, int, char[][], int[], int[], int)	150	* @see org.eclipse.jdt.internal.compiler.IDocumentElementRequestor#enterClass(int, int[], int, int, int, char[], int, int, char[], int, int, char[][], int[], int[], int)
151	*/	151	*/
152	public void enterCompilationUnit() {	152	public void enterCompilationUnit() {
153	if (fBuildingCU) {	153	if (fBuildingCU) {
Lines 159-165 Link Here
159	* Finishes the configuration of the compilation unit DOM object which	159	* Finishes the configuration of the compilation unit DOM object which
160	* was created by a previous enterCompilationUnit call.	160	* was created by a previous enterCompilationUnit call.
161	*	161	*
162	* @see IDocumentElementRequestor#exitCompilationUnit(int)	162	* @see org.eclipse.jdt.internal.compiler.IDocumentElementRequestor#exitCompilationUnit(int)
163	*/	163	*/
164	public void exitCompilationUnit(int declarationEnd) {	164	public void exitCompilationUnit(int declarationEnd) {
165	DOMCompilationUnit cu = (DOMCompilationUnit) fStack.pop();	165	DOMCompilationUnit cu = (DOMCompilationUnit) fStack.pop();

Lines 546-552 Link Here

(-)model/org/eclipse/jdt/internal/core/jdom/DOMField.java (-3 / +3 lines)
546	setMask(MASK_FIELD_HAS_INITIALIZER, hasInitializer);	546	setMask(MASK_FIELD_HAS_INITIALIZER, hasInitializer);
547	}	547	}
548	/**	548	/**
549	* @see IDOMField#setInitializer(char[])	549	* @see IDOMField#setInitializer(String)
550	*/	550	*/
551	public void setInitializer(String initializer) {	551	public void setInitializer(String initializer) {
552	becomeDetailed();	552	becomeDetailed();
Lines 570-576 Link Here
570	setMask(MASK_FIELD_IS_VARIABLE_DECLARATOR, isVariableDeclarator);	570	setMask(MASK_FIELD_IS_VARIABLE_DECLARATOR, isVariableDeclarator);
571	}	571	}
572	/**	572	/**
573	* @see IDOMField#setName(char[])	573	* @see IDOMField#setName(String)
574	*/	574	*/
575	public void setName(String name) throws IllegalArgumentException {	575	public void setName(String name) throws IllegalArgumentException {
576	if (name == null) {	576	if (name == null) {
Lines 581-587 Link Here
581	}	581	}
582	}	582	}
583	/**	583	/**
584	* @see IDOMField#setType(char[])	584	* @see IDOMField#setType(String)
585	*/	585	*/
586	public void setType(String typeName) throws IllegalArgumentException {	586	public void setType(String typeName) throws IllegalArgumentException {
587	if (typeName == null) {	587	if (typeName == null) {

Lines 118-124 Link Here

(-)model/org/eclipse/jdt/internal/core/jdom/DOMInitializer.java (-3 / +3 lines)
118	// nothing to do	118	// nothing to do
119	}	119	}
120	/**	120	/**
121	* @see DOMNode#appendSimpleContents(CharArrayBuffer)	121	* @see DOMMember#appendSimpleContents(CharArrayBuffer)
122	*/	122	*/
123	protected void appendSimpleContents(CharArrayBuffer buffer) {	123	protected void appendSimpleContents(CharArrayBuffer buffer) {
124	// append eveything before my name	124	// append eveything before my name
Lines 180-186 Link Here
180	return IDOMNode.INITIALIZER;	180	return IDOMNode.INITIALIZER;
181	}	181	}
182	/**	182	/**
183	* @see IDOMNode#isSigantureEqual(IDOMNode).	183	* @see IDOMNode#isSignatureEqual(IDOMNode)
184	*	184	*
185	* <p>This method always answers false since an initializer	185	* <p>This method always answers false since an initializer
186	* does not have a signature.	186	* does not have a signature.
Lines 202-208 Link Here
202	offsetRange(fBodyRange, offset);	202	offsetRange(fBodyRange, offset);
203	}	203	}
204	/**	204	/**
205	* @see IDOMInitializer#setBody(char[])	205	* @see IDOMInitializer#setBody(String)
206	*/	206	*/
207	public void setBody(String body) {	207	public void setBody(String body) {
208	becomeDetailed();	208	becomeDetailed();

Lines 408-421 Link Here

(-)model/org/eclipse/jdt/internal/core/util/Disassembler.java (-2 / +10 lines)
408	}	408	}
409		409
410	/**	410	/**
411	* @see org.eclipse.jdt.core.util.IClassFileDisassembler#disassemble(org.eclipse.jdt.core.util.IClassFileReader, java.lang.String)	411	* @see #disassemble(org.eclipse.jdt.core.util.IClassFileReader, java.lang.String, int)
412	*/	412	*/
413	public String disassemble(IClassFileReader classFileReader, String lineSeparator) {	413	public String disassemble(IClassFileReader classFileReader, String lineSeparator) {
414	return disassemble(classFileReader, lineSeparator, ClassFileBytesDisassembler.DEFAULT);	414	return disassemble(classFileReader, lineSeparator, ClassFileBytesDisassembler.DEFAULT);
415	}	415	}
416		416
417	/**	417	/**
418	* @see org.eclipse.jdt.core.util.IClassFileDisassembler#disassemble(org.eclipse.jdt.core.util.IClassFileReader, java.lang.String, int)	418	* Answers back the disassembled string of the IClassFileReader according to the
		419	* mode.
		420	* This is an output quite similar to the javap tool.
		421	*
		422	* @param classFileReader The classFileReader to be disassembled
		423	* @param lineSeparator the line separator to use.
		424	* @param mode the mode used to disassemble the IClassFileReader
		425	*
		426	* @return the disassembled string of the IClassFileReader according to the mode
419	*/	427	*/
420	public String disassemble(IClassFileReader classFileReader, String lineSeparator, int mode) {	428	public String disassemble(IClassFileReader classFileReader, String lineSeparator, int mode) {
421	if (classFileReader == null) return EMPTY_OUTPUT;	429	if (classFileReader == null) return EMPTY_OUTPUT;

Lines 37-43 Link Here

(-)model/org/eclipse/jdt/internal/core/util/FieldInfo.java (-4 / +4 lines)
37		37
38	/**	38	/**
39	* @param classFileBytes byte[]	39	* @param classFileBytes byte[]
40	* @param offsets int[]	40	* @param constantPool IConstantPool
41	* @param offset int	41	* @param offset int
42	*/	42	*/
43	public FieldInfo(byte classFileBytes[], IConstantPool constantPool, int offset)	43	public FieldInfo(byte classFileBytes[], IConstantPool constantPool, int offset)
Lines 65-71 Link Here
65	this.attributes = new IClassFileAttribute[this.attributesCount];	65	this.attributes = new IClassFileAttribute[this.attributesCount];
66	}	66	}
67	int attributesIndex = 0;	67	int attributesIndex = 0;
68	for (int i = 0; i < attributesCount; i++) {	68	for (int i = 0; i < this.attributesCount; i++) {
69	constantPoolEntry = constantPool.decodeEntry(u2At(classFileBytes, readOffset, offset));	69	constantPoolEntry = constantPool.decodeEntry(u2At(classFileBytes, readOffset, offset));
70	if (constantPoolEntry.getKind() != IConstantPoolConstant.CONSTANT_Utf8) {	70	if (constantPoolEntry.getKind() != IConstantPoolConstant.CONSTANT_Utf8) {
71	throw new ClassFormatException(ClassFormatException.INVALID_CONSTANT_POOL_ENTRY);	71	throw new ClassFormatException(ClassFormatException.INVALID_CONSTANT_POOL_ENTRY);
Lines 86-92 Link Here
86	readOffset += (6 + u4At(classFileBytes, readOffset + 2, offset));	86	readOffset += (6 + u4At(classFileBytes, readOffset + 2, offset));
87	}	87	}
88		88
89	attributeBytes = readOffset;	89	this.attributeBytes = readOffset;
90	}	90	}
91	/**	91	/**
92	* @see IFieldInfo#getAccessFlags()	92	* @see IFieldInfo#getAccessFlags()
Lines 138-144 Link Here
138	}	138	}
139		139
140	int sizeInBytes() {	140	int sizeInBytes() {
141	return attributeBytes;	141	return this.attributeBytes;
142	}	142	}
143	/**	143	/**
144	* @see IFieldInfo#getAttributeCount()	144	* @see IFieldInfo#getAttributeCount()