sometsome 1.0.2 → 3.10.42

data/lib/proguard4.7/src/proguard/DuplicateClassPrinter.java

@@ -0,0 +1,63 @@
+/*
+ * 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;
+
+import proguard.classfile.*;
+import proguard.classfile.util.*;
+import proguard.classfile.visitor.ClassVisitor;
+
+/**
+ * This ClassVisitor writes out notes about the class files that it visits
+ * being duplicates.
+ *
+ * @author Eric Lafortune
+ */
+public class DuplicateClassPrinter implements ClassVisitor
+{
+    private final WarningPrinter notePrinter;
+
+
+    /**
+     * Creates a new DuplicateClassVisitor.
+     */
+    public DuplicateClassPrinter(WarningPrinter notePrinter)
+    {
+        this.notePrinter = notePrinter;
+    }
+
+
+    // Implementations for ClassVisitor.
+
+    public void visitProgramClass(ProgramClass programClass)
+    {
+        notePrinter.print(programClass.getName(),
+                          "Note: duplicate definition of program class [" +
+                          ClassUtil.externalClassName(programClass.getName()) + "]");
+    }
+
+
+    public void visitLibraryClass(LibraryClass libraryClass)
+    {
+        notePrinter.print(libraryClass.getName(),
+                          "Note: duplicate definition of library class [" +
+                          ClassUtil.externalClassName(libraryClass.getName()) + "]");
+    }
+}

data/lib/proguard4.7/src/proguard/FileWordReader.java

@@ -0,0 +1,55 @@
+/*
+ * 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;
+
+import java.io.*;
+import java.net.URL;
+
+
+/**
+ * A <code>WordReader</code> that returns words from a file or a URL.
+ *
+ * @author Eric Lafortune
+ */
+public class FileWordReader extends LineWordReader
+{
+    /**
+     * Creates a new FileWordReader for the given file.
+     */
+    public FileWordReader(File file) throws IOException
+    {
+        super(new LineNumberReader(new BufferedReader(new FileReader(file))),
+              "file '" + file.getPath() + "'",
+              file.getParentFile()
+        );
+    }
+
+
+    /**
+     * Creates a new FileWordReader for the given URL.
+     */
+    public FileWordReader(URL url) throws IOException
+    {
+        super(new LineNumberReader(new BufferedReader(new InputStreamReader(url.openStream()))),
+              "file '" + url.toString() + "'",
+              null);
+    }
+}

data/lib/proguard4.7/src/proguard/FullyQualifiedClassNameChecker.java

