com.android.dx.cf.code.LocalVariableList Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of builder Show documentation
Show all versions of builder Show documentation
Library to build Android applications.
/*
* Copyright (C) 2007 The Android Open Source Project
*
* 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 com.android.dx.cf.code;
import com.android.dx.rop.code.LocalItem;
import com.android.dx.rop.cst.CstString;
import com.android.dx.rop.type.Type;
import com.android.dx.util.FixedSizeList;
/**
* List of "local variable" entries, which are the contents of
* {@code LocalVariableTable} and {@code LocalVariableTypeTable}
* attributes, as well as combinations of the two.
*/
public final class LocalVariableList extends FixedSizeList {
/** {@code non-null;} zero-size instance */
public static final LocalVariableList EMPTY = new LocalVariableList(0);
/**
* Returns an instance which is the concatenation of the two given
* instances. The result is immutable.
*
* @param list1 {@code non-null;} first instance
* @param list2 {@code non-null;} second instance
* @return {@code non-null;} combined instance
*/
public static LocalVariableList concat(LocalVariableList list1,
LocalVariableList list2) {
if (list1 == EMPTY) {
// easy case
return list2;
}
int sz1 = list1.size();
int sz2 = list2.size();
LocalVariableList result = new LocalVariableList(sz1 + sz2);
for (int i = 0; i < sz1; i++) {
result.set(i, list1.get(i));
}
for (int i = 0; i < sz2; i++) {
result.set(sz1 + i, list2.get(i));
}
result.setImmutable();
return result;
}
/**
* Returns an instance which is the result of merging the two
* given instances, where one instance should have only type
* descriptors and the other only type signatures. The merged
* result is identical to the one with descriptors, except that
* any element whose {name, index, start, length} matches an
* element in the signature list gets augmented with the
* corresponding signature. The result is immutable.
*
* @param descriptorList {@code non-null;} list with descriptors
* @param signatureList {@code non-null;} list with signatures
* @return {@code non-null;} the merged result
*/
public static LocalVariableList mergeDescriptorsAndSignatures(
LocalVariableList descriptorList,
LocalVariableList signatureList) {
int descriptorSize = descriptorList.size();
LocalVariableList result = new LocalVariableList(descriptorSize);
for (int i = 0; i < descriptorSize; i++) {
Item item = descriptorList.get(i);
Item signatureItem = signatureList.itemToLocal(item);
if (signatureItem != null) {
CstString signature = signatureItem.getSignature();
item = item.withSignature(signature);
}
result.set(i, item);
}
result.setImmutable();
return result;
}
/**
* Constructs an instance.
*
* @param count the number of elements to be in the list
*/
public LocalVariableList(int count) {
super(count);
}
/**
* Gets the indicated item.
*
* @param n {@code >= 0;} which item
* @return {@code null-ok;} the indicated item
*/
public Item get(int n) {
return (Item) get0(n);
}
/**
* Sets the item at the given index.
*
* @param n {@code >= 0, < size();} which element
* @param item {@code non-null;} the item
*/
public void set(int n, Item item) {
if (item == null) {
throw new NullPointerException("item == null");
}
set0(n, item);
}
/**
* Sets the item at the given index.
*
* Note: At least one of {@code descriptor} or
* {@code signature} must be passed as non-null.
*
* @param n {@code >= 0, < size();} which element
* @param startPc {@code >= 0;} the start pc of this variable's scope
* @param length {@code >= 0;} the length (in bytecodes) of this variable's
* scope
* @param name {@code non-null;} the variable's name
* @param descriptor {@code null-ok;} the variable's type descriptor
* @param signature {@code null-ok;} the variable's type signature
* @param index {@code >= 0;} the variable's local index
*/
public void set(int n, int startPc, int length, CstString name,
CstString descriptor, CstString signature, int index) {
set0(n, new Item(startPc, length, name, descriptor, signature, index));
}
/**
* Gets the local variable information in this instance which matches
* the given {@link com.android.dx.cf.code.LocalVariableList.Item}
* in all respects but the type descriptor and signature, if any.
*
* @param item {@code non-null;} local variable information to match
* @return {@code null-ok;} the corresponding local variable information stored
* in this instance, or {@code null} if there is no matching
* information
*/
public Item itemToLocal(Item item) {
int sz = size();
for (int i = 0; i < sz; i++) {
Item one = (Item) get0(i);
if ((one != null) && one.matchesAllButType(item)) {
return one;
}
}
return null;
}
/**
* Gets the local variable information associated with a given address
* and local index, if any. Note: In standard classfiles, a
* variable's start point is listed as the address of the instruction
* just past the one that sets the variable.
*
* @param pc {@code >= 0;} the address to look up
* @param index {@code >= 0;} the local variable index
* @return {@code null-ok;} the associated local variable information, or
* {@code null} if none is known
*/
public Item pcAndIndexToLocal(int pc, int index) {
int sz = size();
for (int i = 0; i < sz; i++) {
Item one = (Item) get0(i);
if ((one != null) && one.matchesPcAndIndex(pc, index)) {
return one;
}
}
return null;
}
/**
* Item in a local variable table.
*/
public static class Item {
/** {@code >= 0;} the start pc of this variable's scope */
private final int startPc;
/** {@code >= 0;} the length (in bytecodes) of this variable's scope */
private final int length;
/** {@code non-null;} the variable's name */
private final CstString name;
/** {@code null-ok;} the variable's type descriptor */
private final CstString descriptor;
/** {@code null-ok;} the variable's type signature */
private final CstString signature;
/** {@code >= 0;} the variable's local index */
private final int index;
/**
* Constructs an instance.
*
* Note: At least one of {@code descriptor} or
* {@code signature} must be passed as non-null.
*
* @param startPc {@code >= 0;} the start pc of this variable's scope
* @param length {@code >= 0;} the length (in bytecodes) of this variable's
* scope
* @param name {@code non-null;} the variable's name
* @param descriptor {@code null-ok;} the variable's type descriptor
* @param signature {@code null-ok;} the variable's type signature
* @param index {@code >= 0;} the variable's local index
*/
public Item(int startPc, int length, CstString name,
CstString descriptor, CstString signature, int index) {
if (startPc < 0) {
throw new IllegalArgumentException("startPc < 0");
}
if (length < 0) {
throw new IllegalArgumentException("length < 0");
}
if (name == null) {
throw new NullPointerException("name == null");
}
if ((descriptor == null) && (signature == null)) {
throw new NullPointerException(
"(descriptor == null) && (signature == null)");
}
if (index < 0) {
throw new IllegalArgumentException("index < 0");
}
this.startPc = startPc;
this.length = length;
this.name = name;
this.descriptor = descriptor;
this.signature = signature;
this.index = index;
}
/**
* Gets the start pc of this variable's scope.
*
* @return {@code >= 0;} the start pc of this variable's scope
*/
public int getStartPc() {
return startPc;
}
/**
* Gets the length (in bytecodes) of this variable's scope.
*
* @return {@code >= 0;} the length (in bytecodes) of this variable's scope
*/
public int getLength() {
return length;
}
/**
* Gets the variable's type descriptor.
*
* @return {@code null-ok;} the variable's type descriptor
*/
public CstString getDescriptor() {
return descriptor;
}
/**
* Gets the variable's LocalItem, a (name, signature) tuple
*
* @return {@code null-ok;} the variable's type descriptor
*/
public LocalItem getLocalItem() {
return LocalItem.make(name, signature);
}
/**
* Gets the variable's type signature. Private because if you need this,
* you want getLocalItem() instead.
*
* @return {@code null-ok;} the variable's type signature
*/
private CstString getSignature() {
return signature;
}
/**
* Gets the variable's local index.
*
* @return {@code >= 0;} the variable's local index
*/
public int getIndex() {
return index;
}
/**
* Gets the variable's type descriptor. This is a convenient shorthand
* for {@code Type.intern(getDescriptor().getString())}.
*
* @return {@code non-null;} the variable's type
*/
public Type getType() {
return Type.intern(descriptor.getString());
}
/**
* Constructs and returns an instance which is identical to this
* one, except that the signature is changed to the given value.
*
* @param newSignature {@code non-null;} the new signature
* @return {@code non-null;} an appropriately-constructed instance
*/
public Item withSignature(CstString newSignature) {
return new Item(startPc, length, name, descriptor, newSignature,
index);
}
/**
* Gets whether this instance matches (describes) the given
* address and index.
*
* @param pc {@code >= 0;} the address in question
* @param index {@code >= 0;} the local variable index in question
* @return {@code true} iff this instance matches {@code pc}
* and {@code index}
*/
public boolean matchesPcAndIndex(int pc, int index) {
return (index == this.index) &&
(pc >= startPc) &&
(pc < (startPc + length));
}
/**
* Gets whether this instance matches (describes) the given
* other instance exactly in all fields except type descriptor and
* type signature.
*
* @param other {@code non-null;} the instance to compare to
* @return {@code true} iff this instance matches
*/
public boolean matchesAllButType(Item other) {
return (startPc == other.startPc)
&& (length == other.length)
&& (index == other.index)
&& name.equals(other.name);
}
}
}
© 2015 - 2024 Weber Informatics LLC | Privacy Policy