Beispiel #1
0
 public Block(int numInputs, Collection<Entry> stmts) {
   this.stmts = new ArrayList<Entry>();
   for (Entry s : stmts) {
     append(s.code, s.attributes());
   }
   this.numInputs = numInputs;
 }
Beispiel #2
0
  /**
   * Import an external block into this one, using a given <i>binding</i>. The binding indicates how
   * the input variables for the external block should be mapped into the variables of this block.
   *
   * <p>
   *
   * <p>Every input variable in the block must be bound to something in the binding. Otherwise, an
   * IllegalArgumentException is raised. In the case of an input bound to a slot >= numSlots(), then
   * the number of slots is increased automatically. <b>NOTE:</b> temporary variables used in the
   * external block will be mapped automatically to unused slots in this environment to prevent
   * collisions. Therefore, temporary variables should not be specified in the binding.
   */
  public void importExternal(Block block, Map<Integer, Integer> binding) {
    int freeSlot = numSlots();

    // First, sanity check that all input variables are bound
    HashMap<Integer, Integer> nbinding = new HashMap<Integer, Integer>();
    for (int i = 0; i != block.numInputs; ++i) {
      Integer target = binding.get(i);
      if (target == null) {
        throw new IllegalArgumentException("Input not mapped by input");
      }
      nbinding.put(i, target);
      freeSlot = Math.max(target + 1, freeSlot);
    }

    // Second, determine binding for temporary variables
    for (int i = block.numInputs; i != block.numSlots(); ++i) {
      nbinding.put(i, i + freeSlot);
    }

    // Third, determine relabelling
    HashMap<String, String> labels = new HashMap<String, String>();

    for (Entry s : block) {
      if (s.code instanceof Code.Label) {
        Code.Label l = (Code.Label) s.code;
        labels.put(l.label, freshLabel());
      }
    }

    // Finally, apply the binding and relabel any labels as well.
    for (Entry s : block) {
      Code ncode = s.code.remap(nbinding).relabel(labels);
      append(ncode, s.attributes());
    }
  }
Beispiel #3
0
  public Block relabel() {
    HashMap<String, String> labels = new HashMap<String, String>();

    for (Entry s : this) {
      if (s.code instanceof Code.Label) {
        Code.Label l = (Code.Label) s.code;
        labels.put(l.label, freshLabel());
      }
    }

    Block block = new Block(numInputs);
    // Finally, apply the binding and relabel any labels as well.
    for (Entry s : this) {
      Code ncode = s.code.relabel(labels);
      block.append(ncode, s.attributes());
    }

    return block;
  }
Beispiel #4
0
 /**
  * Insert a block at a given position in this block. It is assumed that the bytecode employs the
  * same environment as this block. The bytecode at the given position (and any after it) are
  * shifted one or more positions down.
  *
  * @param index --- position to insert block at.
  * @param block --- block to insert.
  */
 public void insert(int index, Block block) {
   for (Entry s : block) {
     insert(index++, s.code, s.attributes());
   }
 }
Beispiel #5
0
 /**
  * Append another block onto the end of this block. It is assumed that the block in question
  * employs the same environment.
  *
  * <p><b>NOTE</b>In the case of the block being appended having more input variables, it is
  * assumed those additional ones correspond to temporaries in this block.
  *
  * @param block --- block to append
  */
 public void append(Block block) {
   for (Entry s : block) {
     append(s.code, s.attributes());
   }
 }