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