sometsome 1.0.2 → 3.10.42

data/lib/proguard4.7/src/proguard/ant/FilterElement.java

@@ -0,0 +1,85 @@
+/*
+ * 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.ant;
+
+import org.apache.tools.ant.types.DataType;
+import proguard.classfile.util.ClassUtil;
+import proguard.util.ListUtil;
+
+import java.util.List;
+
+/**
+ * This DataType represents a name filter in Ant.
+ *
+ * @author Eric Lafortune
+ */
+public class FilterElement extends DataType
+{
+    private String filter;
+
+
+    /**
+     * Adds the contents of this element to the given name filter.
+     * @param filter   the list of attributes to be extended.
+     * @param internal specifies whether the filter string should be converted
+     *                 to internal types.
+     */
+    public void appendTo(List filter, boolean internal)
+    {
+        // Get the referenced element, or else this one.
+        FilterElement filterElement = isReference() ?
+            (FilterElement)getCheckedRef(this.getClass(),
+                                         this.getClass().getName()) :
+            this;
+
+        String filterString = filterElement.filter;
+
+        if (filterString == null)
+        {
+            // Clear the filter to keep all names.
+            filter.clear();
+        }
+        else
+        {
+            if (internal)
+            {
+                filterString = ClassUtil.internalClassName(filterString);
+            }
+
+            // Append the filter.
+            filter.addAll(ListUtil.commaSeparatedList(filterString));
+        }
+    }
+
+
+    // Ant task attributes.
+
+    public void setName(String name)
+    {
+        this.filter = name;
+    }
+
+
+    public void setFilter(String filter)
+    {
+        this.filter = filter;
+    }
+}

data/lib/proguard4.7/src/proguard/ant/KeepSpecificationElement.java

@@ -0,0 +1,87 @@
+/*
+ * 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.ant;
+
+import proguard.KeepClassSpecification;
+
+import java.util.List;
+
+/**
+ * This DataType represents a class specification in Ant.
+ *
+ * @author Eric Lafortune
+ */
+public class KeepSpecificationElement extends ClassSpecificationElement
+{
+    private boolean allowShrinking;
+    private boolean allowOptimization;
+    private boolean allowObfuscation;
+
+
+    /**
+     * Adds the contents of this class specification element to the given list.
+     * @param keepSpecifications the class specifications to be extended.
+     * @param markClasses         specifies whether to mark the classes.
+     * @param markConditionally   specifies whether to mark the classes
+     *                            and class members conditionally.
+     */
+    public void appendTo(List    keepSpecifications,
+                         boolean markClasses,
+                         boolean markConditionally)
+    {
+        // Get the referenced file set, or else this one.
+        KeepSpecificationElement keepSpecificationElement = isReference() ?
+            (KeepSpecificationElement)getCheckedRef(this.getClass(),
+                                                     this.getClass().getName()) :
+            this;
+
+        KeepClassSpecification keepClassSpecification =
+            new KeepClassSpecification(markClasses,
+                                  markConditionally,
+                                  allowShrinking,
+                                  allowOptimization,
+                                  allowObfuscation,
+                                  createClassSpecification(keepSpecificationElement));
+
+        // Add it to the list.
+        keepSpecifications.add(keepClassSpecification);
+    }
+
+
+    // Ant task attributes.
+
+    public void setAllowshrinking(boolean allowShrinking)
+    {
+        this.allowShrinking = allowShrinking;
+    }
+
+
+    public void setAllowoptimization(boolean allowOptimization)
+    {
+        this.allowOptimization = allowOptimization;
+    }
+
+
+    public void setAllowobfuscation(boolean allowObfuscation)
+    {
+        this.allowObfuscation = allowObfuscation;
+    }
+}

data/lib/proguard4.7/src/proguard/ant/MemberSpecificationElement.java

