sometsome 1.0.2 → 3.10.42

data/lib/proguard4.7/src/proguard/classfile/editor/InterfaceAdder.java

@@ -0,0 +1,62 @@
+/*
+ * 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.classfile.editor;
+
+import proguard.classfile.*;
+import proguard.classfile.attribute.*;
+import proguard.classfile.attribute.annotation.*;
+import proguard.classfile.attribute.preverification.*;
+import proguard.classfile.constant.ClassConstant;
+import proguard.classfile.constant.visitor.ConstantVisitor;
+import proguard.classfile.util.SimplifiedVisitor;
+
+/**
+ * This ConstantVisitor adds all interfaces that it visits to the given
+ * target class.
+ *
+ * @author Eric Lafortune
+ */
+public class InterfaceAdder
+extends      SimplifiedVisitor
+implements   ConstantVisitor
+{
+    private final ConstantAdder    constantAdder;
+    private final InterfacesEditor interfacesEditor;
+
+
+    /**
+     * Creates a new InterfaceAdder that will add interfaces to the given
+     * target class.
+     */
+    public InterfaceAdder(ProgramClass targetClass)
+    {
+        constantAdder    = new ConstantAdder(targetClass);
+        interfacesEditor = new InterfacesEditor(targetClass);
+    }
+
+
+    // Implementations for ConstantVisitor.
+
+    public void visitClassConstant(Clazz clazz, ClassConstant classConstant)
+    {
+        interfacesEditor.addInterface(constantAdder.addConstant(clazz, classConstant));
+    }
+}

data/lib/proguard4.7/src/proguard/classfile/editor/InterfaceSorter.java

@@ -0,0 +1,152 @@
+/*
+ * 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.classfile.editor;
+
+import proguard.classfile.*;
+import proguard.classfile.attribute.*;
+import proguard.classfile.attribute.visitor.AttributeVisitor;
+import proguard.classfile.constant.*;
+import proguard.classfile.constant.visitor.ConstantVisitor;
+import proguard.classfile.util.*;
+import proguard.classfile.visitor.ClassVisitor;
+
+import java.util.*;
+
+/**
+ * This ClassVisitor sorts the interfaces of the program classes that it visits.
+ *
+ * @author Eric Lafortune
+ */
+public class InterfaceSorter
+extends      SimplifiedVisitor
+implements   ClassVisitor,
+             AttributeVisitor
+{
+    // Implementations for ClassVisitor.
+
+    public void visitProgramClass(ProgramClass programClass)
+    {
+        int[] interfaces      = programClass.u2interfaces;
+        int   interfacesCount = programClass.u2interfacesCount;
+
+        if (interfacesCount > 1)
+        {
+            // Sort the interfaces.
+            Arrays.sort(interfaces, 0, interfacesCount);
+
+            // Remove any duplicate entries.
+            int newInterfacesCount     = 0;
+            int previousInterfaceIndex = 0;
+            for (int index = 0; index < interfacesCount; index++)
+            {
+                int interfaceIndex = interfaces[index];
+
+                // Isn't this a duplicate of the previous interface?
+                if (interfaceIndex != previousInterfaceIndex)
+                {
+                    interfaces[newInterfacesCount++] = interfaceIndex;
+
+                    // Remember the interface.
+                    previousInterfaceIndex = interfaceIndex;
+                }
+            }
+
+            programClass.u2interfacesCount = newInterfacesCount;
+
+            // Update the signature, if any
+            programClass.attributesAccept(this);
+        }
+    }
+
+
+    // Implementations for AttributeVisitor.
+
+    public void visitAnyAttribute(Clazz clazz, Attribute attribute) {}
+
+
+    public void visitSignatureAttribute(Clazz clazz, SignatureAttribute signatureAttribute)
+    {
+        // Process the generic definitions, superclass, and implemented
+        // interfaces.
+        String signature = clazz.getString(signatureAttribute.u2signatureIndex);
+
+        // Count the signature types.
+        InternalTypeEnumeration internalTypeEnumeration =
+            new InternalTypeEnumeration(signature);
+
+        int count           =  0;
+        int interfacesCount = -1;
+        while (internalTypeEnumeration.hasMoreTypes())
+        {
+            String internalType = internalTypeEnumeration.nextType();
+
+            count++;
+
+            if (ClassUtil.isInternalClassType(internalType))
+            {
+                interfacesCount++;
+            }
+        }
+
+        // Put the signature types in an array.
+        internalTypeEnumeration =
+            new InternalTypeEnumeration(signature);
+
+        String[] internalTypes = new String[count];
+
+        for (int index = 0; index < count; index++)
+        {
+            String internalType = internalTypeEnumeration.nextType();
+
+            internalTypes[index] = internalType;
+        }
+
+        // Sort the interface types in the array.
+        Arrays.sort(internalTypes, count - interfacesCount, count);
+
+        // Recompose the signature types in a string.
+        StringBuffer newSignatureBuffer = new StringBuffer();
+
+        for (int index = 0; index < count; index++)
+        {
+            // Is this not an interface type, or an interface type that isn't
+            // a duplicate of the previous interface type?
+            if (index < count - interfacesCount ||
+                !internalTypes[index].equals(internalTypes[index-1]))
+            {
+                newSignatureBuffer.append(internalTypes[index]);
+            }
+        }
+
+        String newSignature = newSignatureBuffer.toString();
+
+        // Did the signature change?
+        if (!newSignature.equals(signature))
+        {
+            // Update the signature.
+            ((Utf8Constant)((ProgramClass)clazz).constantPool[signatureAttribute.u2signatureIndex]).setString(newSignatureBuffer.toString());
+
+            // Clear the referenced classes.
+            // TODO: Properly update the referenced classes.
+            signatureAttribute.referencedClasses = null;
+        }
+    }
+}

