/** Return {@code true} if a double slot is read (in case of Double or Long constant). */
private boolean readConstantPoolEntry(final DataInput di, final int index) throws IOException {
final int tag = di.readUnsignedByte();
switch (tag) {
case CP_METHOD_TYPE:
di.skipBytes(2); // readUnsignedShort()
return false;
case CP_METHOD_HANDLE:
di.skipBytes(3);
return false;
case CP_INTEGER:
case CP_FLOAT:
case CP_REF_FIELD:
case CP_REF_METHOD:
case CP_REF_INTERFACE:
case CP_NAME_AND_TYPE:
case CP_INVOKE_DYNAMIC:
di.skipBytes(4); // readInt() / readFloat() / readUnsignedShort() * 2
return false;
case CP_LONG:
case CP_DOUBLE:
di.skipBytes(8); // readLong() / readDouble()
return true;
case CP_UTF8:
constantPool[index] = di.readUTF();
return false;
case CP_CLASS:
case CP_STRING:
// reference to CP_UTF8 entry. The referenced index can have a higher number!
constantPool[index] = di.readUnsignedShort();
return false;
default:
throw new ClassFormatError("Unkown tag value for constant pool entry: " + tag);
}
}
private void readRowByte(
final DataInput input,
Rectangle srcRegion,
int xSub,
int ySub,
byte[] rowDataByte,
final int off,
final int length,
WritableRaster destChannel,
Raster srcChannel,
int y)
throws IOException {
// If subsampled or outside source region, skip entire row
if (y % ySub != 0 || y < srcRegion.y || y >= srcRegion.y + srcRegion.height) {
input.skipBytes(length);
return;
}
input.readFully(rowDataByte, off, length);
// Subsample horizontal
if (xSub != 1) {
for (int x = 0; x < srcRegion.width / xSub; x++) {
rowDataByte[srcRegion.x + x] = rowDataByte[srcRegion.x + x * xSub];
}
}
int dstY = (y - srcRegion.y) / ySub;
destChannel.setDataElements(0, dstY, srcChannel);
}
private void readVersion(final DataInput di) throws IOException {
// sequence: minor version, major version (argument_index is 1-based)
if (DEBUG) {
print("Java Class version %2$d.%1$d", di.readUnsignedShort(), di.readUnsignedShort());
} else {
di.skipBytes(4);
}
}
@Override
public int skipBytes(int n) {
try {
return input.skipBytes(n);
} catch (IOException e) {
throw new IllegalStateException(e);
}
}
public ConstantValueAttr(ConstantPool cp, String name, int length, DataInput din)
throws IOException {
super(cp, name);
int index = din.readUnsignedShort();
if ((length -= 2) > 0) {
din.skipBytes(length);
}
mConstant = cp.getConstant(index);
}
private static void skipField(DataInput in) throws IOException {
int len = in.readInt();
// skipBytes doesn't have to block
int skipped = in.skipBytes(len);
if (skipped < len) {
// wastefully use readFully() if skipBytes didn't work
byte[] bytes = new byte[(len - skipped)];
in.readFully(bytes);
}
}
private void skip(int num) throws IOException {
while (num > 0) {
long result;
if (in != null) {
result = in.skip(num);
} else {
result = din.skipBytes(num);
}
if (result > 0) {
num -= result;
}
}
}
public static String readFixedString(int size, DataInput in) throws IOException {
StringBuilder b = new StringBuilder(size);
int i = 0;
boolean more = true;
while (more && i < size) {
char ch = in.readChar();
i++;
if (ch == 0) more = false;
else b.append(ch);
}
in.skipBytes(2 * (size - i));
return b.toString();
}
/**
* Skip <i>len</i> number of bytes in input stream<i>in</i>
*
* @param in input stream
* @param len number of bytes to skip
* @throws IOException when skipped less number of bytes
*/
public static void skipFully(DataInput in, int len) throws IOException {
int total = 0;
int cur = 0;
while ((total < len) && ((cur = in.skipBytes(len - total)) > 0)) {
total += cur;
}
if (total < len) {
throw new IOException(
"Not able to skip " + len + " bytes, possibly " + "due to end of input.");
}
}
private void readAnnotationElementValue(final DataInput di) throws IOException {
final int tag = di.readUnsignedByte();
if (DEBUG) {
print("tag='%c'", (char) tag);
}
switch (tag) {
case BYTE:
case CHAR:
case DOUBLE:
case FLOAT:
case INT:
case LONG:
case SHORT:
case BOOLEAN:
case STRING:
di.skipBytes(2);
break;
case ENUM:
di.skipBytes(4); // 2 * u2
break;
case CLASS:
di.skipBytes(2);
break;
case ANNOTATION:
readAnnotation(di);
break;
case ARRAY:
final int count = di.readUnsignedShort();
for (int i = 0; i < count; ++i) {
readAnnotationElementValue(di);
}
break;
default:
throw new ClassFormatError(
"Not a valid annotation element type tag: 0x" + Integer.toHexString(tag));
}
}
private String readAnnotation(final DataInput di) throws IOException {
final String rawTypeName = resolveUtf8(di);
// num_element_value_pairs
final int count = di.readUnsignedShort();
if (DEBUG) {
print("annotation elements count: %d", count);
}
for (int i = 0; i < count; ++i) {
if (DEBUG) {
print("element '%s'", resolveUtf8(di));
} else {
di.skipBytes(2);
}
readAnnotationElementValue(di);
}
return rawTypeName;
}
public void readObject(DataInput in) throws IOException {
boolean sgIO = in.readBoolean();
int nodeID = in.readInt();
int nodeClassID = in.readShort();
nodeClassName = null;
if (nodeClassID == -1) nodeClassName = in.readUTF();
readConstructorParams(in);
if (nodeClassID != -1) {
node = createNode();
nodeClassName = node.getClass().getName();
} else node = createNode(nodeClassName);
if (sgIO) {
if (control.getCurrentFileVersion() == 1)
((com.sun.j3d.utils.scenegraph.io.SceneGraphIO) node).readSceneGraphObject(in);
else {
int size = in.readInt();
if (node instanceof com.sun.j3d.utils.scenegraph.io.SceneGraphIO) {
byte[] bytes = new byte[size];
in.readFully(bytes);
ByteArrayInputStream byteStream = new ByteArrayInputStream(bytes);
DataInputStream tmpIn = new DataInputStream(byteStream);
((com.sun.j3d.utils.scenegraph.io.SceneGraphIO) node).readSceneGraphObject(tmpIn);
tmpIn.close();
} else {
in.skipBytes(size);
}
}
}
symbol = control.getSymbolTable().createSymbol(this, node, nodeID);
readUserData(in);
if (control.getCurrentFileVersion() > 2) {
node.setName(readString(in));
}
readCapabilities(in);
}
private void readAttributes(
final DataInput di, final char reporterType, final boolean skipReporting) throws IOException {
final int count = di.readUnsignedShort();
if (DEBUG) {
print("attribute count (%s) = %d", reporterType, count);
}
for (int i = 0; i < count; ++i) {
final String name = resolveUtf8(di);
// in bytes, use this to skip the attribute info block
final int length = di.readInt();
if (!skipReporting
&& ("RuntimeVisibleAnnotations".equals(name)
|| "RuntimeInvisibleAnnotations".equals(name))) {
readAnnotations(di, reporterType);
} else {
if (DEBUG) {
print("skip attribute %s", name);
}
di.skipBytes(length);
}
}
}
private void skip(int num) throws IOException {
while (num > 0) {
long result;
if (in != null) {
result = in.skip(num);
} else {
result = din.skipBytes(num);
}
if (result > 0) {
num -= result;
} else {
if (in != null) {
result = in.read();
} else {
result = din.readByte();
}
if (result == -1) {
throw new IOException("Premature end of input.");
} else {
num--;
}
}
}
}
/**
* Factory method for creating <tt>AttributeInfo</tt> structures.
*
* <p>An <tt>AttributeInfo</tt> of the appropriate subtype from the <tt>attributes</tt> package is
* created unless the type of the attribute is unknown in which case an instance of
* <tt>AttributeInfo</tt> is returned.
*
* <p>
*
* <p>Attributes are skipped if the environment variable <tt>SYSTEM_PROPERTY_SKIP_ATTRIBUTES</tt>
* is set to true.
*
* @param in the <tt>DataInput</tt> from which to read the <tt>AttributeInfo</tt> structure
* @param classFile the parent class file of the structure to be created
* @return the new <tt>AttributeInfo</tt> structure
* @throws InvalidByteCodeException if the byte code is invalid
* @throws IOException if an exception occurs with the <tt>DataInput</tt>
*/
public static AttributeInfo createOrSkip(DataInput in, ClassFile classFile)
throws InvalidByteCodeException, IOException {
AttributeInfo attributeInfo = null;
if (Boolean.getBoolean(SYSTEM_PROPERTY_SKIP_ATTRIBUTES)) {
in.skipBytes(2);
in.skipBytes(in.readInt());
} else {
int attributeNameIndex = in.readUnsignedShort();
int attributeLength = in.readInt();
ConstantUtf8Info cpInfoName = classFile.getConstantPoolUtf8Entry(attributeNameIndex);
String attributeName = null;
if (cpInfoName == null) {
return null;
}
attributeName = cpInfoName.getString();
if (ConstantValueAttribute.ATTRIBUTE_NAME.equals(attributeName)) {
attributeInfo = new ConstantValueAttribute();
} else if (CodeAttribute.ATTRIBUTE_NAME.equals(attributeName)) {
attributeInfo = new CodeAttribute();
} else if (ExceptionsAttribute.ATTRIBUTE_NAME.equals(attributeName)) {
attributeInfo = new ExceptionsAttribute();
} else if (InnerClassesAttribute.ATTRIBUTE_NAME.equals(attributeName)) {
attributeInfo = new InnerClassesAttribute();
} else if (SyntheticAttribute.ATTRIBUTE_NAME.equals(attributeName)) {
attributeInfo = new SyntheticAttribute();
} else if (SourceFileAttribute.ATTRIBUTE_NAME.equals(attributeName)) {
attributeInfo = new SourceFileAttribute();
} else if (LineNumberTableAttribute.ATTRIBUTE_NAME.equals(attributeName)) {
attributeInfo = new LineNumberTableAttribute();
} else if (LocalVariableTableAttribute.ATTRIBUTE_NAME.equals(attributeName)) {
attributeInfo = new LocalVariableTableAttribute();
} else if (DeprecatedAttribute.ATTRIBUTE_NAME.equals(attributeName)) {
attributeInfo = new DeprecatedAttribute();
} else if (EnclosingMethodAttribute.ATTRIBUTE_NAME.equals(attributeName)) {
attributeInfo = new EnclosingMethodAttribute();
} else if (SignatureAttribute.ATTRIBUTE_NAME.equals(attributeName)) {
attributeInfo = new SignatureAttribute();
} else if (LocalVariableTypeTableAttribute.ATTRIBUTE_NAME.equals(attributeName)) {
attributeInfo = new LocalVariableTypeTableAttribute();
} else if (RuntimeVisibleAnnotationsAttribute.ATTRIBUTE_NAME.equals(attributeName)) {
attributeInfo = new RuntimeVisibleAnnotationsAttribute();
} else if (RuntimeInvisibleAnnotationsAttribute.ATTRIBUTE_NAME.equals(attributeName)) {
attributeInfo = new RuntimeInvisibleAnnotationsAttribute();
} else if (AnnotationDefaultAttribute.ATTRIBUTE_NAME.equals(attributeName)) {
attributeInfo = new AnnotationDefaultAttribute();
} else if (BootstrapMethodsAttribute.ATTRIBUTE_NAME.equals(attributeName)) {
attributeInfo = new BootstrapMethodsAttribute(attributeLength);
} else {
attributeInfo = new AttributeInfo(attributeLength);
}
attributeInfo.setAttributeNameIndex(attributeNameIndex);
attributeInfo.setClassFile(classFile);
attributeInfo.read(in);
}
return attributeInfo;
}
public static void skipCompressedByteArray(DataInput in) throws IOException {
int length = in.readInt();
if (length != -1) in.skipBytes(length);
}
private void readInterfaces(final DataInput di) throws IOException {
final int count = di.readUnsignedShort();
di.skipBytes(count * 2); // count * u2
}
private void readSuperClass(final DataInput di) throws IOException {
di.skipBytes(2); // u2
}
private void readAccessFlags(final DataInput di) throws IOException {
di.skipBytes(2); // u2
}
/**
* skips samplesToSkip data points. It is up to the caller to insure that the type of SAC file
* (iftype = LEVEN, IRLIM, IAMPH) and how many data points remain are compatible with the size of
* the float array to be read.
*
* @throws IOException
*/
public static int skipSamples(DataInput dataIn, int samplesToSkip) throws IOException {
return dataIn.skipBytes(samplesToSkip * 4) / 4;
}
public int skipBytes(int n) throws IOException {
return in.skipBytes(n);
}
public int skipBytes(int n) throws IOException {
return dataInput.skipBytes(n);
}