RubyGems - sometsome - Versions diffs - 1.0.2 → 3.10.42 - Mend

sometsome 1.0.2 → 3.10.42

Files changed (732) hide show

data/lib/proguard4.7/src/proguard/io/ZipDataEntry.java ADDED

@@ -0,0 +1,98 @@
+/*
+ * ProGuard -- shrinking, optimization, obfuscation, and preverification
+ *             of Java bytecode.
+ *
+ * Copyright (c) 2002-2011 Eric Lafortune (eric@graphics.cornell.edu)
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the Free
+ * Software Foundation; either version 2 of the License, or (at your option)
+ * any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+ */
+package proguard.io;
+import proguard.classfile.ClassConstants;
+import java.io.*;
+import java.util.zip.*;
+/**
+ * This <code>DataEntry</code> represents a ZIP entry.
+ *
+ * @author Eric Lafortune
+ */
+public class ZipDataEntry implements DataEntry
+{
+    private final DataEntry      parent;
+    private final ZipEntry       zipEntry;
+    private       ZipInputStream zipInputStream;
+    public ZipDataEntry(DataEntry      parent,
+                        ZipEntry       zipEntry,
+                        ZipInputStream zipInputStream)
+    {
+        this.parent         = parent;
+        this.zipEntry       = zipEntry;
+        this.zipInputStream = zipInputStream;
+    }
+    // Implementations for DataEntry.
+    public String getName()
+    {
+        // Get the right separators.
+        String name = zipEntry.getName()
+            .replace(File.separatorChar, ClassConstants.INTERNAL_PACKAGE_SEPARATOR);
+        // Chop the trailing directory slash, if any.
+        int length = name.length();
+        return length > 0 &&
+               name.charAt(length-1) == ClassConstants.INTERNAL_PACKAGE_SEPARATOR ?
+                   name.substring(0, length -1) :
+                   name;
+    }
+    public boolean isDirectory()
+    {
+        return zipEntry.isDirectory();
+    }
+    public InputStream getInputStream() throws IOException
+    {
+        return zipInputStream;
+    }
+    public void closeInputStream() throws IOException
+    {
+        zipInputStream.closeEntry();
+        zipInputStream = null;
+    }
+    public DataEntry getParent()
+    {
+        return parent;
+    }
+    // Implementations for Object.
+    public String toString()
+    {
+        return parent.toString() + ':' + getName();
+    }
+}

data/lib/proguard4.7/src/proguard/io/package.html ADDED

@@ -0,0 +1,4 @@
+<body>
+This package contains classes to read and write files, optionally wrapped in
+jars, wars, ears, zips, directories,...
+</body>

data/lib/proguard4.7/src/proguard/obfuscate/AttributeShrinker.java ADDED

@@ -0,0 +1,120 @@
+/*
+ * ProGuard -- shrinking, optimization, obfuscation, and preverification
+ *             of Java bytecode.
+ *
+ * Copyright (c) 2002-2011 Eric Lafortune (eric@graphics.cornell.edu)
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the Free
+ * Software Foundation; either version 2 of the License, or (at your option)
+ * any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+ */
+package proguard.obfuscate;
+import proguard.classfile.*;
+import proguard.classfile.attribute.*;
+import proguard.classfile.attribute.visitor.AttributeVisitor;
+import proguard.classfile.util.SimplifiedVisitor;
+import proguard.classfile.visitor.*;
+import java.util.Arrays;
+/**
+ * This ClassVisitor removes attributes that are not marked as being used or
+ * required.
+ *
+ * @see AttributeUsageMarker
+ *
+ * @author Eric Lafortune
+ */
+public class AttributeShrinker
+extends      SimplifiedVisitor
+implements   ClassVisitor,
+             MemberVisitor,
+             AttributeVisitor
+{
+    // Implementations for ClassVisitor.
+    public void visitProgramClass(ProgramClass programClass)
+    {
+        // Compact the array for class attributes.
+        programClass.u2attributesCount =
+            shrinkArray(programClass.attributes,
+                        programClass.u2attributesCount);
+        // Compact the attributes in fields, methods, and class attributes,
+        programClass.fieldsAccept(this);
+        programClass.methodsAccept(this);
+        programClass.attributesAccept(this);
+    }
+    public void visitLibraryClass(LibraryClass libraryClass)
+    {
+        // Library classes are left unchanged.
+    }
+    // Implementations for MemberVisitor.
+    public void visitProgramMember(ProgramClass programClass, ProgramMember programMember)
+    {
+        // Compact the attributes array.
+        programMember.u2attributesCount =
+            shrinkArray(programMember.attributes,
+                        programMember.u2attributesCount);
+        // Compact any attributes of the remaining attributes.
+        programMember.attributesAccept(programClass, this);
+    }
+    // Implementations for AttributeVisitor.
+    public void visitAnyAttribute(Clazz clazz, Attribute attribute) {}
+    public void visitCodeAttribute(Clazz clazz, Method method, CodeAttribute codeAttribute)
+    {
+        // Compact the attributes array.
+        codeAttribute.u2attributesCount =
+            shrinkArray(codeAttribute.attributes,
+                        codeAttribute.u2attributesCount);
+    }
+    // Small utility methods.
+    /**
+     * Removes all VisitorAccepter objects that are not marked as being used
+     * from the given array.
+     * @return the new number of VisitorAccepter objects.
+     */
+    private static int shrinkArray(VisitorAccepter[] array, int length)
+    {
+        int counter = 0;
+        // Shift the used objects together.
+        for (int index = 0; index < length; index++)
+        {
+            if (AttributeUsageMarker.isUsed(array[index]))
+            {
+                array[counter++] = array[index];
+            }
+        }
+        // Clear the remaining array elements.
+        Arrays.fill(array, counter, length, null);
+        return counter;
+    }
+}

