method.java

深入java虚拟机（第二版）光盘所有源码

/*
* Copyright (c) 1996-1999 Bill Venners. All Rights Reserved.
*
* This Java source file is part of the Interactive Illustrations Web
* Site, which is delivered in the applets directory of the CD-ROM
* that accompanies the book "Inside the Java 2 Virtual Machine" by Bill
* Venners, published by McGraw-Hill, 1999, ISBN: 0-07-135093-4. This
* source file is provided for evaluation purposes only, but you can
* redistribute it under certain conditions, described in the full
* copyright notice below.
*
* Full Copyright Notice:
*
* All the web pages and Java applets delivered in the applets
* directory of the CD-ROM, consisting of ".html," ".gif," ".class,"
* and ".java" files, are copyrighted (c) 1996-1999 by Bill
* Venners, and all rights are reserved.  This material may be copied
* and placed on any commercial or non-commercial web server on any
* network (including the internet) provided that the following
* guidelines are followed:
*
* a. All the web pages and Java Applets (".html," ".gif," ".class,"
* and ".java" files), including the source code, that are delivered
* in the applets directory of the CD-ROM that
* accompanies the book must be published together on the same web
* site.
*
* b. All the web pages and Java Applets (".html," ".gif," ".class,"
* and ".java" files) must be published "as is" and may not be altered
* in any way.
*
* c. All use and access to this web site must be free, and no fees
* can be charged to view these materials, unless express written
* permission is obtained from Bill Venners.
*
* d. The web pages and Java Applets may not be distributed on any
* media, other than a web server on a network, and may not accompany
* any book or publication.
*
* BILL VENNERS MAKES NO REPRESENTATIONS OR WARRANTIES ABOUT THE
* SUITABILITY OF THE SOFTWARE, EITHER EXPRESS OR IMPLIED, INCLUDING
* BUT NOT LIMITED TO THE IMPLIED WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR PARTICULAR PURPOSE, OR NON-INFRINGEMENT.  BILL VENNERS
* SHALL NOT BE LIABLE FOR ANY DAMAGES SUFFERED BY A LICENSEE AS A
* RESULT OF USING, MODIFYING OR DISTRIBUTING THIS SOFTWARE OR ITS
* DERIVATIVES.
*/
package COM.artima.jvmsim;

/**
* This class represents the method being executed by the
* JVM simulation and performs the actual interpreting of
* the bytecodes.
*
* @author  Bill Venners
*/
class Method {

    private final static int EQ = 0;
    private final static int NE = 1;
    private final static int LT = 2;
    private final static int LE = 3;
    private final static int GT = 4;
    private final static int GE = 5;

    private int pc; // the program counter register
    private byte[] code; // the method's bytecode stream
	private ExceptionTableEntry[] exceptionTable;
	private ConstantPoolEntry[] constantPool;

    private StackFrame sf;

    Method(StackFrame sf, byte[] code, ExceptionTableEntry[] exceptionTable,
		ConstantPoolEntry[] constantPool) {

        this.code = code;
        this.sf = sf;
		this.exceptionTable = exceptionTable;
		this.constantPool = constantPool;
    }

    void resetState() {
        pc = 0;
        sf.resetState();
    }