@@ -0,0 +1,218 @@
+/*
+ * 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.ant;
+
+import org.apache.tools.ant.BuildException;
+import org.apache.tools.ant.types.DataType;
+import proguard.MemberSpecification;
+import proguard.classfile.ClassConstants;
+import proguard.classfile.util.ClassUtil;
+import proguard.util.ListUtil;
+
+import java.util.*;
+
+/**
+ * This DataType represents a class member specification in Ant.
+ *
+ * @author Eric Lafortune
+ */
+public class MemberSpecificationElement extends DataType
+{
+    private String access;
+    private String annotation;
+    private String type;
+    private String name;
+    private String parameters;
+
+
+    /**
+     * Adds the contents of this class member specification element to the given
+     * list.
+     * @param memberSpecifications the class member specifications to be
+     *                                  extended.
+     * @param isMethod                  specifies whether this specification
+     *                                  refers to a method.
+     * @param isConstructor             specifies whether this specification
+     *                                  refers to a constructor.
+     */
+    public void appendTo(List    memberSpecifications,
+                         boolean isMethod,
+                         boolean isConstructor)
+    {
+        // Get the referenced file set, or else this one.
+        MemberSpecificationElement memberSpecificationElement = isReference() ?
+            (MemberSpecificationElement)getCheckedRef(this.getClass(),
+                                                      this.getClass().getName()) :
+            this;
+
+        // Create a new class specification.
+        String access     = memberSpecificationElement.access;
+        String type       = memberSpecificationElement.type;
+        String annotation = memberSpecificationElement.annotation;
+        String name       = memberSpecificationElement.name;
+        String parameters = memberSpecificationElement.parameters;
+
+        // Perform some basic conversions and checks on the attributes.
+        if (annotation != null)
+        {
+            annotation = ClassUtil.internalType(annotation);
+        }
+
+        if (isMethod)
+        {
+            if (isConstructor)
+            {
+                if (type != null)
+                {
+                    throw new BuildException("Type attribute not allowed in constructor specification ["+type+"]");
+                }
+
+                if (parameters != null)
+                {
+                    type = ClassConstants.EXTERNAL_TYPE_VOID;
+                }
+
+                name = ClassConstants.INTERNAL_METHOD_NAME_INIT;
+            }
+            else if ((type != null) ^ (parameters != null))
+            {
+                throw new BuildException("Type and parameters attributes must always be present in combination in method specification");
+            }
+        }
+        else
+        {
+            if (parameters != null)
+            {
+                throw new BuildException("Parameters attribute not allowed in field specification ["+parameters+"]");
+            }
+        }
+
+        List parameterList = ListUtil.commaSeparatedList(parameters);
+
+        String descriptor =
+            parameters != null ? ClassUtil.internalMethodDescriptor(type, parameterList) :
+            type       != null ? ClassUtil.internalType(type)                            :
+                                 null;
+
+        MemberSpecification memberSpecification =
+            new MemberSpecification(requiredAccessFlags(true,  access),
+                                    requiredAccessFlags(false, access),
+                                    annotation,
+                                    name,
+                                    descriptor);
+
+        // Add it to the list.
+        memberSpecifications.add(memberSpecification);
+    }
+
+
+    // Ant task attributes.
+
+    public void setAccess(String access)
+    {
+        this.access = access;
+    }
+
+
+    public void setAnnotation(String annotation)
+    {
+        this.annotation = annotation;
+    }
+
+
+    public void setType(String type)
+    {
+        this.type = type;
+    }
+
+
+    public void setName(String name)
+    {
+        this.name = name;
+    }
+
+
+    public void setParameters(String parameters)
+    {
+        this.parameters = parameters;
+    }
+
+
+    /**
+     * @deprecated Use {@link #setParameters(String)} instead.
+     */
+    public void setParam(String parameters)
+    {
+        this.parameters = parameters;
+    }
+
+
+    // Small utility methods.
+
+    private int requiredAccessFlags(boolean set,
+                                    String  access)
+    throws BuildException
+    {
+        int accessFlags = 0;
+
+        if (access != null)
+        {
+            StringTokenizer tokenizer = new StringTokenizer(access, " ,");
+            while (tokenizer.hasMoreTokens())
+            {
+                String token = tokenizer.nextToken();
+
+                if (token.startsWith("!") ^ set)
+                {
+                    String strippedToken = token.startsWith("!") ?
+                        token.substring(1) :
+                        token;
+
+                    int accessFlag =
+                        strippedToken.equals(ClassConstants.EXTERNAL_ACC_PUBLIC)       ? ClassConstants.INTERNAL_ACC_PUBLIC       :
+                        strippedToken.equals(ClassConstants.EXTERNAL_ACC_PRIVATE)      ? ClassConstants.INTERNAL_ACC_PRIVATE      :
+                        strippedToken.equals(ClassConstants.EXTERNAL_ACC_PROTECTED)    ? ClassConstants.INTERNAL_ACC_PROTECTED    :
+                        strippedToken.equals(ClassConstants.EXTERNAL_ACC_STATIC)       ? ClassConstants.INTERNAL_ACC_STATIC       :
+                        strippedToken.equals(ClassConstants.EXTERNAL_ACC_FINAL)        ? ClassConstants.INTERNAL_ACC_FINAL        :
+                        strippedToken.equals(ClassConstants.EXTERNAL_ACC_SYNCHRONIZED) ? ClassConstants.INTERNAL_ACC_SYNCHRONIZED :
+                        strippedToken.equals(ClassConstants.EXTERNAL_ACC_VOLATILE)     ? ClassConstants.INTERNAL_ACC_VOLATILE     :
+                        strippedToken.equals(ClassConstants.EXTERNAL_ACC_TRANSIENT)    ? ClassConstants.INTERNAL_ACC_TRANSIENT    :
+                        strippedToken.equals(ClassConstants.EXTERNAL_ACC_BRIDGE)       ? ClassConstants.INTERNAL_ACC_BRIDGE       :
+                        strippedToken.equals(ClassConstants.EXTERNAL_ACC_VARARGS)      ? ClassConstants.INTERNAL_ACC_VARARGS      :
+                        strippedToken.equals(ClassConstants.EXTERNAL_ACC_NATIVE)       ? ClassConstants.INTERNAL_ACC_NATIVE       :
+                        strippedToken.equals(ClassConstants.EXTERNAL_ACC_ABSTRACT)     ? ClassConstants.INTERNAL_ACC_ABSTRACT     :
+                        strippedToken.equals(ClassConstants.EXTERNAL_ACC_STRICT)       ? ClassConstants.INTERNAL_ACC_STRICT       :
+                        strippedToken.equals(ClassConstants.EXTERNAL_ACC_SYNTHETIC)    ? ClassConstants.INTERNAL_ACC_SYNTHETIC    :
+                        0;
+
+                    if (accessFlag == 0)
+                    {
+                        throw new BuildException("Incorrect class member access modifier ["+strippedToken+"]");
+                    }
+
+                    accessFlags |= accessFlag;
+                }
+            }
+        }
+
+        return accessFlags;
+    }
+}