data/lib/proguard4.7/src/proguard/obfuscate/AttributeUsageMarker.java ADDED

@@ -0,0 +1,71 @@
+/*
+ * ProGuard -- shrinking, optimization, obfuscation, and preverification
+ *             of Java bytecode.
+ *
+ * Copyright (c) 2002-2011 Eric Lafortune (eric@graphics.cornell.edu)
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the Free
+ * Software Foundation; either version 2 of the License, or (at your option)
+ * any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+ */
+package proguard.obfuscate;
+import proguard.classfile.*;
+import proguard.classfile.attribute.Attribute;
+import proguard.classfile.attribute.visitor.AttributeVisitor;
+import proguard.classfile.util.SimplifiedVisitor;
+/**
+ * This AttributeVisitor marks all attributes that it visits.
+ *
+ * @see AttributeShrinker
+ *
+ * @author Eric Lafortune
+ */
+public class AttributeUsageMarker
+extends      SimplifiedVisitor
+implements   AttributeVisitor
+{
+    // A visitor info flag to indicate the attribute is being used.
+    private static final Object USED = new Object();
+    // Implementations for AttributeVisitor.
+    public void visitAnyAttribute(Clazz clazz, Attribute attribute)
+    {
+        markAsUsed(attribute);
+    }
+    // Small utility methods.
+    /**
+     * Marks the given VisitorAccepter as being used (or useful).
+     * In this context, the VisitorAccepter will be an Attribute object.
+     */
+    private static void markAsUsed(VisitorAccepter visitorAccepter)
+    {
+        visitorAccepter.setVisitorInfo(USED);
+    }
+    /**
+     * Returns whether the given VisitorAccepter has been marked as being used.
+     * In this context, the VisitorAccepter will be an Attribute object.
+     */
+    static boolean isUsed(VisitorAccepter visitorAccepter)
+    {
+        return visitorAccepter.getVisitorInfo() == USED;
+    }
+}

data/lib/proguard4.7/src/proguard/obfuscate/ClassObfuscator.java ADDED