    // This method is synchronized because executing an instruction must be
    // an idivisible act. If this is being called from the thread that gets
    // fired off by pressing the Run button, it must not be interrupted by
    // the user pressing the Stop button or leaving the page in the browser.
    synchronized int executeNextInstruction() throws BreakpointException {
        switch (((int) code[pc]) & 0xff) {

        case OpCode.AALOAD:
            executeAALOAD();
            break;

        case OpCode.ACONST_NULL:
            executeACONST_NULL();
            break;

        case OpCode.ALOAD:
            executeALOAD();
            break;

        case OpCode.ALOAD_0:
            executeALOAD_N(0);
            break;

        case OpCode.ALOAD_1:
            executeALOAD_N(1);
            break;

        case OpCode.ALOAD_2:
            executeALOAD_N(2);
            break;

        case OpCode.ALOAD_3:
            executeALOAD_N(3);
            break;

        case OpCode.ASTORE:
            executeASTORE();
            break;

        case OpCode.ASTORE_0:
            executeASTORE_N(0);
            break;

        case OpCode.ASTORE_1:
            executeASTORE_N(1);
            break;

        case OpCode.ASTORE_2:
            executeASTORE_N(2);
            break;

        case OpCode.ASTORE_3:
            executeASTORE_N(3);
            break;

        case OpCode.ATHROW:
            executeATHROW();
            break;

        case OpCode.BIPUSH:
            executeBIPUSH();
            break;

        case OpCode.BREAKPOINT:
            throw new BreakpointException();

        case OpCode.D2F:
            executeD2F();
            break;

        case OpCode.D2I:
            executeD2I();
            break;

        case OpCode.D2L:
            executeD2L();
            break;

        case OpCode.DADD:
            executeDADD();
            break;

        case OpCode.DCMPG:
            executeDCMPG();
            break;

        case OpCode.DCONST_0:
            executeDCONST_N(0.0);
            break;

        case OpCode.DCONST_1:
            executeDCONST_N(1.0);
            break;

        case OpCode.DDIV:
            executeDDIV();
            break;

        case OpCode.DLOAD:
            executeDLOAD();
            break;

        case OpCode.DLOAD_0:
            executeDLOAD_N(0);
            break;

        case OpCode.DLOAD_1:
            executeDLOAD_N(1);
            break;

        case OpCode.DLOAD_2:
            executeDLOAD_N(2);
            break;

        case OpCode.DLOAD_3:
            executeDLOAD_N(3);
            break;

        case OpCode.DMUL:
            executeDMUL();
            break;

        case OpCode.DNEG:
            executeDNEG();
            break;

        case OpCode.DREM:
            executeDREM();
            break;

        case OpCode.DSTORE:
            executeDSTORE();
            break;

        case OpCode.DSTORE_0:
            executeDSTORE_N(0);
            break;

        case OpCode.DSTORE_1:
            executeDSTORE_N(1);
            break;

        case OpCode.DSTORE_2:
            executeDSTORE_N(2);
            break;

        case OpCode.DSTORE_3:
            executeDSTORE_N(3);
            break;

        case OpCode.DSUB:
            executeDSUB();
            break;

        case OpCode.F2D:
            executeF2D();
            break;

        case OpCode.F2I:
            executeF2I();
            break;

        case OpCode.F2L:
            executeF2L();
            break;

        case OpCode.FADD:
            executeFADD();
            break;

        case OpCode.FCONST_0:
            executeFCONST_N(0.0f);
            break;

        case OpCode.FCONST_1:
            executeFCONST_N(1.0f);
            break;

        case OpCode.FCONST_2:
            executeFCONST_N(2.0f);
            break;

        case OpCode.FDIV:
            executeFDIV();
            break;

        case OpCode.FLOAD:
            executeFLOAD();
            break;

        case OpCode.FLOAD_0:
            executeFLOAD_N(0);
            break;

        case OpCode.FLOAD_1:
            executeFLOAD_N(1);
            break;

        case OpCode.FLOAD_2:
            executeFLOAD_N(2);
            break;

        case OpCode.FLOAD_3:
            executeFLOAD_N(3);
            break;

        case OpCode.FMUL:
            executeFMUL();
            break;

        case OpCode.FNEG:
            executeFNEG();
            break;

        case OpCode.FREM:
            executeFREM();
            break;

        case OpCode.FSTORE:
            executeFSTORE();
            break;

        case OpCode.FSTORE_0:
            executeFSTORE_N(0);
            break;

        case OpCode.FSTORE_1:
            executeFSTORE_N(1);
            break;

        case OpCode.FSTORE_2:
            executeFSTORE_N(2);
            break;

        case OpCode.FSTORE_3:
            executeFSTORE_N(3);
            break;

        case OpCode.FSUB:
            executeFSUB();
            break;

        case OpCode.GETSTATIC:
			executeGETSTATIC();
            break;

        case OpCode.GOTO:
            executeGOTO();
            break;

        case OpCode.I2B:
            executeI2B();
            break;

        case OpCode.I2C:
            executeI2C();
            break;

        case OpCode.I2D:
            executeI2D();
            break;

        case OpCode.I2F:
            executeI2F();
            break;

        case OpCode.I2L:
            executeI2L();
            break;

        case OpCode.I2S:
            executeI2S();
            break;

        case OpCode.IADD:
            executeIADD();
            break;

        case OpCode.IAND:
            executeIAND();
            break;

        case OpCode.IASTORE:
            executeIASTORE();
            break;

        case OpCode.ICONST_M1:
            executeICONST_N(-1);
            break;

        case OpCode.ICONST_0:
            executeICONST_N(0);
            break;

        case OpCode.ICONST_1:
            executeICONST_N(1);
            break;

        case OpCode.ICONST_2:
            executeICONST_N(2);
            break;

        case OpCode.ICONST_3:
            executeICONST_N(3);
            break;

        case OpCode.ICONST_4:
            executeICONST_N(4);
            break;

        case OpCode.ICONST_5:
            executeICONST_N(5);
            break;

        case OpCode.IDIV:
            executeIDIV();
            break;

        case OpCode.IFEQ:
            executeIFCOND(Method.EQ);
            break;

        case OpCode.IFNE:
            executeIFCOND(Method.NE);
            break;

        case OpCode.IFLT:
            executeIFCOND(Method.LT);
            break;

        case OpCode.IFLE:
            executeIFCOND(Method.LE);
            break;

        case OpCode.IFGT:
            executeIFCOND(Method.GT);
            break;

        case OpCode.IFGE:
            executeIFCOND(Method.GE);
            break;

        case OpCode.IF_ICMPEQ:
            executeIF_ICMPCOND(Method.EQ);
            break;

        case OpCode.IF_ICMPNE:
            executeIF_ICMPCOND(Method.NE);
            break;

        case OpCode.IF_ICMPLT:
            executeIF_ICMPCOND(Method.LT);
            break;

        case OpCode.IF_ICMPLE:
            executeIF_ICMPCOND(Method.LE);
            break;

        case OpCode.IF_ICMPGT:
            executeIF_ICMPCOND(Method.GT);
            break;

        case OpCode.IF_ICMPGE:
            executeIF_ICMPCOND(Method.GE);
            break;

        case OpCode.IINC:
            executeIINC();
            break;

        case OpCode.ILOAD:
            executeILOAD();
            break;

        case OpCode.ILOAD_0:
            executeILOAD_N(0);
            break;

        case OpCode.ILOAD_1:
            executeILOAD_N(1);
            break;

        case OpCode.ILOAD_2:
            executeILOAD_N(2);
            break;

        case OpCode.ILOAD_3:
            executeILOAD_N(3);
            break;

        case OpCode.IMUL:
            executeIMUL();
            break;

        case OpCode.INEG:
            executeINEG();
            break;

        case OpCode.INVOKESTATIC:
            executeINVOKESTATIC();
            break;

        case OpCode.IOR:
            executeIOR();
            break;

        case OpCode.IREM:
            executeIREM();
            break;

        case OpCode.ISHL:
            executeISHL();
            break;

        case OpCode.ISHR:
            executeISHR();
            break;

        case OpCode.ISTORE:
            executeISTORE();
            break;

        case OpCode.ISTORE_0:
            executeISTORE_N(0);
            break;

        case OpCode.ISTORE_1:
            executeISTORE_N(1);