---

Fields.java

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

import de.fub.bytecode.*;
import de.fub.bytecode.classfile.*;
import de.fub.bytecode.generic.*;
import gov.nasa.arc.ase.jpf.*;
import gov.nasa.arc.ase.util.Debug;
import gov.nasa.arc.ase.util.HashData;
import java.io.*;
import java.util.*;
//#ifdef MARK_N_SWEEP || REFERENCE_COUNT
import gov.nasa.arc.ase.util.BSet;
//#endif MARK_N_SWEEP || REFERENCE_COUNT

/**
 * Represents the fields of an object or class.
 */
public class Fields {
  /**
   * Type of the object or class.
   */
  private String type;

  /**
   * Reference to the class information.
   */
  private ClassInfo ci;

  /**
   * Set of values.
   */
  private int[] values;

  /**
   * The number of fields.
   */
  private int nFields;

  /**
   * Set to true if the fields belong to a class.
   */
  private boolean isClass;

//#ifdef MARK_N_SWEEP || REFERENCE_COUNT

  /**
   * Keeps track of which values are references.
   */
  //** warning: should keep one for each class.             **//
  BSet vRefs;
  
//#endif MARK_N_SWEEP || REFERENCE_COUNT

  /**
   * Creates a new empty fields object. Used by clone.
   */
  private Fields() {
  }  
  /**
   * Creates a new field object.
   */
  public Fields(String t,
      ClassInfo c,
      int size,
      int nf,
      boolean ic
//#ifdef MARK_N_SWEEP || REFERENCE_COUNT
      , BSet v
//#endif MARK_N_SWEEP || REFERENCE_COUNT
      ) {
    type = t;
    ci = c;
    values = new int[size];
    nFields = nf;
    isClass = ic;
//#ifdef MARK_N_SWEEP || REFERENCE_COUNT
    vRefs = v;
//#endif MARK_N_SWEEP || REFERENCE_COUNT
    initFields();
  }  
  /**
   * Creates a clone.
   */
  public Object clone() {
    Fields f = new Fields();

    f.type = type;
    f.ci = ci;
    f.values = new int[values.length];
    System.arraycopy(values, 0, f.values, 0, values.length);
    f.nFields = nFields;
    f.isClass = isClass;
//#ifdef MARK_N_SWEEP || REFERENCE_COUNT
    f.vRefs = vRefs;
//#endif MARK_N_SWEEP || REFERENCE_COUNT
    
    return f;
  }  
  /**
   * Number of fields.
   */
  public int countFields() {
    return nFields;
  }  
  /**
   * Checks for equality.
   */
  public boolean equals(Object o) {
    if(o == null) return false;
    if(!(o instanceof Fields)) return false;

    Fields f = (Fields)o;

    if(!type.equals(f.type)) return false;
    if(ci != f.ci) return false;
    if(nFields != f.nFields) return false;
    if(isClass != f.isClass) return false;
    
    int[] v1 = values;
    int[] v2 = f.values;
    int l = v1.length;

    if(l != v2.length) return false;

    for(int i = 0; i < l; i++)
      if(v1[i] != v2[i]) return false;

//#ifdef MARK_N_SWEEP || REFERENCE_COUNT
//    if(!vRefs.equals(f.vRefs))
//      return false;
//#endif MARK_N_SWEEP || REFERENCE_COUNT

    return true;
  }  
  public int findex(String fname) {
    if(isClass)
      return ci.staticFieldIndex(fname);
    else
      return ci.dynamicFieldIndex(fname);
  }  
  /**
   * Returns a reference to the class information.
   */
  public ClassInfo getClassInfo() {
    return ci;
  }  
  /**
   * Gets the value of a field.
   */
  public int getField(int index) { return values[index]; }  
//#endif MARK_N_SWEEP

  /**
   * Gets the value of a field.
   */
  public int getField(String fname) {
    return getField(findex(fname));
  }  
//#endif MARK_N_SWEEP || REFERENCE_COUNT

  /**
   * Returns the name of the field.
   */
  public String getFieldName(int index) {
    if(isArray())
      return Integer.toString(index / Types.getTypeSize(Types.getArrayElementType(type)));
    else
      if(isClass)
    return ci.getStaticField(index).getName();
      else
    return ci.getDynamicField(index).getName();
  }  
  public String getFieldType(int findex) {
    if(isArray())
      return type.substring(1);
    else
      if(isClass)
    return ci.getStaticField(findex).getType();
      else
    return ci.getDynamicField(findex).getType();
  }  
  public String getFieldType(String fname) {
    return getFieldType(findex(fname));
  }  
  public long getLongField(int index) {
    return Types.intsToLong(values[index+1], values[index]);
  }  
  public long getLongField(String fname) {
    return getLongField(findex(fname));
  }  
  /**
   * Returns the type of the object or class associated with the fields.
   */
  public String getType() {
    return type;
  }  
  /**
   * Adds some data to the computation of an hashcode.
   */
  public void hash(HashData hd) {
    for(int i = 0, s = values.length; i < s; i++)
      hd.add(values[i]);
  }  
  /**
   * Computes an hash code.
   */
  public int hashCode() {
    HashData hd = new HashData();

    hash(hd);

    return hd.getValue();
  }  
  private void initFields() {
    for(int i = 0; i < values.length; ) {
      String t = getFieldType(i);
      switch(Types.getBaseType(t)) {
    case Types.T_CHAR:
    case Types.T_FLOAT:
    case Types.T_BYTE:
    case Types.T_INT:
    case Types.T_SHORT:
    case Types.T_BOOLEAN:
      values[i] = 0;
      break;

    case Types.T_DOUBLE:
    case Types.T_LONG:
      values[i] = 0;
      values[i+1] = 0;
      break;
      
    case Types.T_ARRAY:
    case Types.T_REFERENCE:
      values[i] = -1;
      break;
      }
      i += Types.getTypeSize(t);
    }
  }  
  /**
   * Returns true if the fields belong to an array.
   */
  public boolean isArray() {
    return Types.getBaseType(type) == Types.T_ARRAY;
  }  
  /**
   * Returns true if the fields belong to a class.
   */
  public boolean isClass() {
    return isClass;
  }  
  /**
   * Returns true if a field contains a reference.
   */
  public boolean isRef(int index) {
    return vRefs.get(index);
  }  
//#ifdef REFERENCE_COUNT












//#endif REFERENCE_COUNT

//#ifdef MARK_N_SWEEP || REFERENCE_COUNT