@@ -0,0 +1,533 @@
+/*
+ * ProGuard -- shrinking, optimization, obfuscation, and preverification
+ *             of Java bytecode.
+ *
+ * Copyright (c) 2002-2011 Eric Lafortune (eric@graphics.cornell.edu)
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the Free
+ * Software Foundation; either version 2 of the License, or (at your option)
+ * any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+ */
+package proguard.obfuscate;
+import proguard.classfile.*;
+import proguard.classfile.attribute.*;
+import proguard.classfile.attribute.visitor.*;
+import proguard.classfile.constant.ClassConstant;
+import proguard.classfile.constant.visitor.ConstantVisitor;
+import proguard.classfile.util.*;
+import proguard.classfile.visitor.ClassVisitor;
+import proguard.util.*;
+import java.util.*;
+/**
+ * This <code>ClassVisitor</code> comes up with obfuscated names for the
+ * classes it visits, and for their class members. The actual renaming is
+ * done afterward.
+ *
+ * @see ClassRenamer
+ *
+ * @author Eric Lafortune
+ */
+public class ClassObfuscator
+extends      SimplifiedVisitor
+implements   ClassVisitor,
+             AttributeVisitor,
+             InnerClassesInfoVisitor,
+             ConstantVisitor
+{
+    private final DictionaryNameFactory classNameFactory;
+    private final DictionaryNameFactory packageNameFactory;
+    private final boolean               useMixedCaseClassNames;
+    private final StringMatcher         keepPackageNamesMatcher;
+    private final String                flattenPackageHierarchy;
+    private final String                repackageClasses;
+    private final boolean               allowAccessModification;
+    private final Set classNamesToAvoid                       = new HashSet();
+    // Map: [package prefix - new package prefix]
+    private final Map packagePrefixMap                        = new HashMap();
+    // Map: [package prefix - package name factory]
+    private final Map packagePrefixPackageNameFactoryMap      = new HashMap();
+    // Map: [package prefix - numeric class name factory]
+    private final Map packagePrefixClassNameFactoryMap        = new HashMap();
+    // Map: [package prefix - numeric class name factory]
+    private final Map packagePrefixNumericClassNameFactoryMap = new HashMap();
+    // Field acting as temporary variables and as return values for names
+    // of outer classes and types of inner classes.
+    private String  newClassName;
+    private boolean numericClassName;
+    /**
+     * Creates a new ClassObfuscator.
+     * @param programClassPool        the class pool in which class names
+     *                                have to be unique.
+     * @param classNameFactory        the optional class obfuscation dictionary.
+     * @param packageNameFactory      the optional package obfuscation
+     *                                dictionary.
+     * @param useMixedCaseClassNames  specifies whether obfuscated packages and
+     *                                classes can get mixed-case names.
+     * @param keepPackageNames        the optional filter for which matching
+     *                                package names are kept.
+     * @param flattenPackageHierarchy the base package if the obfuscated package
+     *                                hierarchy is to be flattened.
+     * @param repackageClasses        the base package if the obfuscated classes
+     *                                are to be repackaged.
+     * @param allowAccessModification specifies whether obfuscated classes can
+     *                                be freely moved between packages.
+     */
+    public ClassObfuscator(ClassPool             programClassPool,
+                           DictionaryNameFactory classNameFactory,
+                           DictionaryNameFactory packageNameFactory,
+                           boolean               useMixedCaseClassNames,
+                           List                  keepPackageNames,
+                           String                flattenPackageHierarchy,
+                           String                repackageClasses,
+                           boolean               allowAccessModification)
+    {
+        this.classNameFactory   = classNameFactory;
+        this.packageNameFactory = packageNameFactory;
+        // First append the package separator if necessary.
+        if (flattenPackageHierarchy != null &&
+            flattenPackageHierarchy.length() > 0)
+        {
+            flattenPackageHierarchy += ClassConstants.INTERNAL_PACKAGE_SEPARATOR;
+        }
+        // First append the package separator if necessary.
+        if (repackageClasses != null &&
+            repackageClasses.length() > 0)
+        {
+            repackageClasses += ClassConstants.INTERNAL_PACKAGE_SEPARATOR;
+        }
+        this.useMixedCaseClassNames  = useMixedCaseClassNames;
+        this.keepPackageNamesMatcher = keepPackageNames == null ? null :
+            new ListParser(new FileNameParser()).parse(keepPackageNames);
+        this.flattenPackageHierarchy = flattenPackageHierarchy;
+        this.repackageClasses        = repackageClasses;
+        this.allowAccessModification = allowAccessModification;
+        // Map the root package onto the root package.
+        packagePrefixMap.put("", "");
+        // Collect all names that have been taken already.
+        programClassPool.classesAccept(new MyKeepCollector());
+    }
+    // Implementations for ClassVisitor.
+    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);
+        }
+    }
+    // Implementations for AttributeVisitor.
+    public void visitAnyAttribute(Clazz clazz, Attribute attribute) {}
+    public void visitInnerClassesAttribute(Clazz clazz, InnerClassesAttribute innerClassesAttribute)
+    {
+        // Make sure the outer classes have a name, if they exist.
+        innerClassesAttribute.innerClassEntriesAccept(clazz, this);
+    }
+    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);
+    }
+    // Implementations for InnerClassesInfoVisitor.
+    public void visitInnerClassesInfo(Clazz clazz, InnerClassesInfo innerClassesInfo)
+    {
+        // Make sure the outer class has a name, if it exists.
+        int innerClassIndex = innerClassesInfo.u2innerClassIndex;
+        int outerClassIndex = innerClassesInfo.u2outerClassIndex;
+        if (innerClassIndex != 0 &&
+            outerClassIndex != 0)
+        {
+            String innerClassName = clazz.getClassName(innerClassIndex);
+            if (innerClassName.equals(clazz.getName()))
+            {
+                clazz.constantPoolEntryAccept(outerClassIndex, this);
+                String outerClassName = clazz.getClassName(outerClassIndex);
+                numericClassName = isNumericClassName(innerClassName,
+                                                      outerClassName);
+            }
+        }
+    }
+    /**
+     * Returns whether the given inner class name is a numeric name.
+     */
+    private boolean isNumericClassName(String innerClassName,
+                                       String outerClassName)
+    {
+        int innerClassNameStart  = outerClassName.length() + 1;
+        int innerClassNameLength = innerClassName.length();
+        if (innerClassNameStart >= innerClassNameLength)
+        {
+            return false;
+        }
+        for (int index = innerClassNameStart; index < innerClassNameLength; index++)
+        {
+            if (!Character.isDigit(innerClassName.charAt(index)))
+            {
+                return false;
+            }
+        }
+        return true;
+    }
+    // Implementations for ConstantVisitor.
+    public void visitClassConstant(Clazz clazz, ClassConstant classConstant)
+    {
+        // Make sure the outer class has a name.
+        classConstant.referencedClassAccept(this);
+    }
+    /**
+     * This ClassVisitor collects package names and class names that have to
+     * be kept.
+     */
+    private class MyKeepCollector implements ClassVisitor
+    {
+        public void visitProgramClass(ProgramClass programClass)
+        {
+            // Does the class already have a new name?
+            String newClassName = newClassName(programClass);
+            if (newClassName != null)
+            {
+                // Remember not to use this name.
+                classNamesToAvoid.add(mixedCaseClassName(newClassName));
+                // Are we not aggressively repackaging all obfuscated classes?
+                if (repackageClasses == null ||
+                    !allowAccessModification)
+                {
+                    String className = programClass.getName();
+                    // Keep the package name for all other classes in the same
+                    // package. Do this recursively if we're not doing any
+                    // repackaging.
+                    mapPackageName(className,
+                                   newClassName,
+                                   repackageClasses        == null &&
+                                   flattenPackageHierarchy == null);
+                }
+            }
+        }
+        public void visitLibraryClass(LibraryClass libraryClass)
+        {
+        }
+        /**
+         * Makes sure the package name of the given class will always be mapped
+         * consistently with its new name.
+         */
+        private void mapPackageName(String  className,
+                                    String  newClassName,
+                                    boolean recursively)
+        {
+            String packagePrefix    = ClassUtil.internalPackagePrefix(className);
+            String newPackagePrefix = ClassUtil.internalPackagePrefix(newClassName);
+            // Put the mapping of this package prefix, and possibly of its
+            // entire hierarchy, into the package prefix map.
+            do
+            {
+                packagePrefixMap.put(packagePrefix, newPackagePrefix);
+                if (!recursively)
+                {
+                    break;
+                }
+                packagePrefix    = ClassUtil.internalPackagePrefix(packagePrefix);
+                newPackagePrefix = ClassUtil.internalPackagePrefix(newPackagePrefix);
+            }
+            while (packagePrefix.length()    > 0 &&
+                   newPackagePrefix.length() > 0);
+        }
+    }
+    // Small utility methods.
+    /**
+     * Finds or creates the new package prefix for the given package.
+     */
+    private String newPackagePrefix(String packagePrefix)
+    {
+        // Doesn't the package prefix have a new package prefix yet?
+        String newPackagePrefix = (String)packagePrefixMap.get(packagePrefix);
+        if (newPackagePrefix == null)
+        {
+            // Are we keeping the package name?
+            if (keepPackageNamesMatcher != null &&
+                keepPackageNamesMatcher.matches(packagePrefix.length() > 0 ?
+                    packagePrefix.substring(0, packagePrefix.length()-1) :
+                    packagePrefix))
+            {
+                return packagePrefix;
+            }
+            // Are we forcing a new package prefix?
+            if (repackageClasses != null)
+            {
+                return repackageClasses;
+            }
+            // Are we forcing a new superpackage prefix?
+            // Otherwise figure out the new superpackage prefix, recursively.
+            String newSuperPackagePrefix = flattenPackageHierarchy != null ?
+                flattenPackageHierarchy :
+                newPackagePrefix(ClassUtil.internalPackagePrefix(packagePrefix));
+            // Come up with a new package prefix.
+            newPackagePrefix = generateUniquePackagePrefix(newSuperPackagePrefix);
+            // Remember to use this mapping in the future.
+            packagePrefixMap.put(packagePrefix, newPackagePrefix);
+        }
+        return newPackagePrefix;
+    }
+    /**
+     * 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);
+    }
+    /**
+     * Creates a new package prefix in the given new superpackage, with the
+     * given package name factory.
+     */
+    private String generateUniquePackagePrefix(String      newSuperPackagePrefix,
+                                               NameFactory packageNameFactory)
+    {
+        // Come up with package names until we get an original one.
+        String newPackagePrefix;
+        do
+        {
+            // Let the factory produce a package name.
+            newPackagePrefix = newSuperPackagePrefix +
+                               packageNameFactory.nextName() +
+                               ClassConstants.INTERNAL_PACKAGE_SEPARATOR;
+        }
+        while (packagePrefixMap.containsValue(newPackagePrefix));
+        return newPackagePrefix;
+    }
+    /**
+     * Creates a new class name in the given new package.
+     */
+    private String generateUniqueClassName(String newPackagePrefix)
+    {
+        // Find the right name factory for this package.
+        NameFactory classNameFactory =
+            (NameFactory)packagePrefixClassNameFactoryMap.get(newPackagePrefix);
+        if (classNameFactory == null)
+        {
+            // We haven't seen classes in this package before.
+            // Create a new name factory for them.
+            classNameFactory = new SimpleNameFactory(useMixedCaseClassNames);
+            if (this.classNameFactory != null)
+            {
+                classNameFactory =
+                    new DictionaryNameFactory(this.classNameFactory,
+                                              classNameFactory);
+            }
+            packagePrefixClassNameFactoryMap.put(newPackagePrefix,
+                                                 classNameFactory);
+        }
+        return generateUniqueClassName(newPackagePrefix, classNameFactory);
+    }
+    /**
+     * 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);
+    }
+    /**
+     * 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;
+        String newMixedCaseClassName;
+        do
+        {
+            // Let the factory produce a class name.
+            newClassName = newPackagePrefix +
+                           classNameFactory.nextName();
+            newMixedCaseClassName = mixedCaseClassName(newClassName);
+        }
+        while (classNamesToAvoid.contains(newMixedCaseClassName));
+        // Explicitly make sure the name isn't used again if we have a
+        // user-specified dictionary and we're not allowed to have mixed case
+        // class names -- just to protect against problematic dictionaries.
+        if (this.classNameFactory != null &&
+            !useMixedCaseClassNames)
+        {
+            classNamesToAvoid.add(newMixedCaseClassName);
+        }
+        return newClassName;
+    }
+    /**
+     * Returns the given class name, unchanged if mixed-case class names are
+     * allowed, or the lower-case version otherwise.
+     */
+    private String mixedCaseClassName(String className)
+    {
+        return useMixedCaseClassNames ?
+            className :
+            className.toLowerCase();
+    }
+    /**
+     * Assigns a new name to the given class.
+     * @param clazz the given class.
+     * @param name  the new name.
+     */
+    static void setNewClassName(Clazz clazz, String name)
+    {
+        clazz.setVisitorInfo(name);
+    }
+    /**
+     * Retrieves the new name of the given class.
+     * @param clazz the given class.
+     * @return the class's new name, or <code>null</code> if it doesn't
+     *         have one yet.
+     */
+    static String newClassName(Clazz clazz)
+    {
+        Object visitorInfo = clazz.getVisitorInfo();
+        return visitorInfo instanceof String ?
+            (String)visitorInfo :
+            null;
+    }
+}