@@ -0,0 +1,191 @@
+/*
+ * 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;
+
+import proguard.classfile.*;
+import proguard.classfile.util.*;
+import proguard.classfile.visitor.*;
+
+import java.util.List;
+
+/**
+ * This class checks if the user has forgotten to fully qualify any classes
+ * in the configuration.
+ *
+ * @author Eric Lafortune
+ */
+public class FullyQualifiedClassNameChecker
+extends      SimplifiedVisitor
+implements   ClassVisitor
+{
+    private final ClassPool      programClassPool;
+    private final ClassPool      libraryClassPool;
+    private final WarningPrinter notePrinter;
+
+
+    /**
+     * Creates a new FullyQualifiedClassNameChecker.
+     */
+    public FullyQualifiedClassNameChecker(ClassPool      programClassPool,
+                                          ClassPool      libraryClassPool,
+                                          WarningPrinter notePrinter)
+    {
+        this.programClassPool = programClassPool;
+        this.libraryClassPool = libraryClassPool;
+        this.notePrinter      = notePrinter;
+    }
+
+
+    /**
+     * Checks the classes mentioned in the given class specifications, printing
+     * notes if necessary.
+     */
+    public void checkClassSpecifications(List classSpecifications)
+    {
+        if (classSpecifications != null)
+        {
+            for (int index = 0; index < classSpecifications.size(); index++)
+            {
+                ClassSpecification classSpecification =
+                    (ClassSpecification)classSpecifications.get(index);
+
+                checkType(classSpecification.annotationType);
+                checkClassName(classSpecification.className);
+                checkType(classSpecification.extendsAnnotationType);
+                checkClassName(classSpecification.extendsClassName);
+
+                checkMemberSpecifications(classSpecification.fieldSpecifications,  true);
+                checkMemberSpecifications(classSpecification.methodSpecifications, false);
+            }
+        }
+    }
+
+
+    /**
+     * Checks the classes mentioned in the given class member specifications,
+     * printing notes if necessary.
+     */
+    private void checkMemberSpecifications(List memberSpecifications, boolean isField)
+    {
+        if (memberSpecifications != null)
+        {
+            for (int index = 0; index < memberSpecifications.size(); index++)
+            {
+                MemberSpecification memberSpecification =
+                    (MemberSpecification)memberSpecifications.get(index);
+
+                checkType(memberSpecification.annotationType);
+
+                if (isField)
+                {
+                     checkType(memberSpecification.descriptor);
+                }
+                else
+                {
+                    checkDescriptor(memberSpecification.descriptor);
+                }
+            }
+        }
+    }
+
+
+    /**
+     * Checks the classes mentioned in the given class member descriptor,
+     * printing notes if necessary.
+     */
+    private void checkDescriptor(String descriptor)
+    {
+        if (descriptor != null)
+        {
+            InternalTypeEnumeration internalTypeEnumeration =
+                new InternalTypeEnumeration(descriptor);
+
+            checkType(internalTypeEnumeration.returnType());
+
+            while (internalTypeEnumeration.hasMoreTypes())
+            {
+                checkType(internalTypeEnumeration.nextType());
+            }
+        }
+    }
+
+
+    /**
+     * Checks the class mentioned in the given type (if any),
+     * printing notes if necessary.
+     */
+    private void checkType(String type)
+    {
+        if (type != null)
+        {
+            checkClassName(ClassUtil.internalClassNameFromType(type));
+        }
+    }
+
+
+    /**
+     * Checks the specified class (if any),
+     * printing notes if necessary.
+     */
+    private void checkClassName(String className)
+    {
+        if (className != null                            &&
+            !containsWildCards(className)                &&
+            programClassPool.getClass(className) == null &&
+            libraryClassPool.getClass(className) == null &&
+            notePrinter.accepts(className))
+        {
+            notePrinter.print(className,
+                              "Note: the configuration refers to the unknown class '" +
+                              ClassUtil.externalClassName(className) + "'");
+
+            String fullyQualifiedClassName =
+                "**" + ClassConstants.INTERNAL_PACKAGE_SEPARATOR +
+                className.substring(className.lastIndexOf(ClassConstants.INTERNAL_PACKAGE_SEPARATOR)+1);
+
+            ClassNameFilter classNameFilter =
+                new ClassNameFilter(fullyQualifiedClassName, this);
+
+            programClassPool.classesAccept(classNameFilter);
+            libraryClassPool.classesAccept(classNameFilter);
+        }
+    }
+
+
+    private static boolean containsWildCards(String string)
+    {
+        return string != null &&
+            (string.indexOf('!')   >= 0 ||
+             string.indexOf('*')   >= 0 ||
+             string.indexOf('?')   >= 0 ||
+             string.indexOf(',')   >= 0 ||
+             string.indexOf("///") >= 0);
+    }
+
+
+    // Implementations for ClassVisitor.
+
+    public void visitAnyClass(Clazz clazz)
+    {
+        System.out.println("      Maybe you meant the fully qualified name '" +
+                           ClassUtil.externalClassName(clazz.getName()) + "'?");
+    }
+}

data/lib/proguard4.7/src/proguard/GPL.java