data/lib/proguard4.7/src/proguard/classfile/editor/InterfacesEditor.java

@@ -0,0 +1,122 @@
+/*
+ * 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.classfile.editor;
+
+import proguard.classfile.*;
+import proguard.classfile.attribute.*;
+
+import java.util.Arrays;
+
+/**
+ * This class can add and delete interfaces to and from classes. References to
+ * the constant pool must be filled out beforehand.
+ *
+ * @author Eric Lafortune
+ */
+public class InterfacesEditor
+{
+    private final ProgramClass targetClass;
+
+
+    /**
+     * Creates a new InterfacesEditor that will edit interfaces in the given
+     * target class.
+     */
+    public InterfacesEditor(ProgramClass targetClass)
+    {
+        this.targetClass = targetClass;
+    }
+
+
+    /**
+     * Adds the specified interface to the target class, if it isn't present yet.
+     */
+    public void addInterface(int interfaceConstantIndex)
+    {
+        // Is the interface not yet present?
+        if (findInterfaceIndex(interfaceConstantIndex) < 0)
+        {
+            int   interfacesCount = targetClass.u2interfacesCount++;
+            int[] interfaces      = targetClass.u2interfaces;
+
+            // Is the array too small to contain the additional interface?
+            if (interfaces.length <= interfacesCount)
+            {
+                // Create a new array and copy the interfaces into it.
+                int[] newinterfaces = new int[interfacesCount + 1];
+                System.arraycopy(interfaces, 0, newinterfaces, 0, interfacesCount);
+                interfaces = newinterfaces;
+
+                targetClass.u2interfaces = interfaces;
+            }
+
+            // Append the interface.
+            interfaces[interfacesCount] = interfaceConstantIndex;
+        }
+    }
+
+
+    /**
+     * Deletes the given interface from the target class, if it is present.
+     */
+    public void deleteInterface(int interfaceConstantIndex)
+    {
+        // Is the interface already present?
+        int interfaceIndex = findInterfaceIndex(interfaceConstantIndex);
+        if (interfaceIndex >= 0)
+        {
+            int   interfacesCount = --targetClass.u2interfacesCount;
+            int[] interfaces      = targetClass.u2interfaces;
+
+            // Shift the other interfaces in the array.
+            for (int index = interfaceIndex; index < interfacesCount; index++)
+            {
+                interfaces[index] = interfaces[index + 1];
+            }
+
+            // Clear the remaining entry in the array.
+            interfaces[interfacesCount] = 0;
+        }
+    }
+
+
+    // Small utility methods.
+
+    /**
+     * Finds the index of the specified interface in the list of interfaces of
+     * the target class.
+     */
+    private int findInterfaceIndex(int interfaceConstantIndex)
+    {
+        int   interfacesCount = targetClass.u2interfacesCount;
+        int[] interfaces      = targetClass.u2interfaces;
+
+        for (int index = 0; index < interfacesCount; index++)
+        {
+            if (interfaces[index] == interfaceConstantIndex)
+              {
+                  return index;
+              }
+        }
+
+        return -1;
+    }
+}

