public void flattenpackagehierarchy(String flattenPackageHierarchy) { configuration.flattenPackageHierarchy = ClassUtil.internalClassName(flattenPackageHierarchy); }
public void target(String targetClassVersion) { configuration.targetClassVersion = ClassUtil.internalClassVersion(targetClassVersion); }
/** * Converts the given external method return type and List of arguments to * an internal method descriptor. * @param externalReturnType the external method return type, * e.g. "<code>boolean</code>". * @param externalArguments the external method arguments, * e.g. <code>{ "int", "int" }</code>. * @return the internal method descriptor, * e.g. "<code>(II)Z</code>". */ public static String internalMethodDescriptor(String externalReturnType, List externalArguments) { StringBuffer internalMethodDescriptor = new StringBuffer(); internalMethodDescriptor.append(ClassConstants.INTERNAL_METHOD_ARGUMENTS_OPEN); for (int index = 0; index < externalArguments.size(); index++) { internalMethodDescriptor.append(internalType((String)externalArguments.get(index))); } internalMethodDescriptor.append(ClassConstants.INTERNAL_METHOD_ARGUMENTS_CLOSE); internalMethodDescriptor.append(internalType(externalReturnType)); return internalMethodDescriptor.toString(); }
/** * Converts an internal method description into an external full method description. * @param internalClassName the internal name of the class of the method, * e.g. "<code>mypackage/MyClass</code>". * @param accessFlags the access flags of the method. * @param internalMethodName the internal method name, * e.g. "<code>myMethod</code>" or * "<code><init></code>". * @param internalMethodDescriptor the internal method descriptor, * e.g. "<code>(II)Z</code>". * @return the external full method description, * e.g. "<code>public boolean myMethod(int,int)</code>" or * "<code>public MyClass(int,int)</code>". */ public static String externalFullMethodDescription(String internalClassName, int accessFlags, String internalMethodName, String internalMethodDescriptor) { return externalMethodAccessFlags(accessFlags) + externalMethodReturnTypeAndName(internalClassName, internalMethodName, internalMethodDescriptor) + ClassConstants.EXTERNAL_METHOD_ARGUMENTS_OPEN + externalMethodArguments(internalMethodDescriptor) + ClassConstants.EXTERNAL_METHOD_ARGUMENTS_CLOSE; }
/** * Converts an internal class name, method name, and method descriptor to * an external method return type and name. * @param internalClassName the internal name of the class of the method, * e.g. "<code>mypackage/MyClass</code>". * @param internalMethodName the internal method name, * e.g. "<code>myMethod</code>" or * "<code><init></code>". * @param internalMethodDescriptor the internal method descriptor, * e.g. "<code>(II)Z</code>". * @return the external method return type and name, * e.g. "<code>boolean myMethod</code>" or * "<code>MyClass</code>". */ private static String externalMethodReturnTypeAndName(String internalClassName, String internalMethodName, String internalMethodDescriptor) { return internalMethodName.equals(ClassConstants.INTERNAL_METHOD_NAME_INIT) ? externalShortClassName(externalClassName(internalClassName)) : (externalMethodReturnType(internalMethodDescriptor) + ' ' + internalMethodName); }
public void visitLibraryField(LibraryClass libraryClass, LibraryField libraryField) { // Print the name of this field. String name = libraryField.getName(libraryClass); String type = libraryField.getDescriptor(libraryClass); ps.println(ClassUtil.externalClassName(libraryClass.getName()) + (verbose ? ": " + ClassUtil.externalFullFieldDescription(0, name, type): "." + name)); // Print the reason for keeping this field. ps.println(" is a library field.\n"); }
indent(); println("Superclass: " + programClass.getSuperName()); println("Major version: 0x" + Integer.toHexString(ClassUtil.internalMajorClassVersion(programClass.u4version))); println("Minor version: 0x" + Integer.toHexString(ClassUtil.internalMinorClassVersion(programClass.u4version))); println(" = target " + ClassUtil.externalClassVersion(programClass.u4version)); println("Access flags: 0x" + Integer.toHexString(programClass.u2accessFlags)); println(" = " + ClassUtil.externalClassAccessFlags(programClass.u2accessFlags) + ((programClass.u2accessFlags & (ClassConstants.ACC_ENUM | ClassConstants.ACC_INTERFACE | ClassConstants.ACC_MODULE)) == 0 ? "class " : "") + ClassUtil.externalClassName(programClass.getName()) + (programClass.u2superClass == 0 ? "" : " extends " + ClassUtil.externalClassName(programClass.getSuperName()))); outdent(); println();
String descriptor = ClassUtil.internalMethodDescriptor(methodReturnType, ListUtil.commaSeparatedList(methodArguments)); !currentNewName.equals(newMethodName)) warningPrinter.print(ClassUtil.internalClassName(className), "Warning: " + className +
annotation = ClassUtil.internalType(annotation); parameters != null ? ClassUtil.internalMethodDescriptor(type, parameterList) : type != null ? ClassUtil.internalType(type) : null;
0, 0, annotationType.equals("") ? null : ClassUtil.internalType(annotationType), className.equals("") || className.equals("*") ? null : ClassUtil.internalClassName(className), extendsAnnotationType.equals("") ? null : ClassUtil.internalType(extendsAnnotationType), extendsClassName.equals("") ? null : ClassUtil.internalClassName(extendsClassName));
ClassUtil.checkMagicNumber(programClass.u4magic); int u2majorVersion = dataInput.readUnsignedShort(); programClass.u4version = ClassUtil.internalClassVersion(u2majorVersion, u2minorVersion); ClassUtil.checkVersionNumbers(programClass.u4version);
type.equals(ClassUtil.externalShortClassName(externalClassName)))) String descriptor = ClassUtil.internalType(type); ClassUtil.internalMethodDescriptor(type, parseCommaSeparatedList("argument", true, true, true, false, true, false, false, false, false, null));
ClassUtil.externalMethodReturnType(enclosingMethodDescriptor) + " " + (enclosingClassName.equals(className) ? "" : ClassUtil.externalClassName(enclosingClassName) + JavaConstants.PACKAGE_SEPARATOR) + enclosingMethodName + JavaConstants.METHOD_ARGUMENTS_OPEN + ClassUtil.externalMethodArguments(enclosingMethodDescriptor) + JavaConstants.METHOD_ARGUMENTS_CLOSE + ":" + enclosingLineNumber + " -> " + obfuscatedMethodName);
public void visitProgramMethod(ProgramClass programClass, ProgramMethod programMethod) { if (notePrinter.accepts(programClass.getName())) { System.out.println(" Maybe this is program method '" + ClassUtil.externalFullClassDescription(0, programClass.getName()) + " { " + ClassUtil.externalFullMethodDescription(null, 0, programMethod.getName(programClass), programMethod.getDescriptor(programClass)) + "; }'"); } }
public void visitLibraryMethod(LibraryClass libraryClass, LibraryMethod libraryMethod) { // Print the name of this method. String name = libraryMethod.getName(libraryClass); String type = libraryMethod.getDescriptor(libraryClass); ps.println(ClassUtil.externalClassName(libraryClass.getName()) + (verbose ? ": " + ClassUtil.externalFullMethodDescription(libraryClass.getName(), 0, name, type): "." + name)); // Print the reason for keeping this method. ps.println(" is a library method.\n"); }
annotationTypeTextField.setText(annotationType == null ? "" : ClassUtil.externalType(annotationType)); typeTextField .setText(descriptor == null ? "***" : ClassUtil.externalType(descriptor)); typeTextField .setText(descriptor == null ? "***" : ClassUtil.externalMethodReturnType(descriptor)); argumentTypesTextField.setText(descriptor == null ? "..." : ClassUtil.externalMethodArguments(descriptor));
public void visitLibraryField(LibraryClass libraryClass, LibraryField libraryField) { if (notePrinter.accepts(libraryClass.getName())) { System.out.println(" Maybe this is library field '" + ClassUtil.externalFullClassDescription(0, libraryClass.getName()) + " { " + ClassUtil.externalFullFieldDescription(0, libraryField.getName(libraryClass), libraryField.getDescriptor(libraryClass)) + "; }'"); } }
public void visitProgramMethod(ProgramClass programClass, ProgramMethod programMethod) { String methodName = programMethod.getName(programClass); String obfuscatedMethodName = MemberObfuscator.newMemberName(programMethod); if (obfuscatedMethodName == null) { obfuscatedMethodName = methodName; } // Print out the method mapping, if it has line numbers. printed = false; programMethod.attributesAccept(programClass, this); // Otherwise print out the method mapping without line numbers. if (!printed) { ps.println(" " + ClassUtil.externalMethodReturnType(programMethod.getDescriptor(programClass)) + " " + methodName + JavaConstants.METHOD_ARGUMENTS_OPEN + ClassUtil.externalMethodArguments(programMethod.getDescriptor(programClass)) + JavaConstants.METHOD_ARGUMENTS_CLOSE + " -> " + obfuscatedMethodName); } }
/** * Fills out the link to the referenced class. */ public void visitStringConstant(Clazz clazz, StringConstant stringConstant) { // Save a reference to the corresponding class. String externalClassName = stringConstant.getString(clazz); String internalClassName = ClassUtil.internalClassName( ClassUtil.externalBaseType(externalClassName)); stringConstant.referencedClass = findClass(clazz.getName(), internalClassName); }
/** * Prints the class name field. The field is then cleared, so it is not * printed again. */ private void printClassNameHeader() { if (className != null) { ps.println(ClassUtil.externalClassName(className) + ":"); className = null; } }