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

sometsome 1.0.2 → 3.10.42

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (732) hide show

data/lib/proguard4.7/src/proguard/classfile/editor/VariableSizeUpdater.java ADDED

@@ -0,0 +1,105 @@
+/*
+ * 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.instruction.*;
+import proguard.classfile.instruction.visitor.InstructionVisitor;
+import proguard.classfile.util.*;
+/**
+ * This AttributeVisitor computes and updates the maximum local variable frame
+ * size of the code attributes that it visits. It also cleans up the local
+ * variable tables.
+ *
+ * @author Eric Lafortune
+ */
+public class VariableSizeUpdater
+extends      SimplifiedVisitor
+implements   AttributeVisitor,
+             InstructionVisitor
+{
+    //*
+    private static final boolean DEBUG = false;
+    /*/
+    private static       boolean DEBUG = true;
+    //*/
+    private VariableCleaner variableCleaner = new VariableCleaner();
+    // Implementations for AttributeVisitor.
+    public void visitAnyAttribute(Clazz clazz, Attribute attribute) {}
+    public void visitCodeAttribute(Clazz clazz, Method method, CodeAttribute codeAttribute)
+    {
+//        DEBUG =
+//            clazz.getName().equals("abc/Def") &&
+//            method.getName(clazz).equals("abc");
+        // The minimum variable size is determined by the arguments.
+        codeAttribute.u2maxLocals =
+            ClassUtil.internalMethodParameterSize(method.getDescriptor(clazz),
+                                                  method.getAccessFlags());
+        if (DEBUG)
+        {
+            System.out.println("VariableSizeUpdater: "+clazz.getName()+"."+method.getName(clazz)+method.getDescriptor(clazz));
+            System.out.println("  Max locals: "+codeAttribute.u2maxLocals+" <- parameters");
+        }
+        // Go over all instructions.
+        codeAttribute.instructionsAccept(clazz, method, this);
+        // Remove the unused variables of the attributes.
+        variableCleaner.visitCodeAttribute(clazz, method, codeAttribute);
+    }
+    // Implementations for InstructionVisitor.
+    public void visitAnyInstruction(Clazz clazz, Method method, CodeAttribute codeAttribute, int offset, Instruction instruction) {}
+    public void visitVariableInstruction(Clazz clazz, Method method, CodeAttribute codeAttribute, int offset, VariableInstruction variableInstruction)
+    {
+        int variableSize = variableInstruction.variableIndex + 1;
+        if (variableInstruction.isCategory2())
+        {
+            variableSize++;
+        }
+        if (codeAttribute.u2maxLocals < variableSize)
+        {
+            codeAttribute.u2maxLocals = variableSize;
+            if (DEBUG)
+            {
+                System.out.println("  Max locals: "+codeAttribute.u2maxLocals+" <- "+variableInstruction.toString(offset));
+            }
+        }
+    }
+}

data/lib/proguard4.7/src/proguard/classfile/editor/package.html ADDED

@@ -0,0 +1,3 @@
+<body>
+This package contains visitors to edit byte code.
+</body>

data/lib/proguard4.7/src/proguard/classfile/instruction/BranchInstruction.java ADDED

