Attachment #22001 for bug #96794

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




 *******************************************************************************/
package org.eclipse.jdt.internal.core.util;

import org.eclipse.jdt.core.Signature;
import org.eclipse.jdt.core.compiler.CharOperation;
import org.eclipse.jdt.core.util.ClassFileBytesDisassembler;
import org.eclipse.jdt.core.util.IBytecodeVisitor;

 */
public class DefaultBytecodeVisitor implements IBytecodeVisitor {
	private static final String EMPTY_CLASS_NAME = "\"\""; //$NON-NLS-1$
	private static final String EMPTY_LOCAL_NAME = ""; //$NON-NLS-1$
	private static final int T_BOOLEAN = 4;
	private static final int T_CHAR = 5;
	private static final int T_FLOAT = 6;

		dumpPcNumber(pc);
		buffer.append(Messages.bind(Messages.classformat_load, (new String[] {
			OpcodeStringValues.BYTECODE_NAMES[IOpcodeMnemonics.ALOAD],
			getLocalVariableName(pc, index, true)
		})));
		writeNewLine();
	}

		writeNewLine();
	}
	private String getLocalVariableName(int pc, int index) {
		return getLocalVariableName(pc, index, false);
	}
	
	private String getLocalVariableName(int pc, int index, boolean showIndex) {
        int nextPC = pc + 1;
        switch(index) {
            case 0 :

            final ILocalVariableTableEntry entry = this.localVariableTableEntries[i];
            final int startPC = entry.getStartPC();
            if (entry.getIndex() == index && (startPC <= nextPC) && ((startPC + entry.getLength()) > nextPC)) {
            	final StringBuffer stringBuffer = new StringBuffer();
            	if (showIndex) {
            		stringBuffer.append(' ').append(index);
            	}
            	stringBuffer.append(' ').append('[').append(entry.getName()).append(']');
            	return String.valueOf(stringBuffer);
            }
        }
    	if (showIndex) {
        	final StringBuffer stringBuffer = new StringBuffer();
        	stringBuffer.append(' ').append(index);
         	return String.valueOf(stringBuffer);
    	}
        return EMPTY_LOCAL_NAME;
	}

	/**

		dumpPcNumber(pc);
		buffer.append(Messages.bind(Messages.classformat_store, (new String[] {
			OpcodeStringValues.BYTECODE_NAMES[IOpcodeMnemonics.ASTORE],
			getLocalVariableName(pc, index, true)
		})));
		writeNewLine();
	}

		dumpPcNumber(pc);
		buffer.append(Messages.bind(Messages.classformat_load, (new String[] {
			OpcodeStringValues.BYTECODE_NAMES[IOpcodeMnemonics.DLOAD],
			getLocalVariableName(pc, index, true)
		})));
		writeNewLine();
	}

		dumpPcNumber(pc);
		buffer.append(Messages.bind(Messages.classformat_store, (new String[] {
			OpcodeStringValues.BYTECODE_NAMES[IOpcodeMnemonics.DSTORE],
			getLocalVariableName(pc, index, true)
		})));
		writeNewLine();
	}

		dumpPcNumber(pc);
		buffer.append(Messages.bind(Messages.classformat_load, (new String[] {
			OpcodeStringValues.BYTECODE_NAMES[IOpcodeMnemonics.FLOAD],
			getLocalVariableName(pc, index, true)
		})));
		writeNewLine();
	}

		dumpPcNumber(pc);
		buffer.append(Messages.bind(Messages.classformat_store, (new String[] {
			OpcodeStringValues.BYTECODE_NAMES[IOpcodeMnemonics.FSTORE],
			getLocalVariableName(pc, index, true)
		})));
		writeNewLine();
	}

			Integer.toString(index),
			returnDeclaringClassName(constantFieldref),
			new String(constantFieldref.getFieldName()),
			returnClassName(Signature.toCharArray(constantFieldref.getFieldDescriptor()))
		})));
		writeNewLine();
	}

	public void _getstatic(int pc, int index, IConstantPoolEntry constantFieldref) {
		dumpPcNumber(pc);
		buffer.append(Messages.bind(Messages.classformat_getstatic, (new String[] {
				OpcodeStringValues.BYTECODE_NAMES[IOpcodeMnemonics.GETSTATIC],
				Integer.toString(index),
				returnDeclaringClassName(constantFieldref),
				new String(constantFieldref.getFieldName()),
				returnClassName(Signature.toCharArray(constantFieldref.getFieldDescriptor()))
			})));
		writeNewLine();
	}


		dumpPcNumber(pc);
		buffer.append(Messages.bind(Messages.classformat_load, (new String[] {
			OpcodeStringValues.BYTECODE_NAMES[IOpcodeMnemonics.ILOAD],
			getLocalVariableName(pc, index, true)
		})));
		writeNewLine();
	}

		IConstantPoolEntry constantInterfaceMethodref) {

		dumpPcNumber(pc);
		buffer.append(Messages.bind(Messages.classformat_invokeinterface, (new String[] {
			OpcodeStringValues.BYTECODE_NAMES[IOpcodeMnemonics.INVOKEINTERFACE],
			Integer.toString(index),
			Integer.toString(nargs),
			Util.toString(
				constantInterfaceMethodref.getClassName(),
				constantInterfaceMethodref.getMethodName(),
				constantInterfaceMethodref.getMethodDescriptor(),
				true,
				isCompact())
		})));
		} else {
			buffer.append(Messages.bind(Messages.classformat_invokeinterface, (new String[] {
					OpcodeStringValues.BYTECODE_NAMES[IOpcodeMnemonics.INVOKEINTERFACE],
					Integer.toString(index),
					Integer.toString(nargs),
					returnDeclaringClassName(constantInterfaceMethodref),
					new String(constantInterfaceMethodref.getMethodName()),
					new String(constantInterfaceMethodref.getMethodDescriptor()),
			})));
		}
		writeNewLine();
	}


	 */
	public void _invokespecial(int pc, int index, IConstantPoolEntry constantMethodref) {
		dumpPcNumber(pc);
		buffer.append(Messages.bind(Messages.classformat_invokespecial, (new String[] {
			OpcodeStringValues.BYTECODE_NAMES[IOpcodeMnemonics.INVOKESPECIAL],
			Integer.toString(index),
			Util.toString(
				constantMethodref.getClassName(),
				constantMethodref.getMethodName(),
				constantMethodref.getMethodDescriptor(),
				true,
				isCompact())
		})));
		} else {
			buffer.append(Messages.bind(Messages.classformat_invokespecial, (new String[] {
					OpcodeStringValues.BYTECODE_NAMES[IOpcodeMnemonics.INVOKESPECIAL],
					Integer.toString(index),
					returnDeclaringClassName(constantMethodref),
					new String(constantMethodref.getMethodName()),
					new String(constantMethodref.getMethodDescriptor()),
			})));
		}
		writeNewLine();
	}


	 */
	public void _invokestatic(int pc, int index, IConstantPoolEntry constantMethodref) {
		dumpPcNumber(pc);
		buffer.append(Messages.bind(Messages.classformat_invokestatic, (new String[] {
			OpcodeStringValues.BYTECODE_NAMES[IOpcodeMnemonics.INVOKESTATIC],
			Integer.toString(index),
			Util.toString(
				constantMethodref.getClassName(),
				constantMethodref.getMethodName(),
				constantMethodref.getMethodDescriptor(),
				true,
				isCompact())
		})));
		} else {
			buffer.append(Messages.bind(Messages.classformat_invokestatic, (new String[] {
				OpcodeStringValues.BYTECODE_NAMES[IOpcodeMnemonics.INVOKESTATIC],
				Integer.toString(index),
				returnDeclaringClassName(constantMethodref),
				new String(constantMethodref.getMethodName()),
				new String(constantMethodref.getMethodDescriptor()),
			})));
		}
		writeNewLine();
	}


	 */
	public void _invokevirtual(int pc, int index, IConstantPoolEntry constantMethodref) {
		dumpPcNumber(pc);
		buffer.append(Messages.bind(Messages.classformat_invokevirtual, (new String[] {
			OpcodeStringValues.BYTECODE_NAMES[IOpcodeMnemonics.INVOKEVIRTUAL],
			Integer.toString(index),
			Util.toString(
				constantMethodref.getClassName(),
				constantMethodref.getMethodName(),
				constantMethodref.getMethodDescriptor(),
				true,
				isCompact())
		})));
		} else {
			buffer.append(Messages.bind(Messages.classformat_invokevirtual, (new String[] {
					OpcodeStringValues.BYTECODE_NAMES[IOpcodeMnemonics.INVOKEVIRTUAL],
					Integer.toString(index),
					returnDeclaringClassName(constantMethodref),
					new String(constantMethodref.getMethodName()),
					new String(constantMethodref.getMethodDescriptor()),
			})));
		}
		writeNewLine();
	}


		dumpPcNumber(pc);
		buffer.append(Messages.bind(Messages.classformat_store, (new String[] {
			OpcodeStringValues.BYTECODE_NAMES[IOpcodeMnemonics.ISTORE],
			getLocalVariableName(pc, index, true)
		})));
		writeNewLine();
	}

		dumpPcNumber(pc);
		buffer.append(Messages.bind(Messages.classformat_load, (new String[] {
			OpcodeStringValues.BYTECODE_NAMES[IOpcodeMnemonics.LLOAD],
			getLocalVariableName(pc, index, true)
		})));
		writeNewLine();
	}

		dumpPcNumber(pc);
		buffer.append(Messages.bind(Messages.classformat_store, (new String[] {
			OpcodeStringValues.BYTECODE_NAMES[IOpcodeMnemonics.LSTORE],
			getLocalVariableName(pc, index, true)
		})));
		writeNewLine();
	}

			Integer.toString(index),
			returnDeclaringClassName(constantFieldref),
			new String(constantFieldref.getFieldName()),
			returnClassName(Signature.toCharArray(constantFieldref.getFieldDescriptor()))
		})));
		writeNewLine();
	}

			Integer.toString(index),
			returnDeclaringClassName(constantFieldref),
			new String(constantFieldref.getFieldName()),
			returnClassName(Signature.toCharArray(constantFieldref.getFieldDescriptor()))
		})));
		writeNewLine();
	}


	private String returnConstantClassName(IConstantPoolEntry constantClass) {
		char[] classInfoName = constantClass.getClassInfoName();
		return returnClassName(classInfoName);
	}
	private String returnClassName(char[] classInfoName) {
		if (classInfoName.length == 0) {
			return EMPTY_CLASS_NAME;
		} else if (isCompact()) {

			if (lastIndexOfSlash != -1) {
				return new String(classInfoName, lastIndexOfSlash + 1, classInfoName.length - lastIndexOfSlash - 1);
			}
			return new String(classInfoName);
		} else {
			return new String(classInfoName);
		}
		CharOperation.replace(classInfoName, '/', '.');
		return new String(classInfoName);
	}

	private String returnDeclaringClassName(IConstantPoolEntry constantRef) {
		final char[] className = constantRef.getClassName();
		return returnClassName(className);
			int lastIndexOfSlash = CharOperation.lastIndexOf('/', className);
			if (lastIndexOfSlash != -1) {
				return new String(className, lastIndexOfSlash + 1, className.length - lastIndexOfSlash - 1);
			}
			return new String(constantRef.getClassName());
		}
		return new String(constantRef.getClassName());
	}

	private void writeNewLine() {




 */
public class Disassembler extends ClassFileBytesDisassembler {

	private static final String EMPTY_CLASS_NAME = "\"\""; //$NON-NLS-1$
	private static final char[] ANY_EXCEPTION = Messages.classfileformat_anyexceptionhandler.toCharArray();	 
	private static final String EMPTY_OUTPUT = ""; //$NON-NLS-1$
	private static final String VERSION_UNKNOWN = "unknown";//$NON-NLS-1$

				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));
		}
		if (checkMode(mode, DETAILED)) {
			if (annotationDefaultAttribute != null) {

		if (superclassName != null) {
			buffer.append(" extends "); //$NON-NLS-1$
			CharOperation.replace(superclassName, '/', '.');
			buffer.append(returnClassName(superclassName, '.', mode));
		}
		char[][] superclassInterfaces = classFileReader.getInterfaceNames();
		int length = superclassInterfaces.length;

				char[] superinterface = superclassInterfaces[i];
				CharOperation.replace(superinterface, '/', '.');
				buffer
					.append(returnClassName(superinterface, '.', mode))
					.append(Messages.disassembler_comma)
					.append(Messages.disassembler_space); 
			}
			char[] superinterface = superclassInterfaces[length - 1];
			CharOperation.replace(superinterface, '/', '.');
			buffer.append(returnClassName(superinterface, '.', mode));
		}
		buffer.append(Messages.bind(Messages.disassembler_opentypedeclaration)); 
		if (checkMode(mode, SYSTEM)) {

				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))
					}));
				writeNewLine(buffer, lineSeparator, tabNumberForLocalVariableAttribute + 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))
				}));
		} 
		ILocalVariableTypeTableAttribute localVariableTypeAttribute= getLocalVariableTypeAttribute(codeAttribute);

				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))
					}));
				writeNewLine(buffer, lineSeparator, tabNumberForLocalVariableAttribute + 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))
				}));
		} 
	}

		return (mode & flag) != 0;
	}
	
	private boolean isCompact(int mode) {
		return (mode & ClassFileBytesDisassembler.COMPACT) != 0;
	}

	private String returnClassName(char[] classInfoName, char separator, int mode) {
		if (classInfoName.length == 0) {
			return EMPTY_CLASS_NAME;
		} else if (isCompact(mode)) {
			int lastIndexOfSlash = CharOperation.lastIndexOf(separator, classInfoName);
			if (lastIndexOfSlash != -1) {
				return new String(classInfoName, lastIndexOfSlash + 1, classInfoName.length - lastIndexOfSlash - 1);
			}
			return new String(classInfoName);
		} else {
			return new String(classInfoName);
		}
	}
	
	private void writeNewLine(StringBuffer buffer, String lineSeparator, int tabNumber) {
		buffer.append(lineSeparator);
		dumpTab(tabNumber, buffer);




	public static String classformat_new;
	public static String classformat_iinc;
	public static String classformat_invokespecial;
	public static String classformat_invokespecial_compact;
	public static String classformat_invokeinterface;
	public static String classformat_invokeinterface_compact;
	public static String classformat_invokestatic;
	public static String classformat_invokestatic_compact;
	public static String classformat_invokevirtual;
	public static String classformat_invokevirtual_compact;
	public static String classformat_getfield;
	public static String classformat_getstatic;
	public static String classformat_putstatic;




		}
		return result;
	}
	private static void appendArrayTypeSignature(char[] string, int start, StringBuffer buffer, boolean compact) {
		// need a minimum 2 char
		if (start >= string.length - 1) {
			throw new IllegalArgumentException();

		if (c != Signature.C_ARRAY) { //$NON-NLS-1$
			throw new IllegalArgumentException();
		}
		appendTypeSignature(string, start + 1, buffer, compact);
		buffer.append('[').append(']');
	}
	private static void appendClassTypeSignature(char[] string, int start, StringBuffer buffer, boolean compact) {
		char c = string[start];
		if (c != Signature.C_RESOLVED) {
			return;

					// all done
					return;
				case Signature.C_DOT :
				case '/' :
					// erase package prefix
					if (compact) {
						buffer.setLength(checkpoint);
					} else {
						buffer.append('.');
					}
					break;
				 case Signature.C_DOLLAR :
					/**

			p++;
		}
	}
	static void appendTypeSignature(char[] string, int start, StringBuffer buffer, boolean compact) {
		char c = string[start];
		switch (c) {
			case Signature.C_ARRAY :
				appendArrayTypeSignature(string, start, buffer, compact);
				break;
			case Signature.C_RESOLVED :
				appendClassTypeSignature(string, start, buffer, compact);
				break;
			case Signature.C_TYPE_VARIABLE :
				int e = Util.scanTypeVariableSignature(string, start);

				break;
		}
	}
	public static String toString(char[] declaringClass, char[] methodName, char[] methodSignature, boolean includeReturnType, boolean compact) {
		final boolean isConstructor = CharOperation.equals(methodName, INIT);
		int firstParen = CharOperation.indexOf(Signature.C_PARAM_START, methodSignature);
		if (firstParen == -1) {
			return ""; //$NON-NLS-1$

		
		StringBuffer buffer = new StringBuffer(methodSignature.length + 10);
		
		if (!isConstructor) {
			// return type
			if (includeReturnType) {
				char[] rts = Signature.getReturnType(methodSignature);
				appendTypeSignature(rts, 0 , buffer);
				buffer.append(' ');
			}
		}
		
		// selector
		int lastIndexOfSlash = CharOperation.lastIndexOf('/', declaringClass);
		if (compact && lastIndexOfSlash != -1) {
			buffer.append(declaringClass, lastIndexOfSlash + 1, declaringClass.length - lastIndexOfSlash - 1);
		} else {
			CharOperation.replace(declaringClass, '/', '.');
			buffer.append(declaringClass);
		}
		if (!isConstructor) {

		buffer.append('(');
		char[][] pts = Signature.getParameterTypes(methodSignature);
		for (int i = 0, max = pts.length; i < max; i++) {
			appendTypeSignature(pts[i], 0 , buffer, compact);
				appendTypeSignature(pts[i], 0 , buffer);
			} else {
				appendTypeSignature(pts[i], 0 , buffer);
			}
			if (i != pts.length - 1) {
				buffer.append(',');
				buffer.append(' ');
			}
		}
		buffer.append(')');
		
		if (!isConstructor) {
			buffer.append(" : "); //$NON-NLS-1$
			// return type
			if (includeReturnType) {
				char[] rts = Signature.getReturnType(methodSignature);
				appendTypeSignature(rts, 0 , buffer, compact);
				buffer.append(' ');
			}
		}
		return String.valueOf(buffer);
	}
	/*




classformat_multianewarray = {0} {2}{3} [{1}]
classformat_new = {0} {2} [{1}]
classformat_iinc = {0} {1} {2} [{3}]
classformat_invokespecial ={0} {2} [{1}]
classformat_invokeinterface ={0} {3} [{1}] [nargs: {2}]
classformat_invokestatic ={0} {2} [{1}]
classformat_invokevirtual ={0} {2} [{1}]
classformat_getfield ={0} {2}.{3} : {4} [{1}]
classformat_getstatic ={0} {2}.{3} : {4} [{1}]
classformat_putstatic ={0} {2}.{3} : {4} [{1}]
classformat_putfield ={0} {2}.{3} : {4} [{1}]
classformat_getfield ={0} {2}.{3} {4} [{1}]
classformat_getstatic ={0} {2}.{3} {4} [{1}]
classformat_putstatic ={0} {2}.{3} {4} [{1}]
classformat_putfield ={0} {2}.{3} {4} [{1}]
classformat_newarray_boolean = {0} boolean [{1}]
classformat_newarray_char = {0} char [{1}]
classformat_newarray_float = {0} float [{1}]

classformat_newarray_short = {0} short [{1}]
classformat_newarray_int = {0} int [{1}]
classformat_newarray_long = {0} long [{1}]
classformat_store = {0}{1}
classformat_load = {0}{1}
classfileformat_anyexceptionhandler=any
classfileformat_exceptiontableentry = [pc: {0}, pc: {1}] -> {2} when : {3}
classfileformat_linenumbertableentry = [pc: {0}, line: {1}]

Return to bug 96794

Lines 39-44 Link Here

(-)model/org/eclipse/jdt/internal/core/util/Disassembler.java (-9 / +36 lines)
39	*/	39	*/
40	public class Disassembler extends ClassFileBytesDisassembler {	40	public class Disassembler extends ClassFileBytesDisassembler {
41		41
		42	private static final String EMPTY_CLASS_NAME = "\"\""; //$NON-NLS-1$
42	private static final char[] ANY_EXCEPTION = Messages.classfileformat_anyexceptionhandler.toCharArray();	43	private static final char[] ANY_EXCEPTION = Messages.classfileformat_anyexceptionhandler.toCharArray();
43	private static final String EMPTY_OUTPUT = ""; //$NON-NLS-1$	44	private static final String EMPTY_OUTPUT = ""; //$NON-NLS-1$
44	private static final String VERSION_UNKNOWN = "unknown";//$NON-NLS-1$	45	private static final String VERSION_UNKNOWN = "unknown";//$NON-NLS-1$
Lines 394-406 Link Here
394	char[] exceptionName = exceptionNames[i];	395	char[] exceptionName = exceptionNames[i];
395	CharOperation.replace(exceptionName, '/', '.');	396	CharOperation.replace(exceptionName, '/', '.');
396	buffer	397	buffer
397	.append(exceptionName)	398	.append(returnClassName(exceptionName, '.', mode))
398	.append(Messages.disassembler_comma)	399	.append(Messages.disassembler_comma)
399	.append(Messages.disassembler_space);	400	.append(Messages.disassembler_space);
400	}	401	}
401	char[] exceptionName = exceptionNames[length - 1];	402	char[] exceptionName = exceptionNames[length - 1];
402	CharOperation.replace(exceptionName, '/', '.');	403	CharOperation.replace(exceptionName, '/', '.');
403	buffer.append(exceptionName);	404	buffer.append(returnClassName(exceptionName, '.', mode));
404	}	405	}
405	if (checkMode(mode, DETAILED)) {	406	if (checkMode(mode, DETAILED)) {
406	if (annotationDefaultAttribute != null) {	407	if (annotationDefaultAttribute != null) {
Lines 578-584 Link Here
578	if (superclassName != null) {	579	if (superclassName != null) {
579	buffer.append(" extends "); //$NON-NLS-1$	580	buffer.append(" extends "); //$NON-NLS-1$
580	CharOperation.replace(superclassName, '/', '.');	581	CharOperation.replace(superclassName, '/', '.');
581	buffer.append(superclassName);	582	buffer.append(returnClassName(superclassName, '.', mode));
582	}	583	}
583	char[][] superclassInterfaces = classFileReader.getInterfaceNames();	584	char[][] superclassInterfaces = classFileReader.getInterfaceNames();
584	int length = superclassInterfaces.length;	585	int length = superclassInterfaces.length;
Lines 588-600 Link Here
588	char[] superinterface = superclassInterfaces[i];	589	char[] superinterface = superclassInterfaces[i];
589	CharOperation.replace(superinterface, '/', '.');	590	CharOperation.replace(superinterface, '/', '.');
590	buffer	591	buffer
591	.append(superinterface)	592	.append(returnClassName(superinterface, '.', mode))
592	.append(Messages.disassembler_comma)	593	.append(Messages.disassembler_comma)
593	.append(Messages.disassembler_space);	594	.append(Messages.disassembler_space);
594	}	595	}
595	char[] superinterface = superclassInterfaces[length - 1];	596	char[] superinterface = superclassInterfaces[length - 1];
596	CharOperation.replace(superinterface, '/', '.');	597	CharOperation.replace(superinterface, '/', '.');
597	buffer.append(superinterface);	598	buffer.append(returnClassName(superinterface, '.', mode));
598	}	599	}
599	buffer.append(Messages.bind(Messages.disassembler_opentypedeclaration));	600	buffer.append(Messages.bind(Messages.disassembler_opentypedeclaration));
600	if (checkMode(mode, SYSTEM)) {	601	if (checkMode(mode, SYSTEM)) {
Lines 743-755 Link Here
743	int index= localVariableTableEntry.getIndex();	744	int index= localVariableTableEntry.getIndex();
744	int startPC = localVariableTableEntry.getStartPC();	745	int startPC = localVariableTableEntry.getStartPC();
745	int length = localVariableTableEntry.getLength();	746	int length = localVariableTableEntry.getLength();
		747	final char[] typeName = Signature.toCharArray(localVariableTableEntry.getDescriptor());
		748	CharOperation.replace(typeName, '/', '.');
746	buffer.append(Messages.bind(Messages.classfileformat_localvariabletableentry,	749	buffer.append(Messages.bind(Messages.classfileformat_localvariabletableentry,
747	new String[] {	750	new String[] {
748	Integer.toString(startPC),	751	Integer.toString(startPC),
749	Integer.toString(startPC + length),	752	Integer.toString(startPC + length),
750	new String(localVariableTableEntry.getName()),	753	new String(localVariableTableEntry.getName()),
751	Integer.toString(index),	754	Integer.toString(index),
752	new String(localVariableTableEntry.getDescriptor())	755	new String(returnClassName(typeName, '.', mode))
753	}));	756	}));
754	writeNewLine(buffer, lineSeparator, tabNumberForLocalVariableAttribute + 1);	757	writeNewLine(buffer, lineSeparator, tabNumberForLocalVariableAttribute + 1);
755	}	758	}
Lines 757-769 Link Here
757	int index= localVariableTableEntry.getIndex();	760	int index= localVariableTableEntry.getIndex();
758	int startPC = localVariableTableEntry.getStartPC();	761	int startPC = localVariableTableEntry.getStartPC();
759	int length = localVariableTableEntry.getLength();	762	int length = localVariableTableEntry.getLength();
		763	final char[] typeName = Signature.toCharArray(localVariableTableEntry.getDescriptor());
		764	CharOperation.replace(typeName, '/', '.');
760	buffer.append(Messages.bind(Messages.classfileformat_localvariabletableentry,	765	buffer.append(Messages.bind(Messages.classfileformat_localvariabletableentry,
761	new String[] {	766	new String[] {
762	Integer.toString(startPC),	767	Integer.toString(startPC),
763	Integer.toString(startPC + length),	768	Integer.toString(startPC + length),
764	new String(localVariableTableEntry.getName()),	769	new String(localVariableTableEntry.getName()),
765	Integer.toString(index),	770	Integer.toString(index),
766	new String(localVariableTableEntry.getDescriptor())	771	new String(returnClassName(typeName, '.', mode))
767	}));	772	}));
768	}	773	}
769	ILocalVariableTypeTableAttribute localVariableTypeAttribute= getLocalVariableTypeAttribute(codeAttribute);	774	ILocalVariableTypeTableAttribute localVariableTypeAttribute= getLocalVariableTypeAttribute(codeAttribute);
Lines 779-791 Link Here
779	int index= localVariableTypeTableEntry.getIndex();	784	int index= localVariableTypeTableEntry.getIndex();
780	int startPC = localVariableTypeTableEntry.getStartPC();	785	int startPC = localVariableTypeTableEntry.getStartPC();
781	int length = localVariableTypeTableEntry.getLength();	786	int length = localVariableTypeTableEntry.getLength();
		787	final char[] typeName = Signature.toCharArray(localVariableTypeTableEntry.getSignature());
		788	CharOperation.replace(typeName, '/', '.');