data/lib/proguard4.7/src/proguard/ant/ProGuardTask.java

@@ -0,0 +1,352 @@
+/*
+ * 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.ant;
+
+import org.apache.tools.ant.BuildException;
+import proguard.*;
+import proguard.classfile.util.ClassUtil;
+
+import java.io.*;
+import java.util.ArrayList;
+
+/**
+ * This Task allows to configure and run ProGuard from Ant.
+ *
+ * @author Eric Lafortune
+ */
+public class ProGuardTask extends ConfigurationTask
+{
+    // Ant task attributes.
+
+    public void setConfiguration(File configurationFile) throws BuildException
+    {
+        try
+        {
+            ConfigurationParser parser = new ConfigurationParser(configurationFile);
+
+            try
+            {
+                parser.parse(configuration);
+            }
+            catch (ParseException ex)
+            {
+                throw new BuildException(ex.getMessage());
+            }
+            finally
+            {
+                parser.close();
+            }
+        }
+        catch (IOException ex)
+        {
+            throw new BuildException(ex.getMessage());
+        }
+    }
+
+
+    /**
+     * @deprecated Use the nested outjar element instead.
+     */
+    public void setOutjar(String parameters)
+    {
+        throw new BuildException("Use the <outjar> nested element instead of the 'outjar' attribute");
+    }
+
+
+    public void setSkipnonpubliclibraryclasses(boolean skipNonPublicLibraryClasses)
+    {
+        configuration.skipNonPublicLibraryClasses = skipNonPublicLibraryClasses;
+    }
+
+
+    public void setSkipnonpubliclibraryclassmembers(boolean skipNonPublicLibraryClassMembers)
+    {
+        configuration.skipNonPublicLibraryClassMembers = skipNonPublicLibraryClassMembers;
+    }
+
+
+    public void setTarget(String target)
+    {
+        configuration.targetClassVersion = ClassUtil.internalClassVersion(target);
+        if (configuration.targetClassVersion == 0)
+        {
+            throw new BuildException("Unsupported target '"+target+"'");
+        }
+    }
+
+
+    public void setForceprocessing(boolean forceProcessing)
+    {
+        configuration.lastModified = forceProcessing ? Long.MAX_VALUE : 0;
+    }
+
+
+    public void setPrintseeds(File printSeeds)
+    {
+        configuration.printSeeds = optionalFile(printSeeds);
+    }
+
+
+    public void setShrink(boolean shrink)
+    {
+        configuration.shrink = shrink;
+    }
+
+
+    public void setPrintusage(File printUsage)
+    {
+        configuration.printUsage = optionalFile(printUsage);
+    }
+
+
+    public void setOptimize(boolean optimize)
+    {
+        configuration.optimize = optimize;
+    }
+
+
+    public void setOptimizationpasses(int optimizationPasses)
+    {
+        configuration.optimizationPasses = optimizationPasses;
+    }
+
+
+    public void setAllowaccessmodification(boolean allowAccessModification)
+    {
+        configuration.allowAccessModification = allowAccessModification;
+    }
+
+
+    public void setMergeinterfacesaggressively(boolean mergeinterfacesaggressively)
+    {
+        configuration.mergeInterfacesAggressively = mergeinterfacesaggressively;
+    }
+
+
+    public void setObfuscate(boolean obfuscate)
+    {
+        configuration.obfuscate = obfuscate;
+    }
+
+
+    public void setPrintmapping(File printMapping)
+    {
+        configuration.printMapping = optionalFile(printMapping);
+    }
+
+
+    public void setApplymapping(File applyMapping)
+    {
+        configuration.applyMapping = resolvedFile(applyMapping);
+    }
+
+
+    public void setObfuscationdictionary(File obfuscationDictionary)
+    {
+        configuration.obfuscationDictionary = resolvedFile(obfuscationDictionary);
+    }
+
+
+    public void setClassobfuscationdictionary(File classObfuscationDictionary)
+    {
+        configuration.classObfuscationDictionary = resolvedFile(classObfuscationDictionary);
+    }
+
+
+    public void setPackageobfuscationdictionary(File packageObfuscationDictionary)
+    {
+        configuration.packageObfuscationDictionary = resolvedFile(packageObfuscationDictionary);
+    }
+
+
+    public void setOverloadaggressively(boolean overloadAggressively)
+    {
+        configuration.overloadAggressively = overloadAggressively;
+    }
+
+
+    public void setUseuniqueclassmembernames(boolean useUniqueClassMemberNames)
+    {
+        configuration.useUniqueClassMemberNames = useUniqueClassMemberNames;
+    }
+
+
+    public void setUsemixedcaseclassnames(boolean useMixedCaseClassNames)
+    {
+        configuration.useMixedCaseClassNames = useMixedCaseClassNames;
+    }
+
+
+    public void setFlattenpackagehierarchy(String flattenPackageHierarchy)
+    {
+        configuration.flattenPackageHierarchy = ClassUtil.internalClassName(flattenPackageHierarchy);
+    }
+
+
+    public void setRepackageclasses(String repackageClasses)
+    {
+        configuration.repackageClasses = ClassUtil.internalClassName(repackageClasses);
+    }
+
+    /**
+     * @deprecated Use the repackageclasses attribute instead.
+     */
+    public void setDefaultpackage(String defaultPackage)
+    {
+        configuration.repackageClasses = ClassUtil.internalClassName(defaultPackage);
+    }
+
+
+    public void setKeepparameternames(boolean keepParameterNames)
+    {
+        configuration.keepParameterNames = keepParameterNames;
+    }
+
+
+    public void setRenamesourcefileattribute(String newSourceFileAttribute)
+    {
+        configuration.newSourceFileAttribute = newSourceFileAttribute;
+    }
+
+
+    public void setPreverify(boolean preverify)
+    {
+        configuration.preverify = preverify;
+    }
+
+
+    public void setMicroedition(boolean microEdition)
+    {
+        configuration.microEdition = microEdition;
+    }
+
+
+    public void setVerbose(boolean verbose)
+    {
+        configuration.verbose = verbose;
+    }
+
+
+    public void setNote(boolean note)
+    {
+        if (note)
+        {
+            // Switch on notes if they were completely disabled.
+            if (configuration.note != null &&
+                configuration.note.isEmpty())
+            {
+                configuration.note = null;
+            }
+        }
+        else
+        {
+            // Switch off notes.
+            configuration.note = new ArrayList();
+        }
+    }
+
+
+    public void setWarn(boolean warn)
+    {
+        if (warn)
+        {
+            // Switch on warnings if they were completely disabled.
+            if (configuration.warn != null &&
+                configuration.warn.isEmpty())
+            {
+                configuration.warn = null;
+            }
+        }
+        else
+        {
+            // Switch off warnings.
+            configuration.warn = new ArrayList();
+        }
+    }
+
+
+    public void setIgnorewarnings(boolean ignoreWarnings)
+    {
+        configuration.ignoreWarnings = ignoreWarnings;
+    }
+
+
+    public void setPrintconfiguration(File printConfiguration)
+    {
+        configuration.printConfiguration = optionalFile(printConfiguration);
+    }
+
+
+    public void setDump(File dump)
+    {
+        configuration.dump = optionalFile(dump);
+    }
+
+
+    // Implementations for Task.
+
+    public void execute() throws BuildException
+    {
+        try
+        {
+            ProGuard proGuard = new ProGuard(configuration);
+            proGuard.execute();
+        }
+        catch (IOException ex)
+        {
+            throw new BuildException(ex.getMessage());
+        }
+    }
+
+
+    // Small utility methods.
+
+    /**
+     * Returns a file that is properly resolved with respect to the project
+     * directory, or <code>null</code> or empty if its name is actually a
+     * boolean flag.
+     */
+    private File optionalFile(File file)
+    {
+        String fileName = file.getName();
+
+        return
+            fileName.equalsIgnoreCase("false") ||
+            fileName.equalsIgnoreCase("no")    ||
+            fileName.equalsIgnoreCase("off")    ? null :
+            fileName.equalsIgnoreCase("true")  ||
+            fileName.equalsIgnoreCase("yes")   ||
+            fileName.equalsIgnoreCase("on")     ? new File("")   :
+                                                  resolvedFile(file);
+    }
+
+
+    /**
+     * Returns a file that is properly resolved with respect to the project
+     * directory.
+     */
+    private File resolvedFile(File file)
+    {
+        return file.isAbsolute() ? file :
+                                   new File(getProject().getBaseDir(),
+                                            file.getName());
+    }
+}