---

Reflection.java

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

import gov.nasa.arc.ase.jpf.*;
import gov.nasa.arc.ase.util.*;
import gov.nasa.arc.ase.jpf.jvm.*;
import de.fub.bytecode.generic.InstructionHandle;
import gov.nasa.arc.ase.util.Debug;
import de.fub.bytecode.Constants;

public class Reflection implements Cloneable, Constants {
  protected int objref;
  protected int classref;
  protected SystemState ss;
  protected KernelState ks;
  protected ThreadInfo th;
  protected DynamicArea da;
  protected StaticArea sa;
  protected ClassInfo ci;

  public long callMethod(String name, int[] args) {
    MethodInfo mi = ci.getMethodInfo(name);

    if(mi.getClassInfo() != ci)
      return ci.callMethod(ss, ks, th, name, args);

    for(int i = 0, s = args.length; i < s; i++)
      th.push(args[i]);

    InstructionHandle pc = th.getPC();
    executeMethod(mi, true);
    th.setPC(pc);

    switch(mi.getMethodGen().getReturnType().getType()) {
      case T_BOOLEAN:
      case T_BYTE:
      case T_CHAR:
      case T_FLOAT:
      case T_INT:
      case T_REFERENCE:
      case T_SHORT:
    return (long)th.pop();

      case T_DOUBLE:
      case T_LONG:
    return th.pop2();
    }

    return 0;
  }  
  public long callStaticMethod(String name, int[] args) {
    MethodInfo mi = ci.getMethodInfo(name);

    for(int i = 0, s = args.length; i < s; i++)
      th.push(args[i]);

    InstructionHandle pc = th.getPC();
    executeStaticMethod(mi, true);
    th.setPC(pc);

    switch(mi.getMethodGen().getReturnType().getType()) {
      case T_BOOLEAN:
      case T_BYTE:
      case T_CHAR:
      case T_FLOAT:
      case T_INT:
      case T_REFERENCE:
      case T_SHORT:
    return (long)th.pop();

      case T_DOUBLE:
      case T_LONG:
    return th.pop2();
    }

    return 0;
  }  
  public Object clone() {
    try {
      return super.clone();
    } catch(CloneNotSupportedException e) {
      e.printStackTrace();
      System.exit(128);
    }

    return null;
  }  
  public InstructionHandle executeMethod(MethodInfo mi, boolean atomic) {
    if(mi.getMethodGen().isNative()) {
      throw new NativeMethodException(mi.getFullName());
    }

    if(mi.getMethodGen().isSynchronized())
      if(!da.monitorLock(objref, th))
    return th.getPC();

    if(atomic) 
      th.executeAtomicMethod();

    return th.getPC();
  }  
  public InstructionHandle executeStaticMethod(MethodInfo mi, boolean atomic) {
    if(mi.getMethodGen().isNative()) {
      throw new NativeMethodException(mi.getFullName());
    }

    if(mi.getMethodGen().isSynchronized())
      if(!sa.monitorLock(classref, th))
    return th.getPC();

    if(atomic) 
      th.executeAtomicMethod();

    return th.getPC();
  }  
// ifdef INITIALIZE



//#endif INITIALIZE

  protected InstructionHandle exit() {
    MethodInfo mi = th.getCurrentMethod();
    th.popFrame();
    th.removeArguments(mi);

    return th.getPC().getNext();
  }  
  protected InstructionHandle exit(int retval) {
    MethodInfo mi = th.getCurrentMethod();
    th.popFrame();
    th.removeArguments(mi);
    th.push(retval);

    return th.getPC().getNext();
  }  
  protected InstructionHandle exit2(long retval) {
    MethodInfo mi = th.getCurrentMethod();
    th.popFrame();
    th.removeArguments(mi);
    th.push2(retval);

    return th.getPC().getNext();
  }  
  protected InstructionHandle exitRef(int retval) {
    MethodInfo mi = th.getCurrentMethod();
    th.popFrame();
    th.removeArguments(mi);
    th.push(retval);
// ifdef MARK_N_SWEEP
    th.setOperandRef();
//#endif MARK_N_SWEEP

    return th.getPC().getNext();
  }  
  public long getField(String name) { return da.getValue(objref, name); }  
  public int getObjectReference() {
    return objref;
  }  
  public long getStaticField(String name) { return sa.getValue(classref, name); }  
  public boolean isMethodDeterministic(MethodInfo mi) {
    return true;
  }  
  public boolean isMethodExecutable(MethodInfo mi) {
    if(mi.getMethodGen().isSynchronized())
      return da.monitorCheckLock(objref, th);

    return true;
  }  
  public boolean isStaticMethodDeterministic(MethodInfo mi) {
    return true;
  }  
  public boolean isStaticMethodExecutable(MethodInfo mi) {
    if(mi.getMethodGen().isSynchronized())
      return sa.monitorCheckLock(classref, th);

    return true;
  }  
  protected InstructionHandle repeat() {
    th.popFrame();

    return th.getPC();
  }  
  public void setClassInfo(ClassInfo c) {
    ci = c;
  }  
  public void setClassRef(int c) {
    classref = c;
  }  
  public void setField(String name, long value) { da.setValue(objref, name, value); }  
  public void setObjectReference(int o) {
    objref = o;
  }  
  public void setState(SystemState s, KernelState k, ThreadInfo t) {
    ss = s;
    ks = k;
    th = t;
    da = ks.dynamic_area;
    sa = ks.static_area;
  }  
  public void setStaticField(String name, long value) { sa.setValue(classref, name, value); }  
}

---