bytecodewriter.java

来自「纯java操作系统jnode,安装简单和操作简单的个人使用的Java操作系统」· Java 代码 · 共 990 行 · 第 1/2 页

	}

	public void ifnonnull(Label label) {
		final int start = used;
		write8(0xc7);
		write16(start, label);
	}

	public void ifnull(Label label) {
		final int start = used;
		write8(0xc6);
		write16(start, label);
	}

	public void iinc(int index, int constValue) {
		write8(0x84);
		write8(index);
		write8(constValue);
	}

	public void iload(int index) {
		if ((index >= 0) && (index <= 3)) {
			write8(0x1a + index);
		} else {
			write8(0x15);
			write8(index);
		}
	}

	public void imul() {
		write8(0x68);
	}

	public void ineg() {
		write8(0x74);
	}

	public void instanceof_(int index) {
		write8(0xc1);
		write16(index);
	}

	public void invokeinterface(int index, int count) {
		write8(0xb9);
		write16(index);
		write8(count);
		write8(0);
	}

	public void invokespecial(int index) {
		write8(0xb7);
		write16(index);
	}

	public void invokestatic(int index) {
		write8(0xb8);
		write16(index);
	}

	public void invokevirtual(int index) {
		write8(0xb6);
		write16(index);
	}

	public void ior() {
		write8(0x80);
	}

	public void irem() {
		write8(0x70);
	}

	public void ireturn() {
		write8(0xac);
	}

	public void ishl() {
		write8(0x78);
	}

	public void ishr() {
		write8(0x7a);
	}

	public void istore(int index) {
		if ((index >= 0) && (index <= 3)) {
			write8(0x3b + index);
		} else {
			write8(0x54);
			write8(index);
		}
	}

	public void isub() {
		write8(0x64);
	}

	public void iushr() {
		write8(0x7c);
	}

	public void ixor() {
		write8(0x82);
	}

	public void jsr(Label label) {
		final int start = used;
		write8(0xa8);
		write16(start, label);
	}

	/*public void jsr_w(Label label) {
		write8(0xc9);
		write32(label);
	}*/

	public void l2d() {
		write8(0x8a);
	}

	public void l2f() {
		write8(0x89);
	}

	public void l2i() {
		write8(0x88);
	}

	public void ladd() {
		write8(0x61);
	}

	public void laload() {
		write8(0x2f);
	}

	public void land() {
		write8(0x7f);
	}

	public void lastore() {
		write8(0x50);
	}

	public void lcmp() {
		write8(0x94);
	}

	public void lconst_0() {
		write8(0x09);
	}

	public void lconst_1() {
		write8(0x0a);
	}

	public void ldc(int index) {
		write8(0x12);
		write8(index);
	}

	public void ldc_w(int index) {
		write8(0x13);
		write16(index);
	}

	public void ldc2_w(int index) {
		write8(0x14);
		write16(index);
	}

	public void ldiv() {
		write8(0x6d);
	}

	public void lload(int index) {
		if ((index >= 0) && (index <= 3)) {
			write8(0x1e + index);
		} else {
			write8(0x16);
			write8(index);
		}
	}

	public void lmul() {
		write8(0x69);
	}

	public void lneg() {
		write8(0x75);
	}

	/*public void lookupswitch(int defaultBranch, int[] branches) {
		// Not implemented yet
	}*/

	public void lor() {
		write8(0x81);
	}

	public void lrem() {
		write8(0x71);
	}

	public void lreturn() {
		write8(0xad);
	}

	public void lshl() {
		write8(0x79);
	}

	public void lshr() {
		write8(0x7b);
	}

	public void lstore(int index) {
		if ((index >= 0) && (index <= 3)) {
			write8(0x3f + index);
		} else {
			write8(0x37);
			write8(index);
		}
	}

	public void lsub() {
		write8(0x65);
	}

	public void lxor() {
		write8(0x83);
	}

	public void monitorenter() {
		write8(0xc2);
	}

	public void monitorexit() {
		write8(0xc3);
	}

	public void multianewarray(int index, int dims) {
		write8(0xc5);
		write16(index);
		write8(dims);
	}

	public void new_(int index) {
		write8(0xbb);
		write16(index);
	}

	public void newarray(int atype) {
		write8(0xbc);
		write8(atype);
	}

	public void nop() {
		write8(0x00);
	}

	public void pop() {
		write8(0x57);
	}

	public void pop2() {
		write8(0x58);
	}

	public void putfield(int index) {
		write8(0xb5);
		write16(index);
	}

	public void putstatic(int index) {
		write8(0xb3);
		write16(index);
	}

	public void ret(int index) {
		write8(0xa9);
		write8(index);
	}

	public void return_() {
		write8(0xb1);
	}

	public void saload() {
		write8(0x53);
	}

	public void sastore() {
		write8(0x56);
	}

	public void sipush(int index) {
		write8(0x11);
		write16((short) index);
	}

	public void swap() {
		write8(0x5f);
	}

	/*public void tableswitch(int defaultBranch, int low, int high, int[] branches) {
		write8(0xaa);
	}*/

	private final void ensureSpace(int extra) {
		final int size = used + extra;
		if ((code == null) || (code.length < size)) {
			final int newSize = (size + 128) & ~127;
			final byte[] newCode = new byte[newSize];
			if (code != null) {
				System.arraycopy(code, 0, newCode, 0, code.length);
			}
			this.code = newCode;
		}
	}

	/**
	 * Write an 8-bit int
	 * @param v
	 */
	private final void write8(int v) {
		ensureSpace(1);
		set8(code, used, v);
		used++;
	}

	/**
	 * Write an 16-bit int
	 * @param v
	 */
	private final void write16(int v) {
		ensureSpace(2);
		set16(code, used, v);
		used += 2;
	}

	/**
	 * Write an 16-bit branch
	 * @param insStart
	 * @param label
	 */
	private final void write16(int insStart, Label label) {
		if (label.isResolved()) {
			write16(label.getAddress() - insStart);
		} else {
			label.addUnresolvedLocation(used);
			write16(used - insStart);
		}
	}

	/**
	 * Write an 32-bit int
	 * @param v
	 */
	/*private final void write32(int v) {
		ensureSpace(4);
		set32(code, used, v);
		used += 4;
	}*/

	/**
	 * Set an 8-bit int
	 * @param code
	 * @param ofs
	 * @param v
	 */
	public static final void set8(byte[] code, int ofs, int v) {
		code[ofs++] = (byte) (v & 0xFF);
	}

	/**
	 * Set an 16-bit int
	 * @param code
	 * @param ofs
	 * @param v
	 */
	public static final void set16(byte[] code, int ofs, int v) {
		code[ofs++] = (byte) ((v >> 8) & 0xFF);
		code[ofs++] = (byte) (v & 0xFF);
	}

	/**
	 * Set an 32-bit int
	 * @param code
	 * @param ofs
	 * @param v
	 */
	public static final void set32(byte[] code, int ofs, int v) {
		code[ofs++] = (byte) ((v >> 24) & 0xFF);
		code[ofs++] = (byte) ((v >> 16) & 0xFF);
		code[ofs++] = (byte) ((v >> 8) & 0xFF);
		code[ofs++] = (byte) (v & 0xFF);
	}

	/**
	 * Get an 8-bit int
	 * @param code
	 * @param ofs
	 * @return int
	 */
	public static final int get8(byte[] code, int ofs) {
		return code[ofs++] & 0xFF;
	}

	/**
	 * Set an 16-bit int
	 * @param code
	 * @param ofs
	 * @return int
	 */
	public static final int get16(byte[] code, int ofs) {
		final int v1 = code[ofs++] & 0xFF;
		final int v2 = code[ofs] & 0xFF;
		return (v1 << 8) | v2;
	}

	/**
	 * Get an 32-bit int
	 * @param code
	 * @param ofs
	 * @return int
	 */
	public static final int get32(byte[] code, int ofs) {
		final int v1 = code[ofs++] & 0xFF;
		final int v2 = code[ofs++] & 0xFF;
		final int v3 = code[ofs++] & 0xFF;
		final int v4 = code[ofs] & 0xFF;
		return (v1 << 24) | (v2 << 16) | (v3 << 8) | v4;
	}

	public final int getLength() {
		return used;
	}

	final byte[] getCode() {
		return code;
	}

	class Label {
		private final String text;
		private List unresolvedLocations;
		private int address = -1;

		Label(String text) {
			this.text = text;
		}

		public String toString() {
			return text;
		}

		public boolean isResolved() {
			return (address >= 0);
		}

		public int getAddress() {
			if (address < 0) {
				throw new RuntimeException("Not resolved yet");
			}
			return address;
		}

		void addUnresolvedLocation(int loc) {
			if (isResolved()) {
				throw new RuntimeException("Already resolved");
			}
			if (unresolvedLocations == null) {
				unresolvedLocations = new ArrayList();
			}
			unresolvedLocations.add(new Integer(loc));
		}

		public void resolve() {
			if (isResolved()) {
				throw new RuntimeException("Cannot resolve twice");
			}
			this.address = getLength();
			if (unresolvedLocations != null) {
				for (Iterator i = unresolvedLocations.iterator(); i.hasNext();) {
					final int loc = ((Integer) i.next()).intValue();
					final int distance = address - get16(getCode(), loc);
					set16(getCode(), loc, distance);
				}
				unresolvedLocations = null;
			}
		}

	}
}