test/langtools/tools/javac/lambdaShapes/org/openjdk/tests/separate/ClassFile.java - platform/libcore - Git at Google

 /*
  * 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);
         }
     }
 }
	/*
	* 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);
	}
	}
	}