@@ -0,0 +1,180 @@
+/*
+ * 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.instruction;
+import proguard.classfile.*;
+import proguard.classfile.attribute.CodeAttribute;
+import proguard.classfile.instruction.visitor.InstructionVisitor;
+/**
+ * This interface describes an instruction that branches to a given offset in
+ * the code.
+ *
+ * @author Eric Lafortune
+ */
+public class BranchInstruction extends Instruction
+{
+    public int branchOffset;
+    /**
+     * Creates an uninitialized BranchInstruction.
+     */
+    public BranchInstruction() {}
+    public BranchInstruction(byte opcode, int branchOffset)
+    {
+        this.opcode       = opcode;
+        this.branchOffset = branchOffset;
+    }
+    /**
+     * Copies the given instruction into this instruction.
+     * @param branchInstruction the instruction to be copied.
+     * @return this instruction.
+     */
+    public BranchInstruction copy(BranchInstruction branchInstruction)
+    {
+        this.opcode       = branchInstruction.opcode;
+        this.branchOffset = branchInstruction.branchOffset;
+        return this;
+    }
+    // Implementations for Instruction.
+    public byte canonicalOpcode()
+    {
+        // Remove the _w extension, if any.
+        switch (opcode)
+        {
+            case InstructionConstants.OP_GOTO_W: return InstructionConstants.OP_GOTO;
+            case InstructionConstants.OP_JSR_W: return InstructionConstants.OP_JSR;
+            default: return opcode;
+        }
+    }
+    public Instruction shrink()
+    {
+        // Do we need an ordinary branch or a wide branch?
+        if (requiredBranchOffsetSize() == 2)
+        {
+            // Can we replace the wide branch by an ordinary branch?
+            if      (opcode == InstructionConstants.OP_GOTO_W)
+            {
+                opcode = InstructionConstants.OP_GOTO;
+            }
+            else if (opcode == InstructionConstants.OP_JSR_W)
+            {
+                opcode = InstructionConstants.OP_JSR;
+            }
+        }
+        else
+        {
+            // Should we replace the ordinary branch by a wide branch?
+            if      (opcode == InstructionConstants.OP_GOTO)
+            {
+                opcode = InstructionConstants.OP_GOTO_W;
+            }
+            else if (opcode == InstructionConstants.OP_JSR)
+            {
+                opcode = InstructionConstants.OP_JSR_W;
+            }
+            else
+            {
+                throw new IllegalArgumentException("Branch instruction can't be widened ("+this.toString()+")");
+            }
+        }
+        return this;
+    }
+    protected void readInfo(byte[] code, int offset)
+    {
+        branchOffset = readSignedValue(code, offset, branchOffsetSize());
+    }
+    protected void writeInfo(byte[] code, int offset)
+    {
+        if (requiredBranchOffsetSize() > branchOffsetSize())
+        {
+            throw new IllegalArgumentException("Instruction has invalid branch offset size ("+this.toString(offset)+")");
+        }
+        writeSignedValue(code, offset, branchOffset, branchOffsetSize());
+    }
+    public int length(int offset)
+    {
+        return 1 + branchOffsetSize();
+    }
+    public void accept(Clazz clazz, Method method, CodeAttribute codeAttribute, int offset, InstructionVisitor instructionVisitor)
+    {
+        instructionVisitor.visitBranchInstruction(clazz, method, codeAttribute, offset, this);
+    }
+    public String toString(int offset)
+    {
+        return "["+offset+"] "+toString()+" (target="+(offset+branchOffset)+")";
+    }
+    // Implementations for Object.
+    public String toString()
+    {
+        return getName()+" "+(branchOffset >= 0 ? "+" : "")+branchOffset;
+    }
+    // Small utility methods.
+    /**
+     * Returns the branch offset size for this instruction.
+     */
+    private int branchOffsetSize()
+    {
+        return opcode == InstructionConstants.OP_GOTO_W ||
+               opcode == InstructionConstants.OP_JSR_W  ? 4 :
+                                                          2;
+    }
+    /**
+     * Computes the required branch offset size for this instruction's branch
+     * offset.
+     */
+    private int requiredBranchOffsetSize()
+    {
+        return branchOffset << 16 >> 16 == branchOffset ? 2 :
+                                                          4;
+    }
+}

data/lib/proguard4.7/src/proguard/classfile/instruction/ConstantInstruction.java ADDED

