---

ATHROW.java

package gov.nasa.arc.ase.jpf.jvm.bytecode;

import de.fub.bytecode.classfile.CodeException;
import de.fub.bytecode.classfile.Utility;
import de.fub.bytecode.generic.CodeExceptionGen;
import de.fub.bytecode.generic.InstructionHandle;
import gov.nasa.arc.ase.jpf.*;
import gov.nasa.arc.ase.jpf.jvm.*;
import gov.nasa.arc.ase.util.Debug;

public class ATHROW extends AbstractInstruction {
  private de.fub.bytecode.generic.ATHROW peer;

  public InstructionHandle execute(SystemState ss, KernelState ks, ThreadInfo th) {
    int objref = th.pop();

    ClassInfo ci = ks.dynamic_area.getClass(objref);

    return findExceptionHandler(th, objref, ci, ks);
  }  
  // tries to find an exception handler so that execution is continued there
  private InstructionHandle findExceptionHandler(ThreadInfo th,
      int exception, ClassInfo type, KernelState ks) {
    JPFVM jpfvm = JPFVM.getJPFVM();

    while (th.depth() != 0) {
      // gets the current position in the method code
      // that is needed to access the exception table
      int pc = th.getPC().getPosition();

      // gets the exception table from the current method
      CodeExceptionGen[] exceptions = th.getCurrentMethod().getExceptions();

      // checks the exception catched in order
      for(int idx = 0, s = exceptions.length; idx < s; idx++) {
    // exception entry
    CodeException ce = exceptions[idx].getCodeException(th.getCPG());

    // gets the class of exceptions catched.
    String classname;
    if (ce.getCatchType() == 0)
      // any exception
      classname = "java.lang.Exception";
    else
      // gets the class name (beware of / -> . substitution)
      classname =  Utility.replace(
          exceptions[idx].getCatchType().getClassName(),"/",".");

    ClassInfo ci;
    if (classname.equals("java.lang.Exception"))
      //** warning: I am not sure what this is for, so  **//
      //**          I just leave it alone for now       **//
      // ci = type so it will always be matched
      ci = type; // matches all exceptions // but also ERRORS now!
    else
      // gets the class info
      ci = jpfvm.getClass(classname);

    // checks if the program counter follows in the range of the
    // exception and if the type catched is the corrent one
    //** error: this doesn't work if an exception derived from the  **//
    //**        base class is thrown. To be corrected soon.     **//
    if (pc >= ce.getStartPC() && pc <= ce.getEndPC() && (ci == type)) {
      // clears all the operand stack
      th.clearOperandStack();

      // pushes the exception on the stack instead
      th.push(exception);
// ifdef MARK_N_SWEEP
      th.setOperandRef();
//#endif MARK_N_SWEEP

      // jumps to the exception handler
      return exceptions[idx].getHandlerPC();
    }
      }

      // now we are exiting the method 
      // to throw the exception at an higher level
      
      // check if this method was synchronized
      MethodInfo mi = th.getCurrentMethod();
      if (mi.getMethodGen().isSynchronized()) {
        // releases the lock
    if (mi.getMethodGen().isStatic()) {
      // static method so it's lock on the class
      String className = mi.getClassInfo().getClassData().getClassName();

      ks.static_area.monitorUnlock(className, th);
    } else {
      // non static method so it's lock on an object
      ks.dynamic_area.monitorUnlock(th.getThis(), th);
    }
      }

      // remove a frame
      th.popFrame();
    }

    // no handler found
    throw new InternalErrorException("No handler found for exception " + type.getClassName());
  }  
  public void setPeer(de.fub.bytecode.generic.Instruction i) {
    peer = (de.fub.bytecode.generic.ATHROW)i;
  }  
}

---