javassist.bytecode.InnerClassesAttribute Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of javassist Show documentation
Show all versions of javassist Show documentation
Javassist (JAVA programming ASSISTant) makes Java bytecode manipulation
simple. It is a class library for editing bytecodes in Java.
/*
* Javassist, a Java-bytecode translator toolkit.
* Copyright (C) 1999- Shigeru Chiba. All Rights Reserved.
*
* The contents of this file are subject to the Mozilla Public License Version
* 1.1 (the "License"); you may not use this file except in compliance with
* the License. Alternatively, the contents of this file may be used under
* the terms of the GNU Lesser General Public License Version 2.1 or later,
* or the Apache License Version 2.0.
*
* Software distributed under the License is distributed on an "AS IS" basis,
* WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
* for the specific language governing rights and limitations under the
* License.
*/
package javassist.bytecode;
import java.io.DataInputStream;
import java.io.IOException;
import java.util.Map;
/**
* InnerClasses_attribute.
*/
public class InnerClassesAttribute extends AttributeInfo {
/**
* The name of this attribute "InnerClasses".
*/
public static final String tag = "InnerClasses";
InnerClassesAttribute(ConstPool cp, int n, DataInputStream in)
throws IOException
{
super(cp, n, in);
}
private InnerClassesAttribute(ConstPool cp, byte[] info) {
super(cp, tag, info);
}
/**
* Constructs an empty InnerClasses attribute.
*
* @see #append(String, String, String, int)
*/
public InnerClassesAttribute(ConstPool cp) {
super(cp, tag, new byte[2]);
ByteArray.write16bit(0, get(), 0);
}
/**
* Returns number_of_classes.
*/
public int tableLength() { return ByteArray.readU16bit(get(), 0); }
/**
* Returns classes[nth].inner_class_info_index.
*/
public int innerClassIndex(int nth) {
return ByteArray.readU16bit(get(), nth * 8 + 2);
}
/**
* Returns the class name indicated
* by classes[nth].inner_class_info_index.
* The class name is fully-qualified and separated by dot.
*
* @return null or the class name.
* @see ConstPool#getClassInfo(int)
*/
public String innerClass(int nth) {
int i = innerClassIndex(nth);
if (i == 0)
return null;
return constPool.getClassInfo(i);
}
/**
* Sets classes[nth].inner_class_info_index to
* the given index.
*/
public void setInnerClassIndex(int nth, int index) {
ByteArray.write16bit(index, get(), nth * 8 + 2);
}
/**
* Returns classes[nth].outer_class_info_index.
*/
public int outerClassIndex(int nth) {
return ByteArray.readU16bit(get(), nth * 8 + 4);
}
/**
* Returns the class name indicated
* by classes[nth].outer_class_info_index.
*
* @return null or the class name.
*/
public String outerClass(int nth) {
int i = outerClassIndex(nth);
if (i == 0)
return null;
return constPool.getClassInfo(i);
}
/**
* Sets classes[nth].outer_class_info_index to
* the given index.
*/
public void setOuterClassIndex(int nth, int index) {
ByteArray.write16bit(index, get(), nth * 8 + 4);
}
/**
* Returns classes[nth].inner_name_index.
*/
public int innerNameIndex(int nth) {
return ByteArray.readU16bit(get(), nth * 8 + 6);
}
/**
* Returns the simple class name indicated
* by classes[nth].inner_name_index.
*
* @return null or the class name.
*/
public String innerName(int nth) {
int i = innerNameIndex(nth);
if (i == 0)
return null;
return constPool.getUtf8Info(i);
}
/**
* Sets classes[nth].inner_name_index to
* the given index.
*/
public void setInnerNameIndex(int nth, int index) {
ByteArray.write16bit(index, get(), nth * 8 + 6);
}
/**
* Returns classes[nth].inner_class_access_flags.
*/
public int accessFlags(int nth) {
return ByteArray.readU16bit(get(), nth * 8 + 8);
}
/**
* Sets classes[nth].inner_class_access_flags to
* the given index.
*/
public void setAccessFlags(int nth, int flags) {
ByteArray.write16bit(flags, get(), nth * 8 + 8);
}
/**
* Finds the entry for the given inner class.
*
* @param name the fully-qualified class name separated by dot and $.
* @return the index or -1 if not found.
* @since 3.22
*/
public int find(String name) {
int n = tableLength();
for (int i = 0; i < n; i++)
if (name.equals(innerClass(i)))
return i;
return -1;
}
/**
* Appends a new entry.
*
* @param inner inner_class_info_index
* @param outer outer_class_info_index
* @param name inner_name_index
* @param flags inner_class_access_flags
*/
public void append(String inner, String outer, String name, int flags) {
int i = constPool.addClassInfo(inner);
int o = constPool.addClassInfo(outer);
int n = constPool.addUtf8Info(name);
append(i, o, n, flags);
}
/**
* Appends a new entry.
*
* @param inner inner_class_info_index
* @param outer outer_class_info_index
* @param name inner_name_index
* @param flags inner_class_access_flags
*/
public void append(int inner, int outer, int name, int flags) {
byte[] data = get();
int len = data.length;
byte[] newData = new byte[len + 8];
for (int i = 2; i < len; ++i)
newData[i] = data[i];
int n = ByteArray.readU16bit(data, 0);
ByteArray.write16bit(n + 1, newData, 0);
ByteArray.write16bit(inner, newData, len);
ByteArray.write16bit(outer, newData, len + 2);
ByteArray.write16bit(name, newData, len + 4);
ByteArray.write16bit(flags, newData, len + 6);
set(newData);
}
/**
* Removes the {@code nth} entry. It does not eliminate
* constant pool items that the removed entry refers to.
* {@link ClassFile#compact()} should be executed to remove
* these unnecessary items.
*
* @param nth 0, 1, 2, ...
* @return the number of items after the removal.
* @see ClassFile#compact()
*/
public int remove(int nth) {
byte[] data = get();
int len = data.length;
if (len < 10)
return 0;
int n = ByteArray.readU16bit(data, 0);
int nthPos = 2 + nth * 8;
if (n <= nth)
return n;
byte[] newData = new byte[len - 8];
ByteArray.write16bit(n - 1, newData, 0);
int i = 2, j = 2;
while (i < len)
if (i == nthPos)
i += 8;
else
newData[j++] = data[i++];
set(newData);
return n - 1;
}
/**
* Makes a copy. Class names are replaced according to the
* given Map object.
*
* @param newCp the constant pool table used by the new copy.
* @param classnames pairs of replaced and substituted
* class names.
*/
@Override
public AttributeInfo copy(ConstPool newCp, Map classnames) {
byte[] src = get();
byte[] dest = new byte[src.length];
ConstPool cp = getConstPool();
InnerClassesAttribute attr = new InnerClassesAttribute(newCp, dest);
int n = ByteArray.readU16bit(src, 0);
ByteArray.write16bit(n, dest, 0);
int j = 2;
for (int i = 0; i < n; ++i) {
int innerClass = ByteArray.readU16bit(src, j);
int outerClass = ByteArray.readU16bit(src, j + 2);
int innerName = ByteArray.readU16bit(src, j + 4);
int innerAccess = ByteArray.readU16bit(src, j + 6);
if (innerClass != 0)
innerClass = cp.copy(innerClass, newCp, classnames);
ByteArray.write16bit(innerClass, dest, j);
if (outerClass != 0)
outerClass = cp.copy(outerClass, newCp, classnames);
ByteArray.write16bit(outerClass, dest, j + 2);
if (innerName != 0)
innerName = cp.copy(innerName, newCp, classnames);
ByteArray.write16bit(innerName, dest, j + 4);
ByteArray.write16bit(innerAccess, dest, j + 6);
j += 8;
}
return attr;
}
}