public void visitProgramClass(ProgramClass programClass) { // Does this class still need a new name? newClassName = newClassName(programClass); if (newClassName == null) { // Make sure the outer class has a name, if it exists. The name will // be stored as the new class name, as a side effect, so we'll be // able to use it as a prefix. programClass.attributesAccept(this); // Figure out a package prefix. The package prefix may actually be // the an outer class prefix, if any, or it may be the fixed base // package, if classes are to be repackaged. String newPackagePrefix = newClassName != null ? newClassName + ClassConstants.INTERNAL_INNER_CLASS_SEPARATOR : newPackagePrefix(ClassUtil.internalPackagePrefix(programClass.getName())); // Come up with a new class name, numeric or ordinary. newClassName = newClassName != null && numericClassName ? generateUniqueNumericClassName(newPackagePrefix) : generateUniqueClassName(newPackagePrefix); setNewClassName(programClass, newClassName); } }
newPackagePrefix(ClassUtil.internalPackagePrefix(packagePrefix)); newPackagePrefix = generateUniquePackagePrefix(newSuperPackagePrefix);
/** * Creates a new class name in the given new package, with the given * class name factory. */ private String generateUniqueClassName(String newPackagePrefix, NameFactory classNameFactory) { // Come up with class names until we get an original one. String newClassName; do { // Let the factory produce a class name. newClassName = newPackagePrefix + classNameFactory.nextName(); } while (classNamesToAvoid.contains(mixedCaseClassName(newClassName))); return newClassName; }
/** * Returns whether the given class has a new name. */ private boolean hasName(Clazz clazz) { return ClassObfuscator.newClassName(clazz) != null; }
String currentNewName = ClassObfuscator.newClassName(clazz); if (currentNewName != null && !currentNewName.equals(newName)) ClassObfuscator.setNewClassName(clazz, newName);
public void visitEnclosingMethodAttribute(Clazz clazz, EnclosingMethodAttribute enclosingMethodAttribute) { // Make sure the enclosing class has a name. enclosingMethodAttribute.referencedClassAccept(this); String innerClassName = clazz.getName(); String outerClassName = clazz.getClassName(enclosingMethodAttribute.u2classIndex); numericClassName = isNumericClassName(innerClassName, outerClassName); }
/** * Creates a new class name in the given new package. */ private String generateUniqueNumericClassName(String newPackagePrefix) { // Find the right name factory for this package. NameFactory classNameFactory = (NameFactory)packagePrefixNumericClassNameFactoryMap.get(newPackagePrefix); if (classNameFactory == null) { // We haven't seen classes in this package before. // Create a new name factory for them. classNameFactory = new NumericNameFactory(); packagePrefixNumericClassNameFactoryMap.put(newPackagePrefix, classNameFactory); } return generateUniqueClassName(newPackagePrefix, classNameFactory); }
/** * Ensures the name of the given class name will be kept. */ public void keepClassName(Clazz clazz) { ClassObfuscator.setNewClassName(clazz, clazz.getName()); }
/** * Creates a new package prefix in the given new superpackage. */ private String generateUniquePackagePrefix(String newSuperPackagePrefix) { // Find the right name factory for this package. NameFactory packageNameFactory = (NameFactory)packagePrefixPackageNameFactoryMap.get(newSuperPackagePrefix); if (packageNameFactory == null) { // We haven't seen packages in this superpackage before. Create // a new name factory for them. packageNameFactory = new SimpleNameFactory(useMixedCaseClassNames); if (this.packageNameFactory != null) { packageNameFactory = new DictionaryNameFactory(this.packageNameFactory, packageNameFactory); } packagePrefixPackageNameFactoryMap.put(newSuperPackagePrefix, packageNameFactory); } return generateUniquePackagePrefix(newSuperPackagePrefix, packageNameFactory); }
new ClassObfuscator(programClassPool, classNameFactory, packageNameFactory,
/** * Returns whether the given class has a new name. */ private boolean hasName(Clazz clazz) { return ClassObfuscator.newClassName(clazz) != null; }
String currentNewName = ClassObfuscator.newClassName(clazz); if (currentNewName != null && !currentNewName.equals(newName)) ClassObfuscator.setNewClassName(clazz, newName);
public void visitEnclosingMethodAttribute(Clazz clazz, EnclosingMethodAttribute enclosingMethodAttribute) { // Make sure the enclosing class has a name. enclosingMethodAttribute.referencedClassAccept(this); String innerClassName = clazz.getName(); String outerClassName = clazz.getClassName(enclosingMethodAttribute.u2classIndex); numericClassName = isNumericClassName(innerClassName, outerClassName); }
/** * Creates a new class name in the given new package. */ private String generateUniqueNumericClassName(String newPackagePrefix) { // Find the right name factory for this package. NameFactory classNameFactory = (NameFactory)packagePrefixNumericClassNameFactoryMap.get(newPackagePrefix); if (classNameFactory == null) { // We haven't seen classes in this package before. // Create a new name factory for them. classNameFactory = new NumericNameFactory(); packagePrefixNumericClassNameFactoryMap.put(newPackagePrefix, classNameFactory); } return generateUniqueClassName(newPackagePrefix, classNameFactory); }
/** * Ensures the name of the given class name will be kept. */ public void keepClassName(Clazz clazz) { ClassObfuscator.setNewClassName(clazz, clazz.getName()); }
/** * Creates a new package prefix in the given new superpackage. */ private String generateUniquePackagePrefix(String newSuperPackagePrefix) { // Find the right name factory for this package. NameFactory packageNameFactory = (NameFactory)packagePrefixPackageNameFactoryMap.get(newSuperPackagePrefix); if (packageNameFactory == null) { // We haven't seen packages in this superpackage before. Create // a new name factory for them. packageNameFactory = new SimpleNameFactory(useMixedCaseClassNames); if (this.packageNameFactory != null) { packageNameFactory = new DictionaryNameFactory(this.packageNameFactory, packageNameFactory); } packagePrefixPackageNameFactoryMap.put(newSuperPackagePrefix, packageNameFactory); } return generateUniquePackagePrefix(newSuperPackagePrefix, packageNameFactory); }
new ClassObfuscator(programClassPool, libraryClassPool, classNameFactory,
public void visitProgramClass(ProgramClass programClass) { // Does this class still need a new name? newClassName = newClassName(programClass); if (newClassName == null) { // Make sure the outer class has a name, if it exists. The name will // be stored as the new class name, as a side effect, so we'll be // able to use it as a prefix. programClass.attributesAccept(this); // Figure out a package prefix. The package prefix may actually be // the an outer class prefix, if any, or it may be the fixed base // package, if classes are to be repackaged. String newPackagePrefix = newClassName != null ? newClassName + ClassConstants.INNER_CLASS_SEPARATOR : newPackagePrefix(ClassUtil.internalPackagePrefix(programClass.getName())); // Come up with a new class name, numeric or ordinary. newClassName = newClassName != null && numericClassName ? generateUniqueNumericClassName(newPackagePrefix) : generateUniqueClassName(newPackagePrefix); setNewClassName(programClass, newClassName); } }
/** * Returns whether the given class has a new name. */ private boolean hasName(Clazz clazz) { return ClassObfuscator.newClassName(clazz) != null; }
String currentNewName = ClassObfuscator.newClassName(clazz); if (currentNewName != null && !currentNewName.equals(newName)) ClassObfuscator.setNewClassName(clazz, newName);