@@ -0,0 +1,197 @@
+/*
+ * 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;
+
+import java.io.*;
+import java.util.*;
+
+/**
+ * This class checks and prints out information about the GPL.
+ *
+ * @author Eric Lafortune
+ */
+public class GPL
+{
+    /**
+     * Prints out a note about the GPL if ProGuard is linked against unknown
+     * code.
+     */
+    public static void check()
+    {
+        ByteArrayOutputStream out = new ByteArrayOutputStream();
+        new Exception().printStackTrace(new PrintStream(out));
+        LineNumberReader reader = new LineNumberReader(
+                                  new InputStreamReader(
+                                  new ByteArrayInputStream(out.toByteArray())));
+
+        Set unknownPackageNames = unknownPackageNames(reader);
+
+        if (unknownPackageNames.size() > 0)
+        {
+            String uniquePackageNames = uniquePackageNames(unknownPackageNames);
+
+            System.out.println("ProGuard is released under the GNU General Public License. You therefore");
+            System.out.println("must ensure that programs that link to it ("+uniquePackageNames+"...)");
+            System.out.println("carry the GNU General Public License as well. Alternatively, you can");
+            System.out.println("apply for an exception with the author of ProGuard.");
+        }
+    }
+
+
+    /**
+     * Returns a set of package names from the given stack trace.
+     */
+    private static Set unknownPackageNames(LineNumberReader reader)
+    {
+        Set packageNames = new HashSet();
+
+        try
+        {
+            while (true)
+            {
+                String line = reader.readLine();
+                if (line == null)
+                {
+                    break;
+                }
+
+                line = line.trim();
+                if (line.startsWith("at "))
+                {
+                    line = line.substring(2).trim();
+                    line = trimSuffix(line, '(');
+                    line = trimSuffix(line, '.');
+                    line = trimSuffix(line, '.');
+
+                    if (line.length() > 0 && !isKnown(line))
+                    {
+                        packageNames.add(line);
+                    }
+                }
+            }
+        }
+        catch (IOException ex)
+        {
+            // We'll just stop looking for more names.
+        }
+
+        return packageNames;
+    }
+
+
+    /**
+     * Returns a comma-separated list of package names from the set, excluding
+     * any subpackages of packages in the set.
+     */
+    private static String uniquePackageNames(Set packageNames)
+    {
+        StringBuffer buffer = new StringBuffer();
+
+        Iterator iterator = packageNames.iterator();
+        while (iterator.hasNext())
+        {
+            String packageName = (String)iterator.next();
+            if (!containsPrefix(packageNames, packageName))
+            {
+                buffer.append(packageName).append(", ");
+            }
+        }
+
+        return buffer.toString();
+    }
+
+
+    /**
+     * Returns a given string without the suffix, as defined by the given
+     * separator.
+     */
+    private static String trimSuffix(String string, char separator)
+    {
+        int index = string.lastIndexOf(separator);
+        return index < 0 ? "" : string.substring(0, index);
+    }
+
+
+    /**
+     * Returns whether the given set contains a prefix of the given name.
+     */
+    private static boolean containsPrefix(Set set, String name)
+    {
+        int index = 0;
+
+        while (!set.contains(name.substring(0, index)))
+        {
+            index = name.indexOf('.', index + 1);
+            if (index < 0)
+            {
+                return false;
+            }
+        }
+
+        return true;
+    }
+
+
+    /**
+     * Returns whether the given package name has been granted an exception
+     * against the GPL linking clause, by the copyright holder of ProGuard.
+     * This method is not legally binding, but of course the actual license is.
+     * Please contact the copyright holder if you would like an exception for
+     * your code as well.
+     */
+    private static boolean isKnown(String packageName)
+    {
+        return packageName.startsWith("java")                   ||
+               packageName.startsWith("sun.reflect")            ||
+               packageName.startsWith("proguard")               ||
+               packageName.startsWith("org.apache.tools.ant")   ||
+               packageName.startsWith("org.apache.tools.maven") ||
+               packageName.startsWith("org.eclipse")            ||
+               packageName.startsWith("org.netbeans")           ||
+               packageName.startsWith("com.android")            ||
+               packageName.startsWith("com.sun.kvem")           ||
+               packageName.startsWith("net.certiv.proguarddt")  ||
+               packageName.startsWith("scala")                  ||
+               packageName.startsWith("sbt")                    ||
+               packageName.startsWith("xsbt")                   ||
+               packageName.startsWith("eclipseme")              ||
+               packageName.startsWith("com.neomades")           ||
+               packageName.startsWith("jg.j2me")                ||
+               packageName.startsWith("jg.common")              ||
+               packageName.startsWith("jg.buildengine");
+    }
+
+
+    public static void main(String[] args)
+    {
+        LineNumberReader reader = new LineNumberReader(
+                                  new InputStreamReader(System.in));
+
+        Set unknownPackageNames = unknownPackageNames(reader);
+
+        if (unknownPackageNames.size() > 0)
+        {
+            String uniquePackageNames = uniquePackageNames(unknownPackageNames);
+
+            System.out.println(uniquePackageNames);
+        }
+    }
+}