@@ -0,0 +1,309 @@
+/*
+ * 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.instruction;
+import proguard.classfile.*;
+import proguard.classfile.attribute.CodeAttribute;
+import proguard.classfile.constant.*;
+import proguard.classfile.constant.visitor.ConstantVisitor;
+import proguard.classfile.instruction.visitor.InstructionVisitor;
+import proguard.classfile.util.ClassUtil;
+/**
+ * This Instruction represents an instruction that refers to an entry in the
+ * constant pool.
+ *
+ * @author Eric Lafortune
+ */
+public class ConstantInstruction extends Instruction
+implements   ConstantVisitor
+{
+    public int constantIndex;
+    public int constant;
+    // Fields acting as return parameters for the ConstantVisitor methods.
+    private int parameterStackDelta;
+    private int typeStackDelta;
+    /**
+     * Creates an uninitialized ConstantInstruction.
+     */
+    public ConstantInstruction() {}
+    /**
+     * Creates a new ConstantInstruction with the given opcode and constant pool
+     * index.
+     */
+    public ConstantInstruction(byte opcode, int constantIndex)
+    {
+        this(opcode, constantIndex, 0);
+    }
+    /**
+     * Creates a new ConstantInstruction with the given opcode, constant pool
+     * index, and constant.
+     */
+    public ConstantInstruction(byte opcode, int constantIndex, int constant)
+    {
+        this.opcode        = opcode;
+        this.constantIndex = constantIndex;
+        this.constant      = constant;
+    }
+    /**
+     * Copies the given instruction into this instruction.
+     * @param constantInstruction the instruction to be copied.
+     * @return this instruction.
+     */
+    public ConstantInstruction copy(ConstantInstruction constantInstruction)
+    {
+        this.opcode        = constantInstruction.opcode;
+        this.constantIndex = constantInstruction.constantIndex;
+        this.constant      = constantInstruction.constant;
+        return this;
+    }
+    // Implementations for Instruction.
+    public byte canonicalOpcode()
+    {
+        // Remove the _w extension, if any.
+        return
+            opcode == InstructionConstants.OP_LDC_W ? InstructionConstants.OP_LDC :
+                                                      opcode;
+    }
+    public Instruction shrink()
+    {
+        // Do we need a short index or a long index?
+        if (requiredConstantIndexSize() == 1)
+        {
+            // Can we replace the long instruction by a short instruction?
+            if (opcode == InstructionConstants.OP_LDC_W)
+            {
+                opcode = InstructionConstants.OP_LDC;
+            }
+        }
+        else
+        {
+            // Should we replace the short instruction by a long instruction?
+            if (opcode == InstructionConstants.OP_LDC)
+            {
+                opcode = InstructionConstants.OP_LDC_W;
+            }
+        }
+        return this;
+    }
+    protected void readInfo(byte[] code, int offset)
+    {
+        int constantIndexSize = constantIndexSize();
+        int constantSize      = constantSize();
+        constantIndex = readValue(code, offset, constantIndexSize);  offset += constantIndexSize;
+        constant      = readValue(code, offset, constantSize);
+    }
+    protected void writeInfo(byte[] code, int offset)
+    {
+        int constantIndexSize = constantIndexSize();
+        int constantSize      = constantSize();
+        if (requiredConstantIndexSize() > constantIndexSize)
+        {
+            throw new IllegalArgumentException("Instruction has invalid constant index size ("+this.toString(offset)+")");
+        }
+        writeValue(code, offset, constantIndex, constantIndexSize); offset += constantIndexSize;
+        writeValue(code, offset, constant,      constantSize);
+    }
+    public int length(int offset)
+    {
+        return 1 + constantIndexSize() + constantSize();
+    }
+    public void accept(Clazz clazz, Method method, CodeAttribute codeAttribute, int offset, InstructionVisitor instructionVisitor)
+    {
+        instructionVisitor.visitConstantInstruction(clazz, method, codeAttribute, offset, this);
+    }
+    public int stackPopCount(Clazz clazz)
+    {
+        int stackPopCount = super.stackPopCount(clazz);
+        // Some special cases.
+        switch (opcode)
+        {
+            case InstructionConstants.OP_MULTIANEWARRAY:
+                // For each dimension, an integer size is popped from the stack.
+                stackPopCount += constant;
+                break;
+            case InstructionConstants.OP_PUTSTATIC:
+            case InstructionConstants.OP_PUTFIELD:
+                // The field value is be popped from the stack.
+                clazz.constantPoolEntryAccept(constantIndex, this);
+                stackPopCount += typeStackDelta;
+                break;
+            case InstructionConstants.OP_INVOKEVIRTUAL:
+            case InstructionConstants.OP_INVOKESPECIAL:
+            case InstructionConstants.OP_INVOKESTATIC:
+            case InstructionConstants.OP_INVOKEINTERFACE:
+            case InstructionConstants.OP_INVOKEDYNAMIC:
+                // Some parameters may be popped from the stack.
+                clazz.constantPoolEntryAccept(constantIndex, this);
+                stackPopCount += parameterStackDelta;
+                break;
+        }
+        return stackPopCount;
+    }
+    public int stackPushCount(Clazz clazz)
+    {
+        int stackPushCount = super.stackPushCount(clazz);
+        // Some special cases.
+        switch (opcode)
+        {
+            case InstructionConstants.OP_GETSTATIC:
+            case InstructionConstants.OP_GETFIELD:
+            case InstructionConstants.OP_INVOKEVIRTUAL:
+            case InstructionConstants.OP_INVOKESPECIAL:
+            case InstructionConstants.OP_INVOKESTATIC:
+            case InstructionConstants.OP_INVOKEINTERFACE:
+            case InstructionConstants.OP_INVOKEDYNAMIC:
+                // The field value or a return value may be pushed onto the stack.
+                clazz.constantPoolEntryAccept(constantIndex, this);
+                stackPushCount += typeStackDelta;
+                break;
+        }
+        return stackPushCount;
+    }
+    // Implementations for ConstantVisitor.
+    public void visitIntegerConstant(Clazz clazz, IntegerConstant integerConstant) {}
+    public void visitLongConstant(Clazz clazz, LongConstant longConstant) {}
+    public void visitFloatConstant(Clazz clazz, FloatConstant floatConstant) {}
+    public void visitDoubleConstant(Clazz clazz, DoubleConstant doubleConstant) {}
+    public void visitStringConstant(Clazz clazz, StringConstant stringConstant) {}
+    public void visitUtf8Constant(Clazz clazz, Utf8Constant utf8Constant) {}
+    public void visitMethodHandleConstant(Clazz clazz, MethodHandleConstant methodHandleConstant) {}
+    public void visitClassConstant(Clazz clazz, ClassConstant classConstant) {}
+    public void visitMethodTypeConstant(Clazz clazz, MethodTypeConstant methodTypeConstant) {}
+    public void visitFieldrefConstant(Clazz clazz, FieldrefConstant fieldrefConstant)
+    {
+        String type = fieldrefConstant.getType(clazz);
+        typeStackDelta = ClassUtil.internalTypeSize(ClassUtil.internalMethodReturnType(type));
+    }
+    public void visitInvokeDynamicConstant(Clazz clazz, InvokeDynamicConstant invokeDynamicConstant)
+    {
+        clazz.constantPoolEntryAccept(invokeDynamicConstant.u2nameAndTypeIndex, this);
+    }
+    public void visitInterfaceMethodrefConstant(Clazz clazz, InterfaceMethodrefConstant interfaceMethodrefConstant)
+    {
+        clazz.constantPoolEntryAccept(interfaceMethodrefConstant.u2nameAndTypeIndex, this);
+    }
+    public void visitMethodrefConstant(Clazz clazz, MethodrefConstant methodrefConstant)
+    {
+        clazz.constantPoolEntryAccept(methodrefConstant.u2nameAndTypeIndex, this);
+    }
+    public void visitNameAndTypeConstant(Clazz clazz, NameAndTypeConstant nameAndTypeConstant)
+    {
+        String type = nameAndTypeConstant.getType(clazz);
+        parameterStackDelta = ClassUtil.internalMethodParameterSize(type);
+        typeStackDelta      = ClassUtil.internalTypeSize(ClassUtil.internalMethodReturnType(type));
+    }
+    // Implementations for Object.
+    public String toString()
+    {
+        return getName()+" #"+constantIndex;
+    }
+    // Small utility methods.
+    /**
+     * Returns the constant pool index size for this instruction.
+     */
+    private int constantIndexSize()
+    {
+        return opcode == InstructionConstants.OP_LDC ? 1 :
+                                                       2;
+    }
+    /**
+     * Returns the constant size for this instruction.
+     */
+    private int constantSize()
+    {
+        return opcode == InstructionConstants.OP_MULTIANEWARRAY  ? 1 :
+               opcode == InstructionConstants.OP_INVOKEDYNAMIC ||
+               opcode == InstructionConstants.OP_INVOKEINTERFACE ? 2 :
+                                                                   0;
+    }
+    /**
+     * Computes the required constant pool index size for this instruction's
+     * constant pool index.
+     */
+    private int requiredConstantIndexSize()
+    {
+        return (constantIndex &   0xff) == constantIndex ? 1 :
+               (constantIndex & 0xffff) == constantIndex ? 2 :
+                                                           4;
+    }
+}