---

ThreadList.java

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

/**
 * Contains the list of the threads.
 * It extends the storage interface.
 */
public class ThreadList implements Storable {
  /**
   * The threads.
   */
  private ThreadInfo[] threads;

  /**
   * Reference of the kernel state this dynamic area is in.
   */
  public KernelState ks;

  /**
   * Creates a new empty thread list.
   */
  public ThreadList(KernelState ks) {
    this.ks = ks;
    threads = new ThreadInfo[0];
  }  
  public ThreadList(ThreadList tl) {
    int l = tl.threads.length;
    threads = new ThreadInfo[l];
    for(int i = 0; i < l; i++) {
      threads[i] = (ThreadInfo)tl.threads[i].clone();
      threads[i].list = this;
      threads[i].index = i;
    }
    ks = null;
  }  
  /**
   * Adds a new thread to the list.
   */
  public void add(int index, ThreadInfo th) {
    th.list = this;
    th.index = index;

    if(index >= threads.length) {
      ThreadInfo[] n = new ThreadInfo[index+1];
      System.arraycopy(threads, 0, n, 0, threads.length);
      threads = n;
    }

    threads[index] = th;
    ks.data = null;
  }  
  public boolean anyAliveThread() {
    for(int i = 0, l = threads.length; i < l; i++)
      if(threads[i].isAlive()) return true;

    return false;
  }  
  /**
   * Restores the state.
   */
  public void backtrackTo(ArrayOffset storing, Object backtrack) {
    Object[] b = (Object[])backtrack;

    int length = storing.get();
    int l = threads.length;

    if(l != length) {
      if(l > length) l = length;

      ThreadInfo[] n = new ThreadInfo[length];
      System.arraycopy(threads, 0, n, 0, l);
      threads = n;
    }

    for(int i = 0; i < length; i++) {
      ThreadInfo th = threads[i];

      if(storing.peek() != -1) {
    if(th == null) {
      th = threads[i] = new ThreadInfo();
      th.list = this;
      th.index = i;
    }

    th.backtrackTo(storing, b[i]);
      } else {
    threads[i] = null;
    storing.get();
      }
    }
  }  
  public Object clone() {
    return new ThreadList(this);
  }  
  /**
   * Returns a specific thread.
   */
  public ThreadInfo get(int index) {
    return threads[index];
  }  
  /**
   * Returns the data used for restoring the state.
   */
  public Object getBacktrackData() {
    int length = threads.length;

    Object[] data = new Object[length];

    for(int i = 0; i < length; i++)
      if(threads[i] != null)
    data[i] = threads[i].getBacktrackData();
      else
    data[i] = null;

    return data;
  }  
  /**
   * Returns the data used for storing the state.
   */
  public int[] getStoringData() {
    int length = threads.length;

    int size = 0;
    int[][] threadData = new int[length][];
    
    for(int i = 0; i < length; i++)
      if(threads[i] != null)
    size += (threadData[i] = threads[i].getStoringData()).length;
      else {
    threadData[i] = null;
    size++;
      }

    int[] data = new int[size + 1];
    data[0] = length;

    for(int i = 0, j = 1; i < length; i++) {
      if(threadData[i] != null) {
    int[] d = threadData[i];
    int s = d.length;

    System.arraycopy(d, 0, data, j, s);
    j += s;
      } else {
    data[j] = -1;
    size++;
    j++;
      }
    }

    return data;
  }  
  /**
   * Returns the length of the list.
   */
  public int length() {
    return threads.length;
  }  
//#endif MARK_N_SWEEP

  public ThreadInfo locate(int objref) {
    for(int i = 0, l = threads.length; i < l; i++)
      if(threads[i].getObjectReference() == objref)
    return threads[i];

    return null;
  }  
//#ifdef MARK_N_SWEEP
  public void mark() {
    for(int i = 0, l = threads.length; i < l; i++)
      threads[i].mark();
  }  
  /**
   * Removes a thread from the list.
   */
  public void remove(int index) {
    threads[index].list = null;
    threads[index].index = -1;
    threads[index] = null;
    ks.data = null;
  }  
}

---