Attachment 52795 Details for Bug 162296 – Proposed fix

[patch] Proposed fix

patch_162296.txt (text/plain), 30.60 KB, created by Olivier Thomann

on 2006-10-26 17:39:47 EDT

(hide)

Description:

Filename:

MIME Type:

Creator: Olivier Thomann

Created: 2006-10-26 17:39:47 EDT

Size: 30.60 KB

patch

obsolete

>### Eclipse Workspace Patch 1.0
>#P org.eclipse.jdt.core
>Index: compiler/org/eclipse/jdt/internal/compiler/ClassFile.java
>===================================================================
>RCS file: /cvsroot/eclipse/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/ClassFile.java,v
>retrieving revision 1.141
>diff -u -r1.141 ClassFile.java
>--- compiler/org/eclipse/jdt/internal/compiler/ClassFile.java	3 Oct 2006 19:38:27 -0000	1.141
>+++ compiler/org/eclipse/jdt/internal/compiler/ClassFile.java	26 Oct 2006 21:43:43 -0000
>@@ -544,9 +544,7 @@
> 				}
> 				// access flag
> 				if (innerClass.isAnonymousType()) {
>-					accessFlags |= ClassFileConstants.AccPrivate;
>-				} else if (innerClass.isLocalType() && !innerClass.isMemberType()) {
>-					accessFlags |= ClassFileConstants.AccPrivate;
>+					accessFlags &= ~ClassFileConstants.AccFinal;
> 				} else if (innerClass.isMemberType() && innerClass.isInterface()) {
> 					accessFlags |= ClassFileConstants.AccStatic; // implicitely static
> 				}
>Index: model/org/eclipse/jdt/internal/core/util/Disassembler.java
>===================================================================
>RCS file: /cvsroot/eclipse/org.eclipse.jdt.core/model/org/eclipse/jdt/internal/core/util/Disassembler.java,v
>retrieving revision 1.81
>diff -u -r1.81 Disassembler.java
>--- model/org/eclipse/jdt/internal/core/util/Disassembler.java	10 Oct 2006 17:36:32 -0000	1.81
>+++ model/org/eclipse/jdt/internal/core/util/Disassembler.java	26 Oct 2006 21:43:43 -0000
>@@ -27,6 +27,137 @@
> 	private static final String EMPTY_OUTPUT = ""; //$NON-NLS-1$
> 	private static final String VERSION_UNKNOWN = Messages.classfileformat_versionUnknown;
> 
>+	private boolean appendModifier(StringBuffer buffer, int accessFlags, int modifierConstant, String modifier, boolean firstModifier) {
>+		if ((accessFlags & modifierConstant) != 0) {
>+			if (!firstModifier) {
>+				buffer.append(Messages.disassembler_space); 
>+			}
>+			if (firstModifier) {
>+				firstModifier = false;
>+			}
>+			buffer.append(modifier);
>+		}
>+		return firstModifier;
>+	}
>+	
>+	private void decodeModifiers(StringBuffer buffer, int accessFlags, int[] checkBits) {
>+		decodeModifiers(buffer, accessFlags, false, false, checkBits);
>+	}
>+	
>+	private void decodeModifiers(StringBuffer buffer, int accessFlags, boolean printDefault, boolean asBridge, int[] checkBits) {
>+		if (checkBits == null) return;
>+		boolean firstModifier = true;
>+		for (int i = 0, max = checkBits.length; i < max; i++) {
>+			switch(checkBits[i]) {
>+				case IModifierConstants.ACC_PUBLIC :
>+					firstModifier = appendModifier(buffer, accessFlags, IModifierConstants.ACC_PUBLIC, "public", firstModifier); //$NON-NLS-1$
>+					break;
>+				case IModifierConstants.ACC_PROTECTED :
>+					firstModifier = appendModifier(buffer, accessFlags, IModifierConstants.ACC_PROTECTED, "protected", firstModifier); //$NON-NLS-1$
>+					break;
>+				case IModifierConstants.ACC_PRIVATE :
>+					firstModifier = appendModifier(buffer, accessFlags, IModifierConstants.ACC_PRIVATE, "private", firstModifier); //$NON-NLS-1$
>+					break;
>+				case IModifierConstants.ACC_ABSTRACT :
>+					firstModifier = appendModifier(buffer, accessFlags, IModifierConstants.ACC_ABSTRACT, "abstract", firstModifier); //$NON-NLS-1$
>+					break;
>+				case IModifierConstants.ACC_STATIC :
>+					firstModifier = appendModifier(buffer, accessFlags, IModifierConstants.ACC_STATIC, "static", firstModifier); //$NON-NLS-1$
>+					break;
>+				case IModifierConstants.ACC_FINAL :
>+					firstModifier = appendModifier(buffer, accessFlags, IModifierConstants.ACC_FINAL, "final", firstModifier); //$NON-NLS-1$
>+					break;
>+				case IModifierConstants.ACC_SYNCHRONIZED :
>+					firstModifier = appendModifier(buffer, accessFlags, IModifierConstants.ACC_SYNCHRONIZED, "synchronized", firstModifier); //$NON-NLS-1$
>+					break;
>+				case IModifierConstants.ACC_NATIVE :
>+					firstModifier = appendModifier(buffer, accessFlags, IModifierConstants.ACC_NATIVE, "native", firstModifier); //$NON-NLS-1$
>+					break;
>+				case IModifierConstants.ACC_STRICT :
>+					firstModifier = appendModifier(buffer, accessFlags, IModifierConstants.ACC_STRICT, "strictfp", firstModifier); //$NON-NLS-1$
>+					break;
>+				case IModifierConstants.ACC_TRANSIENT :
>+					firstModifier = appendModifier(buffer, accessFlags, IModifierConstants.ACC_TRANSIENT, "transient", firstModifier); //$NON-NLS-1$
>+					break;
>+				case IModifierConstants.ACC_VOLATILE :
>+				// case IModifierConstants.ACC_BRIDGE :
>+					if (asBridge) {
>+						firstModifier = appendModifier(buffer, accessFlags, IModifierConstants.ACC_BRIDGE, "bridge", firstModifier); //$NON-NLS-1$
>+					} else {
>+						firstModifier = appendModifier(buffer, accessFlags, IModifierConstants.ACC_VOLATILE, "volatile", firstModifier); //$NON-NLS-1$
>+					}
>+					break;
>+				case IModifierConstants.ACC_ENUM :
>+					firstModifier = appendModifier(buffer, accessFlags, IModifierConstants.ACC_ENUM, "enum", firstModifier); //$NON-NLS-1$
>+					break;
>+			}
>+		}
>+		if (!firstModifier) {
>+			if (!printDefault) buffer.append(Messages.disassembler_space); 
>+		} else if (printDefault) {
>+			// no modifier: package default visibility
>+			buffer.append("default"); //$NON-NLS-1$
>+		}
>+	}
>+	
>+	private void decodeModifiersForField(StringBuffer buffer, int accessFlags) {
>+		decodeModifiers(buffer, accessFlags, new int[] {
>+				IModifierConstants.ACC_PUBLIC,
>+				IModifierConstants.ACC_PROTECTED,
>+				IModifierConstants.ACC_PRIVATE,
>+				IModifierConstants.ACC_STATIC,
>+				IModifierConstants.ACC_FINAL,
>+				IModifierConstants.ACC_TRANSIENT,
>+				IModifierConstants.ACC_VOLATILE,
>+				IModifierConstants.ACC_ENUM
>+		});
>+	}
>+
>+	private void decodeModifiersForFieldForWorkingCopy(StringBuffer buffer, int accessFlags) {
>+		decodeModifiers(buffer, accessFlags, new int[] {
>+				IModifierConstants.ACC_PUBLIC,
>+				IModifierConstants.ACC_PROTECTED,
>+				IModifierConstants.ACC_PRIVATE,
>+				IModifierConstants.ACC_STATIC,
>+				IModifierConstants.ACC_FINAL,
>+				IModifierConstants.ACC_TRANSIENT,
>+				IModifierConstants.ACC_VOLATILE,
>+		});
>+	}	
>+	
>+	private final void decodeModifiersForInnerClasses(StringBuffer buffer, int accessFlags, boolean printDefault) {
>+		decodeModifiers(buffer, accessFlags, printDefault, false, new int[] {
>+				IModifierConstants.ACC_PUBLIC,
>+				IModifierConstants.ACC_PROTECTED,
>+				IModifierConstants.ACC_PRIVATE,
>+				IModifierConstants.ACC_ABSTRACT,
>+				IModifierConstants.ACC_STATIC,
>+				IModifierConstants.ACC_FINAL,
>+		});
>+	}
>+
>+	private final void decodeModifiersForMethod(StringBuffer buffer, int accessFlags) {
>+		decodeModifiers(buffer, accessFlags, false, true, new int[] {
>+				IModifierConstants.ACC_PUBLIC,
>+				IModifierConstants.ACC_PROTECTED,
>+				IModifierConstants.ACC_PRIVATE,
>+				IModifierConstants.ACC_ABSTRACT,
>+				IModifierConstants.ACC_STATIC,
>+				IModifierConstants.ACC_FINAL,
>+				IModifierConstants.ACC_SYNCHRONIZED,
>+				IModifierConstants.ACC_NATIVE,
>+				IModifierConstants.ACC_STRICT,
>+				IModifierConstants.ACC_BRIDGE,
>+		});
>+	}
>+
>+	private final void decodeModifiersForType(StringBuffer buffer, int accessFlags) {
>+		decodeModifiers(buffer, accessFlags, new int[] {
>+				IModifierConstants.ACC_PUBLIC,
>+				IModifierConstants.ACC_ABSTRACT,
>+				IModifierConstants.ACC_FINAL,
>+		});
>+	}
> 	public static String escapeString(String s) {
> 		StringBuffer buffer = new StringBuffer();
> 		for (int i = 0, max = s.length(); i < max; i++) {
>@@ -77,89 +208,8 @@
> 		}
> 		return buffer.toString();
> 	}
>-	private boolean appendModifier(StringBuffer buffer, int accessFlags, int modifierConstant, String modifier, boolean firstModifier) {
>-		if ((accessFlags & modifierConstant) != 0) {		
>-			if (!firstModifier) {
>-				buffer.append(Messages.disassembler_space); 
>-			}
>-			if (firstModifier) {
>-				firstModifier = false;
>-			}
>-			buffer.append(modifier);
>-		}
>-		return firstModifier;
>-	}
>-	
>-	private void decodeModifiersForField(StringBuffer buffer, int accessFlags) {
>-		boolean firstModifier = true;
>-		firstModifier = appendModifier(buffer, accessFlags, IModifierConstants.ACC_PUBLIC, "public", firstModifier); //$NON-NLS-1$
>-		firstModifier = appendModifier(buffer, accessFlags, IModifierConstants.ACC_PROTECTED, "protected", firstModifier); //$NON-NLS-1$
>-		firstModifier = appendModifier(buffer, accessFlags, IModifierConstants.ACC_PRIVATE, "private", firstModifier); //$NON-NLS-1$
>-		firstModifier = appendModifier(buffer, accessFlags, IModifierConstants.ACC_STATIC, "static", firstModifier); //$NON-NLS-1$
>-		firstModifier = appendModifier(buffer, accessFlags, IModifierConstants.ACC_FINAL, "final", firstModifier); //$NON-NLS-1$
>-		firstModifier = appendModifier(buffer, accessFlags, IModifierConstants.ACC_TRANSIENT, "transient", firstModifier); //$NON-NLS-1$
>-		firstModifier = appendModifier(buffer, accessFlags, IModifierConstants.ACC_VOLATILE, "volatile", firstModifier); //$NON-NLS-1$
>-		firstModifier = appendModifier(buffer, accessFlags, IModifierConstants.ACC_ENUM, "enum", firstModifier); //$NON-NLS-1$
>-		if (!firstModifier) {
>-			buffer.append(Messages.disassembler_space); 
>-		}
>-	}	
>-
>-	private void decodeModifiersForFieldForWorkingCopy(StringBuffer buffer, int accessFlags) {
>-		boolean firstModifier = true;
>-		firstModifier = appendModifier(buffer, accessFlags, IModifierConstants.ACC_PUBLIC, "public", firstModifier); //$NON-NLS-1$
>-		firstModifier = appendModifier(buffer, accessFlags, IModifierConstants.ACC_PROTECTED, "protected", firstModifier); //$NON-NLS-1$
>-		firstModifier = appendModifier(buffer, accessFlags, IModifierConstants.ACC_PRIVATE, "private", firstModifier); //$NON-NLS-1$
>-		firstModifier = appendModifier(buffer, accessFlags, IModifierConstants.ACC_STATIC, "static", firstModifier); //$NON-NLS-1$
>-		firstModifier = appendModifier(buffer, accessFlags, IModifierConstants.ACC_FINAL, "final", firstModifier); //$NON-NLS-1$
>-		firstModifier = appendModifier(buffer, accessFlags, IModifierConstants.ACC_TRANSIENT, "transient", firstModifier); //$NON-NLS-1$
>-		firstModifier = appendModifier(buffer, accessFlags, IModifierConstants.ACC_VOLATILE, "volatile", firstModifier); //$NON-NLS-1$
>-		if (!firstModifier) {
>-			buffer.append(Messages.disassembler_space); 
>-		}
>-	}	
>-	
>-	private final void decodeModifiersForInnerClasses(StringBuffer buffer, int accessFlags) {
>-		boolean firstModifier = true;
>-		firstModifier = appendModifier(buffer, accessFlags, IModifierConstants.ACC_PUBLIC, "public", firstModifier); //$NON-NLS-1$
>-		firstModifier = appendModifier(buffer, accessFlags, IModifierConstants.ACC_PROTECTED, "protected", firstModifier); //$NON-NLS-1$
>-		firstModifier = appendModifier(buffer, accessFlags, IModifierConstants.ACC_PRIVATE, "private", firstModifier); //$NON-NLS-1$
>-		firstModifier = appendModifier(buffer, accessFlags, IModifierConstants.ACC_ABSTRACT, "abstract", firstModifier); //$NON-NLS-1$
>-		firstModifier = appendModifier(buffer, accessFlags, IModifierConstants.ACC_STATIC, "static", firstModifier); //$NON-NLS-1$
>-		firstModifier = appendModifier(buffer, accessFlags, IModifierConstants.ACC_FINAL, "final", firstModifier); //$NON-NLS-1$
>-		if (!firstModifier) {
>-			buffer.append(Messages.disassembler_space); 
>-		}
>-	}
> 
>-	private final void decodeModifiersForMethod(StringBuffer buffer, int accessFlags) {
>-		boolean firstModifier = true;
>-		firstModifier = appendModifier(buffer, accessFlags, IModifierConstants.ACC_PUBLIC, "public", firstModifier); //$NON-NLS-1$
>-		firstModifier = appendModifier(buffer, accessFlags, IModifierConstants.ACC_PROTECTED, "protected", firstModifier); //$NON-NLS-1$
>-		firstModifier = appendModifier(buffer, accessFlags, IModifierConstants.ACC_PRIVATE, "private", firstModifier); //$NON-NLS-1$
>-		firstModifier = appendModifier(buffer, accessFlags, IModifierConstants.ACC_ABSTRACT, "abstract", firstModifier); //$NON-NLS-1$
>-		firstModifier = appendModifier(buffer, accessFlags, IModifierConstants.ACC_STATIC, "static", firstModifier); //$NON-NLS-1$
>-		firstModifier = appendModifier(buffer, accessFlags, IModifierConstants.ACC_FINAL, "final", firstModifier); //$NON-NLS-1$
>-		firstModifier = appendModifier(buffer, accessFlags, IModifierConstants.ACC_SYNCHRONIZED, "synchronized", firstModifier); //$NON-NLS-1$
>-		firstModifier = appendModifier(buffer, accessFlags, IModifierConstants.ACC_NATIVE, "native", firstModifier); //$NON-NLS-1$
>-		firstModifier = appendModifier(buffer, accessFlags, IModifierConstants.ACC_STRICT, "strictfp", firstModifier); //$NON-NLS-1$
>-		firstModifier = appendModifier(buffer, accessFlags, IModifierConstants.ACC_BRIDGE, "bridge", firstModifier); //$NON-NLS-1$
>-		if (!firstModifier) {
>-			buffer.append(Messages.disassembler_space); 
>-		}
>-	}
>-
>-	private final void decodeModifiersForType(StringBuffer buffer, int accessFlags) {
>-		boolean firstModifier = true;
>-		firstModifier = appendModifier(buffer, accessFlags, IModifierConstants.ACC_PUBLIC, "public", firstModifier); //$NON-NLS-1$
>-		firstModifier = appendModifier(buffer, accessFlags, IModifierConstants.ACC_ABSTRACT, "abstract", firstModifier); //$NON-NLS-1$
>-		firstModifier = appendModifier(buffer, accessFlags, IModifierConstants.ACC_FINAL, "final", firstModifier); //$NON-NLS-1$
>-		if (!firstModifier) {
>-			buffer.append(Messages.disassembler_space); 
>-		}
>-	}
>-
>-	private String decodeStringValue(char[] chars) {
>+	static String decodeStringValue(char[] chars) {
> 		StringBuffer buffer = new StringBuffer();
> 		for (int i = 0, max = chars.length; i < max; i++) {
> 			char c = chars[i];
>@@ -179,15 +229,6 @@
> 				case '\r' :
> 					buffer.append("\\r"); //$NON-NLS-1$
> 					break;
>-				case '\"':
>-					buffer.append("\\\""); //$NON-NLS-1$
>-					break;
>-				case '\'':
>-					buffer.append("\\\'"); //$NON-NLS-1$
>-					break;
>-				case '\\':
>-					buffer.append("\\\\"); //$NON-NLS-1$
>-					break;
> 				case '\0' :
> 					buffer.append("\\0"); //$NON-NLS-1$
> 					break;
>@@ -219,7 +260,7 @@
> 		return buffer.toString();
> 	}
> 
>-	private String decodeStringValue(String s) {
>+	static String decodeStringValue(String s) {
> 		return decodeStringValue(s.toCharArray());
> 	}
> 
>@@ -397,17 +438,16 @@
> 			buffer.append(" throws "); //$NON-NLS-1$
> 			char[][] exceptionNames = exceptionAttribute.getExceptionNames();
> 			int length = exceptionNames.length;
>-			for (int i = 0; i < length - 1; i++) {
>+			for (int i = 0; i < length; i++) {
>+				if (i != 0) {
>+					buffer
>+    					.append(Messages.disassembler_comma)
>+    					.append(Messages.disassembler_space);
>+				}
> 				char[] exceptionName = exceptionNames[i];
> 				CharOperation.replace(exceptionName, '/', '.');
>-				buffer
>-					.append(returnClassName(exceptionName, '.', mode))
>-					.append(Messages.disassembler_comma)
>-					.append(Messages.disassembler_space); 
>-			}
>-			char[] exceptionName = exceptionNames[length - 1];
>-			CharOperation.replace(exceptionName, '/', '.');
>-			buffer.append(returnClassName(exceptionName, '.', mode));
>+				buffer.append(returnClassName(exceptionName, '.', mode));
>+			}
> 		}
> 		if (((accessFlags & IModifierConstants.ACC_NATIVE) == 0)
> 				&& ((accessFlags & IModifierConstants.ACC_ABSTRACT) == 0)) {
>@@ -530,17 +570,16 @@
> 			buffer.append(" throws "); //$NON-NLS-1$
> 			char[][] exceptionNames = exceptionAttribute.getExceptionNames();
> 			int length = exceptionNames.length;
>-			for (int i = 0; i < length - 1; i++) {
>+			for (int i = 0; i < length; i++) {
>+				if (i != 0) {
>+					buffer
>+						.append(Messages.disassembler_comma)
>+						.append(Messages.disassembler_space);
>+				}
> 				char[] exceptionName = exceptionNames[i];
> 				CharOperation.replace(exceptionName, '/', '.');
>-				buffer
>-					.append(returnClassName(exceptionName, '.', mode))
>-					.append(Messages.disassembler_comma)
>-					.append(Messages.disassembler_space); 
>-			}
>-			char[] exceptionName = exceptionNames[length - 1];
>-			CharOperation.replace(exceptionName, '/', '.');
>-			buffer.append(returnClassName(exceptionName, '.', mode));
>+				buffer.append(returnClassName(exceptionName, '.', mode));
>+			}
> 		}
> 		if (checkMode(mode, DETAILED)) {
> 			if (annotationDefaultAttribute != null) {
>@@ -748,7 +787,7 @@
> 					char[] innerClassName = entry.getInnerClassName();
> 					if (innerClassName != null) {
> 						if (CharOperation.equals(classFileReader.getClassName(), innerClassName)) {
>-							decodeModifiersForInnerClasses(buffer, entry.getAccessFlags());
>+							decodeModifiersForInnerClasses(buffer, entry.getAccessFlags(), false);
> 							decoded = true;
> 						}
> 					}
>@@ -806,17 +845,17 @@
> 				} else {
> 					buffer.append(" implements "); //$NON-NLS-1$
> 				}
>-				for (int i = 0; i < length - 1; i++) {
>+				for (int i = 0; i < length; i++) {
>+					if (i != 0) {
>+						buffer
>+							.append(Messages.disassembler_comma)
>+							.append(Messages.disassembler_space); 
>+					}
> 					char[] superinterface = superclassInterfaces[i];
> 					CharOperation.replace(superinterface, '/', '.');
> 					buffer
>-						.append(returnClassName(superinterface, '.', mode))
>-						.append(Messages.disassembler_comma)
>-						.append(Messages.disassembler_space); 
>+						.append(returnClassName(superinterface, '.', mode));
> 				}
>-				char[] superinterface = superclassInterfaces[length - 1];
>-				CharOperation.replace(superinterface, '/', '.');
>-				buffer.append(returnClassName(superinterface, '.', mode));
> 			}
> 		}
> 		buffer.append(Messages.bind(Messages.disassembler_opentypedeclaration)); 
>@@ -886,6 +925,9 @@
> 		if (typeParametersLength != 0) {
> 			buffer.append('<');
> 			for (int i = 0; i < typeParametersLength; i++) {
>+				if (i != 0) {
>+					buffer.append(Messages.disassembler_comma);
>+				}
> 				// extract the name
> 				buffer.append(typeParameters[i], 0, CharOperation.indexOf(':', typeParameters[i]));
> 				final char[][] bounds = Signature.getTypeParameterBounds(typeParameters[i]);
>@@ -900,15 +942,13 @@
> 						}
> 					} else {
> 						buffer.append(" extends "); //$NON-NLS-1$
>-						for (int j= 0; j < boundsLength - 1; j++) {
>-							buffer.append(returnClassName(Signature.toCharArray(bounds[j]), '.', mode));
>-							buffer.append(" & "); //$NON-NLS-1$
>+						for (int j= 0; j < boundsLength; j++) {
>+							if (j != 0) {
>+								buffer.append(" & "); //$NON-NLS-1$
> 							}
>-						buffer.append(returnClassName(Signature.toCharArray(bounds[boundsLength - 1]), '.', mode));
>+							buffer.append(returnClassName(Signature.toCharArray(bounds[j]), '.', mode));
>+						}
> 					}
>-				}	
>-				if (i < typeParametersLength - 1) {
>-					buffer.append(',');
> 				}
> 			}
> 			buffer.append('>');
>@@ -938,7 +978,10 @@
> 			final IExceptionTableEntry[] exceptionTableEntries = codeAttribute.getExceptionTable();
> 			buffer.append(Messages.disassembler_exceptiontableheader); 
> 			writeNewLine(buffer, lineSeparator, tabNumberForExceptionAttribute + 1);
>-			for (int i = 0; i < exceptionTableLength - 1; i++) {
>+			for (int i = 0; i < exceptionTableLength; i++) {
>+				if (i != 0) {
>+					writeNewLine(buffer, lineSeparator, tabNumberForExceptionAttribute + 1);
>+				}
> 				IExceptionTableEntry exceptionTableEntry = exceptionTableEntries[i];
> 				char[] catchType;
> 				if (exceptionTableEntry.getCatchTypeIndex() != 0) {
>@@ -955,24 +998,7 @@
> 						Integer.toString(exceptionTableEntry.getHandlerPC()),
> 						new String(catchType)
> 					}));
>-				writeNewLine(buffer, lineSeparator, tabNumberForExceptionAttribute + 1);
> 			}
>-			IExceptionTableEntry exceptionTableEntry = exceptionTableEntries[exceptionTableLength - 1];
>-			char[] catchType;
>-			if (exceptionTableEntry.getCatchTypeIndex() != 0) {
>-				catchType = exceptionTableEntry.getCatchType();
>-				CharOperation.replace(catchType, '/', '.');
>-				catchType = returnClassName(catchType, '.', mode);
>-			} else {
>-				catchType = ANY_EXCEPTION;
>-			}
>-			buffer.append(Messages.bind(Messages.classfileformat_exceptiontableentry,
>-				new String[] {
>-					Integer.toString(exceptionTableEntry.getStartPC()),
>-					Integer.toString(exceptionTableEntry.getEndPC()),
>-					Integer.toString(exceptionTableEntry.getHandlerPC()),
>-					new String(catchType)
>-				}));
> 		}
> 		final ILineNumberAttribute lineNumberAttribute = codeAttribute.getLineNumberAttribute();
> 		final int lineAttributeLength = lineNumberAttribute == null ? 0 : lineNumberAttribute.getLineNumberTableLength();
>@@ -987,19 +1013,16 @@
> 			buffer.append(Messages.disassembler_linenumberattributeheader); 
> 			writeNewLine(buffer, lineSeparator, tabNumberForLineAttribute + 1);
> 			int[][] lineattributesEntries = lineNumberAttribute.getLineNumberTable();
>-			for (int i = 0; i < lineAttributeLength - 1; i++) {
>+			for (int i = 0; i < lineAttributeLength; i++) {
>+				if (i != 0) {
>+					writeNewLine(buffer, lineSeparator, tabNumberForLineAttribute + 1);
>+				}
> 				buffer.append(Messages.bind(Messages.classfileformat_linenumbertableentry,
> 					new String[] {
> 						Integer.toString(lineattributesEntries[i][0]),
> 						Integer.toString(lineattributesEntries[i][1])
> 					}));
>-				writeNewLine(buffer, lineSeparator, tabNumberForLineAttribute + 1);
> 			}
>-			buffer.append(Messages.bind(Messages.classfileformat_linenumbertableentry,
>-				new String[] {
>-					Integer.toString(lineattributesEntries[lineAttributeLength - 1][0]),
>-					Integer.toString(lineattributesEntries[lineAttributeLength - 1][1])
>-				}));
> 		} 
> 		final ILocalVariableAttribute localVariableAttribute = codeAttribute.getLocalVariableAttribute();
> 		final int localVariableAttributeLength = localVariableAttribute == null ? 0 : localVariableAttribute.getLocalVariableTableLength();
>@@ -1014,7 +1037,10 @@
> 			buffer.append(Messages.disassembler_localvariabletableattributeheader); 
> 			writeNewLine(buffer, lineSeparator, tabNumberForLocalVariableAttribute + 1);
> 			ILocalVariableTableEntry[] localVariableTableEntries = localVariableAttribute.getLocalVariableTable();
>-			for (int i = 0; i < localVariableAttributeLength - 1; i++) {
>+			for (int i = 0; i < localVariableAttributeLength; i++) {
>+				if (i != 0) {
>+					writeNewLine(buffer, lineSeparator, tabNumberForLocalVariableAttribute + 1);
>+				}
> 				ILocalVariableTableEntry localVariableTableEntry = localVariableTableEntries[i];
> 				int index= localVariableTableEntry.getIndex();
> 				int startPC = localVariableTableEntry.getStartPC();
>@@ -1029,22 +1055,7 @@
> 						Integer.toString(index),
> 						new String(returnClassName(typeName, '.', mode))
> 					}));
>-				writeNewLine(buffer, lineSeparator, tabNumberForLocalVariableAttribute + 1);
> 			}
>-			ILocalVariableTableEntry localVariableTableEntry = localVariableTableEntries[localVariableAttributeLength - 1];
>-			int index= localVariableTableEntry.getIndex();
>-			int startPC = localVariableTableEntry.getStartPC();
>-			int length  = localVariableTableEntry.getLength();
>-			final char[] typeName = Signature.toCharArray(localVariableTableEntry.getDescriptor());
>-			CharOperation.replace(typeName, '/', '.');
>-			buffer.append(Messages.bind(Messages.classfileformat_localvariabletableentry,
>-				new String[] {
>-					Integer.toString(startPC),
>-					Integer.toString(startPC + length),
>-					new String(localVariableTableEntry.getName()),
>-					Integer.toString(index),
>-					new String(returnClassName(typeName, '.', mode))
>-				}));
> 		}
> 		final ILocalVariableTypeTableAttribute localVariableTypeAttribute= (ILocalVariableTypeTableAttribute) getAttribute(IAttributeNamesConstants.LOCAL_VARIABLE_TYPE_TABLE, codeAttribute);
> 		final int localVariableTypeTableLength = localVariableTypeAttribute == null ? 0 : localVariableTypeAttribute.getLocalVariableTypeTableLength();
>@@ -1059,7 +1070,10 @@
> 			buffer.append(Messages.disassembler_localvariabletypetableattributeheader); 
> 			writeNewLine(buffer, lineSeparator, tabNumberForLocalVariableAttribute + 1);
> 			ILocalVariableTypeTableEntry[] localVariableTypeTableEntries = localVariableTypeAttribute.getLocalVariableTypeTable();
>-			for (int i = 0; i < localVariableTypeTableLength - 1; i++) {
>+			for (int i = 0; i < localVariableTypeTableLength; i++) {
>+				if (i != 0) {
>+					writeNewLine(buffer, lineSeparator, tabNumberForLocalVariableAttribute + 1);
>+				}
> 				ILocalVariableTypeTableEntry localVariableTypeTableEntry = localVariableTypeTableEntries[i];
> 				int index= localVariableTypeTableEntry.getIndex();
> 				int startPC = localVariableTypeTableEntry.getStartPC();
>@@ -1074,22 +1088,7 @@
> 						Integer.toString(index),
> 						new String(returnClassName(typeName, '.', mode))
> 					}));
>-				writeNewLine(buffer, lineSeparator, tabNumberForLocalVariableAttribute + 1);
> 			}
>-			ILocalVariableTypeTableEntry localVariableTypeTableEntry = localVariableTypeTableEntries[localVariableTypeTableLength - 1];
>-			int index= localVariableTypeTableEntry.getIndex();
>-			int startPC = localVariableTypeTableEntry.getStartPC();
>-			int length  = localVariableTypeTableEntry.getLength();
>-			final char[] typeName = Signature.toCharArray(localVariableTypeTableEntry.getSignature());
>-			CharOperation.replace(typeName, '/', '.');
>-			buffer.append(Messages.bind(Messages.classfileformat_localvariabletableentry,
>-				new String[] {
>-					Integer.toString(startPC),
>-					Integer.toString(startPC + length),
>-					new String(localVariableTypeTableEntry.getName()),
>-					Integer.toString(index),
>-					new String(returnClassName(typeName, '.', mode))
>-				}));
> 		}
> 		final int length = codeAttribute.getAttributesCount();
> 		if (length != 0) {
>@@ -1267,6 +1266,9 @@
> 		buffer.append(Messages.disassembler_constantpoolheader); 
> 		writeNewLine(buffer, lineSeparator, tabNumber + 1);
> 		for (int i = 1; i < length; i++) {
>+			if (i != 1) {
>+				writeNewLine(buffer, lineSeparator, tabNumber + 1);
>+			}
> 			IConstantPoolEntry constantPoolEntry = constantPool.decodeEntry(i);
> 			switch (constantPool.getEntryKind(i)) {
> 				case IConstantPoolConstant.CONSTANT_Class :
>@@ -1361,19 +1363,16 @@
> 							new String[] {
> 								Integer.toString(i),
> 								Integer.toString(constantPoolEntry.getStringIndex()),
>-								escapeString(constantPoolEntry.getStringValue())}));
>+								decodeStringValue(constantPoolEntry.getStringValue())}));
> 					break;
> 				case IConstantPoolConstant.CONSTANT_Utf8 :
> 					buffer.append(
> 						Messages.bind(Messages.disassembler_constantpool_utf8,
> 							new String[] {
> 								Integer.toString(i),
>-								escapeString(new String(constantPoolEntry.getUtf8Value()))}));
>+								decodeStringValue(new String(constantPoolEntry.getUtf8Value()))}));
> 					break;
> 			}
>-			if (i < length - 1) {
>-				writeNewLine(buffer, lineSeparator, tabNumber + 1);
>-			}
> 		}
> 	}
> 
>@@ -1415,6 +1414,9 @@
> 		if (length != 0) {
> 			// insert default value for corresponding argument types
> 			for (int i = 0; i < length; i++) {
>+				if (i != 0) {
>+					buffer.append(Messages.disassembler_comma);
>+				}
> 				final char[] type = argumentTypes[i];
> 				switch(type.length) {
> 					case 1 :
>@@ -1438,12 +1440,9 @@
> 					default :
> 						buffer.append("null"); //$NON-NLS-1$
> 				}
>-				if (i < length - 1) {
>-					buffer.append(',');
>-				}
> 			}
> 		}
>-		buffer.append(')').append(',');
>+		buffer.append(')').append(Messages.disassembler_comma);
> 	}
> 	
> 	/**
>@@ -1579,7 +1578,11 @@
> 		int length = innerClassesAttributeEntries.length;
> 		int innerClassNameIndex, outerClassNameIndex, innerNameIndex, accessFlags;
> 		IInnerClassesAttributeEntry innerClassesAttributeEntry;
>-		for (int i = 0; i < length - 1; i++) {
>+		for (int i = 0; i < length; i++) {
>+			if (i != 0) {
>+				buffer.append(Messages.disassembler_comma);
>+				writeNewLine(buffer, lineSeparator, tabNumber + 1);				
>+			}
> 			innerClassesAttributeEntry = innerClassesAttributeEntries[i];
> 			innerClassNameIndex = innerClassesAttributeEntry.getInnerClassNameIndex();
> 			outerClassNameIndex = innerClassesAttributeEntry.getOuterClassNameIndex();
>@@ -1624,59 +1627,10 @@
> 				.append(Messages.disassembler_inner_accessflags) 
> 				.append(accessFlags)
> 				.append(Messages.disassembler_space); 
>-			decodeModifiersForInnerClasses(buffer, accessFlags);
>+			decodeModifiersForInnerClasses(buffer, accessFlags, true);
> 			buffer
>-				.append(Messages.disassembler_closeinnerclassentry) 
>-				.append(Messages.disassembler_comma); 
>-			writeNewLine(buffer, lineSeparator, tabNumber + 1);
>+				.append(Messages.disassembler_closeinnerclassentry);
> 		}
>-		// last entry
>-		innerClassesAttributeEntry = innerClassesAttributeEntries[length - 1];
>-		innerClassNameIndex = innerClassesAttributeEntry.getInnerClassNameIndex();
>-		outerClassNameIndex = innerClassesAttributeEntry.getOuterClassNameIndex();
>-		innerNameIndex = innerClassesAttributeEntry.getInnerNameIndex();
>-		accessFlags = innerClassesAttributeEntry.getAccessFlags();
>-		buffer
>-			.append(Messages.disassembler_openinnerclassentry) 
>-			.append(Messages.disassembler_inner_class_info_name) 
>-			.append(Messages.disassembler_constantpoolindex) 
>-			.append(innerClassNameIndex);
>-		if (innerClassNameIndex != 0) {
>-			buffer
>-				.append(Messages.disassembler_space) 
>-				.append(innerClassesAttributeEntry.getInnerClassName());
>-		}
>-		buffer
>-			.append(Messages.disassembler_comma) 
>-			.append(Messages.disassembler_space) 
>-			.append(Messages.disassembler_outer_class_info_name) 
>-			.append(Messages.disassembler_constantpoolindex) 
>-			.append(outerClassNameIndex);
>-		if (outerClassNameIndex != 0) {
>-			buffer	
>-				.append(Messages.disassembler_space) 
>-				.append(innerClassesAttributeEntry.getOuterClassName());
>-		}
>-		writeNewLine(buffer, lineSeparator, tabNumber);
>-		dumpTab(tabNumber, buffer);
>-		buffer.append(Messages.disassembler_space); 
>-		buffer
>-			.append(Messages.disassembler_inner_name) 
>-			.append(Messages.disassembler_constantpoolindex) 
>-			.append(innerNameIndex);
>-		if (innerNameIndex != 0) {
>-			buffer
>-				.append(Messages.disassembler_space) 
>-				.append(innerClassesAttributeEntry.getInnerName());
>-		}
>-		buffer
>-			.append(Messages.disassembler_comma) 
>-			.append(Messages.disassembler_space) 
>-			.append(Messages.disassembler_inner_accessflags) 
>-			.append(accessFlags)
>-			.append(Messages.disassembler_space); 
>-		decodeModifiersForInnerClasses(buffer, accessFlags);
>-		buffer.append(Messages.disassembler_closeinnerclassentry); 
> 	}
> 
> 	private void disassemble(int index, IParameterAnnotation parameterAnnotation, StringBuffer buffer, String lineSeparator, int tabNumber) {
>@@ -1729,7 +1683,11 @@
> 		StringBuffer buffer = new StringBuffer();
> 		buffer.append('{');
> 		for (int i = 0, max = infos.length; i < max; i++) {
>-			if(i != 0) buffer.append(", "); //$NON-NLS-1$
>+			if(i != 0) {
>+				buffer
>+						.append(Messages.disassembler_comma)
>+						.append(Messages.disassembler_space);
>+			}
> 			switch(infos[i].getTag()) {
> 				case IVerificationTypeInfo.ITEM_DOUBLE :
> 					buffer.append("double"); //$NON-NLS-1$

Actions: View | Diff

Attachments on bug 162296: 52795 | 52796 | 52799