|
Lines 27-32
Link Here
|
| 27 |
private static final String EMPTY_OUTPUT = ""; //$NON-NLS-1$ |
27 |
private static final String EMPTY_OUTPUT = ""; //$NON-NLS-1$ |
| 28 |
private static final String VERSION_UNKNOWN = Messages.classfileformat_versionUnknown; |
28 |
private static final String VERSION_UNKNOWN = Messages.classfileformat_versionUnknown; |
| 29 |
|
29 |
|
|
|
30 |
private boolean appendModifier(StringBuffer buffer, int accessFlags, int modifierConstant, String modifier, boolean firstModifier) { |
| 31 |
if ((accessFlags & modifierConstant) != 0) { |
| 32 |
if (!firstModifier) { |
| 33 |
buffer.append(Messages.disassembler_space); |
| 34 |
} |
| 35 |
if (firstModifier) { |
| 36 |
firstModifier = false; |
| 37 |
} |
| 38 |
buffer.append(modifier); |
| 39 |
} |
| 40 |
return firstModifier; |
| 41 |
} |
| 42 |
|
| 43 |
private void decodeModifiers(StringBuffer buffer, int accessFlags, int[] checkBits) { |
| 44 |
decodeModifiers(buffer, accessFlags, false, false, checkBits); |
| 45 |
} |
| 46 |
|
| 47 |
private void decodeModifiers(StringBuffer buffer, int accessFlags, boolean printDefault, boolean asBridge, int[] checkBits) { |
| 48 |
if (checkBits == null) return; |
| 49 |
boolean firstModifier = true; |
| 50 |
for (int i = 0, max = checkBits.length; i < max; i++) { |
| 51 |
switch(checkBits[i]) { |
| 52 |
case IModifierConstants.ACC_PUBLIC : |
| 53 |
firstModifier = appendModifier(buffer, accessFlags, IModifierConstants.ACC_PUBLIC, "public", firstModifier); //$NON-NLS-1$ |
| 54 |
break; |
| 55 |
case IModifierConstants.ACC_PROTECTED : |
| 56 |
firstModifier = appendModifier(buffer, accessFlags, IModifierConstants.ACC_PROTECTED, "protected", firstModifier); //$NON-NLS-1$ |
| 57 |
break; |
| 58 |
case IModifierConstants.ACC_PRIVATE : |
| 59 |
firstModifier = appendModifier(buffer, accessFlags, IModifierConstants.ACC_PRIVATE, "private", firstModifier); //$NON-NLS-1$ |
| 60 |
break; |
| 61 |
case IModifierConstants.ACC_ABSTRACT : |
| 62 |
firstModifier = appendModifier(buffer, accessFlags, IModifierConstants.ACC_ABSTRACT, "abstract", firstModifier); //$NON-NLS-1$ |
| 63 |
break; |
| 64 |
case IModifierConstants.ACC_STATIC : |
| 65 |
firstModifier = appendModifier(buffer, accessFlags, IModifierConstants.ACC_STATIC, "static", firstModifier); //$NON-NLS-1$ |
| 66 |
break; |
| 67 |
case IModifierConstants.ACC_FINAL : |
| 68 |
firstModifier = appendModifier(buffer, accessFlags, IModifierConstants.ACC_FINAL, "final", firstModifier); //$NON-NLS-1$ |
| 69 |
break; |
| 70 |
case IModifierConstants.ACC_SYNCHRONIZED : |
| 71 |
firstModifier = appendModifier(buffer, accessFlags, IModifierConstants.ACC_SYNCHRONIZED, "synchronized", firstModifier); //$NON-NLS-1$ |
| 72 |
break; |
| 73 |
case IModifierConstants.ACC_NATIVE : |
| 74 |
firstModifier = appendModifier(buffer, accessFlags, IModifierConstants.ACC_NATIVE, "native", firstModifier); //$NON-NLS-1$ |
| 75 |
break; |
| 76 |
case IModifierConstants.ACC_STRICT : |
| 77 |
firstModifier = appendModifier(buffer, accessFlags, IModifierConstants.ACC_STRICT, "strictfp", firstModifier); //$NON-NLS-1$ |
| 78 |
break; |
| 79 |
case IModifierConstants.ACC_TRANSIENT : |
| 80 |
firstModifier = appendModifier(buffer, accessFlags, IModifierConstants.ACC_TRANSIENT, "transient", firstModifier); //$NON-NLS-1$ |
| 81 |
break; |
| 82 |
case IModifierConstants.ACC_VOLATILE : |
| 83 |
// case IModifierConstants.ACC_BRIDGE : |
| 84 |
if (asBridge) { |
| 85 |
firstModifier = appendModifier(buffer, accessFlags, IModifierConstants.ACC_BRIDGE, "bridge", firstModifier); //$NON-NLS-1$ |
| 86 |
} else { |
| 87 |
firstModifier = appendModifier(buffer, accessFlags, IModifierConstants.ACC_VOLATILE, "volatile", firstModifier); //$NON-NLS-1$ |
| 88 |
} |
| 89 |
break; |
| 90 |
case IModifierConstants.ACC_ENUM : |
| 91 |
firstModifier = appendModifier(buffer, accessFlags, IModifierConstants.ACC_ENUM, "enum", firstModifier); //$NON-NLS-1$ |
| 92 |
break; |
| 93 |
} |
| 94 |
} |
| 95 |
if (!firstModifier) { |
| 96 |
if (!printDefault) buffer.append(Messages.disassembler_space); |
| 97 |
} else if (printDefault) { |
| 98 |
// no modifier: package default visibility |
| 99 |
buffer.append("default"); //$NON-NLS-1$ |
| 100 |
} |
| 101 |
} |
| 102 |
|
| 103 |
private void decodeModifiersForField(StringBuffer buffer, int accessFlags) { |
| 104 |
decodeModifiers(buffer, accessFlags, new int[] { |
| 105 |
IModifierConstants.ACC_PUBLIC, |
| 106 |
IModifierConstants.ACC_PROTECTED, |
| 107 |
IModifierConstants.ACC_PRIVATE, |
| 108 |
IModifierConstants.ACC_STATIC, |
| 109 |
IModifierConstants.ACC_FINAL, |
| 110 |
IModifierConstants.ACC_TRANSIENT, |
| 111 |
IModifierConstants.ACC_VOLATILE, |
| 112 |
IModifierConstants.ACC_ENUM |
| 113 |
}); |
| 114 |
} |
| 115 |
|
| 116 |
private void decodeModifiersForFieldForWorkingCopy(StringBuffer buffer, int accessFlags) { |
| 117 |
decodeModifiers(buffer, accessFlags, new int[] { |
| 118 |
IModifierConstants.ACC_PUBLIC, |
| 119 |
IModifierConstants.ACC_PROTECTED, |
| 120 |
IModifierConstants.ACC_PRIVATE, |
| 121 |
IModifierConstants.ACC_STATIC, |
| 122 |
IModifierConstants.ACC_FINAL, |
| 123 |
IModifierConstants.ACC_TRANSIENT, |
| 124 |
IModifierConstants.ACC_VOLATILE, |
| 125 |
}); |
| 126 |
} |
| 127 |
|
| 128 |
private final void decodeModifiersForInnerClasses(StringBuffer buffer, int accessFlags, boolean printDefault) { |
| 129 |
decodeModifiers(buffer, accessFlags, printDefault, false, new int[] { |
| 130 |
IModifierConstants.ACC_PUBLIC, |
| 131 |
IModifierConstants.ACC_PROTECTED, |
| 132 |
IModifierConstants.ACC_PRIVATE, |
| 133 |
IModifierConstants.ACC_ABSTRACT, |
| 134 |
IModifierConstants.ACC_STATIC, |
| 135 |
IModifierConstants.ACC_FINAL, |
| 136 |
}); |
| 137 |
} |
| 138 |
|
| 139 |
private final void decodeModifiersForMethod(StringBuffer buffer, int accessFlags) { |
| 140 |
decodeModifiers(buffer, accessFlags, false, true, new int[] { |
| 141 |
IModifierConstants.ACC_PUBLIC, |
| 142 |
IModifierConstants.ACC_PROTECTED, |
| 143 |
IModifierConstants.ACC_PRIVATE, |
| 144 |
IModifierConstants.ACC_ABSTRACT, |
| 145 |
IModifierConstants.ACC_STATIC, |
| 146 |
IModifierConstants.ACC_FINAL, |
| 147 |
IModifierConstants.ACC_SYNCHRONIZED, |
| 148 |
IModifierConstants.ACC_NATIVE, |
| 149 |
IModifierConstants.ACC_STRICT, |
| 150 |
IModifierConstants.ACC_BRIDGE, |
| 151 |
}); |
| 152 |
} |
| 153 |
|
| 154 |
private final void decodeModifiersForType(StringBuffer buffer, int accessFlags) { |
| 155 |
decodeModifiers(buffer, accessFlags, new int[] { |
| 156 |
IModifierConstants.ACC_PUBLIC, |
| 157 |
IModifierConstants.ACC_ABSTRACT, |
| 158 |
IModifierConstants.ACC_FINAL, |
| 159 |
}); |
| 160 |
} |
| 30 |
public static String escapeString(String s) { |
161 |
public static String escapeString(String s) { |
| 31 |
StringBuffer buffer = new StringBuffer(); |
162 |
StringBuffer buffer = new StringBuffer(); |
| 32 |
for (int i = 0, max = s.length(); i < max; i++) { |
163 |
for (int i = 0, max = s.length(); i < max; i++) { |
|
Lines 77-165
Link Here
|
| 77 |
} |
208 |
} |
| 78 |
return buffer.toString(); |
209 |
return buffer.toString(); |
| 79 |
} |
210 |
} |
| 80 |
private boolean appendModifier(StringBuffer buffer, int accessFlags, int modifierConstant, String modifier, boolean firstModifier) { |
|
|
| 81 |
if ((accessFlags & modifierConstant) != 0) { |
| 82 |
if (!firstModifier) { |
| 83 |
buffer.append(Messages.disassembler_space); |
| 84 |
} |
| 85 |
if (firstModifier) { |
| 86 |
firstModifier = false; |
| 87 |
} |
| 88 |
buffer.append(modifier); |
| 89 |
} |
| 90 |
return firstModifier; |
| 91 |
} |
| 92 |
|
| 93 |
private void decodeModifiersForField(StringBuffer buffer, int accessFlags) { |
| 94 |
boolean firstModifier = true; |
| 95 |
firstModifier = appendModifier(buffer, accessFlags, IModifierConstants.ACC_PUBLIC, "public", firstModifier); //$NON-NLS-1$ |
| 96 |
firstModifier = appendModifier(buffer, accessFlags, IModifierConstants.ACC_PROTECTED, "protected", firstModifier); //$NON-NLS-1$ |
| 97 |
firstModifier = appendModifier(buffer, accessFlags, IModifierConstants.ACC_PRIVATE, "private", firstModifier); //$NON-NLS-1$ |
| 98 |
firstModifier = appendModifier(buffer, accessFlags, IModifierConstants.ACC_STATIC, "static", firstModifier); //$NON-NLS-1$ |
| 99 |
firstModifier = appendModifier(buffer, accessFlags, IModifierConstants.ACC_FINAL, "final", firstModifier); //$NON-NLS-1$ |
| 100 |
firstModifier = appendModifier(buffer, accessFlags, IModifierConstants.ACC_TRANSIENT, "transient", firstModifier); //$NON-NLS-1$ |
| 101 |
firstModifier = appendModifier(buffer, accessFlags, IModifierConstants.ACC_VOLATILE, "volatile", firstModifier); //$NON-NLS-1$ |
| 102 |
firstModifier = appendModifier(buffer, accessFlags, IModifierConstants.ACC_ENUM, "enum", firstModifier); //$NON-NLS-1$ |
| 103 |
if (!firstModifier) { |
| 104 |
buffer.append(Messages.disassembler_space); |
| 105 |
} |
| 106 |
} |
| 107 |
|
| 108 |
private void decodeModifiersForFieldForWorkingCopy(StringBuffer buffer, int accessFlags) { |
| 109 |
boolean firstModifier = true; |
| 110 |
firstModifier = appendModifier(buffer, accessFlags, IModifierConstants.ACC_PUBLIC, "public", firstModifier); //$NON-NLS-1$ |
| 111 |
firstModifier = appendModifier(buffer, accessFlags, IModifierConstants.ACC_PROTECTED, "protected", firstModifier); //$NON-NLS-1$ |
| 112 |
firstModifier = appendModifier(buffer, accessFlags, IModifierConstants.ACC_PRIVATE, "private", firstModifier); //$NON-NLS-1$ |
| 113 |
firstModifier = appendModifier(buffer, accessFlags, IModifierConstants.ACC_STATIC, "static", firstModifier); //$NON-NLS-1$ |
| 114 |
firstModifier = appendModifier(buffer, accessFlags, IModifierConstants.ACC_FINAL, "final", firstModifier); //$NON-NLS-1$ |
| 115 |
firstModifier = appendModifier(buffer, accessFlags, IModifierConstants.ACC_TRANSIENT, "transient", firstModifier); //$NON-NLS-1$ |
| 116 |
firstModifier = appendModifier(buffer, accessFlags, IModifierConstants.ACC_VOLATILE, "volatile", firstModifier); //$NON-NLS-1$ |
| 117 |
if (!firstModifier) { |
| 118 |
buffer.append(Messages.disassembler_space); |
| 119 |
} |
| 120 |
} |
| 121 |
|
| 122 |
private final void decodeModifiersForInnerClasses(StringBuffer buffer, int accessFlags) { |
| 123 |
boolean firstModifier = true; |
| 124 |
firstModifier = appendModifier(buffer, accessFlags, IModifierConstants.ACC_PUBLIC, "public", firstModifier); //$NON-NLS-1$ |
| 125 |
firstModifier = appendModifier(buffer, accessFlags, IModifierConstants.ACC_PROTECTED, "protected", firstModifier); //$NON-NLS-1$ |
| 126 |
firstModifier = appendModifier(buffer, accessFlags, IModifierConstants.ACC_PRIVATE, "private", firstModifier); //$NON-NLS-1$ |
| 127 |
firstModifier = appendModifier(buffer, accessFlags, IModifierConstants.ACC_ABSTRACT, "abstract", firstModifier); //$NON-NLS-1$ |
| 128 |
firstModifier = appendModifier(buffer, accessFlags, IModifierConstants.ACC_STATIC, "static", firstModifier); //$NON-NLS-1$ |
| 129 |
firstModifier = appendModifier(buffer, accessFlags, IModifierConstants.ACC_FINAL, "final", firstModifier); //$NON-NLS-1$ |
| 130 |
if (!firstModifier) { |
| 131 |
buffer.append(Messages.disassembler_space); |
| 132 |
} |
| 133 |
} |
| 134 |
|
211 |
|
| 135 |
private final void decodeModifiersForMethod(StringBuffer buffer, int accessFlags) { |
212 |
static String decodeStringValue(char[] chars) { |
| 136 |
boolean firstModifier = true; |
|
|
| 137 |
firstModifier = appendModifier(buffer, accessFlags, IModifierConstants.ACC_PUBLIC, "public", firstModifier); //$NON-NLS-1$ |
| 138 |
firstModifier = appendModifier(buffer, accessFlags, IModifierConstants.ACC_PROTECTED, "protected", firstModifier); //$NON-NLS-1$ |
| 139 |
firstModifier = appendModifier(buffer, accessFlags, IModifierConstants.ACC_PRIVATE, "private", firstModifier); //$NON-NLS-1$ |
| 140 |
firstModifier = appendModifier(buffer, accessFlags, IModifierConstants.ACC_ABSTRACT, "abstract", firstModifier); //$NON-NLS-1$ |
| 141 |
firstModifier = appendModifier(buffer, accessFlags, IModifierConstants.ACC_STATIC, "static", firstModifier); //$NON-NLS-1$ |
| 142 |
firstModifier = appendModifier(buffer, accessFlags, IModifierConstants.ACC_FINAL, "final", firstModifier); //$NON-NLS-1$ |
| 143 |
firstModifier = appendModifier(buffer, accessFlags, IModifierConstants.ACC_SYNCHRONIZED, "synchronized", firstModifier); //$NON-NLS-1$ |
| 144 |
firstModifier = appendModifier(buffer, accessFlags, IModifierConstants.ACC_NATIVE, "native", firstModifier); //$NON-NLS-1$ |
| 145 |
firstModifier = appendModifier(buffer, accessFlags, IModifierConstants.ACC_STRICT, "strictfp", firstModifier); //$NON-NLS-1$ |
| 146 |
firstModifier = appendModifier(buffer, accessFlags, IModifierConstants.ACC_BRIDGE, "bridge", firstModifier); //$NON-NLS-1$ |
| 147 |
if (!firstModifier) { |
| 148 |
buffer.append(Messages.disassembler_space); |
| 149 |
} |
| 150 |
} |
| 151 |
|
| 152 |
private final void decodeModifiersForType(StringBuffer buffer, int accessFlags) { |
| 153 |
boolean firstModifier = true; |
| 154 |
firstModifier = appendModifier(buffer, accessFlags, IModifierConstants.ACC_PUBLIC, "public", firstModifier); //$NON-NLS-1$ |
| 155 |
firstModifier = appendModifier(buffer, accessFlags, IModifierConstants.ACC_ABSTRACT, "abstract", firstModifier); //$NON-NLS-1$ |
| 156 |
firstModifier = appendModifier(buffer, accessFlags, IModifierConstants.ACC_FINAL, "final", firstModifier); //$NON-NLS-1$ |
| 157 |
if (!firstModifier) { |
| 158 |
buffer.append(Messages.disassembler_space); |
| 159 |
} |
| 160 |
} |
| 161 |
|
| 162 |
private String decodeStringValue(char[] chars) { |
| 163 |
StringBuffer buffer = new StringBuffer(); |
213 |
StringBuffer buffer = new StringBuffer(); |
| 164 |
for (int i = 0, max = chars.length; i < max; i++) { |
214 |
for (int i = 0, max = chars.length; i < max; i++) { |
| 165 |
char c = chars[i]; |
215 |
char c = chars[i]; |
|
Lines 179-193
Link Here
|
| 179 |
case '\r' : |
229 |
case '\r' : |
| 180 |
buffer.append("\\r"); //$NON-NLS-1$ |
230 |
buffer.append("\\r"); //$NON-NLS-1$ |
| 181 |
break; |
231 |
break; |
| 182 |
case '\"': |
|
|
| 183 |
buffer.append("\\\""); //$NON-NLS-1$ |
| 184 |
break; |
| 185 |
case '\'': |
| 186 |
buffer.append("\\\'"); //$NON-NLS-1$ |
| 187 |
break; |
| 188 |
case '\\': |
| 189 |
buffer.append("\\\\"); //$NON-NLS-1$ |
| 190 |
break; |
| 191 |
case '\0' : |
232 |
case '\0' : |
| 192 |
buffer.append("\\0"); //$NON-NLS-1$ |
233 |
buffer.append("\\0"); //$NON-NLS-1$ |
| 193 |
break; |
234 |
break; |
|
Lines 219-225
Link Here
|
| 219 |
return buffer.toString(); |
260 |
return buffer.toString(); |
| 220 |
} |
261 |
} |
| 221 |
|
262 |
|
| 222 |
private String decodeStringValue(String s) { |
263 |
static String decodeStringValue(String s) { |
| 223 |
return decodeStringValue(s.toCharArray()); |
264 |
return decodeStringValue(s.toCharArray()); |
| 224 |
} |
265 |
} |
| 225 |
|
266 |
|
|
Lines 397-413
Link Here
|
| 397 |
buffer.append(" throws "); //$NON-NLS-1$ |
438 |
buffer.append(" throws "); //$NON-NLS-1$ |
| 398 |
char[][] exceptionNames = exceptionAttribute.getExceptionNames(); |
439 |
char[][] exceptionNames = exceptionAttribute.getExceptionNames(); |
| 399 |
int length = exceptionNames.length; |
440 |
int length = exceptionNames.length; |
| 400 |
for (int i = 0; i < length - 1; i++) { |
441 |
for (int i = 0; i < length; i++) { |
|
|
442 |
if (i != 0) { |
| 443 |
buffer |
| 444 |
.append(Messages.disassembler_comma) |
| 445 |
.append(Messages.disassembler_space); |
| 446 |
} |
| 401 |
char[] exceptionName = exceptionNames[i]; |
447 |
char[] exceptionName = exceptionNames[i]; |
| 402 |
CharOperation.replace(exceptionName, '/', '.'); |
448 |
CharOperation.replace(exceptionName, '/', '.'); |
| 403 |
buffer |
449 |
buffer.append(returnClassName(exceptionName, '.', mode)); |
| 404 |
.append(returnClassName(exceptionName, '.', mode)) |
450 |
} |
| 405 |
.append(Messages.disassembler_comma) |
|
|
| 406 |
.append(Messages.disassembler_space); |
| 407 |
} |
| 408 |
char[] exceptionName = exceptionNames[length - 1]; |
| 409 |
CharOperation.replace(exceptionName, '/', '.'); |
| 410 |
buffer.append(returnClassName(exceptionName, '.', mode)); |
| 411 |
} |
451 |
} |
| 412 |
if (((accessFlags & IModifierConstants.ACC_NATIVE) == 0) |
452 |
if (((accessFlags & IModifierConstants.ACC_NATIVE) == 0) |
| 413 |
&& ((accessFlags & IModifierConstants.ACC_ABSTRACT) == 0)) { |
453 |
&& ((accessFlags & IModifierConstants.ACC_ABSTRACT) == 0)) { |
|
Lines 530-546
Link Here
|
| 530 |
buffer.append(" throws "); //$NON-NLS-1$ |
570 |
buffer.append(" throws "); //$NON-NLS-1$ |
| 531 |
char[][] exceptionNames = exceptionAttribute.getExceptionNames(); |
571 |
char[][] exceptionNames = exceptionAttribute.getExceptionNames(); |
| 532 |
int length = exceptionNames.length; |
572 |
int length = exceptionNames.length; |
| 533 |
for (int i = 0; i < length - 1; i++) { |
573 |
for (int i = 0; i < length; i++) { |
|
|
574 |
if (i != 0) { |
| 575 |
buffer |
| 576 |
.append(Messages.disassembler_comma) |
| 577 |
.append(Messages.disassembler_space); |
| 578 |
} |
| 534 |
char[] exceptionName = exceptionNames[i]; |
579 |
char[] exceptionName = exceptionNames[i]; |
| 535 |
CharOperation.replace(exceptionName, '/', '.'); |
580 |
CharOperation.replace(exceptionName, '/', '.'); |
| 536 |
buffer |
581 |
buffer.append(returnClassName(exceptionName, '.', mode)); |
| 537 |
.append(returnClassName(exceptionName, '.', mode)) |
582 |
} |
| 538 |
.append(Messages.disassembler_comma) |
|
|
| 539 |
.append(Messages.disassembler_space); |
| 540 |
} |
| 541 |
char[] exceptionName = exceptionNames[length - 1]; |
| 542 |
CharOperation.replace(exceptionName, '/', '.'); |
| 543 |
buffer.append(returnClassName(exceptionName, '.', mode)); |
| 544 |
} |
583 |
} |
| 545 |
if (checkMode(mode, DETAILED)) { |
584 |
if (checkMode(mode, DETAILED)) { |
| 546 |
if (annotationDefaultAttribute != null) { |
585 |
if (annotationDefaultAttribute != null) { |
|
Lines 748-754
Link Here
|
| 748 |
char[] innerClassName = entry.getInnerClassName(); |
787 |
char[] innerClassName = entry.getInnerClassName(); |
| 749 |
if (innerClassName != null) { |
788 |
if (innerClassName != null) { |
| 750 |
if (CharOperation.equals(classFileReader.getClassName(), innerClassName)) { |
789 |
if (CharOperation.equals(classFileReader.getClassName(), innerClassName)) { |
| 751 |
decodeModifiersForInnerClasses(buffer, entry.getAccessFlags()); |
790 |
decodeModifiersForInnerClasses(buffer, entry.getAccessFlags(), false); |
| 752 |
decoded = true; |
791 |
decoded = true; |
| 753 |
} |
792 |
} |
| 754 |
} |
793 |
} |
|
Lines 806-822
Link Here
|
| 806 |
} else { |
845 |
} else { |
| 807 |
buffer.append(" implements "); //$NON-NLS-1$ |
846 |
buffer.append(" implements "); //$NON-NLS-1$ |
| 808 |
} |
847 |
} |
| 809 |
for (int i = 0; i < length - 1; i++) { |
848 |
for (int i = 0; i < length; i++) { |
|
|
849 |
if (i != 0) { |
| 850 |
buffer |
| 851 |
.append(Messages.disassembler_comma) |
| 852 |
.append(Messages.disassembler_space); |
| 853 |
} |
| 810 |
char[] superinterface = superclassInterfaces[i]; |
854 |
char[] superinterface = superclassInterfaces[i]; |
| 811 |
CharOperation.replace(superinterface, '/', '.'); |
855 |
CharOperation.replace(superinterface, '/', '.'); |
| 812 |
buffer |
856 |
buffer |
| 813 |
.append(returnClassName(superinterface, '.', mode)) |
857 |
.append(returnClassName(superinterface, '.', mode)); |
| 814 |
.append(Messages.disassembler_comma) |
|
|
| 815 |
.append(Messages.disassembler_space); |
| 816 |
} |
858 |
} |
| 817 |
char[] superinterface = superclassInterfaces[length - 1]; |
|
|
| 818 |
CharOperation.replace(superinterface, '/', '.'); |
| 819 |
buffer.append(returnClassName(superinterface, '.', mode)); |
| 820 |
} |
859 |
} |
| 821 |
} |
860 |
} |
| 822 |
buffer.append(Messages.bind(Messages.disassembler_opentypedeclaration)); |
861 |
buffer.append(Messages.bind(Messages.disassembler_opentypedeclaration)); |
|
Lines 886-891
Link Here
|
| 886 |
if (typeParametersLength != 0) { |
925 |
if (typeParametersLength != 0) { |
| 887 |
buffer.append('<'); |
926 |
buffer.append('<'); |
| 888 |
for (int i = 0; i < typeParametersLength; i++) { |
927 |
for (int i = 0; i < typeParametersLength; i++) { |
|
|
928 |
if (i != 0) { |
| 929 |
buffer.append(Messages.disassembler_comma); |
| 930 |
} |
| 889 |
// extract the name |
931 |
// extract the name |
| 890 |
buffer.append(typeParameters[i], 0, CharOperation.indexOf(':', typeParameters[i])); |
932 |
buffer.append(typeParameters[i], 0, CharOperation.indexOf(':', typeParameters[i])); |
| 891 |
final char[][] bounds = Signature.getTypeParameterBounds(typeParameters[i]); |
933 |
final char[][] bounds = Signature.getTypeParameterBounds(typeParameters[i]); |
|
Lines 900-914
Link Here
|
| 900 |
} |
942 |
} |
| 901 |
} else { |
943 |
} else { |
| 902 |
buffer.append(" extends "); //$NON-NLS-1$ |
944 |
buffer.append(" extends "); //$NON-NLS-1$ |
| 903 |
for (int j= 0; j < boundsLength - 1; j++) { |
945 |
for (int j= 0; j < boundsLength; j++) { |
| 904 |
buffer.append(returnClassName(Signature.toCharArray(bounds[j]), '.', mode)); |
946 |
if (j != 0) { |
| 905 |
buffer.append(" & "); //$NON-NLS-1$ |
947 |
buffer.append(" & "); //$NON-NLS-1$ |
| 906 |
} |
948 |
} |
| 907 |
buffer.append(returnClassName(Signature.toCharArray(bounds[boundsLength - 1]), '.', mode)); |
949 |
buffer.append(returnClassName(Signature.toCharArray(bounds[j]), '.', mode)); |
|
|
950 |
} |
| 908 |
} |
951 |
} |
| 909 |
} |
|
|
| 910 |
if (i < typeParametersLength - 1) { |
| 911 |
buffer.append(','); |
| 912 |
} |
952 |
} |
| 913 |
} |
953 |
} |
| 914 |
buffer.append('>'); |
954 |
buffer.append('>'); |
|
Lines 938-944
Link Here
|
| 938 |
final IExceptionTableEntry[] exceptionTableEntries = codeAttribute.getExceptionTable(); |
978 |
final IExceptionTableEntry[] exceptionTableEntries = codeAttribute.getExceptionTable(); |
| 939 |
buffer.append(Messages.disassembler_exceptiontableheader); |
979 |
buffer.append(Messages.disassembler_exceptiontableheader); |
| 940 |
writeNewLine(buffer, lineSeparator, tabNumberForExceptionAttribute + 1); |
980 |
writeNewLine(buffer, lineSeparator, tabNumberForExceptionAttribute + 1); |
| 941 |
for (int i = 0; i < exceptionTableLength - 1; i++) { |
981 |
for (int i = 0; i < exceptionTableLength; i++) { |
|
|
982 |
if (i != 0) { |
| 983 |
writeNewLine(buffer, lineSeparator, tabNumberForExceptionAttribute + 1); |
| 984 |
} |
| 942 |
IExceptionTableEntry exceptionTableEntry = exceptionTableEntries[i]; |
985 |
IExceptionTableEntry exceptionTableEntry = exceptionTableEntries[i]; |
| 943 |
char[] catchType; |
986 |
char[] catchType; |
| 944 |
if (exceptionTableEntry.getCatchTypeIndex() != 0) { |
987 |
if (exceptionTableEntry.getCatchTypeIndex() != 0) { |
|
Lines 955-978
Link Here
|
| 955 |
Integer.toString(exceptionTableEntry.getHandlerPC()), |
998 |
Integer.toString(exceptionTableEntry.getHandlerPC()), |
| 956 |
new String(catchType) |
999 |
new String(catchType) |
| 957 |
})); |
1000 |
})); |
| 958 |
writeNewLine(buffer, lineSeparator, tabNumberForExceptionAttribute + 1); |
|
|
| 959 |
} |
1001 |
} |
| 960 |
IExceptionTableEntry exceptionTableEntry = exceptionTableEntries[exceptionTableLength - 1]; |
|
|
| 961 |
char[] catchType; |
| 962 |
if (exceptionTableEntry.getCatchTypeIndex() != 0) { |
| 963 |
catchType = exceptionTableEntry.getCatchType(); |
| 964 |
CharOperation.replace(catchType, '/', '.'); |
| 965 |
catchType = returnClassName(catchType, '.', mode); |
| 966 |
} else { |
| 967 |
catchType = ANY_EXCEPTION; |
| 968 |
} |
| 969 |
buffer.append(Messages.bind(Messages.classfileformat_exceptiontableentry, |
| 970 |
new String[] { |
| 971 |
Integer.toString(exceptionTableEntry.getStartPC()), |
| 972 |
Integer.toString(exceptionTableEntry.getEndPC()), |
| 973 |
Integer.toString(exceptionTableEntry.getHandlerPC()), |
| 974 |
new String(catchType) |
| 975 |
})); |
| 976 |
} |
1002 |
} |
| 977 |
final ILineNumberAttribute lineNumberAttribute = codeAttribute.getLineNumberAttribute(); |
1003 |
final ILineNumberAttribute lineNumberAttribute = codeAttribute.getLineNumberAttribute(); |
| 978 |
final int lineAttributeLength = lineNumberAttribute == null ? 0 : lineNumberAttribute.getLineNumberTableLength(); |
1004 |
final int lineAttributeLength = lineNumberAttribute == null ? 0 : lineNumberAttribute.getLineNumberTableLength(); |
|
Lines 987-1005
Link Here
|
| 987 |
buffer.append(Messages.disassembler_linenumberattributeheader); |
1013 |
buffer.append(Messages.disassembler_linenumberattributeheader); |
| 988 |
writeNewLine(buffer, lineSeparator, tabNumberForLineAttribute + 1); |
1014 |
writeNewLine(buffer, lineSeparator, tabNumberForLineAttribute + 1); |
| 989 |
int[][] lineattributesEntries = lineNumberAttribute.getLineNumberTable(); |
1015 |
int[][] lineattributesEntries = lineNumberAttribute.getLineNumberTable(); |
| 990 |
for (int i = 0; i < lineAttributeLength - 1; i++) { |
1016 |
for (int i = 0; i < lineAttributeLength; i++) { |
|
|
1017 |
if (i != 0) { |
| 1018 |
writeNewLine(buffer, lineSeparator, tabNumberForLineAttribute + 1); |
| 1019 |
} |
| 991 |
buffer.append(Messages.bind(Messages.classfileformat_linenumbertableentry, |
1020 |
buffer.append(Messages.bind(Messages.classfileformat_linenumbertableentry, |
| 992 |
new String[] { |
1021 |
new String[] { |
| 993 |
Integer.toString(lineattributesEntries[i][0]), |
1022 |
Integer.toString(lineattributesEntries[i][0]), |
| 994 |
Integer.toString(lineattributesEntries[i][1]) |
1023 |
Integer.toString(lineattributesEntries[i][1]) |
| 995 |
})); |
1024 |
})); |
| 996 |
writeNewLine(buffer, lineSeparator, tabNumberForLineAttribute + 1); |
|
|
| 997 |
} |
1025 |
} |
| 998 |
buffer.append(Messages.bind(Messages.classfileformat_linenumbertableentry, |
|
|
| 999 |
new String[] { |
| 1000 |
Integer.toString(lineattributesEntries[lineAttributeLength - 1][0]), |
| 1001 |
Integer.toString(lineattributesEntries[lineAttributeLength - 1][1]) |
| 1002 |
})); |
| 1003 |
} |
1026 |
} |
| 1004 |
final ILocalVariableAttribute localVariableAttribute = codeAttribute.getLocalVariableAttribute(); |
1027 |
final ILocalVariableAttribute localVariableAttribute = codeAttribute.getLocalVariableAttribute(); |
| 1005 |
final int localVariableAttributeLength = localVariableAttribute == null ? 0 : localVariableAttribute.getLocalVariableTableLength(); |
1028 |
final int localVariableAttributeLength = localVariableAttribute == null ? 0 : localVariableAttribute.getLocalVariableTableLength(); |
|
Lines 1014-1020
Link Here
|
| 1014 |
buffer.append(Messages.disassembler_localvariabletableattributeheader); |
1037 |
buffer.append(Messages.disassembler_localvariabletableattributeheader); |
| 1015 |
writeNewLine(buffer, lineSeparator, tabNumberForLocalVariableAttribute + 1); |
1038 |
writeNewLine(buffer, lineSeparator, tabNumberForLocalVariableAttribute + 1); |
| 1016 |
ILocalVariableTableEntry[] localVariableTableEntries = localVariableAttribute.getLocalVariableTable(); |
1039 |
ILocalVariableTableEntry[] localVariableTableEntries = localVariableAttribute.getLocalVariableTable(); |
| 1017 |
for (int i = 0; i < localVariableAttributeLength - 1; i++) { |
1040 |
for (int i = 0; i < localVariableAttributeLength; i++) { |
|
|
1041 |
if (i != 0) { |
| 1042 |
writeNewLine(buffer, lineSeparator, tabNumberForLocalVariableAttribute + 1); |
| 1043 |
} |
| 1018 |
ILocalVariableTableEntry localVariableTableEntry = localVariableTableEntries[i]; |
1044 |
ILocalVariableTableEntry localVariableTableEntry = localVariableTableEntries[i]; |
| 1019 |
int index= localVariableTableEntry.getIndex(); |
1045 |
int index= localVariableTableEntry.getIndex(); |
| 1020 |
int startPC = localVariableTableEntry.getStartPC(); |
1046 |
int startPC = localVariableTableEntry.getStartPC(); |
|
Lines 1029-1050
Link Here
|
| 1029 |
Integer.toString(index), |
1055 |
Integer.toString(index), |
| 1030 |
new String(returnClassName(typeName, '.', mode)) |
1056 |
new String(returnClassName(typeName, '.', mode)) |
| 1031 |
})); |
1057 |
})); |
| 1032 |
writeNewLine(buffer, lineSeparator, tabNumberForLocalVariableAttribute + 1); |
|
|
| 1033 |
} |
1058 |
} |
| 1034 |
ILocalVariableTableEntry localVariableTableEntry = localVariableTableEntries[localVariableAttributeLength - 1]; |
|
|
| 1035 |
int index= localVariableTableEntry.getIndex(); |
| 1036 |
int startPC = localVariableTableEntry.getStartPC(); |
| 1037 |
int length = localVariableTableEntry.getLength(); |
| 1038 |
final char[] typeName = Signature.toCharArray(localVariableTableEntry.getDescriptor()); |
| 1039 |
CharOperation.replace(typeName, '/', '.'); |
| 1040 |
buffer.append(Messages.bind(Messages.classfileformat_localvariabletableentry, |
| 1041 |
new String[] { |
| 1042 |
Integer.toString(startPC), |
| 1043 |
Integer.toString(startPC + length), |
| 1044 |
new String(localVariableTableEntry.getName()), |
| 1045 |
Integer.toString(index), |
| 1046 |
new String(returnClassName(typeName, '.', mode)) |
| 1047 |
})); |
| 1048 |
} |
1059 |
} |
| 1049 |
final ILocalVariableTypeTableAttribute localVariableTypeAttribute= (ILocalVariableTypeTableAttribute) getAttribute(IAttributeNamesConstants.LOCAL_VARIABLE_TYPE_TABLE, codeAttribute); |
1060 |
final ILocalVariableTypeTableAttribute localVariableTypeAttribute= (ILocalVariableTypeTableAttribute) getAttribute(IAttributeNamesConstants.LOCAL_VARIABLE_TYPE_TABLE, codeAttribute); |
| 1050 |
final int localVariableTypeTableLength = localVariableTypeAttribute == null ? 0 : localVariableTypeAttribute.getLocalVariableTypeTableLength(); |
1061 |
final int localVariableTypeTableLength = localVariableTypeAttribute == null ? 0 : localVariableTypeAttribute.getLocalVariableTypeTableLength(); |
|
Lines 1059-1065
Link Here
|
| 1059 |
buffer.append(Messages.disassembler_localvariabletypetableattributeheader); |
1070 |
buffer.append(Messages.disassembler_localvariabletypetableattributeheader); |
| 1060 |
writeNewLine(buffer, lineSeparator, tabNumberForLocalVariableAttribute + 1); |
1071 |
writeNewLine(buffer, lineSeparator, tabNumberForLocalVariableAttribute + 1); |
| 1061 |
ILocalVariableTypeTableEntry[] localVariableTypeTableEntries = localVariableTypeAttribute.getLocalVariableTypeTable(); |
1072 |
ILocalVariableTypeTableEntry[] localVariableTypeTableEntries = localVariableTypeAttribute.getLocalVariableTypeTable(); |
| 1062 |
for (int i = 0; i < localVariableTypeTableLength - 1; i++) { |
1073 |
for (int i = 0; i < localVariableTypeTableLength; i++) { |
|
|
1074 |
if (i != 0) { |
| 1075 |
writeNewLine(buffer, lineSeparator, tabNumberForLocalVariableAttribute + 1); |
| 1076 |
} |
| 1063 |
ILocalVariableTypeTableEntry localVariableTypeTableEntry = localVariableTypeTableEntries[i]; |
1077 |
ILocalVariableTypeTableEntry localVariableTypeTableEntry = localVariableTypeTableEntries[i]; |
| 1064 |
int index= localVariableTypeTableEntry.getIndex(); |
1078 |
int index= localVariableTypeTableEntry.getIndex(); |
| 1065 |
int startPC = localVariableTypeTableEntry.getStartPC(); |
1079 |
int startPC = localVariableTypeTableEntry.getStartPC(); |
|
Lines 1074-1095
Link Here
|
| 1074 |
Integer.toString(index), |
1088 |
Integer.toString(index), |
| 1075 |
new String(returnClassName(typeName, '.', mode)) |
1089 |
new String(returnClassName(typeName, '.', mode)) |
| 1076 |
})); |
1090 |
})); |
| 1077 |
writeNewLine(buffer, lineSeparator, tabNumberForLocalVariableAttribute + 1); |
|
|
| 1078 |
} |
1091 |
} |
| 1079 |
ILocalVariableTypeTableEntry localVariableTypeTableEntry = localVariableTypeTableEntries[localVariableTypeTableLength - 1]; |
|
|
| 1080 |
int index= localVariableTypeTableEntry.getIndex(); |
| 1081 |
int startPC = localVariableTypeTableEntry.getStartPC(); |
| 1082 |
int length = localVariableTypeTableEntry.getLength(); |
| 1083 |
final char[] typeName = Signature.toCharArray(localVariableTypeTableEntry.getSignature()); |
| 1084 |
CharOperation.replace(typeName, '/', '.'); |
| 1085 |
buffer.append(Messages.bind(Messages.classfileformat_localvariabletableentry, |
| 1086 |
new String[] { |
| 1087 |
Integer.toString(startPC), |
| 1088 |
Integer.toString(startPC + length), |
| 1089 |
new String(localVariableTypeTableEntry.getName()), |
| 1090 |
Integer.toString(index), |
| 1091 |
new String(returnClassName(typeName, '.', mode)) |
| 1092 |
})); |
| 1093 |
} |
1092 |
} |
| 1094 |
final int length = codeAttribute.getAttributesCount(); |
1093 |
final int length = codeAttribute.getAttributesCount(); |
| 1095 |
if (length != 0) { |
1094 |
if (length != 0) { |
|
Lines 1267-1272
Link Here
|
| 1267 |
buffer.append(Messages.disassembler_constantpoolheader); |
1266 |
buffer.append(Messages.disassembler_constantpoolheader); |
| 1268 |
writeNewLine(buffer, lineSeparator, tabNumber + 1); |
1267 |
writeNewLine(buffer, lineSeparator, tabNumber + 1); |
| 1269 |
for (int i = 1; i < length; i++) { |
1268 |
for (int i = 1; i < length; i++) { |
|
|
1269 |
if (i != 1) { |
| 1270 |
writeNewLine(buffer, lineSeparator, tabNumber + 1); |
| 1271 |
} |
| 1270 |
IConstantPoolEntry constantPoolEntry = constantPool.decodeEntry(i); |
1272 |
IConstantPoolEntry constantPoolEntry = constantPool.decodeEntry(i); |
| 1271 |
switch (constantPool.getEntryKind(i)) { |
1273 |
switch (constantPool.getEntryKind(i)) { |
| 1272 |
case IConstantPoolConstant.CONSTANT_Class : |
1274 |
case IConstantPoolConstant.CONSTANT_Class : |
|
Lines 1361-1379
Link Here
|
| 1361 |
new String[] { |
1363 |
new String[] { |
| 1362 |
Integer.toString(i), |
1364 |
Integer.toString(i), |
| 1363 |
Integer.toString(constantPoolEntry.getStringIndex()), |
1365 |
Integer.toString(constantPoolEntry.getStringIndex()), |
| 1364 |
escapeString(constantPoolEntry.getStringValue())})); |
1366 |
decodeStringValue(constantPoolEntry.getStringValue())})); |
| 1365 |
break; |
1367 |
break; |
| 1366 |
case IConstantPoolConstant.CONSTANT_Utf8 : |
1368 |
case IConstantPoolConstant.CONSTANT_Utf8 : |
| 1367 |
buffer.append( |
1369 |
buffer.append( |
| 1368 |
Messages.bind(Messages.disassembler_constantpool_utf8, |
1370 |
Messages.bind(Messages.disassembler_constantpool_utf8, |
| 1369 |
new String[] { |
1371 |
new String[] { |
| 1370 |
Integer.toString(i), |
1372 |
Integer.toString(i), |
| 1371 |
escapeString(new String(constantPoolEntry.getUtf8Value()))})); |
1373 |
decodeStringValue(new String(constantPoolEntry.getUtf8Value()))})); |
| 1372 |
break; |
1374 |
break; |
| 1373 |
} |
1375 |
} |
| 1374 |
if (i < length - 1) { |
|
|
| 1375 |
writeNewLine(buffer, lineSeparator, tabNumber + 1); |
| 1376 |
} |
| 1377 |
} |
1376 |
} |
| 1378 |
} |
1377 |
} |
| 1379 |
|
1378 |
|
|
Lines 1415-1420
Link Here
|
| 1415 |
if (length != 0) { |
1414 |
if (length != 0) { |
| 1416 |
// insert default value for corresponding argument types |
1415 |
// insert default value for corresponding argument types |
| 1417 |
for (int i = 0; i < length; i++) { |
1416 |
for (int i = 0; i < length; i++) { |
|
|
1417 |
if (i != 0) { |
| 1418 |
buffer.append(Messages.disassembler_comma); |
| 1419 |
} |
| 1418 |
final char[] type = argumentTypes[i]; |
1420 |
final char[] type = argumentTypes[i]; |
| 1419 |
switch(type.length) { |
1421 |
switch(type.length) { |
| 1420 |
case 1 : |
1422 |
case 1 : |
|
Lines 1438-1449
Link Here
|
| 1438 |
default : |
1440 |
default : |
| 1439 |
buffer.append("null"); //$NON-NLS-1$ |
1441 |
buffer.append("null"); //$NON-NLS-1$ |
| 1440 |
} |
1442 |
} |
| 1441 |
if (i < length - 1) { |
|
|
| 1442 |
buffer.append(','); |
| 1443 |
} |
| 1444 |
} |
1443 |
} |
| 1445 |
} |
1444 |
} |
| 1446 |
buffer.append(')').append(','); |
1445 |
buffer.append(')').append(Messages.disassembler_comma); |
| 1447 |
} |
1446 |
} |
| 1448 |
|
1447 |
|
| 1449 |
/** |
1448 |
/** |
|
Lines 1579-1585
Link Here
|
| 1579 |
int length = innerClassesAttributeEntries.length; |
1578 |
int length = innerClassesAttributeEntries.length; |
| 1580 |
int innerClassNameIndex, outerClassNameIndex, innerNameIndex, accessFlags; |
1579 |
int innerClassNameIndex, outerClassNameIndex, innerNameIndex, accessFlags; |
| 1581 |
IInnerClassesAttributeEntry innerClassesAttributeEntry; |
1580 |
IInnerClassesAttributeEntry innerClassesAttributeEntry; |
| 1582 |
for (int i = 0; i < length - 1; i++) { |
1581 |
for (int i = 0; i < length; i++) { |
|
|
1582 |
if (i != 0) { |
| 1583 |
buffer.append(Messages.disassembler_comma); |
| 1584 |
writeNewLine(buffer, lineSeparator, tabNumber + 1); |
| 1585 |
} |
| 1583 |
innerClassesAttributeEntry = innerClassesAttributeEntries[i]; |
1586 |
innerClassesAttributeEntry = innerClassesAttributeEntries[i]; |
| 1584 |
innerClassNameIndex = innerClassesAttributeEntry.getInnerClassNameIndex(); |
1587 |
innerClassNameIndex = innerClassesAttributeEntry.getInnerClassNameIndex(); |
| 1585 |
outerClassNameIndex = innerClassesAttributeEntry.getOuterClassNameIndex(); |
1588 |
outerClassNameIndex = innerClassesAttributeEntry.getOuterClassNameIndex(); |
|
Lines 1624-1682
Link Here
|
| 1624 |
.append(Messages.disassembler_inner_accessflags) |
1627 |
.append(Messages.disassembler_inner_accessflags) |
| 1625 |
.append(accessFlags) |
1628 |
.append(accessFlags) |
| 1626 |
.append(Messages.disassembler_space); |
1629 |
.append(Messages.disassembler_space); |
| 1627 |
decodeModifiersForInnerClasses(buffer, accessFlags); |
1630 |
decodeModifiersForInnerClasses(buffer, accessFlags, true); |
| 1628 |
buffer |
1631 |
buffer |
| 1629 |
.append(Messages.disassembler_closeinnerclassentry) |
1632 |
.append(Messages.disassembler_closeinnerclassentry); |
| 1630 |
.append(Messages.disassembler_comma); |
|
|
| 1631 |
writeNewLine(buffer, lineSeparator, tabNumber + 1); |
| 1632 |
} |
1633 |
} |
| 1633 |
// last entry |
|
|
| 1634 |
innerClassesAttributeEntry = innerClassesAttributeEntries[length - 1]; |
| 1635 |
innerClassNameIndex = innerClassesAttributeEntry.getInnerClassNameIndex(); |
| 1636 |
outerClassNameIndex = innerClassesAttributeEntry.getOuterClassNameIndex(); |
| 1637 |
innerNameIndex = innerClassesAttributeEntry.getInnerNameIndex(); |
| 1638 |
accessFlags = innerClassesAttributeEntry.getAccessFlags(); |
| 1639 |
buffer |
| 1640 |
.append(Messages.disassembler_openinnerclassentry) |
| 1641 |
.append(Messages.disassembler_inner_class_info_name) |
| 1642 |
.append(Messages.disassembler_constantpoolindex) |
| 1643 |
.append(innerClassNameIndex); |
| 1644 |
if (innerClassNameIndex != 0) { |
| 1645 |
buffer |
| 1646 |
.append(Messages.disassembler_space) |
| 1647 |
.append(innerClassesAttributeEntry.getInnerClassName()); |
| 1648 |
} |
| 1649 |
buffer |
| 1650 |
.append(Messages.disassembler_comma) |
| 1651 |
.append(Messages.disassembler_space) |
| 1652 |
.append(Messages.disassembler_outer_class_info_name) |
| 1653 |
.append(Messages.disassembler_constantpoolindex) |
| 1654 |
.append(outerClassNameIndex); |
| 1655 |
if (outerClassNameIndex != 0) { |
| 1656 |
buffer |
| 1657 |
.append(Messages.disassembler_space) |
| 1658 |
.append(innerClassesAttributeEntry.getOuterClassName()); |
| 1659 |
} |
| 1660 |
writeNewLine(buffer, lineSeparator, tabNumber); |
| 1661 |
dumpTab(tabNumber, buffer); |
| 1662 |
buffer.append(Messages.disassembler_space); |
| 1663 |
buffer |
| 1664 |
.append(Messages.disassembler_inner_name) |
| 1665 |
.append(Messages.disassembler_constantpoolindex) |
| 1666 |
.append(innerNameIndex); |
| 1667 |
if (innerNameIndex != 0) { |
| 1668 |
buffer |
| 1669 |
.append(Messages.disassembler_space) |
| 1670 |
.append(innerClassesAttributeEntry.getInnerName()); |
| 1671 |
} |
| 1672 |
buffer |
| 1673 |
.append(Messages.disassembler_comma) |
| 1674 |
.append(Messages.disassembler_space) |
| 1675 |
.append(Messages.disassembler_inner_accessflags) |
| 1676 |
.append(accessFlags) |
| 1677 |
.append(Messages.disassembler_space); |
| 1678 |
decodeModifiersForInnerClasses(buffer, accessFlags); |
| 1679 |
buffer.append(Messages.disassembler_closeinnerclassentry); |
| 1680 |
} |
1634 |
} |
| 1681 |
|
1635 |
|
| 1682 |
private void disassemble(int index, IParameterAnnotation parameterAnnotation, StringBuffer buffer, String lineSeparator, int tabNumber) { |
1636 |
private void disassemble(int index, IParameterAnnotation parameterAnnotation, StringBuffer buffer, String lineSeparator, int tabNumber) { |
|
Lines 1729-1735
Link Here
|
| 1729 |
StringBuffer buffer = new StringBuffer(); |
1683 |
StringBuffer buffer = new StringBuffer(); |
| 1730 |
buffer.append('{'); |
1684 |
buffer.append('{'); |
| 1731 |
for (int i = 0, max = infos.length; i < max; i++) { |
1685 |
for (int i = 0, max = infos.length; i < max; i++) { |
| 1732 |
if(i != 0) buffer.append(", "); //$NON-NLS-1$ |
1686 |
if(i != 0) { |
|
|
1687 |
buffer |
| 1688 |
.append(Messages.disassembler_comma) |
| 1689 |
.append(Messages.disassembler_space); |
| 1690 |
} |
| 1733 |
switch(infos[i].getTag()) { |
1691 |
switch(infos[i].getTag()) { |
| 1734 |
case IVerificationTypeInfo.ITEM_DOUBLE : |
1692 |
case IVerificationTypeInfo.ITEM_DOUBLE : |
| 1735 |
buffer.append("double"); //$NON-NLS-1$ |
1693 |
buffer.append("double"); //$NON-NLS-1$ |
