proguard.classfile.editor.ComparableConstant Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of proguard-core Show documentation
Show all versions of proguard-core Show documentation
ProGuardCORE is a free library to read, analyze, modify, and write Java class files.
/*
* ProGuardCORE -- library to process Java bytecode.
*
* Copyright (c) 2002-2020 Guardsquare NV
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package proguard.classfile.editor;
import proguard.classfile.*;
import proguard.classfile.constant.*;
import proguard.classfile.constant.visitor.ConstantVisitor;
import proguard.util.ArrayUtil;
/**
* This class is a {@link Comparable} wrapper of {@link Constant}
* instances. It can store an index, in order to identify the constant pool
* entry after it has been sorted. The comparison is primarily based on the
* types of the constant pool entries, and secondarily on the contents of
* the constant pool entries.
*
* @author Eric Lafortune
*/
class ComparableConstant
implements Comparable, ConstantVisitor
{
private static final int[] PRIORITIES = new int[100];
static
{
PRIORITIES[Constant.INTEGER] = 0; // Possibly byte index (ldc).
PRIORITIES[Constant.FLOAT] = 1;
PRIORITIES[Constant.STRING] = 2;
PRIORITIES[Constant.CLASS] = 3;
PRIORITIES[Constant.LONG] = 4; // Always wide index (ldc2_w).
PRIORITIES[Constant.DOUBLE] = 5; // Always wide index (ldc2_w).
PRIORITIES[Constant.FIELDREF] = 6; // Always wide index (getfield,...).
PRIORITIES[Constant.METHODREF] = 7; // Always wide index (invokespecial,...).
PRIORITIES[Constant.INTERFACE_METHODREF] = 8; // Always wide index (invokeinterface).
PRIORITIES[Constant.DYNAMIC] = 9; // Always wide index (invokedynamic).
PRIORITIES[Constant.INVOKE_DYNAMIC] = 10; // Always wide index (invokedynamic).
PRIORITIES[Constant.METHOD_HANDLE] = 11;
PRIORITIES[Constant.NAME_AND_TYPE] = 12;
PRIORITIES[Constant.METHOD_TYPE] = 13;
PRIORITIES[Constant.MODULE] = 14;
PRIORITIES[Constant.PACKAGE] = 15;
PRIORITIES[Constant.UTF8] = 16;
PRIORITIES[Constant.PRIMITIVE_ARRAY] = 17;
}
private final Clazz clazz;
private final int thisIndex;
private final Constant thisConstant;
private Constant otherConstant;
private int result;
public ComparableConstant(Clazz clazz, int index, Constant constant)
{
this.clazz = clazz;
this.thisIndex = index;
this.thisConstant = constant;
}
public int getIndex()
{
return thisIndex;
}
public Constant getConstant()
{
return thisConstant;
}
// Implementations for Comparable.
public int compareTo(Object other)
{
ComparableConstant otherComparableConstant = (ComparableConstant)other;
otherConstant = otherComparableConstant.thisConstant;
// Compare based on the original indices, if the actual constant pool
// entries are the same.
if (thisConstant == otherConstant)
{
int otherIndex = otherComparableConstant.thisIndex;
return Integer.compare(thisIndex, otherIndex);
}
// Compare based on the tags, if they are different.
int thisTag = thisConstant.getTag();
int otherTag = otherConstant.getTag();
if (thisTag != otherTag)
{
return Integer.compare(PRIORITIES[thisTag], PRIORITIES[otherTag]);
}
// Otherwise compare based on the contents of the Constant objects.
thisConstant.accept(clazz, this);
return result;
}
// Implementations for ConstantVisitor.
public void visitIntegerConstant(Clazz clazz, IntegerConstant integerConstant)
{
result = Integer.compare(integerConstant.getValue(),
((IntegerConstant)otherConstant).getValue());
}
public void visitLongConstant(Clazz clazz, LongConstant longConstant)
{
result = Long.compare(longConstant.getValue(),
((LongConstant)otherConstant).getValue());
}
public void visitFloatConstant(Clazz clazz, FloatConstant floatConstant)
{
result = Float.compare(floatConstant.getValue(),
((FloatConstant)otherConstant).getValue());
}
public void visitDoubleConstant(Clazz clazz, DoubleConstant doubleConstant)
{
result = Double.compare(doubleConstant.getValue(),
((DoubleConstant)otherConstant).getValue());
}
public void visitPrimitiveArrayConstant(Clazz clazz, PrimitiveArrayConstant primitiveArrayConstant)
{
PrimitiveArrayConstant otherPrimitiveArrayConstant =
(PrimitiveArrayConstant)otherConstant;
char primitiveType = primitiveArrayConstant.getPrimitiveType();
char otherPrimitiveType = otherPrimitiveArrayConstant.getPrimitiveType();
if (primitiveType != otherPrimitiveType)
{
result = Integer.compare(primitiveType, otherPrimitiveType);
}
else
{
Object values = primitiveArrayConstant.getValues();
Object otherValues = otherPrimitiveArrayConstant.getValues();
result =
values instanceof boolean[] ? ArrayUtil.compare((boolean[])values, ((boolean[])values).length, (boolean[])otherValues, ((boolean[])otherValues).length) :
values instanceof byte[] ? ArrayUtil.compare((byte[]) values, ((byte[]) values).length, (byte[]) otherValues, ((byte[]) otherValues).length) :
values instanceof char[] ? ArrayUtil.compare((char[]) values, ((char[]) values).length, (char[]) otherValues, ((char[]) otherValues).length) :
values instanceof short[] ? ArrayUtil.compare((short[]) values, ((short[]) values).length, (short[]) otherValues, ((short[]) otherValues).length) :
values instanceof int[] ? ArrayUtil.compare((int[]) values, ((int[]) values).length, (int[]) otherValues, ((int[]) otherValues).length) :
values instanceof float[] ? ArrayUtil.compare((float[]) values, ((float[]) values).length, (float[]) otherValues, ((float[]) otherValues).length) :
values instanceof long[] ? ArrayUtil.compare((long[]) values, ((long[]) values).length, (long[]) otherValues, ((long[]) otherValues).length) :
/*values instanceof double[] */ ArrayUtil.compare((double[]) values, ((double[]) values).length, (double[]) otherValues, ((double[]) otherValues).length);
}
}
public void visitStringConstant(Clazz clazz, StringConstant stringConstant)
{
result = stringConstant.getString(clazz).compareTo(((StringConstant)otherConstant).getString(clazz));
}
public void visitUtf8Constant(Clazz clazz, Utf8Constant utf8Constant)
{
result = utf8Constant.getString().compareTo(((Utf8Constant)otherConstant).getString());
}
public void visitDynamicConstant(Clazz clazz, DynamicConstant dynamicConstant)
{
DynamicConstant otherDynamicConstant = (DynamicConstant)otherConstant;
int index = dynamicConstant.getBootstrapMethodAttributeIndex();
int otherIndex = otherDynamicConstant.getBootstrapMethodAttributeIndex();
result = index < otherIndex ? -1 :
index > otherIndex ? 1 :
compare(dynamicConstant.getName(clazz),
dynamicConstant.getType(clazz),
otherDynamicConstant.getName(clazz),
otherDynamicConstant.getType(clazz));
}
public void visitInvokeDynamicConstant(Clazz clazz, InvokeDynamicConstant invokeDynamicConstant)
{
InvokeDynamicConstant otherInvokeDynamicConstant = (InvokeDynamicConstant)otherConstant;
int index = invokeDynamicConstant.getBootstrapMethodAttributeIndex();
int otherIndex = otherInvokeDynamicConstant.getBootstrapMethodAttributeIndex();
result = index < otherIndex ? -1 :
index > otherIndex ? 1 :
compare(invokeDynamicConstant.getName(clazz),
invokeDynamicConstant.getType(clazz),
otherInvokeDynamicConstant.getName(clazz),
otherInvokeDynamicConstant.getType(clazz));
}
public void visitMethodHandleConstant(Clazz clazz, MethodHandleConstant methodHandleConstant)
{
MethodHandleConstant otherMethodHandleConstant = (MethodHandleConstant)otherConstant;
int kind = methodHandleConstant.getReferenceKind();
int otherKind = otherMethodHandleConstant.getReferenceKind();
result = kind < otherKind ? -1 :
kind > otherKind ? 1 :
compare(methodHandleConstant.getClassName(clazz),
methodHandleConstant.getName(clazz),
methodHandleConstant.getType(clazz),
otherMethodHandleConstant.getClassName(clazz),
otherMethodHandleConstant.getName(clazz),
otherMethodHandleConstant.getType(clazz));
}
public void visitAnyRefConstant(Clazz clazz, RefConstant refConstant)
{
RefConstant otherRefConstant = (RefConstant)otherConstant;
result = compare(refConstant.getClassName(clazz),
refConstant.getName(clazz),
refConstant.getType(clazz),
otherRefConstant.getClassName(clazz),
otherRefConstant.getName(clazz),
otherRefConstant.getType(clazz));
}
public void visitClassConstant(Clazz clazz, ClassConstant classConstant)
{
result = classConstant.getName(clazz).compareTo(((ClassConstant)otherConstant).getName(clazz));
}
public void visitMethodTypeConstant(Clazz clazz, MethodTypeConstant MethodTypeConstant)
{
MethodTypeConstant otherMethodTypeConstant = (MethodTypeConstant)otherConstant;
result = MethodTypeConstant.getType(clazz)
.compareTo
(otherMethodTypeConstant.getType(clazz));
}
public void visitNameAndTypeConstant(Clazz clazz, NameAndTypeConstant nameAndTypeConstant)
{
NameAndTypeConstant otherNameAndTypeConstant = (NameAndTypeConstant)otherConstant;
result = compare(nameAndTypeConstant.getName(clazz),
nameAndTypeConstant.getType(clazz),
otherNameAndTypeConstant.getName(clazz),
otherNameAndTypeConstant.getType(clazz));
}
public void visitModuleConstant(Clazz clazz, ModuleConstant moduleConstant)
{
result = moduleConstant.getName(clazz).compareTo(((ModuleConstant)otherConstant).getName(clazz));
}
public void visitPackageConstant(Clazz clazz, PackageConstant packageConstant)
{
result = packageConstant.getName(clazz).compareTo(((PackageConstant)otherConstant).getName(clazz));
}
// Implementations for Object.
public boolean equals(Object other)
{
return other != null &&
this.getClass().equals(other.getClass()) &&
this.getConstant().getClass().equals(((ComparableConstant)other).getConstant().getClass()) &&
this.compareTo(other) == 0;
}
public int hashCode()
{
return this.getClass().hashCode();
}
// Small utility methods.
/**
* Compares the given two pairs of strings.
*/
private int compare(String string1a, String string1b,
String string2a, String string2b)
{
int comparison;
return
(comparison = string1a.compareTo(string2a)) != 0 ? comparison :
string1b.compareTo(string2b);
}
/**
* Compares the given two triplets of strings.
*/
private int compare(String string1a, String string1b, String string1c,
String string2a, String string2b, String string2c)
{
int comparison;
return
(comparison = string1a.compareTo(string2a)) != 0 ? comparison :
(comparison = string1b.compareTo(string2b)) != 0 ? comparison :
string1c.compareTo(string2c);
}
}
© 2015 - 2024 Weber Informatics LLC | Privacy Policy