782	buffer.append(Messages.bind(Messages.classfileformat_localvariabletableentry,	789	buffer.append(Messages.bind(Messages.classfileformat_localvariabletableentry,
783	new String[] {	790	new String[] {
784	Integer.toString(startPC),	791	Integer.toString(startPC),
785	Integer.toString(startPC + length),	792	Integer.toString(startPC + length),
786	new String(localVariableTypeTableEntry.getName()),	793	new String(localVariableTypeTableEntry.getName()),
787	Integer.toString(index),	794	Integer.toString(index),
788	new String(localVariableTypeTableEntry.getSignature())	795	new String(returnClassName(typeName, '.', mode))
789	}));	796	}));
790	writeNewLine(buffer, lineSeparator, tabNumberForLocalVariableAttribute + 1);	797	writeNewLine(buffer, lineSeparator, tabNumberForLocalVariableAttribute + 1);
791	}	798	}
Lines 793-805 Link Here
793	int index= localVariableTypeTableEntry.getIndex();	800	int index= localVariableTypeTableEntry.getIndex();
794	int startPC = localVariableTypeTableEntry.getStartPC();	801	int startPC = localVariableTypeTableEntry.getStartPC();
795	int length = localVariableTypeTableEntry.getLength();	802	int length = localVariableTypeTableEntry.getLength();
		803	final char[] typeName = Signature.toCharArray(localVariableTypeTableEntry.getSignature());
		804	CharOperation.replace(typeName, '/', '.');
