/*
* Copyright (c) 2012, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License version 2 only, as
* published by the Free Software Foundation.
*
* This code 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
* version 2 for more details (a copy is included in the LICENSE file that
* accompanied this code).
*
* You should have received a copy of the GNU General Public License version
* 2 along with this work; if not, write to the Free Software Foundation,
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
*
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
* or visit www.oracle.com if you need additional information or have any
* questions.
*/
package org.openjdk.tests.separate;
import java.io.*;
import java.util.*;
class CfInputStream extends ByteArrayInputStream {
private int ct;
public CfInputStream(byte[] input) {
super(input);
}
byte u1() { return (byte)read(); }
short u2() {
int b0 = read() << 8;
int b1 = read();
return (short)(b0 | b1);
}
int u4() {
int b0 = read() << 24;
int b1 = read() << 16;
int b2 = read() << 8;
int b3 = read();
return b0 | b1 | b2 | b3;
}
byte[] array(int count) {
byte[] ret = new byte[count];
read(ret, 0, count);
return ret;
}
};
class CfOutputStream extends ByteArrayOutputStream {
void u1(byte b) { write((int)b); }
void u2(short s) {
write((s >> 8) & 0xff);
write(s & 0xff);
}
void u4(int i) {
write((i >> 24) & 0xff);
write((i >> 16) & 0xff);
write((i >> 8) & 0xff);
write(i & 0xff);
}
void array(byte[] a) {
write(a, 0, a.length);
}
public byte[] toByteArray() { return super.toByteArray(); }
};
// A quick and dirty class file parser and representation
public class ClassFile {
int magic;
short minor_version;
short major_version;
ArrayList<CpEntry> constant_pool;
short access_flags;
short this_class;
short super_class;
ArrayList<Interface> interfaces;
ArrayList<Field> fields;
ArrayList<Method> methods;
ArrayList<Attribute> attributes;
ClassFile(byte[] cf) {
CfInputStream in = new CfInputStream(cf);
magic = in.u4();
minor_version = in.u2();
major_version = in.u2();
short cpCount = in.u2();
constant_pool = new ArrayList<>();
constant_pool.add(new CpNull());
for (int i = 1; i < cpCount; ++i) {
constant_pool.add(CpEntry.newCpEntry(in));
}
access_flags = in.u2();
this_class = in.u2();
super_class = in.u2();
short ifaceCount = in.u2();
interfaces = new ArrayList<>();
for (int i = 0; i < ifaceCount; ++i) {
interfaces.add(new Interface(in));
}
short fieldCount = in.u2();
fields = new ArrayList<>();
for (int i = 0; i < fieldCount; ++i) {
fields.add(new Field(in));
}
short methodCount = in.u2();
methods = new ArrayList<>();
for (int i = 0; i < methodCount; ++i) {
methods.add(new Method(in));
}
short attributeCount = in.u2();
attributes = new ArrayList<>();
for (int i = 0; i < attributeCount; ++i) {
attributes.add(new Attribute(in));
}
}
byte[] toByteArray() {
CfOutputStream out = new CfOutputStream();
out.u4(magic);
out.u2(minor_version);
out.u2(major_version);
out.u2((short)(constant_pool.size()));
for (CpEntry cp : constant_pool) {
cp.write(out);
}
out.u2(access_flags);
out.u2(this_class);
out.u2(super_class);
out.u2((short)interfaces.size());
for (Interface iface : interfaces) {
iface.write(out);
}
out.u2((short)fields.size());
for (Field field : fields) {
field.write(out);
}
out.u2((short)methods.size());
for (Method method : methods) {
method.write(out);
}
out.u2((short)attributes.size());
for (Attribute attribute : attributes) {
attribute.write(out);
}
return out.toByteArray();
}
static abstract class CpEntry {
byte tag;
CpEntry(byte t) { tag = t; }
void write(CfOutputStream out) {
out.u1(tag);
}
static CpEntry newCpEntry(CfInputStream in) {
byte tag = in.u1();
switch (tag) {
case CpUtf8.TAG: return new CpUtf8(in);
case CpInteger.TAG: return new CpInteger(in);
case CpFloat.TAG: return new CpFloat(in);
case CpLong.TAG: return new CpLong(in);
case CpDouble.TAG: return new CpDouble(in);
case CpClass.TAG: return new CpClass(in);
case CpString.TAG: return new CpString(in);
case CpFieldRef.TAG: return new CpFieldRef(in);
case CpMethodRef.TAG: return new CpMethodRef(in);
case CpInterfaceMethodRef.TAG:
return new CpInterfaceMethodRef(in);
case CpNameAndType.TAG: return new CpNameAndType(in);
case CpMethodHandle.TAG: return new CpMethodHandle(in);
case CpMethodType.TAG: return new CpMethodType(in);
case CpInvokeDynamic.TAG: return new CpInvokeDynamic(in);
default: throw new RuntimeException("Bad cp entry tag: " + tag);
}
}
}
static class CpNull extends CpEntry {
CpNull() { super((byte)0); }
CpNull(CfInputStream in) { super((byte)0); }
void write(CfOutputStream out) {}
}
static class CpUtf8 extends CpEntry {
static final byte TAG = 1;
byte[] bytes;
CpUtf8() { super(TAG); }
CpUtf8(CfInputStream in) {
this();
short length = in.u2();
bytes = in.array(length);
}
void write(CfOutputStream out) {
super.write(out);
out.u2((short)bytes.length);
out.array(bytes);
}
}
static class CpU4Constant extends CpEntry {
byte[] bytes;
CpU4Constant(byte tag) { super(tag); }
CpU4Constant(byte tag, CfInputStream in) {
this(tag);
bytes = in.array(4);
}
void write(CfOutputStream out) { super.write(out); out.array(bytes); }
}
static class CpInteger extends CpU4Constant {
static final byte TAG = 3;
CpInteger() { super(TAG); }
CpInteger(CfInputStream in) { super(TAG, in); }
}
static class CpFloat extends CpU4Constant {
static final byte TAG = 4;
CpFloat() { super(TAG); }
CpFloat(CfInputStream in) { super(TAG, in); }
}
static class CpU8Constant extends CpEntry {
byte[] bytes;
CpU8Constant(byte tag) { super(tag); }
CpU8Constant(byte tag, CfInputStream in) {
this(tag);
bytes = in.array(8);
}
void write(CfOutputStream out) { super.write(out); out.array(bytes); }
}
static class CpLong extends CpU8Constant {
static final byte TAG = 5;
CpLong() { super(TAG); }
CpLong(CfInputStream in) { super(TAG, in); }
}
static class CpDouble extends CpU8Constant {
static final byte TAG = 6;
CpDouble() { super(TAG); }
CpDouble(CfInputStream in) { super(TAG, in); }
}
static class CpClass extends CpEntry {
static final byte TAG = 7;
short name_index;
CpClass() { super(TAG); }
CpClass(CfInputStream in) { super(TAG); name_index = in.u2(); }
void write(CfOutputStream out) {
super.write(out);
out.u2(name_index);
}
}
static class CpString extends CpEntry {
static final byte TAG = 8;
short string_index;
CpString() { super(TAG); }
CpString(CfInputStream in) { super(TAG); string_index = in.u2(); }
void write(CfOutputStream out) {
super.write(out);
out.u2(string_index);
}
}
static class CpRef extends CpEntry {
short class_index;
short name_and_type_index;
CpRef(byte tag) { super(tag); }
CpRef(byte tag, CfInputStream in) {
this(tag);
class_index = in.u2();
name_and_type_index = in.u2();
}
void write(CfOutputStream out) {
super.write(out);
out.u2(class_index);
out.u2(name_and_type_index);
}
}
static class CpFieldRef extends CpRef {
static final byte TAG = 9;
CpFieldRef() { super(TAG); }
CpFieldRef(CfInputStream in) { super(TAG, in); }
}
static class CpMethodRef extends CpRef {
static final byte TAG = 10;
CpMethodRef() { super(TAG); }
CpMethodRef(CfInputStream in) { super(TAG, in); }
}
static class CpInterfaceMethodRef extends CpRef {
static final byte TAG = 11;
CpInterfaceMethodRef() { super(TAG); }
CpInterfaceMethodRef(CfInputStream in) { super(TAG, in); }
}
static class CpNameAndType extends CpEntry {
static final byte TAG = 12;
short name_index;
short descriptor_index;
CpNameAndType() { super(TAG); }
CpNameAndType(CfInputStream in) {
this();
name_index = in.u2();
descriptor_index = in.u2();
}
void write(CfOutputStream out) {
super.write(out);
out.u2(name_index);
out.u2(descriptor_index);
}
}
static class CpMethodHandle extends CpEntry {
static final byte TAG = 15;
byte reference_kind;
short reference_index;
CpMethodHandle() { super(TAG); }
CpMethodHandle(CfInputStream in) {
this();
reference_kind = in.u1();
reference_index = in.u2();
}
void write(CfOutputStream out) {
super.write(out);
out.u1(reference_kind);
out.u2(reference_index);
}
}
static class CpMethodType extends CpEntry {
static final byte TAG = 16;
short descriptor_index;
CpMethodType() { super(TAG); }
CpMethodType(CfInputStream in) {
this();
descriptor_index = in.u2();
}
void write(CfOutputStream out) {
super.write(out);
out.u2(descriptor_index);
}
}
static class CpInvokeDynamic extends CpEntry {
static final byte TAG = 18;
short bootstrap_index;
short name_and_type_index;
CpInvokeDynamic() { super(TAG); }
CpInvokeDynamic(CfInputStream in) {
this();
bootstrap_index = in.u2();
name_and_type_index = in.u2();
}
void write(CfOutputStream out) {
super.write(out);
out.u2(bootstrap_index);
out.u2(name_and_type_index);
}
}
static class Interface {
short index;
Interface() {}
Interface(CfInputStream in) { index = in.u2(); }
void write(CfOutputStream out) { out.u2(index); }
}
static class FieldOrMethod {
short access_flags;
short name_index;
short descriptor_index;
ArrayList<Attribute> attributes;
FieldOrMethod() { attributes = new ArrayList<>(); }
FieldOrMethod(CfInputStream in) {
access_flags = in.u2();
name_index = in.u2();
descriptor_index = in.u2();
short attrCount = in.u2();
attributes = new ArrayList<>();
for (int i = 0; i < attrCount; ++i) {
attributes.add(new Attribute(in));
}
}
void write(CfOutputStream out) {
out.u2(access_flags);
out.u2(name_index);
out.u2(descriptor_index);
out.u2((short)attributes.size());
for (Attribute attribute : attributes) { attribute.write(out); }
}
}
static class Field extends FieldOrMethod {
Field() {}
Field(CfInputStream in) { super(in); }
}
static class Method extends FieldOrMethod {
Method() {}
Method(CfInputStream in) { super(in); }
}
static class Attribute {
short attribute_name_index;
byte[] info;
Attribute() { info = new byte[0]; }
Attribute(CfInputStream in) {
attribute_name_index = in.u2();
int length = in.u4();
info = in.array(length);
}
void write(CfOutputStream out) {
out.u2(attribute_name_index);
out.u4(info.length);
out.array(info);
}
}
}