data/lib/proguard4.7/src/proguard/classfile/editor/LineNumberInfoAdder.java

@@ -0,0 +1,59 @@
+/*
+ * 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.classfile.editor;
+
+import proguard.classfile.attribute.visitor.LineNumberInfoVisitor;
+import proguard.classfile.attribute.*;
+import proguard.classfile.*;
+
+/**
+ * This LineNumberInfoVisitor adds all line numbers that it visits to the given
+ * target line number attribute.
+ */
+public class LineNumberInfoAdder
+implements   LineNumberInfoVisitor
+{
+    private final LineNumberTableAttributeEditor lineNumberTableAttributeEditor;
+
+
+    /**
+     * Creates a new LineNumberInfoAdder that will copy line numbers into the
+     * given target line number table.
+     */
+    public LineNumberInfoAdder(LineNumberTableAttribute targetLineNumberTableAttribute)
+    {
+        this.lineNumberTableAttributeEditor = new LineNumberTableAttributeEditor(targetLineNumberTableAttribute);
+    }
+
+
+    // Implementations for LineNumberInfoVisitor.
+
+    public void visitLineNumberInfo(Clazz clazz, Method method, CodeAttribute codeAttribute, LineNumberInfo lineNumberInfo)
+    {
+        // Create a new line number.
+        LineNumberInfo newLineNumberInfo =
+            new LineNumberInfo(lineNumberInfo.u2startPC,
+                               lineNumberInfo.u2lineNumber);
+
+        // Add it to the target.
+        lineNumberTableAttributeEditor.addLineNumberInfo(newLineNumberInfo);
+    }
+}

data/lib/proguard4.7/src/proguard/classfile/editor/LineNumberTableAttributeEditor.java

@@ -0,0 +1,67 @@
+/*
+ * 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.classfile.editor;
+
+import proguard.classfile.attribute.*;
+
+/**
+ * This class can add line numbers to a given line number table attribute.
+ * Line numbers to be added must have been filled out beforehand.
+ *
+ * @author Eric Lafortune
+ */
+public class LineNumberTableAttributeEditor
+{
+    private LineNumberTableAttribute targetLineNumberTableAttribute;
+
+
+    /**
+     * Creates a new LineNumberTableAttributeEditor that will edit line numbers
+     * in the given line number table attribute.
+     */
+    public LineNumberTableAttributeEditor(LineNumberTableAttribute targetLineNumberTableAttribute)
+    {
+        this.targetLineNumberTableAttribute = targetLineNumberTableAttribute;
+    }
+
+
+    /**
+     * Adds a given line number to the line number table attribute.
+     */
+    public void addLineNumberInfo(LineNumberInfo lineNumberInfo)
+    {
+        int              lineNumberTableLength = targetLineNumberTableAttribute.u2lineNumberTableLength;
+        LineNumberInfo[] lineNumberTable       = targetLineNumberTableAttribute.lineNumberTable;
+
+        // Make sure there is enough space for the new lineNumberInfo.
+        if (lineNumberTable.length <= lineNumberTableLength)
+        {
+            targetLineNumberTableAttribute.lineNumberTable = new LineNumberInfo[lineNumberTableLength+1];
+            System.arraycopy(lineNumberTable, 0,
+                             targetLineNumberTableAttribute.lineNumberTable, 0,
+                             lineNumberTableLength);
+            lineNumberTable = targetLineNumberTableAttribute.lineNumberTable;
+        }
+
+        // Add the lineNumberInfo.
+        lineNumberTable[targetLineNumberTableAttribute.u2lineNumberTableLength++] = lineNumberInfo;
+    }
+}