796	buffer.append(Messages.bind(Messages.classfileformat_localvariabletableentry,	805	buffer.append(Messages.bind(Messages.classfileformat_localvariabletableentry,
797	new String[] {	806	new String[] {
798	Integer.toString(startPC),	807	Integer.toString(startPC),
799	Integer.toString(startPC + length),	808	Integer.toString(startPC + length),
800	new String(localVariableTypeTableEntry.getName()),	809	new String(localVariableTypeTableEntry.getName()),
801	Integer.toString(index),	810	Integer.toString(index),
802	new String(localVariableTypeTableEntry.getSignature())	811	new String(returnClassName(typeName, '.', mode))
803	}));	812	}));
804	}	813	}
805	}	814	}
Lines 1438-1443 Link Here
1438	return (mode & flag) != 0;	1447	return (mode & flag) != 0;
1439	}	1448	}
1440		1449
		1450	private boolean isCompact(int mode) {
		1451	return (mode & ClassFileBytesDisassembler.COMPACT) != 0;
		1452	}
		1453
		1454	private String returnClassName(char[] classInfoName, char separator, int mode) {
		1455	if (classInfoName.length == 0) {
		1456	return EMPTY_CLASS_NAME;
		1457	} else if (isCompact(mode)) {
		1458	int lastIndexOfSlash = CharOperation.lastIndexOf(separator, classInfoName);
		1459	if (lastIndexOfSlash != -1) {
		1460	return new String(classInfoName, lastIndexOfSlash + 1, classInfoName.length - lastIndexOfSlash - 1);
		1461	}
		1462	return new String(classInfoName);
		1463	} else {
		1464	return new String(classInfoName);
		1465	}
		1466	}
		1467