  /**
   * Returns true if a field contains a reference.
   */
  public boolean isRef(String fname) {
    return isRef(findex(fname));
  }  
  /**
   * Logs the content of the fields object.
   */
  public void log(int ref) {
    Debug.print(Debug.MESSAGE, "  ");
    if(isClass())
      Debug.print(Debug.MESSAGE, "@");
    else
      Debug.print(Debug.MESSAGE, "#");
    Debug.println(Debug.MESSAGE, ref + " " + Types.getTypeName(type) + "("+type+")");
    for(int i = 0; i < values.length; ) {
      Debug.print(Debug.MESSAGE, "    " + getFieldName(i)  + ":");

      String t = getFieldType(i);
      Debug.print(Debug.MESSAGE, "(" + Types.getTypeName(t) + ")");
      switch(Types.getBaseType(t)) {
    case Types.T_CHAR:
      Debug.println(Debug.MESSAGE, new Character((char)getField(i)).toString());
      break;

    case Types.T_DOUBLE:
      Debug.println(Debug.MESSAGE, Double.toString(Types.longToDouble(getLongField(i))));
      break;
      
    case Types.T_FLOAT:
      Debug.println(Debug.MESSAGE, Float.toString(Types.intToFloat(getField(i))));
      break;
      
    case Types.T_BYTE:
    case Types.T_INT:
    case Types.T_SHORT:
      Debug.println(Debug.MESSAGE, Integer.toString(getField(i)));
      break;
      
    case Types.T_LONG:
      Debug.println(Debug.MESSAGE, Long.toString(getLongField(i)));
      break;
      
    case Types.T_BOOLEAN:
      Debug.println(Debug.MESSAGE, new Boolean(Types.intToBoolean(getField(i))).toString());
      break;

    case Types.T_ARRAY:
    case Types.T_REFERENCE:
      Debug.println(Debug.MESSAGE, "#" + values[i]);
      break;
      }
      i += Types.getTypeSize(t);
    }
  }  
//#ifdef MARK_N_SWEEP

  /**
   * Marks all the references contained in the fields of an object.
   */
  //** warning: it might not work for arrays of references.     **//
  public void mark(DynamicArea da) {
    for(int i = 0, l = values.length; i < l; i++)
      if(vRefs.get(i))
    da.mark(values[i]);
  }  
  /**
   * Sets the value of a field.
   */
  public void setField(int index, int value) {
//#ifdef MARK_N_SWEEP
    if(vRefs.get(index)
    && values[index] != -1
    && values[index] != value)
      VirtualMachine.getSS().activateGC();
//#endif MARK_N_SWEEP

//#ifdef REFERENCE_COUNT





//#endif REFERENCE_COUNT

    values[index] = value;
  }  
  /**
   * Sets the value of a field.
   */
  public void setField(String fname, int value) {
    setField(findex(fname), value);
  }  
  public void setLongField(int index, long value) {
    setField(index, Types.hiLong(value));
    setField(index+1, Types.loLong(value));
  }  
  public void setLongField(String fname, long value) {
    setLongField(findex(fname), value);
  }  
  /**
   * Size of the fields.
   */
  public int size() {
    return values.length;
  }  
  public String toString() {
    StringBuffer sb = new StringBuffer();
    sb.append("Fields(");

    sb.append("type=");
    sb.append(type);
    sb.append(",");

    sb.append("ci=");
    sb.append(ci.getName());
    sb.append(",");

    sb.append("values=");
    sb.append('[');
    for(int i = 0; i < values.length; i++) {
      if(i != 0)
    sb.append(',');
      sb.append(values[i]);
    }
    sb.append(']');
    sb.append(",");

    sb.append("nFields=");
    sb.append(nFields);
    sb.append(",");

    sb.append("isClass=");
    sb.append(isClass);
    sb.append(",");

//#ifdef MARK_N_SWEEP || REFERENCE_COUNT
    sb.append("vRefs=");
    sb.append(vRefs);
//#endif MARK_N_SWEEP || REFERENCE_COUNT

    sb.append(")");

    return sb.toString();
  }  
}

---