1441	private void writeNewLine(StringBuffer buffer, String lineSeparator, int tabNumber) {	1468	private void writeNewLine(StringBuffer buffer, String lineSeparator, int tabNumber) {
1442	buffer.append(lineSeparator);	1469	buffer.append(lineSeparator);
1443	dumpTab(tabNumber, buffer);	1470	dumpTab(tabNumber, buffer);

Lines 291-303 Link Here

(-)model/org/eclipse/jdt/internal/core/util/Messages.java (-4 lines)
291	public static String classformat_new;	291	public static String classformat_new;
292	public static String classformat_iinc;	292	public static String classformat_iinc;
293	public static String classformat_invokespecial;	293	public static String classformat_invokespecial;
294	public static String classformat_invokespecial_compact;
295	public static String classformat_invokeinterface;	294	public static String classformat_invokeinterface;
296	public static String classformat_invokeinterface_compact;
297	public static String classformat_invokestatic;	295	public static String classformat_invokestatic;
298	public static String classformat_invokestatic_compact;
299	public static String classformat_invokevirtual;	296	public static String classformat_invokevirtual;
300	public static String classformat_invokevirtual_compact;
301	public static String classformat_getfield;	297	public static String classformat_getfield;
302	public static String classformat_getstatic;	298	public static String classformat_getstatic;
303	public static String classformat_putstatic;	299	public static String classformat_putstatic;

Lines 2022-2028 Link Here

(-)model/org/eclipse/jdt/internal/core/util/Util.java (-28 / +27 lines)
2022	}	2022	}
2023	return result;	2023	return result;
2024	}	2024	}
2025	private static void appendArrayTypeSignature(char[] string, int start, StringBuffer buffer) {	2025	private static void appendArrayTypeSignature(char[] string, int start, StringBuffer buffer, boolean compact) {
2026	// need a minimum 2 char	2026	// need a minimum 2 char
2027	if (start >= string.length - 1) {	2027	if (start >= string.length - 1) {
2028	throw new IllegalArgumentException();	2028	throw new IllegalArgumentException();
Lines 2031-2040 Link Here
2031	if (c != Signature.C_ARRAY) { //$NON-NLS-1$	2031	if (c != Signature.C_ARRAY) { //$NON-NLS-1$
2032	throw new IllegalArgumentException();	2032	throw new IllegalArgumentException();
2033	}	2033	}
2034	appendTypeSignature(string, start + 1, buffer);	2034	appendTypeSignature(string, start + 1, buffer, compact);
2035	buffer.append('[').append(']');	2035	buffer.append('[').append(']');
2036	}	2036	}
2037	private static void appendClassTypeSignature(char[] string, int start, StringBuffer buffer) {	2037	private static void appendClassTypeSignature(char[] string, int start, StringBuffer buffer, boolean compact) {
2038	char c = string[start];	2038	char c = string[start];
2039	if (c != Signature.C_RESOLVED) {	2039	if (c != Signature.C_RESOLVED) {
2040	return;	2040	return;
Lines 2048-2059 Link Here
2048	// all done	2048	// all done
2049	return;	2049	return;
2050	case Signature.C_DOT :	2050	case Signature.C_DOT :
		2051	case '/' :
2051	// erase package prefix	2052	// erase package prefix
2052	buffer.setLength(checkpoint);	2053	if (compact) {
2053	break;	2054	buffer.setLength(checkpoint);
2054	case '/' :	2055	} else {
2055	// erase package prefix	2056	buffer.append('.');
2056	buffer.setLength(checkpoint);	2057	}
2057	break;	2058	break;
2058	case Signature.C_DOLLAR :	2059	case Signature.C_DOLLAR :
2059	/**	2060	/**
Lines 2070-2083 Link Here
2070	p++;	2071	p++;
2071	}	2072	}
2072	}	2073	}
2073	static void appendTypeSignature(char[] string, int start, StringBuffer buffer) {	2074	static void appendTypeSignature(char[] string, int start, StringBuffer buffer, boolean compact) {
2074	char c = string[start];	2075	char c = string[start];
2075	switch (c) {	2076	switch (c) {
2076	case Signature.C_ARRAY :	2077	case Signature.C_ARRAY :
2077	appendArrayTypeSignature(string, start, buffer);	2078	appendArrayTypeSignature(string, start, buffer, compact);
2078	break;	2079	break;
2079	case Signature.C_RESOLVED :	2080	case Signature.C_RESOLVED :
2080	appendClassTypeSignature(string, start, buffer);	2081	appendClassTypeSignature(string, start, buffer, compact);
2081	break;	2082	break;
2082	case Signature.C_TYPE_VARIABLE :	2083	case Signature.C_TYPE_VARIABLE :
2083	int e = Util.scanTypeVariableSignature(string, start);	2084	int e = Util.scanTypeVariableSignature(string, start);
Lines 2112-2119 Link Here
2112	break;	2113	break;
2113	}	2114	}
2114	}	2115	}
2115	public static String toString(char[] declaringClass, char[] methodName, char[] methodSignature, boolean includeReturnType) {	2116	public static String toString(char[] declaringClass, char[] methodName, char[] methodSignature, boolean includeReturnType, boolean compact) {
2116	boolean isConstructor = CharOperation.equals(methodName, INIT);	2117	final boolean isConstructor = CharOperation.equals(methodName, INIT);
2117	int firstParen = CharOperation.indexOf(Signature.C_PARAM_START, methodSignature);	2118	int firstParen = CharOperation.indexOf(Signature.C_PARAM_START, methodSignature);
2118	if (firstParen == -1) {	2119	if (firstParen == -1) {
2119	return ""; //$NON-NLS-1$	2120	return ""; //$NON-NLS-1$
Lines 2121-2140 Link Here
2121		2122
2122	StringBuffer buffer = new StringBuffer(methodSignature.length + 10);	2123	StringBuffer buffer = new StringBuffer(methodSignature.length + 10);
2123		2124
2124	if (!isConstructor) {
2125	// return type
2126	if (includeReturnType) {
2127	char[] rts = Signature.getReturnType(methodSignature);
2128	appendTypeSignature(rts, 0 , buffer);
2129	buffer.append(' ');
2130	}
2131	}
2132
2133	// selector	2125	// selector
2134	int lastIndexOfSlash = CharOperation.lastIndexOf('/', declaringClass);	2126	int lastIndexOfSlash = CharOperation.lastIndexOf('/', declaringClass);
2135	if (lastIndexOfSlash != -1) {	2127	if (compact && lastIndexOfSlash != -1) {
2136	buffer.append(declaringClass, lastIndexOfSlash + 1, declaringClass.length - lastIndexOfSlash - 1);	2128	buffer.append(declaringClass, lastIndexOfSlash + 1, declaringClass.length - lastIndexOfSlash - 1);
2137	} else {	2129	} else {
		2130	CharOperation.replace(declaringClass, '/', '.');
2138	buffer.append(declaringClass);	2131	buffer.append(declaringClass);
2139	}	2132	}
2140	if (!isConstructor) {	2133	if (!isConstructor) {
Lines 2149-2165 Link Here
2149	buffer.append('(');	2142	buffer.append('(');
2150	char[][] pts = Signature.getParameterTypes(methodSignature);	2143	char[][] pts = Signature.getParameterTypes(methodSignature);
2151	for (int i = 0, max = pts.length; i < max; i++) {	2144	for (int i = 0, max = pts.length; i < max; i++) {
2152	if (i == max - 1) {	2145	appendTypeSignature(pts[i], 0 , buffer, compact);
2153	appendTypeSignature(pts[i], 0 , buffer);
2154	} else {
2155	appendTypeSignature(pts[i], 0 , buffer);
2156	}
2157	if (i != pts.length - 1) {	2146	if (i != pts.length - 1) {
2158	buffer.append(',');	2147	buffer.append(',');
2159	buffer.append(' ');	2148	buffer.append(' ');
2160	}	2149	}
2161	}	2150	}
2162	buffer.append(')');	2151	buffer.append(')');
		2152
		2153	if (!isConstructor) {
		2154	buffer.append(" : "); //$NON-NLS-1$
		2155	// return type
		2156	if (includeReturnType) {
		2157	char[] rts = Signature.getReturnType(methodSignature);
		2158	appendTypeSignature(rts, 0 , buffer, compact);
		2159	buffer.append(' ');
		2160	}
		2161	}
2163	return String.valueOf(buffer);	2162	return String.valueOf(buffer);
2164	}	2163	}
2165	/*	2164	/*

Lines 317-334 Link Here

(-)model/org/eclipse/jdt/internal/core/util/messages.properties (-14 / +10 lines)
317	classformat_multianewarray = {0} {2}{3} [{1}]	317	classformat_multianewarray = {0} {2}{3} [{1}]
318	classformat_new = {0} {2} [{1}]	318	classformat_new = {0} {2} [{1}]
319	classformat_iinc = {0} {1} {2} [{3}]	319	classformat_iinc = {0} {1} {2} [{3}]
320	classformat_invokespecial = {0} {2}.{3}{4} [{1}]	320	classformat_invokespecial ={0} {2} [{1}]
321	classformat_invokespecial_compact ={0} {2} [{1}]	321	classformat_invokeinterface ={0} {3} [{1}] [nargs: {2}]
322	classformat_invokeinterface ={0} {3}.{4}{5} [{1}] [nargs: {2}]	322	classformat_invokestatic ={0} {2} [{1}]
323	classformat_invokeinterface_compact ={0} {3} [{1}] [nargs: {2}]	323	classformat_invokevirtual ={0} {2} [{1}]
324	classformat_invokestatic ={0} {2}.{3}{4} [{1}]	324	classformat_getfield ={0} {2}.{3} : {4} [{1}]
325	classformat_invokestatic_compact ={0} {2} [{1}]	325	classformat_getstatic ={0} {2}.{3} : {4} [{1}]
326	classformat_invokevirtual ={0} {2}.{3}{4} [{1}]	326	classformat_putstatic ={0} {2}.{3} : {4} [{1}]
327	classformat_invokevirtual_compact ={0} {2} [{1}]	327	classformat_putfield ={0} {2}.{3} : {4} [{1}]
328	classformat_getfield ={0} {2}.{3} {4} [{1}]
329	classformat_getstatic ={0} {2}.{3} {4} [{1}]
330	classformat_putstatic ={0} {2}.{3} {4} [{1}]
331	classformat_putfield ={0} {2}.{3} {4} [{1}]
332	classformat_newarray_boolean = {0} boolean [{1}]	328	classformat_newarray_boolean = {0} boolean [{1}]
333	classformat_newarray_char = {0} char [{1}]	329	classformat_newarray_char = {0} char [{1}]
334	classformat_newarray_float = {0} float [{1}]	330	classformat_newarray_float = {0} float [{1}]
Lines 337-344 Link Here
337	classformat_newarray_short = {0} short [{1}]	333	classformat_newarray_short = {0} short [{1}]
338	classformat_newarray_int = {0} int [{1}]	334	classformat_newarray_int = {0} int [{1}]
339	classformat_newarray_long = {0} long [{1}]	335	classformat_newarray_long = {0} long [{1}]
340	classformat_store = {0} [{1}]	336	classformat_store = {0}{1}
341	classformat_load = {0} [{1}]	337	classformat_load = {0}{1}
342	classfileformat_anyexceptionhandler=any	338	classfileformat_anyexceptionhandler=any
343	classfileformat_exceptiontableentry = [pc: {0}, pc: {1}] -> {2} when : {3}	339	classfileformat_exceptiontableentry = [pc: {0}, pc: {1}] -> {2} when : {3}
344	classfileformat_linenumbertableentry = [pc: {0}, line: {1}]	340	classfileformat_linenumbertableentry = [pc: {0}, line: {1}]

Lines 10-15 Link Here

(-)model/org/eclipse/jdt/internal/core/util/DefaultBytecodeVisitor.java (-112 / +85 lines)
10	*******************************************************************************/	10	*******************************************************************************/
11	package org.eclipse.jdt.internal.core.util;	11	package org.eclipse.jdt.internal.core.util;
12		12
		13	import org.eclipse.jdt.core.Signature;
13	import org.eclipse.jdt.core.compiler.CharOperation;	14	import org.eclipse.jdt.core.compiler.CharOperation;
14	import org.eclipse.jdt.core.util.ClassFileBytesDisassembler;	15	import org.eclipse.jdt.core.util.ClassFileBytesDisassembler;
15	import org.eclipse.jdt.core.util.IBytecodeVisitor;	16	import org.eclipse.jdt.core.util.IBytecodeVisitor;
Lines 26-31 Link Here
26	*/	27	*/
27	public class DefaultBytecodeVisitor implements IBytecodeVisitor {	28	public class DefaultBytecodeVisitor implements IBytecodeVisitor {
28	private static final String EMPTY_CLASS_NAME = "\"\""; //$NON-NLS-1$	29	private static final String EMPTY_CLASS_NAME = "\"\""; //$NON-NLS-1$
		30	private static final String EMPTY_LOCAL_NAME = ""; //$NON-NLS-1$
29	private static final int T_BOOLEAN = 4;	31	private static final int T_BOOLEAN = 4;
30	private static final int T_CHAR = 5;	32	private static final int T_CHAR = 5;
31	private static final int T_FLOAT = 6;	33	private static final int T_FLOAT = 6;
Lines 153-159 Link Here
153	dumpPcNumber(pc);	155	dumpPcNumber(pc);
154	buffer.append(Messages.bind(Messages.classformat_load, (new String[] {	156	buffer.append(Messages.bind(Messages.classformat_load, (new String[] {
155	OpcodeStringValues.BYTECODE_NAMES[IOpcodeMnemonics.ALOAD],	157	OpcodeStringValues.BYTECODE_NAMES[IOpcodeMnemonics.ALOAD],
156	getLocalVariableName(pc, index)	158	getLocalVariableName(pc, index, true)
157	})));	159	})));
158	writeNewLine();	160	writeNewLine();
159	}	161	}
Lines 214-219 Link Here
214	writeNewLine();	216	writeNewLine();
215	}	217	}
216	private String getLocalVariableName(int pc, int index) {	218	private String getLocalVariableName(int pc, int index) {
		219	return getLocalVariableName(pc, index, false);
		220	}
		221
		222	private String getLocalVariableName(int pc, int index, boolean showIndex) {
217	int nextPC = pc + 1;	223	int nextPC = pc + 1;
218	switch(index) {	224	switch(index) {
219	case 0 :	225	case 0 :
Lines 229-239 Link Here
229	final ILocalVariableTableEntry entry = this.localVariableTableEntries[i];	235	final ILocalVariableTableEntry entry = this.localVariableTableEntries[i];
230	final int startPC = entry.getStartPC();	236	final int startPC = entry.getStartPC();
231	if (entry.getIndex() == index && (startPC <= nextPC) && ((startPC + entry.getLength()) > nextPC)) {	237	if (entry.getIndex() == index && (startPC <= nextPC) && ((startPC + entry.getLength()) > nextPC)) {
232	return new String(entry.getName());	238	final StringBuffer stringBuffer = new StringBuffer();
		239	if (showIndex) {
		240	stringBuffer.append(' ').append(index);
		241	}
		242	stringBuffer.append(' ').append('[').append(entry.getName()).append(']');
		243	return String.valueOf(stringBuffer);
233	}	244	}
234	}	245	}
235	String localVariableName = Messages.bind(Messages.disassembler_localvariablename, (new String[] {Integer.toString(index)}));	246	if (showIndex) {
236	return localVariableName;	247	final StringBuffer stringBuffer = new StringBuffer();
		248	stringBuffer.append(' ').append(index);
		249	return String.valueOf(stringBuffer);
		250	}
		251	return EMPTY_LOCAL_NAME;
237	}	252	}
238		253
239	/**	254	/**
Lines 267-273 Link Here
267	dumpPcNumber(pc);	282	dumpPcNumber(pc);
268	buffer.append(Messages.bind(Messages.classformat_store, (new String[] {	283	buffer.append(Messages.bind(Messages.classformat_store, (new String[] {
269	OpcodeStringValues.BYTECODE_NAMES[IOpcodeMnemonics.ASTORE],	284	OpcodeStringValues.BYTECODE_NAMES[IOpcodeMnemonics.ASTORE],
270	getLocalVariableName(pc, index)	285	getLocalVariableName(pc, index, true)
271	})));	286	})));
272	writeNewLine();	287	writeNewLine();
273	}	288	}
Lines 496-502 Link Here
496	dumpPcNumber(pc);	511	dumpPcNumber(pc);
497	buffer.append(Messages.bind(Messages.classformat_load, (new String[] {	512	buffer.append(Messages.bind(Messages.classformat_load, (new String[] {
498	OpcodeStringValues.BYTECODE_NAMES[IOpcodeMnemonics.DLOAD],	513	OpcodeStringValues.BYTECODE_NAMES[IOpcodeMnemonics.DLOAD],
499	getLocalVariableName(pc, index)	514	getLocalVariableName(pc, index, true)
500	})));	515	})));
501	writeNewLine();	516	writeNewLine();
502	}	517	}
Lines 592-598 Link Here
592	dumpPcNumber(pc);	607	dumpPcNumber(pc);
593	buffer.append(Messages.bind(Messages.classformat_store, (new String[] {	608	buffer.append(Messages.bind(Messages.classformat_store, (new String[] {
594	OpcodeStringValues.BYTECODE_NAMES[IOpcodeMnemonics.DSTORE],	609	OpcodeStringValues.BYTECODE_NAMES[IOpcodeMnemonics.DSTORE],
595	getLocalVariableName(pc, index)	610	getLocalVariableName(pc, index, true)
596	})));	611	})));
597	writeNewLine();	612	writeNewLine();
598	}	613	}
Lines 823-829 Link Here
823	dumpPcNumber(pc);	838	dumpPcNumber(pc);
824	buffer.append(Messages.bind(Messages.classformat_load, (new String[] {	839	buffer.append(Messages.bind(Messages.classformat_load, (new String[] {
825	OpcodeStringValues.BYTECODE_NAMES[IOpcodeMnemonics.FLOAD],	840	OpcodeStringValues.BYTECODE_NAMES[IOpcodeMnemonics.FLOAD],
826	getLocalVariableName(pc, index)	841	getLocalVariableName(pc, index, true)
827	})));	842	})));
828	writeNewLine();	843	writeNewLine();
829	}	844	}
Lines 919-925 Link Here
919	dumpPcNumber(pc);	934	dumpPcNumber(pc);
920	buffer.append(Messages.bind(Messages.classformat_store, (new String[] {	935	buffer.append(Messages.bind(Messages.classformat_store, (new String[] {
921	OpcodeStringValues.BYTECODE_NAMES[IOpcodeMnemonics.FSTORE],	936	OpcodeStringValues.BYTECODE_NAMES[IOpcodeMnemonics.FSTORE],
922	getLocalVariableName(pc, index)	937	getLocalVariableName(pc, index, true)
923	})));	938	})));
924	writeNewLine();	939	writeNewLine();
925	}	940	}
Lines 943-949 Link Here
943	Integer.toString(index),	958	Integer.toString(index),
944	returnDeclaringClassName(constantFieldref),	959	returnDeclaringClassName(constantFieldref),
945	new String(constantFieldref.getFieldName()),	960	new String(constantFieldref.getFieldName()),
946	new String(constantFieldref.getFieldDescriptor())	961	returnClassName(Signature.toCharArray(constantFieldref.getFieldDescriptor()))
947	})));	962	})));
948	writeNewLine();	963	writeNewLine();
949	}	964	}
Lines 954-965 Link Here
954	public void _getstatic(int pc, int index, IConstantPoolEntry constantFieldref) {	969	public void _getstatic(int pc, int index, IConstantPoolEntry constantFieldref) {
955	dumpPcNumber(pc);	970	dumpPcNumber(pc);
956	buffer.append(Messages.bind(Messages.classformat_getstatic, (new String[] {	971	buffer.append(Messages.bind(Messages.classformat_getstatic, (new String[] {
957	OpcodeStringValues.BYTECODE_NAMES[IOpcodeMnemonics.GETSTATIC],	972	OpcodeStringValues.BYTECODE_NAMES[IOpcodeMnemonics.GETSTATIC],
958	Integer.toString(index),	973	Integer.toString(index),
959	returnDeclaringClassName(constantFieldref),	974	returnDeclaringClassName(constantFieldref),
960	new String(constantFieldref.getFieldName()),	975	new String(constantFieldref.getFieldName()),
961	new String(constantFieldref.getFieldDescriptor())	976	returnClassName(Signature.toCharArray(constantFieldref.getFieldDescriptor()))
962	})));	977	})));
963	writeNewLine();	978	writeNewLine();
964	}	979	}
965		980
Lines 1392-1398 Link Here
1392	dumpPcNumber(pc);	1407	dumpPcNumber(pc);
1393	buffer.append(Messages.bind(Messages.classformat_load, (new String[] {	1408	buffer.append(Messages.bind(Messages.classformat_load, (new String[] {
1394	OpcodeStringValues.BYTECODE_NAMES[IOpcodeMnemonics.ILOAD],	1409	OpcodeStringValues.BYTECODE_NAMES[IOpcodeMnemonics.ILOAD],
1395	getLocalVariableName(pc, index)	1410	getLocalVariableName(pc, index, true)
1396	})));	1411	})));
1397	writeNewLine();	1412	writeNewLine();
1398	}	1413	}
Lines 1438-1464 Link Here
1438	IConstantPoolEntry constantInterfaceMethodref) {	1453	IConstantPoolEntry constantInterfaceMethodref) {
1439		1454
1440	dumpPcNumber(pc);	1455	dumpPcNumber(pc);
1441	if (isCompact()) {	1456	buffer.append(Messages.bind(Messages.classformat_invokeinterface, (new String[] {
1442	buffer.append(Messages.bind(Messages.classformat_invokeinterface_compact, (new String[] {	1457	OpcodeStringValues.BYTECODE_NAMES[IOpcodeMnemonics.INVOKEINTERFACE],
1443	OpcodeStringValues.BYTECODE_NAMES[IOpcodeMnemonics.INVOKEINTERFACE],	1458	Integer.toString(index),
1444	Integer.toString(index),	1459	Integer.toString(nargs),
1445	Integer.toString(nargs),	1460	Util.toString(
1446	Util.toString(	1461	constantInterfaceMethodref.getClassName(),
1447	constantInterfaceMethodref.getClassName(),	1462	constantInterfaceMethodref.getMethodName(),
1448	constantInterfaceMethodref.getMethodName(),	1463	constantInterfaceMethodref.getMethodDescriptor(),
1449	constantInterfaceMethodref.getMethodDescriptor(),	1464	true,
1450	true)	1465	isCompact())
1451	})));	1466	})));
1452	} else {
1453	buffer.append(Messages.bind(Messages.classformat_invokeinterface, (new String[] {
1454	OpcodeStringValues.BYTECODE_NAMES[IOpcodeMnemonics.INVOKEINTERFACE],
1455	Integer.toString(index),
1456	Integer.toString(nargs),
1457	returnDeclaringClassName(constantInterfaceMethodref),
1458	new String(constantInterfaceMethodref.getMethodName()),
1459	new String(constantInterfaceMethodref.getMethodDescriptor()),
1460	})));
1461	}
1462	writeNewLine();	1467	writeNewLine();
1463	}	1468	}
1464		1469
Lines 1467-1491 Link Here
1467	*/	1472	*/
1468	public void _invokespecial(int pc, int index, IConstantPoolEntry constantMethodref) {	1473	public void _invokespecial(int pc, int index, IConstantPoolEntry constantMethodref) {
1469	dumpPcNumber(pc);	1474	dumpPcNumber(pc);
1470	if (isCompact()) {	1475	buffer.append(Messages.bind(Messages.classformat_invokespecial, (new String[] {
1471	buffer.append(Messages.bind(Messages.classformat_invokespecial_compact, (new String[] {	1476	OpcodeStringValues.BYTECODE_NAMES[IOpcodeMnemonics.INVOKESPECIAL],
1472	OpcodeStringValues.BYTECODE_NAMES[IOpcodeMnemonics.INVOKESPECIAL],	1477	Integer.toString(index),
1473	Integer.toString(index),	1478	Util.toString(
1474	Util.toString(	1479	constantMethodref.getClassName(),
1475	constantMethodref.getClassName(),	1480	constantMethodref.getMethodName(),
1476	constantMethodref.getMethodName(),	1481	constantMethodref.getMethodDescriptor(),
1477	constantMethodref.getMethodDescriptor(),	1482	true,
1478	true)	1483	isCompact())
1479	})));	1484	})));
1480	} else {
1481	buffer.append(Messages.bind(Messages.classformat_invokespecial, (new String[] {
1482	OpcodeStringValues.BYTECODE_NAMES[IOpcodeMnemonics.INVOKESPECIAL],
1483	Integer.toString(index),
1484	returnDeclaringClassName(constantMethodref),
1485	new String(constantMethodref.getMethodName()),
1486	new String(constantMethodref.getMethodDescriptor()),
1487	})));
1488	}
1489	writeNewLine();	1485	writeNewLine();
1490	}	1486	}
1491		1487
Lines 1494-1518 Link Here
1494	*/	1490	*/
1495	public void _invokestatic(int pc, int index, IConstantPoolEntry constantMethodref) {	1491	public void _invokestatic(int pc, int index, IConstantPoolEntry constantMethodref) {
1496	dumpPcNumber(pc);	1492	dumpPcNumber(pc);
1497	if (isCompact()) {	1493	buffer.append(Messages.bind(Messages.classformat_invokestatic, (new String[] {
1498	buffer.append(Messages.bind(Messages.classformat_invokestatic_compact, (new String[] {	1494	OpcodeStringValues.BYTECODE_NAMES[IOpcodeMnemonics.INVOKESTATIC],
1499	OpcodeStringValues.BYTECODE_NAMES[IOpcodeMnemonics.INVOKESTATIC],	1495	Integer.toString(index),
1500	Integer.toString(index),	1496	Util.toString(
1501	Util.toString(	1497	constantMethodref.getClassName(),
1502	constantMethodref.getClassName(),	1498	constantMethodref.getMethodName(),
1503	constantMethodref.getMethodName(),	1499	constantMethodref.getMethodDescriptor(),
1504	constantMethodref.getMethodDescriptor(),	1500	true,
1505	true)	1501	isCompact())
1506	})));	1502	})));
1507	} else {
1508	buffer.append(Messages.bind(Messages.classformat_invokestatic, (new String[] {
1509	OpcodeStringValues.BYTECODE_NAMES[IOpcodeMnemonics.INVOKESTATIC],
1510	Integer.toString(index),
1511	returnDeclaringClassName(constantMethodref),
1512	new String(constantMethodref.getMethodName()),
1513	new String(constantMethodref.getMethodDescriptor()),
1514	})));
1515	}
1516	writeNewLine();	1503	writeNewLine();
1517	}	1504	}
1518		1505
Lines 1521-1545 Link Here
1521	*/	1508	*/
1522	public void _invokevirtual(int pc, int index, IConstantPoolEntry constantMethodref) {	1509	public void _invokevirtual(int pc, int index, IConstantPoolEntry constantMethodref) {
1523	dumpPcNumber(pc);	1510	dumpPcNumber(pc);
1524	if (isCompact()) {	1511	buffer.append(Messages.bind(Messages.classformat_invokevirtual, (new String[] {
1525	buffer.append(Messages.bind(Messages.classformat_invokevirtual_compact, (new String[] {	1512	OpcodeStringValues.BYTECODE_NAMES[IOpcodeMnemonics.INVOKEVIRTUAL],
1526	OpcodeStringValues.BYTECODE_NAMES[IOpcodeMnemonics.INVOKEVIRTUAL],	1513	Integer.toString(index),
1527	Integer.toString(index),	1514	Util.toString(
1528	Util.toString(	1515	constantMethodref.getClassName(),
1529	constantMethodref.getClassName(),	1516	constantMethodref.getMethodName(),
1530	constantMethodref.getMethodName(),	1517	constantMethodref.getMethodDescriptor(),
1531	constantMethodref.getMethodDescriptor(),	1518	true,
1532	true)	1519	isCompact())
1533	})));	1520	})));
1534	} else {
1535	buffer.append(Messages.bind(Messages.classformat_invokevirtual, (new String[] {
1536	OpcodeStringValues.BYTECODE_NAMES[IOpcodeMnemonics.INVOKEVIRTUAL],
1537	Integer.toString(index),
1538	returnDeclaringClassName(constantMethodref),
1539	new String(constantMethodref.getMethodName()),
1540	new String(constantMethodref.getMethodDescriptor()),
1541	})));
1542	}
1543	writeNewLine();	1521	writeNewLine();
1544	}	1522	}
1545		1523
Lines 1643-1649 Link Here
1643	dumpPcNumber(pc);	1621	dumpPcNumber(pc);
1644	buffer.append(Messages.bind(Messages.classformat_store, (new String[] {	1622	buffer.append(Messages.bind(Messages.classformat_store, (new String[] {
1645	OpcodeStringValues.BYTECODE_NAMES[IOpcodeMnemonics.ISTORE],	1623	OpcodeStringValues.BYTECODE_NAMES[IOpcodeMnemonics.ISTORE],
1646	getLocalVariableName(pc, index)	1624	getLocalVariableName(pc, index, true)
1647	})));	1625	})));
1648	writeNewLine();	1626	writeNewLine();
1649	}	1627	}
Lines 1948-1954 Link Here
1948	dumpPcNumber(pc);	1926	dumpPcNumber(pc);
1949	buffer.append(Messages.bind(Messages.classformat_load, (new String[] {	1927	buffer.append(Messages.bind(Messages.classformat_load, (new String[] {
1950	OpcodeStringValues.BYTECODE_NAMES[IOpcodeMnemonics.LLOAD],	1928	OpcodeStringValues.BYTECODE_NAMES[IOpcodeMnemonics.LLOAD],
1951	getLocalVariableName(pc, index)	1929	getLocalVariableName(pc, index, true)
1952	})));	1930	})));
1953	writeNewLine();	1931	writeNewLine();
1954	}	1932	}
Lines 2091-2097 Link Here
2091	dumpPcNumber(pc);	2069	dumpPcNumber(pc);
2092	buffer.append(Messages.bind(Messages.classformat_store, (new String[] {	2070	buffer.append(Messages.bind(Messages.classformat_store, (new String[] {
2093	OpcodeStringValues.BYTECODE_NAMES[IOpcodeMnemonics.LSTORE],	2071	OpcodeStringValues.BYTECODE_NAMES[IOpcodeMnemonics.LSTORE],
2094	getLocalVariableName(pc, index)	2072	getLocalVariableName(pc, index, true)
2095	})));	2073	})));
2096	writeNewLine();	2074	writeNewLine();
2097	}	2075	}
Lines 2266-2272 Link Here
2266	Integer.toString(index),	2244	Integer.toString(index),
2267	returnDeclaringClassName(constantFieldref),	2245	returnDeclaringClassName(constantFieldref),
2268	new String(constantFieldref.getFieldName()),	2246	new String(constantFieldref.getFieldName()),
2269	new String(constantFieldref.getFieldDescriptor())	2247	returnClassName(Signature.toCharArray(constantFieldref.getFieldDescriptor()))
2270	})));	2248	})));
2271	writeNewLine();	2249	writeNewLine();
2272	}	2250	}
Lines 2281-2287 Link Here
2281	Integer.toString(index),	2259	Integer.toString(index),
2282	returnDeclaringClassName(constantFieldref),	2260	returnDeclaringClassName(constantFieldref),
2283	new String(constantFieldref.getFieldName()),	2261	new String(constantFieldref.getFieldName()),
2284	new String(constantFieldref.getFieldDescriptor())	2262	returnClassName(Signature.toCharArray(constantFieldref.getFieldDescriptor()))
2285	})));	2263	})));
2286	writeNewLine();	2264	writeNewLine();
2287	}	2265	}
Lines 2464-2469 Link Here
2464		2442
2465	private String returnConstantClassName(IConstantPoolEntry constantClass) {	2443	private String returnConstantClassName(IConstantPoolEntry constantClass) {
2466	char[] classInfoName = constantClass.getClassInfoName();	2444	char[] classInfoName = constantClass.getClassInfoName();
		2445	return returnClassName(classInfoName);
		2446	}
		2447	private String returnClassName(char[] classInfoName) {
2467	if (classInfoName.length == 0) {	2448	if (classInfoName.length == 0) {
2468	return EMPTY_CLASS_NAME;	2449	return EMPTY_CLASS_NAME;
2469	} else if (isCompact()) {	2450	} else if (isCompact()) {
Lines 2471-2492 Link Here
2471	if (lastIndexOfSlash != -1) {	2452	if (lastIndexOfSlash != -1) {
2472	return new String(classInfoName, lastIndexOfSlash + 1, classInfoName.length - lastIndexOfSlash - 1);	2453	return new String(classInfoName, lastIndexOfSlash + 1, classInfoName.length - lastIndexOfSlash - 1);
2473	}	2454	}
2474	return new String(classInfoName);
2475	} else {
2476	return new String(classInfoName);
2477	}	2455	}
		2456	CharOperation.replace(classInfoName, '/', '.');
		2457	return new String(classInfoName);
2478	}	2458	}
2479		2459
2480	private String returnDeclaringClassName(IConstantPoolEntry constantRef) {	2460	private String returnDeclaringClassName(IConstantPoolEntry constantRef) {
2481	if (isCompact()) {	2461	final char[] className = constantRef.getClassName();
2482	char[] className = constantRef.getClassName();	2462	return returnClassName(className);
2483	int lastIndexOfSlash = CharOperation.lastIndexOf('/', className);
2484	if (lastIndexOfSlash != -1) {
2485	return new String(className, lastIndexOfSlash + 1, className.length - lastIndexOfSlash - 1);
2486	}
2487	return new String(constantRef.getClassName());
2488	}
2489	return new String(constantRef.getClassName());
2490	}	2463	}
2491		2464
2492	private void writeNewLine() {	2465	private void writeNewLine() {