jdk-sandbox: comparison jaxp/src/java.xml/share/classes/com/sun/org/apache/bcel/internal/generic/InstructionList.java

equal deleted inserted replaced

-:5546b5710844
+:5611d2529b49
 /*
-* reserved comment block
+* Copyright (c) 2017, Oracle and/or its affiliates. All rights reserved.
-* DO NOT REMOVE OR ALTER!
 */
 /*
 * Licensed to the Apache Software Foundation (ASF) under one or more
 * contributor license agreements.  See the NOTICE file distributed with
 * this work for additional information regarding copyright ownership.
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
 package com.sun.org.apache.bcel.internal.generic;
+import com.sun.org.apache.bcel.internal.Const;
-import com.sun.org.apache.bcel.internal.Constants;
 import com.sun.org.apache.bcel.internal.classfile.Constant;
 import com.sun.org.apache.bcel.internal.util.ByteSequence;
-import java.io.*;
+import java.io.ByteArrayOutputStream;
+import java.io.DataOutputStream;
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.HashMap;
 import java.util.Iterator;
-import java.util.HashMap;
+import java.util.List;
-import java.util.ArrayList;
+import java.util.Map;
+import java.util.NoSuchElementException;
 /**
 * This class is a container for a list of <a
-* href="Instruction.html">Instruction</a> objects. Instructions can
+* href="Instruction.html">Instruction</a> objects. Instructions can be
-* be appended, inserted, moved, deleted, etc.. Instructions are being
+* appended, inserted, moved, deleted, etc.. Instructions are being wrapped into
-* wrapped into <a
+* <a href="InstructionHandle.html">InstructionHandles</a> objects that are
-* href="InstructionHandle.html">InstructionHandles</a> objects that
+* returned upon append/insert operations. They give the user (read only) access
-* are returned upon append/insert operations. They give the user
+* to the list structure, such that it can be traversed and manipulated in a
-* (read only) access to the list structure, such that it can be traversed and
+* controlled way.
-* manipulated in a controlled way.
 *
 * A list is finally dumped to a byte code array with <a
 * href="#getByteCode()">getByteCode</a>.
 *
-* @author  <A HREF="mailto:markus.dahm@berlin.de">M. Dahm</A>
+* @version $Id: InstructionList.java 1749603 2016-06-21 20:50:19Z ggregory $
-* @see     Instruction
+* @see Instruction
-* @see     InstructionHandle
+* @see InstructionHandle
 * @see BranchHandle
 */
-public class InstructionList implements Serializable {
+public class InstructionList implements Iterable<InstructionHandle> {
-private InstructionHandle start  = null, end = null;
+private InstructionHandle start = null;
-private int               length = 0; // number of elements in list
+private InstructionHandle end = null;
-private int[]             byte_positions; // byte code offsets corresponding to instructions
+private int length = 0; // number of elements in list
+private int[] byte_positions; // byte code offsets corresponding to instructions
-/**
-* Create (empty) instruction list.
+/**
-*/
+* Create (empty) instruction list.
-public InstructionList() {}
+*/
+public InstructionList() {
-/**
+}
-* Create instruction list containing one instruction.
-* @param i initial instruction
+/**
-*/
+* Create instruction list containing one instruction.
-public InstructionList(Instruction i) {
+*
-append(i);
+* @param i initial instruction
-}
+*/
+public InstructionList(final Instruction i) {
-/**
+append(i);
-* Create instruction list containing one instruction.
+}
-* @param i initial instruction
-*/
+/**
-public InstructionList(BranchInstruction i) {
+* Create instruction list containing one instruction.
-append(i);
+*
-}
+* @param i initial instruction
+*/
-/**
+public InstructionList(final BranchInstruction i) {
-* Initialize list with (nonnull) compound instruction. Consumes argument
+append(i);
-* list, i.e., it becomes empty.
+}
-*
-* @param c compound instruction (list)
+/**
-*/
+* Initialize list with (nonnull) compound instruction. Consumes argument
-public InstructionList(CompoundInstruction c) {
+* list, i.e., it becomes empty.
-append(c.getInstructionList());
+*
-}
+* @param c compound instruction (list)
+*/
-/**
+public InstructionList(final CompoundInstruction c) {
-* Test for empty list.
+append(c.getInstructionList());
-*/
+}
-public boolean isEmpty() { return start == null; } // && end == null
+/**
-/**
+* Test for empty list.
-* Find the target instruction (handle) that corresponds to the given target
+*/
-* position (byte code offset).
+public boolean isEmpty() {
-*
+return start == null;
-* @param ihs array of instruction handles, i.e. il.getInstructionHandles()
+} // && end == null
-* @param pos array of positions corresponding to ihs, i.e. il.getInstructionPositions()
-* @param count length of arrays
+/**
-* @param target target position to search for
+* Find the target instruction (handle) that corresponds to the given target
-* @return target position's instruction handle if available
+* position (byte code offset).
-*/
+*
-public static InstructionHandle findHandle(InstructionHandle[] ihs,
+* @param ihs array of instruction handles, i.e. il.getInstructionHandles()
-int[] pos, int count,
+* @param pos array of positions corresponding to ihs, i.e.
-int target) {
+* il.getInstructionPositions()
-int l=0, r = count - 1;
+* @param count length of arrays
+* @param target target position to search for
-/* Do a binary search since the pos array is orderd.
+* @return target position's instruction handle if available
 */
-do {
+public static InstructionHandle findHandle(final InstructionHandle[] ihs, final int[] pos, final int count, final int target) {
-int i = (l + r) / 2;
+int l = 0;
-int j = pos[i];
+int r = count - 1;
+/*
-if(j == target) // target found
+* Do a binary search since the pos array is orderd.
-return ihs[i];
-else if(target < j) // else constrain search area
-r = i - 1;
-else // target > j
-l = i + 1;
-} while(l <= r);
-return null;
-}
-/**
-* Get instruction handle for instruction at byte code position pos.
-* This only works properly, if the list is freshly initialized from a byte array or
-* setPositions() has been called before this method.
-*
-* @param pos byte code position to search for
-* @return target position's instruction handle if available
-*/
-public InstructionHandle findHandle(int pos) {
-InstructionHandle[] ihs = getInstructionHandles();
-return findHandle(ihs, byte_positions, length, pos);
-}
-/**
-* Initialize instruction list from byte array.
-*
-* @param code byte array containing the instructions
-*/
-public InstructionList(byte[] code) {
-ByteSequence        bytes = new ByteSequence(code);
-InstructionHandle[] ihs   = new InstructionHandle[code.length];
-int[]               pos   = new int[code.length]; // Can't be more than that
-int                 count = 0; // Contains actual length
-/* Pass 1: Create an object for each byte code and append them
-* to the list.
-*/
-try {
-while(bytes.available() > 0) {
-// Remember byte offset and associate it with the instruction
-int off =  bytes.getIndex();
-pos[count] = off;
-/* Read one instruction from the byte stream, the byte position is set
-* accordingly.
 */
-Instruction       i = Instruction.readInstruction(bytes);
+do {
+final int i = (l + r) / 2;
+final int j = pos[i];
+if (j == target) {
+return ihs[i];
+} else if (target < j) {
+r = i - 1;
+} else {
+l = i + 1;
+}
+} while (l <= r);
+return null;
+}
+/**
+* Get instruction handle for instruction at byte code position pos. This
+* only works properly, if the list is freshly initialized from a byte array
+* or setPositions() has been called before this method.
+*
+* @param pos byte code position to search for
+* @return target position's instruction handle if available
+*/
+public InstructionHandle findHandle(final int pos) {
+final int[] positions = byte_positions;
+InstructionHandle ih = start;
+for (int i = 0; i < length; i++) {
+if (positions[i] == pos) {
+return ih;
+}
+ih = ih.getNext();
+}
+return null;
+}
+/**
+* Initialize instruction list from byte array.
+*
+* @param code byte array containing the instructions
+*/
+public InstructionList(final byte[] code) {
+int count = 0; // Contains actual length
+int[] pos;
+InstructionHandle[] ihs;
+try (ByteSequence bytes = new ByteSequence(code)) {
+ihs = new InstructionHandle[code.length];
+pos = new int[code.length]; // Can't be more than that
+/*
+* Pass 1: Create an object for each byte code and append them to the list.
+*/
+while (bytes.available() > 0) {
+// Remember byte offset and associate it with the instruction
+final int off = bytes.getIndex();
+pos[count] = off;
+/*
+* Read one instruction from the byte stream, the byte position is set accordingly.
+*/
+final Instruction i = Instruction.readInstruction(bytes);
+InstructionHandle ih;
+if (i instanceof BranchInstruction) {
+ih = append((BranchInstruction) i);
+} else {
+ih = append(i);
+}
+ih.setPosition(off);
+ihs[count] = ih;
+count++;
+}
+} catch (final IOException e) {
+throw new ClassGenException(e.toString(), e);
+}
+byte_positions = new int[count]; // Trim to proper size
+System.arraycopy(pos, 0, byte_positions, 0, count);
+/*
+* Pass 2: Look for BranchInstruction and update their targets, i.e., convert offsets to instruction handles.
+*/
+for (int i = 0; i < count; i++) {
+if (ihs[i] instanceof BranchHandle) {
+final BranchInstruction bi = (BranchInstruction) ihs[i].getInstruction();
+int target = bi.getPosition() + bi.getIndex(); /*
+* Byte code position: relative -> absolute.
+*/
+// Search for target position
+InstructionHandle ih = findHandle(ihs, pos, count, target);
+if (ih == null) {
+throw new ClassGenException("Couldn't find target for branch: " + bi);
+}
+bi.setTarget(ih); // Update target
+// If it is a Select instruction, update all branch targets
+if (bi instanceof Select) { // Either LOOKUPSWITCH or TABLESWITCH
+final Select s = (Select) bi;
+final int[] indices = s.getIndices();
+for (int j = 0; j < indices.length; j++) {
+target = bi.getPosition() + indices[j];
+ih = findHandle(ihs, pos, count, target);
+if (ih == null) {
+throw new ClassGenException("Couldn't find target for switch: " + bi);
+}
+s.setTarget(j, ih); // Update target
+}
+}
+}
+}
+}
+/**
+* Append another list after instruction (handle) ih contained in this list.
+* Consumes argument list, i.e., it becomes empty.
+*
+* @param ih where to append the instruction list
+* @param il Instruction list to append to this one
+* @return instruction handle pointing to the <B>first</B> appended
+* instruction
+*/
+public InstructionHandle append(final InstructionHandle ih, final InstructionList il) {
+if (il == null) {
+throw new ClassGenException("Appending null InstructionList");
+}
+if (il.isEmpty()) {
+return ih;
+}
+final InstructionHandle next = ih.getNext();
+final InstructionHandle ret = il.start;
+ih.setNext(il.start);
+il.start.setPrev(ih);
+il.end.setNext(next);
+if (next != null) {
+next.setPrev(il.end);
+} else {
+end = il.end; // Update end ...
+}
+length += il.length; // Update length
+il.clear();
+return ret;
+}
+/**
+* Append another list after instruction i contained in this list. Consumes
+* argument list, i.e., it becomes empty.
+*
+* @param i where to append the instruction list
+* @param il Instruction list to append to this one
+* @return instruction handle pointing to the <B>first</B> appended
+* instruction
+*/
+public InstructionHandle append(final Instruction i, final InstructionList il) {
 InstructionHandle ih;
-if(i instanceof BranchInstruction) // Use proper append() method
+if ((ih = findInstruction2(i)) == null) {
-ih = append((BranchInstruction)i);
+throw new ClassGenException("Instruction " + i + " is not contained in this list.");
-else
+}
-ih = append(i);
+return append(ih, il);
+}
-ih.setPosition(off);
-ihs[count] = ih;
+/**
+* Append another list to this one. Consumes argument list, i.e., it becomes
-count++;
+* empty.
-}
+*
-} catch(IOException e) { throw new ClassGenException(e.toString()); }
+* @param il list to append to end of this list
+* @return instruction handle of the <B>first</B> appended instruction
-byte_positions = new int[count]; // Trim to proper size
+*/
-System.arraycopy(pos, 0, byte_positions, 0, count);
+public InstructionHandle append(final InstructionList il) {
+if (il == null) {
-/* Pass 2: Look for BranchInstruction and update their targets, i.e.,
+throw new ClassGenException("Appending null InstructionList");
-* convert offsets to instruction handles.
+}
-*/
+if (il.isEmpty()) {
-for(int i=0; i < count; i++) {
+return null;
-if(ihs[i] instanceof BranchHandle) {
+}
-BranchInstruction bi = (BranchInstruction)ihs[i].instruction;
+if (isEmpty()) {
-int target = bi.position + bi.getIndex(); /* Byte code position:
+start = il.start;
-* relative -> absolute. */
+end = il.end;
-// Search for target position
+length = il.length;
-InstructionHandle ih = findHandle(ihs, pos, count, target);
+il.clear();
+return start;
-if(ih == null) // Search failed
+}
-throw new ClassGenException("Couldn't find target for branch: " + bi);
+return append(end, il); // was end.instruction
+}
-bi.setTarget(ih); // Update target
+/**
-// If it is a Select instruction, update all branch targets
+* Append an instruction to the end of this list.
-if(bi instanceof Select) { // Either LOOKUPSWITCH or TABLESWITCH
+*
-Select s       = (Select)bi;
+* @param ih instruction to append
-int[]  indices = s.getIndices();
+*/
+private void append(final InstructionHandle ih) {
-for(int j=0; j < indices.length; j++) {
+if (isEmpty()) {
-target = bi.position + indices[j];
+start = end = ih;
-ih     = findHandle(ihs, pos, count, target);
+ih.setNext(ih.setPrev(null));
+} else {
-if(ih == null) // Search failed
+end.setNext(ih);
-throw new ClassGenException("Couldn't find target for switch: " + bi);
+ih.setPrev(end);
+ih.setNext(null);
-s.setTarget(j, ih); // Update target
+end = ih;
 }
-}
-}
+length++; // Update length
 }
-}
+/**
-/**
+* Append an instruction to the end of this list.
-* Append another list after instruction (handle) ih contained in this list.
+*
-* Consumes argument list, i.e., it becomes empty.
+* @param i instruction to append
-*
+* @return instruction handle of the appended instruction
-* @param ih where to append the instruction list
+*/
-* @param il Instruction list to append to this one
+public InstructionHandle append(final Instruction i) {
-* @return instruction handle pointing to the <B>first</B> appended instruction
+final InstructionHandle ih = InstructionHandle.getInstructionHandle(i);
-*/
+append(ih);
-public InstructionHandle append(InstructionHandle ih, InstructionList il) {
-if(il == null)
-throw new ClassGenException("Appending null InstructionList");
-if(il.isEmpty()) // Nothing to do
-return ih;
-InstructionHandle next = ih.next, ret = il.start;
-ih.next = il.start;
-il.start.prev = ih;
-il.end.next = next;
-if(next != null) // i == end ?
-next.prev = il.end;
-else
-end = il.end; // Update end ...
-length += il.length; // Update length
-il.clear();
-return ret;
-}
-/**
-* Append another list after instruction i contained in this list.
-* Consumes argument list, i.e., it becomes empty.
-*
-* @param i  where to append the instruction list
-* @param il Instruction list to append to this one
-* @return instruction handle pointing to the <B>first</B> appended instruction
-*/
-public InstructionHandle append(Instruction i, InstructionList il) {
-InstructionHandle ih;
-if((ih = findInstruction2(i)) == null) // Also applies for empty list
-throw new ClassGenException("Instruction " + i +
-" is not contained in this list.");
-return append(ih, il);
-}
-/**
-* Append another list to this one.
-* Consumes argument list, i.e., it becomes empty.
-*
-* @param il list to append to end of this list
-* @return instruction handle of the <B>first</B> appended instruction
-*/
-public InstructionHandle append(InstructionList il) {
-if(il == null)
-throw new ClassGenException("Appending null InstructionList");
-if(il.isEmpty()) // Nothing to do
-return null;
-if(isEmpty()) {
-start  = il.start;
-end    = il.end;
-length = il.length;
-il.clear();
-return start;
-} else
-return append(end, il);  // was end.instruction
-}
-/**
-* Append an instruction to the end of this list.
-*
-* @param ih instruction to append
-*/
-private void append(InstructionHandle ih) {
-if(isEmpty()) {
-start = end = ih;
-ih.next = ih.prev = null;
-}
-else {
-end.next = ih;
-ih.prev  = end;
-ih.next  = null;
-end      = ih;
-}
-length++; // Update length
-}
-/**
-* Append an instruction to the end of this list.
-*
-* @param i instruction to append
-* @return instruction handle of the appended instruction
-*/
-public InstructionHandle append(Instruction i) {
-InstructionHandle ih = InstructionHandle.getInstructionHandle(i);
-append(ih);
-return ih;
-}
-/**
-* Append a branch instruction to the end of this list.
-*
-* @param i branch instruction to append
-* @return branch instruction handle of the appended instruction
-*/
-public BranchHandle append(BranchInstruction i) {
-BranchHandle ih = BranchHandle.getBranchHandle(i);
-append(ih);
-return ih;
-}
-/**
-* Append a single instruction j after another instruction i, which
-* must be in this list of course!
-*
-* @param i Instruction in list
-* @param j Instruction to append after i in list
-* @return instruction handle of the first appended instruction
-*/
-public InstructionHandle append(Instruction i, Instruction j) {
-return append(i, new InstructionList(j));
-}
-/**
-* Append a compound instruction, after instruction i.
-*
-* @param i Instruction in list
-* @param c The composite instruction (containing an InstructionList)
-* @return instruction handle of the first appended instruction
-*/
-public InstructionHandle append(Instruction i, CompoundInstruction c) {
-return append(i, c.getInstructionList());
-}
-/**
-* Append a compound instruction.
-*
-* @param c The composite instruction (containing an InstructionList)
-* @return instruction handle of the first appended instruction
-*/
-public InstructionHandle append(CompoundInstruction c) {
-return append(c.getInstructionList());
-}
-/**
-* Append a compound instruction.
-*
-* @param ih where to append the instruction list
-* @param c The composite instruction (containing an InstructionList)
-* @return instruction handle of the first appended instruction
-*/
-public InstructionHandle append(InstructionHandle ih, CompoundInstruction c) {
-return append(ih, c.getInstructionList());
-}
-/**
-* Append an instruction after instruction (handle) ih contained in this list.
-*
-* @param ih where to append the instruction list
-* @param i Instruction to append
-* @return instruction handle pointing to the <B>first</B> appended instruction
-*/
-public InstructionHandle append(InstructionHandle ih, Instruction i) {
-return append(ih, new InstructionList(i));
-}
-/**
-* Append an instruction after instruction (handle) ih contained in this list.
-*
-* @param ih where to append the instruction list
-* @param i Instruction to append
-* @return instruction handle pointing to the <B>first</B> appended instruction
-*/
-public BranchHandle append(InstructionHandle ih, BranchInstruction i) {
-BranchHandle    bh = BranchHandle.getBranchHandle(i);
-InstructionList il = new InstructionList();
-il.append(bh);
-append(ih, il);
-return bh;
-}
-/**
-* Insert another list before Instruction handle ih contained in this list.
-* Consumes argument list, i.e., it becomes empty.
-*
-* @param i  where to append the instruction list
-* @param il Instruction list to insert
-* @return instruction handle of the first inserted instruction
-*/
-public InstructionHandle insert(InstructionHandle ih, InstructionList il) {
-if(il == null)
-throw new ClassGenException("Inserting null InstructionList");
-if(il.isEmpty()) // Nothing to do
-return ih;
-InstructionHandle prev = ih.prev, ret = il.start;
-ih.prev = il.end;
-il.end.next = ih;
-il.start.prev = prev;
-if(prev != null) // ih == start ?
-prev.next = il.start;
-else
-start = il.start; // Update start ...
-length += il.length; // Update length
-il.clear();
-return ret;
-}
-/**
-* Insert another list.
-*
-* @param il list to insert before start of this list
-* @return instruction handle of the first inserted instruction
-*/
-public InstructionHandle insert(InstructionList il) {
-if(isEmpty()) {
-append(il); // Code is identical for this case
-return start;
-}
-else
-return insert(start, il);
-}
-/**
-* Insert an instruction at start of this list.
-*
-* @param ih instruction to insert
-*/
-private void insert(InstructionHandle ih) {
-if(isEmpty()) {
-start = end = ih;
-ih.next = ih.prev = null;
-} else {
-start.prev = ih;
-ih.next    = start;
-ih.prev    = null;
-start      = ih;
-}
-length++;
-}
-/**
-* Insert another list before Instruction i contained in this list.
-* Consumes argument list, i.e., it becomes empty.
-*
-* @param i  where to append the instruction list
-* @param il Instruction list to insert
-* @return instruction handle pointing to the first inserted instruction,
-* i.e., il.getStart()
-*/
-public InstructionHandle insert(Instruction i, InstructionList il) {
-InstructionHandle ih;
-if((ih = findInstruction1(i)) == null)
-throw new ClassGenException("Instruction " + i +
-" is not contained in this list.");
-return insert(ih, il);
-}
-/**
-* Insert an instruction at start of this list.
-*
-* @param i instruction to insert
-* @return instruction handle of the inserted instruction
-*/
-public InstructionHandle insert(Instruction i) {
-InstructionHandle ih = InstructionHandle.getInstructionHandle(i);
-insert(ih);
-return ih;
-}
-/**
-* Insert a branch instruction at start of this list.
-*
-* @param i branch instruction to insert
-* @return branch instruction handle of the appended instruction
-*/
-public BranchHandle insert(BranchInstruction i) {
-BranchHandle ih = BranchHandle.getBranchHandle(i);
-insert(ih);
-return ih;
-}
-/**
-* Insert a single instruction j before another instruction i, which
-* must be in this list of course!
-*
-* @param i Instruction in list
-* @param j Instruction to insert before i in list
-* @return instruction handle of the first inserted instruction
-*/
-public InstructionHandle insert(Instruction i, Instruction j) {
-return insert(i, new InstructionList(j));
-}
-/**
-* Insert a compound instruction before instruction i.
-*
-* @param i Instruction in list
-* @param c The composite instruction (containing an InstructionList)
-* @return instruction handle of the first inserted instruction
-*/
-public InstructionHandle insert(Instruction i, CompoundInstruction c) {
-return insert(i, c.getInstructionList());
-}
-/**
-* Insert a compound instruction.
-*
-* @param c The composite instruction (containing an InstructionList)
-* @return instruction handle of the first inserted instruction
-*/
-public InstructionHandle insert(CompoundInstruction c) {
-return insert(c.getInstructionList());
-}
-/**
-* Insert an instruction before instruction (handle) ih contained in this list.
-*
-* @param ih where to insert to the instruction list
-* @param i Instruction to insert
-* @return instruction handle of the first inserted instruction
-*/
-public InstructionHandle insert(InstructionHandle ih, Instruction i) {
-return insert(ih, new InstructionList(i));
-}
-/**
-* Insert a compound instruction.
-*
-* @param ih where to insert the instruction list
-* @param c The composite instruction (containing an InstructionList)
-* @return instruction handle of the first inserted instruction
-*/
-public InstructionHandle insert(InstructionHandle ih, CompoundInstruction c) {
-return insert(ih, c.getInstructionList());
-}
-/**
-* Insert an instruction before instruction (handle) ih contained in this list.
-*
-* @param ih where to insert to the instruction list
-* @param i Instruction to insert
-* @return instruction handle of the first inserted instruction
-*/
-public BranchHandle insert(InstructionHandle ih, BranchInstruction i) {
-BranchHandle    bh = BranchHandle.getBranchHandle(i);
-InstructionList il = new InstructionList();
-il.append(bh);
-insert(ih, il);
-return bh;
-}
-/**
-* Take all instructions (handles) from "start" to "end" and append them after the
-* new location "target". Of course, "end" must be after "start" and target must
-* not be located withing this range. If you want to move something to the start of
-* the list use null as value for target.<br>
-* Any instruction targeters pointing to handles within the block, keep their targets.
-*
-* @param start  of moved block
-* @param end    of moved block
-* @param target of moved block
-*/
-public void move(InstructionHandle start, InstructionHandle end, InstructionHandle target) {
-// Step 1: Check constraints
-if((start == null) || (end == null))
-throw new ClassGenException("Invalid null handle: From " + start + " to " + end);
-if((target == start) || (target == end))
-throw new ClassGenException("Invalid range: From " + start + " to " + end +
-" contains target " + target);
-for(InstructionHandle ih = start; ih != end.next; ih = ih.next) {
-if(ih == null) // At end of list, end not found yet
-throw new ClassGenException("Invalid range: From " + start + " to " + end);
-else if(ih == target) // target may be null
-throw new ClassGenException("Invalid range: From " + start + " to " + end +
-" contains target " + target);
-}
-// Step 2: Temporarily remove the given instructions from the list
-InstructionHandle prev = start.prev, next = end.next;
-if(prev != null)
-prev.next = next;
-else // start == this.start!
-this.start = next;
-if(next != null)
-next.prev = prev;
-else // end == this.end!
-this.end = prev;
-start.prev = end.next = null;
-// Step 3: append after target
-if(target == null) { // append to start of list
-end.next = this.start;
-this.start = start;
-} else {
-next = target.next;
-target.next = start;
-start.prev  = target;
-end.next    = next;
-if(next != null)
-next.prev = end;
-}
-}
-/**
-* Move a single instruction (handle) to a new location.
-*
-* @param ih     moved instruction
-* @param target new location of moved instruction
-*/
-public void move(InstructionHandle ih, InstructionHandle target) {
-move(ih, ih, target);
-}
-/**
-* Remove from instruction `prev' to instruction `next' both contained
-* in this list. Throws TargetLostException when one of the removed instruction handles
-* is still being targeted.
-*
-* @param prev where to start deleting (predecessor, exclusive)
-* @param next where to end deleting (successor, exclusive)
-*/
-private void remove(InstructionHandle prev, InstructionHandle next)
-throws TargetLostException
-{
-InstructionHandle first, last; // First and last deleted instruction
-if((prev == null) && (next == null)) { // singleton list
-first = last = start;
-start = end = null;
-} else {
-if(prev == null) { // At start of list
-first = start;
-start = next;
-} else {
-first     = prev.next;
-prev.next = next;
-}
-if(next == null) { // At end of list
-last = end;
-end  = prev;
-} else {
-last      = next.prev;
-next.prev = prev;
-}
-}
-first.prev = null; // Completely separated from rest of list
-last.next  = null;
-ArrayList target_vec = new ArrayList();
-for(InstructionHandle ih=first; ih != null; ih = ih.next)
-ih.getInstruction().dispose(); // e.g. BranchInstructions release their targets
-StringBuffer buf = new StringBuffer("{ ");
-for(InstructionHandle ih=first; ih != null; ih = next) {
-next = ih.next;
-length--;
-if(ih.hasTargeters()) { // Still got targeters?
-target_vec.add(ih);
-buf.append(ih.toString(true) + " ");
-ih.next = ih.prev = null;
-} else
-ih.dispose();
-}
-buf.append("}");
-if(!target_vec.isEmpty()) {
-InstructionHandle[] targeted = new InstructionHandle[target_vec.size()];
-target_vec.toArray(targeted);
-throw new TargetLostException(targeted, buf.toString());
-}
-}
-/**
-* Remove instruction from this list. The corresponding Instruction
-* handles must not be reused!
-*
-* @param ih instruction (handle) to remove
-*/
-public void delete(InstructionHandle ih) throws TargetLostException {
-remove(ih.prev, ih.next);
-}
-/**
-* Remove instruction from this list. The corresponding Instruction
-* handles must not be reused!
-*
-* @param i instruction to remove
-*/
-public void delete(Instruction i) throws TargetLostException {
-InstructionHandle ih;
-if((ih = findInstruction1(i)) == null)
-throw new ClassGenException("Instruction " + i +
-" is not contained in this list.");
-delete(ih);
-}
-/**
-* Remove instructions from instruction `from' to instruction `to' contained
-* in this list. The user must ensure that `from' is an instruction before
-* `to', or risk havoc. The corresponding Instruction handles must not be reused!
-*
-* @param from where to start deleting (inclusive)
-* @param to   where to end deleting (inclusive)
-*/
-public void delete(InstructionHandle from, InstructionHandle to)
-throws TargetLostException
-{
-remove(from.prev, to.next);
-}
-/**
-* Remove instructions from instruction `from' to instruction `to' contained
-* in this list. The user must ensure that `from' is an instruction before
-* `to', or risk havoc. The corresponding Instruction handles must not be reused!
-*
-* @param from where to start deleting (inclusive)
-* @param to   where to end deleting (inclusive)
-*/
-public void delete(Instruction from, Instruction to) throws TargetLostException {
-InstructionHandle from_ih, to_ih;
-if((from_ih = findInstruction1(from)) == null)
-throw new ClassGenException("Instruction " + from +
-" is not contained in this list.");
-if((to_ih = findInstruction2(to)) == null)
-throw new ClassGenException("Instruction " + to +
-" is not contained in this list.");
-delete(from_ih, to_ih);
-}
-/**
-* Search for given Instruction reference, start at beginning of list.
-*
-* @param i instruction to search for
-* @return instruction found on success, null otherwise
-*/
-private InstructionHandle findInstruction1(Instruction i) {
-for(InstructionHandle ih=start; ih != null; ih = ih.next)
-if(ih.instruction == i)
 return ih;
+}
-return null;
-}
+/**
+* Append a branch instruction to the end of this list.
-/**
+*
-* Search for given Instruction reference, start at end of list
+* @param i branch instruction to append
-*
+* @return branch instruction handle of the appended instruction
-* @param i instruction to search for
+*/
-* @return instruction found on success, null otherwise
+public BranchHandle append(final BranchInstruction i) {
-*/
+final BranchHandle ih = BranchHandle.getBranchHandle(i);
-private InstructionHandle findInstruction2(Instruction i) {
+append(ih);
-for(InstructionHandle ih=end; ih != null; ih = ih.prev)
-if(ih.instruction == i)
 return ih;
+}
-return null;
-}
+/**
+* Append a single instruction j after another instruction i, which must be
-public boolean contains(InstructionHandle i) {
+* in this list of course!
-if(i == null)
+*
-return false;
+* @param i Instruction in list
+* @param j Instruction to append after i in list
-for(InstructionHandle ih=start; ih != null; ih = ih.next)
+* @return instruction handle of the first appended instruction
-if(ih == i)
+*/
-return true;
+public InstructionHandle append(final Instruction i, final Instruction j) {
+return append(i, new InstructionList(j));
-return false;
+}
-}
+/**
-public boolean contains(Instruction i) {
+* Append a compound instruction, after instruction i.
-return findInstruction1(i) != null;
+*
-}
+* @param i Instruction in list
+* @param c The composite instruction (containing an InstructionList)
-public void setPositions() {
+* @return instruction handle of the first appended instruction
-setPositions(false);
+*/
-}
+public InstructionHandle append(final Instruction i, final CompoundInstruction c) {
+return append(i, c.getInstructionList());
-/**
+}
-* Give all instructions their position number (offset in byte stream), i.e.,
-* make the list ready to be dumped.
+/**
-*
+* Append a compound instruction.
-* @param check Perform sanity checks, e.g. if all targeted instructions really belong
+*
-* to this list
+* @param c The composite instruction (containing an InstructionList)
-*/
+* @return instruction handle of the first appended instruction
-public void setPositions(boolean check) {
+*/
-int max_additional_bytes = 0, additional_bytes = 0;
+public InstructionHandle append(final CompoundInstruction c) {
-int index = 0, count = 0;
+return append(c.getInstructionList());
-int[] pos = new int[length];
+}
-/* Pass 0: Sanity checks
+/**
-*/
+* Append a compound instruction.
-if(check) {
+*
-for(InstructionHandle ih=start; ih != null; ih = ih.next) {
+* @param ih where to append the instruction list
-Instruction i = ih.instruction;
+* @param c The composite instruction (containing an InstructionList)
+* @return instruction handle of the first appended instruction
-if(i instanceof BranchInstruction) { // target instruction within list?
+*/
-Instruction inst = ((BranchInstruction)i).getTarget().instruction;
+public InstructionHandle append(final InstructionHandle ih, final CompoundInstruction c) {
-if(!contains(inst))
+return append(ih, c.getInstructionList());
-throw new ClassGenException("Branch target of " +
+}
-Constants.OPCODE_NAMES[i.opcode] + ":" +
+/**
+* Append an instruction after instruction (handle) ih contained in this
+* list.
+*
+* @param ih where to append the instruction list
+* @param i Instruction to append
+* @return instruction handle pointing to the <B>first</B> appended
+* instruction
+*/
+public InstructionHandle append(final InstructionHandle ih, final Instruction i) {
+return append(ih, new InstructionList(i));
+}
+/**
+* Append an instruction after instruction (handle) ih contained in this
+* list.
+*
+* @param ih where to append the instruction list
+* @param i Instruction to append
+* @return instruction handle pointing to the <B>first</B> appended
+* instruction
+*/
+public BranchHandle append(final InstructionHandle ih, final BranchInstruction i) {
+final BranchHandle bh = BranchHandle.getBranchHandle(i);
+final InstructionList il = new InstructionList();
+il.append(bh);
+append(ih, il);
+return bh;
+}
+/**
+* Insert another list before Instruction handle ih contained in this list.
+* Consumes argument list, i.e., it becomes empty.
+*
+* @param ih where to append the instruction list
+* @param il Instruction list to insert
+* @return instruction handle of the first inserted instruction
+*/
+public InstructionHandle insert(final InstructionHandle ih, final InstructionList il) {
+if (il == null) {
+throw new ClassGenException("Inserting null InstructionList");
+}
+if (il.isEmpty()) {
+return ih;
+}
+final InstructionHandle prev = ih.getPrev();
+final InstructionHandle ret = il.start;
+ih.setPrev(il.end);
+il.end.setNext(ih);
+il.start.setPrev(prev);
+if (prev != null) {
+prev.setNext(il.start);
+} else {
+start = il.start; // Update start ...
+}
+length += il.length; // Update length
+il.clear();
+return ret;
+}
+/**
+* Insert another list.
+*
+* @param il list to insert before start of this list
+* @return instruction handle of the first inserted instruction
+*/
+public InstructionHandle insert(final InstructionList il) {
+if (isEmpty()) {
+append(il); // Code is identical for this case
+return start;
+}
+return insert(start, il);
+}
+/**
+* Insert an instruction at start of this list.
+*
+* @param ih instruction to insert
+*/
+private void insert(final InstructionHandle ih) {
+if (isEmpty()) {
+start = end = ih;
+ih.setNext(ih.setPrev(null));
+} else {
+start.setPrev(ih);
+ih.setNext(start);
+ih.setPrev(null);
+start = ih;
+}
+length++;
+}
+/**
+* Insert another list before Instruction i contained in this list. Consumes
+* argument list, i.e., it becomes empty.
+*
+* @param i where to append the instruction list
+* @param il Instruction list to insert
+* @return instruction handle pointing to the first inserted instruction,
+* i.e., il.getStart()
+*/
+public InstructionHandle insert(final Instruction i, final InstructionList il) {
+InstructionHandle ih;
+if ((ih = findInstruction1(i)) == null) {
+throw new ClassGenException("Instruction " + i + " is not contained in this list.");
+}
+return insert(ih, il);
+}
+/**
+* Insert an instruction at start of this list.
+*
+* @param i instruction to insert
+* @return instruction handle of the inserted instruction
+*/
+public InstructionHandle insert(final Instruction i) {
+final InstructionHandle ih = InstructionHandle.getInstructionHandle(i);
+insert(ih);
+return ih;
+}
+/**
+* Insert a branch instruction at start of this list.
+*
+* @param i branch instruction to insert
+* @return branch instruction handle of the appended instruction
+*/
+public BranchHandle insert(final BranchInstruction i) {
+final BranchHandle ih = BranchHandle.getBranchHandle(i);
+insert(ih);
+return ih;
+}
+/**
+* Insert a single instruction j before another instruction i, which must be
+* in this list of course!
+*
+* @param i Instruction in list
+* @param j Instruction to insert before i in list
+* @return instruction handle of the first inserted instruction
+*/
+public InstructionHandle insert(final Instruction i, final Instruction j) {
+return insert(i, new InstructionList(j));
+}
+/**
+* Insert a compound instruction before instruction i.
+*
+* @param i Instruction in list
+* @param c The composite instruction (containing an InstructionList)
+* @return instruction handle of the first inserted instruction
+*/
+public InstructionHandle insert(final Instruction i, final CompoundInstruction c) {
+return insert(i, c.getInstructionList());
+}
+/**
+* Insert a compound instruction.
+*
+* @param c The composite instruction (containing an InstructionList)
+* @return instruction handle of the first inserted instruction
+*/
+public InstructionHandle insert(final CompoundInstruction c) {
+return insert(c.getInstructionList());
+}
+/**
+* Insert an instruction before instruction (handle) ih contained in this
+* list.
+*
+* @param ih where to insert to the instruction list
+* @param i Instruction to insert
+* @return instruction handle of the first inserted instruction
+*/
+public InstructionHandle insert(final InstructionHandle ih, final Instruction i) {
+return insert(ih, new InstructionList(i));
+}
+/**
+* Insert a compound instruction.
+*
+* @param ih where to insert the instruction list
+* @param c The composite instruction (containing an InstructionList)
+* @return instruction handle of the first inserted instruction
+*/
+public InstructionHandle insert(final InstructionHandle ih, final CompoundInstruction c) {
+return insert(ih, c.getInstructionList());
+}
+/**
+* Insert an instruction before instruction (handle) ih contained in this
+* list.
+*
+* @param ih where to insert to the instruction list
+* @param i Instruction to insert
+* @return instruction handle of the first inserted instruction
+*/
+public BranchHandle insert(final InstructionHandle ih, final BranchInstruction i) {
+final BranchHandle bh = BranchHandle.getBranchHandle(i);
+final InstructionList il = new InstructionList();
+il.append(bh);
+insert(ih, il);
+return bh;
+}
+/**
+* Take all instructions (handles) from "start" to "end" and append them
+* after the new location "target". Of course, "end" must be after "start"
+* and target must not be located withing this range. If you want to move
+* something to the start of the list use null as value for target.<br>
+* Any instruction targeters pointing to handles within the block, keep
+* their targets.
+*
+* @param start of moved block
+* @param end of moved block
+* @param target of moved block
+*/
+public void move(final InstructionHandle start, final InstructionHandle end, final InstructionHandle target) {
+// Step 1: Check constraints
+if ((start == null) || (end == null)) {
+throw new ClassGenException("Invalid null handle: From " + start + " to " + end);
+}
+if ((target == start) || (target == end)) {
+throw new ClassGenException("Invalid range: From " + start + " to " + end + " contains target " + target);
+}
+for (InstructionHandle ih = start; ih != end.getNext(); ih = ih.getNext()) {
+if (ih == null) {
+throw new ClassGenException("Invalid range: From " + start + " to " + end);
+} else if (ih == target) {
+throw new ClassGenException("Invalid range: From " + start + " to " + end + " contains target " + target);
+}
+}
+// Step 2: Temporarily remove the given instructions from the list
+final InstructionHandle prev = start.getPrev();
+InstructionHandle next = end.getNext();
+if (prev != null) {
+prev.setNext(next);
+} else {
+this.start = next;
+}
+if (next != null) {
+next.setPrev(prev);
+} else {
+this.end = prev;
+}
+start.setPrev(end.setNext(null));
+// Step 3: append after target
+if (target == null) { // append to start of list
+if (this.start != null) {
+this.start.setPrev(end);
+}
+end.setNext(this.start);
+this.start = start;
+} else {
+next = target.getNext();
+target.setNext(start);
+start.setPrev(target);
+end.setNext(next);
+if (next != null) {
+next.setPrev(end);
+} else {
+this.end = end;
+}
+}
+}
+/**
+* Move a single instruction (handle) to a new location.
+*
+* @param ih moved instruction
+* @param target new location of moved instruction
+*/
+public void move(final InstructionHandle ih, final InstructionHandle target) {
+move(ih, ih, target);
+}
+/**
+* Remove from instruction `prev' to instruction `next' both contained in
+* this list. Throws TargetLostException when one of the removed instruction
+* handles is still being targeted.
+*
+* @param prev where to start deleting (predecessor, exclusive)
+* @param next where to end deleting (successor, exclusive)
+*/
+private void remove(final InstructionHandle prev, InstructionHandle next) throws TargetLostException {
+InstructionHandle first;
+InstructionHandle last; // First and last deleted instruction
+if ((prev == null) && (next == null)) {
+first = start;
+last = end;
+start = end = null;
+} else {
+if (prev == null) { // At start of list
+first = start;
+start = next;
+} else {
+first = prev.getNext();
+prev.setNext(next);
+}
+if (next == null) { // At end of list
+last = end;
+end = prev;
+} else {
+last = next.getPrev();
+next.setPrev(prev);
+}
+}
+first.setPrev(null); // Completely separated from rest of list
+last.setNext(null);
+final List<InstructionHandle> target_vec = new ArrayList<>();
+for (InstructionHandle ih = first; ih != null; ih = ih.getNext()) {
+ih.getInstruction().dispose(); // e.g. BranchInstructions release their targets
+}
+final StringBuilder buf = new StringBuilder("{ ");
+for (InstructionHandle ih = first; ih != null; ih = next) {
+next = ih.getNext();
+length--;
+if (ih.hasTargeters()) { // Still got targeters?
+target_vec.add(ih);
+buf.append(ih.toString(true)).append(" ");
+ih.setNext(ih.setPrev(null));
+} else {
+ih.dispose();
+}
+}
+buf.append("}");
+if (!target_vec.isEmpty()) {
+final InstructionHandle[] targeted = new InstructionHandle[target_vec.size()];
+target_vec.toArray(targeted);
+throw new TargetLostException(targeted, buf.toString());
+}
+}
+/**
+* Remove instruction from this list. The corresponding Instruction handles
+* must not be reused!
+*
+* @param ih instruction (handle) to remove
+*/
+public void delete(final InstructionHandle ih) throws TargetLostException {
+remove(ih.getPrev(), ih.getNext());
+}
+/**
+* Remove instruction from this list. The corresponding Instruction handles
+* must not be reused!
+*
+* @param i instruction to remove
+*/
+public void delete(final Instruction i) throws TargetLostException {
+InstructionHandle ih;
+if ((ih = findInstruction1(i)) == null) {
+throw new ClassGenException("Instruction " + i + " is not contained in this list.");
+}
+delete(ih);
+}
+/**
+* Remove instructions from instruction `from' to instruction `to' contained
+* in this list. The user must ensure that `from' is an instruction before
+* `to', or risk havoc. The corresponding Instruction handles must not be
+* reused!
+*
+* @param from where to start deleting (inclusive)
+* @param to where to end deleting (inclusive)
+*/
+public void delete(final InstructionHandle from, final InstructionHandle to) throws TargetLostException {
+remove(from.getPrev(), to.getNext());
+}
+/**
+* Remove instructions from instruction `from' to instruction `to' contained
+* in this list. The user must ensure that `from' is an instruction before
+* `to', or risk havoc. The corresponding Instruction handles must not be
+* reused!
+*
+* @param from where to start deleting (inclusive)
+* @param to where to end deleting (inclusive)
+*/
+public void delete(final Instruction from, final Instruction to) throws TargetLostException {
+InstructionHandle from_ih;
+InstructionHandle to_ih;
+if ((from_ih = findInstruction1(from)) == null) {
+throw new ClassGenException("Instruction " + from + " is not contained in this list.");
+}
+if ((to_ih = findInstruction2(to)) == null) {
+throw new ClassGenException("Instruction " + to + " is not contained in this list.");
+}
+delete(from_ih, to_ih);
+}
+/**
+* Search for given Instruction reference, start at beginning of list.
+*
+* @param i instruction to search for
+* @return instruction found on success, null otherwise
+*/
+private InstructionHandle findInstruction1(final Instruction i) {
+for (InstructionHandle ih = start; ih != null; ih = ih.getNext()) {
+if (ih.getInstruction() == i) {
+return ih;
+}
+}
+return null;
+}
+/**
+* Search for given Instruction reference, start at end of list
+*
+* @param i instruction to search for
+* @return instruction found on success, null otherwise
+*/
+private InstructionHandle findInstruction2(final Instruction i) {
+for (InstructionHandle ih = end; ih != null; ih = ih.getPrev()) {
+if (ih.getInstruction() == i) {
+return ih;
+}
+}
+return null;
+}
+public boolean contains(final InstructionHandle i) {
+if (i == null) {
+return false;
+}
+for (InstructionHandle ih = start; ih != null; ih = ih.getNext()) {
+if (ih == i) {
+return true;
+}
+}
+return false;
+}
+public boolean contains(final Instruction i) {
+return findInstruction1(i) != null;
+}
+public void setPositions() { // TODO could be package-protected? (some test code would need to be repackaged)
+setPositions(false);
+}
+/**
+* Give all instructions their position number (offset in byte stream),
+* i.e., make the list ready to be dumped.
+*
+* @param check Perform sanity checks, e.g. if all targeted instructions
+* really belong to this list
+*/
+public void setPositions(final boolean check) { // called by code in other packages
+int max_additional_bytes = 0;
+int additional_bytes = 0;
+int index = 0;
+int count = 0;
+final int[] pos = new int[length];
+/*
+* Pass 0: Sanity checks
+*/
+if (check) {
+for (InstructionHandle ih = start; ih != null; ih = ih.getNext()) {
+final Instruction i = ih.getInstruction();
+if (i instanceof BranchInstruction) { // target instruction within list?
+Instruction inst = ((BranchInstruction) i).getTarget().getInstruction();
+if (!contains(inst)) {
+throw new ClassGenException("Branch target of " +
+Const.getOpcodeName(i.getOpcode()) + ":" +
+inst + " not in instruction list");
+}
+if (i instanceof Select) {
+final InstructionHandle[] targets = ((Select) i).getTargets();
+for (final InstructionHandle target : targets) {
+inst = target.getInstruction();
+if (!contains(inst)) {
+throw new ClassGenException("Branch target of " +
+Const.getOpcodeName(i.getOpcode()) + ":" +
 inst + " not in instruction list");
+}
-if(i instanceof Select) {
+}
-InstructionHandle[] targets = ((Select)i).getTargets();
+}
+if (!(ih instanceof BranchHandle)) {
-for(int j=0; j < targets.length; j++) {
+throw new ClassGenException(
-inst = targets[j].instruction;
+"Branch instruction " +
-if(!contains(inst))
+Const.getOpcodeName(i.getOpcode()) + ":" +
-throw new ClassGenException("Branch target of " +
-Constants.OPCODE_NAMES[i.opcode] + ":" +
-inst + " not in instruction list");
-}
-}
-if(!(ih instanceof BranchHandle))
-throw new ClassGenException("Branch instruction " +
-Constants.OPCODE_NAMES[i.opcode] + ":" +
 inst + " not contained in BranchHandle.");
+}
 }
 }
 }
+/*
-/* Pass 1: Set position numbers and sum up the maximum number of bytes an
+* Pass 1: Set position numbers and sum up the maximum number of bytes an instruction may be shifted.
-* instruction may be shifted.
+*/
-*/
+for (InstructionHandle ih = start; ih != null; ih = ih.getNext()) {
-for(InstructionHandle ih=start; ih != null; ih = ih.next) {
-Instruction i = ih.instruction;
+final Instruction i = ih.getInstruction();
+ih.setPosition(index);
-ih.setPosition(index);
+pos[count++] = index;
-pos[count++] = index;
+/*
-/* Get an estimate about how many additional bytes may be added, because
+* Get an estimate about how many additional bytes may be added,
-* BranchInstructions may have variable length depending on the target
+* because BranchInstructions may have variable length depending on the target offset
-* offset (short vs. int) or alignment issues (TABLESWITCH and
+* (short vs. int) or alignment issues (TABLESWITCH and LOOKUPSWITCH).
-* LOOKUPSWITCH).
+*/
-*/
+switch (i.getOpcode()) {
-switch(i.getOpcode()) {
+case Const.JSR:
-case Constants.JSR: case Constants.GOTO:
+case Const.GOTO:
 max_additional_bytes += 2;
 break;
+case Const.TABLESWITCH:
-case Constants.TABLESWITCH: case Constants.LOOKUPSWITCH:
+case Const.LOOKUPSWITCH:
 max_additional_bytes += 3;
 break;
 }
+index += i.getLength();
-index += i.getLength();
+}
-}
+/* Pass 2: Expand the variable-length (Branch)Instructions depending on
-/* Pass 2: Expand the variable-length (Branch)Instructions depending on
+* the target offset (short or int) and ensure that branch targets are
-* the target offset (short or int) and ensure that branch targets are
+* within this list.
-* within this list.
+*/
-*/
+for (InstructionHandle ih = start; ih != null; ih = ih.getNext()) {
-for(InstructionHandle ih=start; ih != null; ih = ih.next)
+additional_bytes += ih.updatePosition(additional_bytes, max_additional_bytes);
-additional_bytes += ih.updatePosition(additional_bytes, max_additional_bytes);
+}
+/*
-/* Pass 3: Update position numbers (which may have changed due to the
+* Pass 3: Update position numbers (which may have changed due to the
 * preceding expansions), like pass 1.
 */
-index=count=0;
+index = count = 0;
-for(InstructionHandle ih=start; ih != null; ih = ih.next) {
+for (InstructionHandle ih = start; ih != null; ih = ih.getNext()) {
-Instruction i = ih.instruction;
+final Instruction i = ih.getInstruction();
 ih.setPosition(index);
 pos[count++] = index;
 index += i.getLength();
 }
+if (length == count) {
-byte_positions = new int[count]; // Trim to proper size
+byte_positions = pos;
-System.arraycopy(pos, 0, byte_positions, 0, count);
+} else {
-}
+byte_positions = new int[count]; // Trim to proper size
+System.arraycopy(pos, 0, byte_positions, 0, count);
-/**
+}
-* When everything is finished, use this method to convert the instruction
+}
-* list into an array of bytes.
-*
+/**
-* @return the byte code ready to be dumped
+* When everything is finished, use this method to convert the instruction
-*/
+* list into an array of bytes.
-public byte[] getByteCode() {
+*
-// Update position indices of instructions
+* @return the byte code ready to be dumped
-setPositions();
+*/
+public byte[] getByteCode() {
-ByteArrayOutputStream b   = new ByteArrayOutputStream();
+// Update position indices of instructions
-DataOutputStream      out = new DataOutputStream(b);
+setPositions();
+final ByteArrayOutputStream b = new ByteArrayOutputStream();
-try {
+final DataOutputStream out = new DataOutputStream(b);
-for(InstructionHandle ih=start; ih != null; ih = ih.next) {
+try {
-Instruction i = ih.instruction;
+for (InstructionHandle ih = start; ih != null; ih = ih.getNext()) {
-i.dump(out); // Traverse list
+final Instruction i = ih.getInstruction();
-}
+i.dump(out); // Traverse list
-} catch(IOException e) {
+}
-System.err.println(e);
+out.flush();
-return null;
+} catch (final IOException e) {
-}
+System.err.println(e);
+return new byte[0];
-return b.toByteArray();
+}
-}
+return b.toByteArray();
+}
-/**
-* @return an array of instructions without target information for branch instructions.
+/**
-*/
+* @return an array of instructions without target information for branch
-public Instruction[] getInstructions() {
+* instructions.
-ByteSequence  bytes        = new ByteSequence(getByteCode());
+*/
-ArrayList     instructions = new ArrayList();
+public Instruction[] getInstructions() {
+final List<Instruction> instructions = new ArrayList<>();
-try {
+try (ByteSequence bytes = new ByteSequence(getByteCode())) {
-while(bytes.available() > 0) {
+while (bytes.available() > 0) {
 instructions.add(Instruction.readInstruction(bytes));
 }
-} catch(IOException e) { throw new ClassGenException(e.toString()); }
+} catch (final IOException e) {
+throw new ClassGenException(e.toString(), e);
-Instruction[] result = new Instruction[instructions.size()];
+}
-instructions.toArray(result);
+return instructions.toArray(new Instruction[instructions.size()]);
-return result;
+}
-}
+@Override
 public String toString() {
 return toString(true);
 }
 /**
 * @param verbose toggle output format
 * @return String containing all instructions in this list.
 */
-public String toString(boolean verbose) {
+public String toString(final boolean verbose) {
-StringBuffer buf = new StringBuffer();
+final StringBuilder buf = new StringBuilder();
+for (InstructionHandle ih = start; ih != null; ih = ih.getNext()) {
-for(InstructionHandle ih=start; ih != null; ih = ih.next) {
+buf.append(ih.toString(verbose)).append("\n");
-buf.append(ih.toString(verbose) + "\n");
+}
-}
+return buf.toString();
+}
-return buf.toString();
-}
+/**
+* @return iterator that lists all instructions (handles)
-/**
+*/
-* @return Enumeration that lists all instructions (handles)
+@Override
-*/
+public Iterator<InstructionHandle> iterator() {
-public Iterator iterator() {
+return new Iterator<InstructionHandle>() {
-return new Iterator() {
 private InstructionHandle ih = start;
-public Object next() {
+@Override
-InstructionHandle i = ih;
+public InstructionHandle next() throws NoSuchElementException {
-ih = ih.next;
+if (ih == null) {
-return i;
+throw new NoSuchElementException();
 }
+final InstructionHandle i = ih;
-public void remove() {
+ih = ih.getNext();
-throw new UnsupportedOperationException();
+return i;
 }
-public boolean hasNext() { return ih != null; }
+@Override
-};
+public void remove() {
-}
+throw new UnsupportedOperationException();
+}
-/**
-* @return array containing all instructions (handles)
+@Override
-*/
+public boolean hasNext() {
-public InstructionHandle[] getInstructionHandles() {
+return ih != null;
-InstructionHandle[] ihs = new InstructionHandle[length];
+}
-InstructionHandle   ih  = start;
+};
+}
-for(int i=0; i < length; i++) {
-ihs[i] = ih;
+/**
-ih = ih.next;
+* @return array containing all instructions (handles)
-}
+*/
+public InstructionHandle[] getInstructionHandles() {
-return ihs;
+final InstructionHandle[] ihs = new InstructionHandle[length];
-}
+InstructionHandle ih = start;
+for (int i = 0; i < length; i++) {
-/**
+ihs[i] = ih;
-* Get positions (offsets) of all instructions in the list. This relies on that
+ih = ih.getNext();
-* the list has been freshly created from an byte code array, or that setPositions()
+}
-* has been called. Otherwise this may be inaccurate.
+return ihs;
-*
+}
-* @return array containing all instruction's offset in byte code
-*/
+/**
-public int[] getInstructionPositions() { return byte_positions; }
+* Get positions (offsets) of all instructions in the list. This relies on
+* that the list has been freshly created from an byte code array, or that
-/**
+* setPositions() has been called. Otherwise this may be inaccurate.
-* @return complete, i.e., deep copy of this list
+*
-*/
+* @return array containing all instruction's offset in byte code
-public InstructionList copy() {
+*/
-HashMap         map = new HashMap();
+public int[] getInstructionPositions() {
-InstructionList il  = new InstructionList();
+return byte_positions;
+}
-/* Pass 1: Make copies of all instructions, append them to the new list
-* and associate old instruction references with the new ones, i.e.,
+/**
-* a 1:1 mapping.
+* @return complete, i.e., deep copy of this list
 */
-for(InstructionHandle ih=start; ih != null; ih = ih.next) {
+public InstructionList copy() {
-Instruction i = ih.instruction;
+final Map<InstructionHandle, InstructionHandle> map = new HashMap<>();
-Instruction c = i.copy(); // Use clone for shallow copy
+final InstructionList il = new InstructionList();
+/*
-if(c instanceof BranchInstruction)
+* Pass 1: Make copies of all instructions, append them to the new list and associate old instruction references with the new ones, i.e., a 1:1 mapping.
-map.put(ih, il.append((BranchInstruction)c));
+*/
-else
+for (InstructionHandle ih = start; ih != null; ih = ih.getNext()) {
-map.put(ih, il.append(c));
+final Instruction i = ih.getInstruction();
-}
+final Instruction c = i.copy(); // Use clone for shallow copy
+if (c instanceof BranchInstruction) {
-/* Pass 2: Update branch targets.
+map.put(ih, il.append((BranchInstruction) c));
-*/
+} else {
-InstructionHandle ih=start;
+map.put(ih, il.append(c));
-InstructionHandle ch=il.start;
+}
+}
-while(ih != null) {
+/*
-Instruction i = ih.instruction;
+* Pass 2: Update branch targets.
-Instruction c = ch.instruction;
+*/
+InstructionHandle ih = start;
-if(i instanceof BranchInstruction) {
+InstructionHandle ch = il.start;
-BranchInstruction bi      = (BranchInstruction)i;
+while (ih != null) {
-BranchInstruction bc      = (BranchInstruction)c;
+final Instruction i = ih.getInstruction();
-InstructionHandle itarget = bi.getTarget(); // old target
+final Instruction c = ch.getInstruction();
+if (i instanceof BranchInstruction) {
-// New target is in hash map
+final BranchInstruction bi = (BranchInstruction) i;
-bc.setTarget((InstructionHandle)map.get(itarget));
+final BranchInstruction bc = (BranchInstruction) c;
+final InstructionHandle itarget = bi.getTarget(); // old target
-if(bi instanceof Select) { // Either LOOKUPSWITCH or TABLESWITCH
+// New target is in hash map
-InstructionHandle[] itargets = ((Select)bi).getTargets();
+bc.setTarget(map.get(itarget));
-InstructionHandle[] ctargets = ((Select)bc).getTargets();
+if (bi instanceof Select) { // Either LOOKUPSWITCH or TABLESWITCH
+final InstructionHandle[] itargets = ((Select) bi).getTargets();
-for(int j=0; j < itargets.length; j++) { // Update all targets
+final InstructionHandle[] ctargets = ((Select) bc).getTargets();
-ctargets[j] = (InstructionHandle)map.get(itargets[j]);
+for (int j = 0; j < itargets.length; j++) { // Update all targets
-}
+ctargets[j] = map.get(itargets[j]);
 }
 }
+}
-ih = ih.next;
+ih = ih.getNext();
-ch = ch.next;
+ch = ch.getNext();
 }
+return il;
-return il;
+}
-}
+/**
-/** Replace all references to the old constant pool with references to the new
+* Replace all references to the old constant pool with references to the
-*  constant pool
+* new constant pool
 */
-public void replaceConstantPool(ConstantPoolGen old_cp, ConstantPoolGen new_cp) {
+public void replaceConstantPool(final ConstantPoolGen old_cp, final ConstantPoolGen new_cp) {
-for(InstructionHandle ih=start; ih != null; ih = ih.next) {
+for (InstructionHandle ih = start; ih != null; ih = ih.getNext()) {
-Instruction i = ih.instruction;
+final Instruction i = ih.getInstruction();
+if (i instanceof CPInstruction) {
-if(i instanceof CPInstruction) {
+final CPInstruction ci = (CPInstruction) i;
-CPInstruction ci = (CPInstruction)i;
+final Constant c = old_cp.getConstant(ci.getIndex());
-Constant      c  = old_cp.getConstant(ci.getIndex());
+ci.setIndex(new_cp.addConstant(c, old_cp));
-ci.setIndex(new_cp.addConstant(c, old_cp));
+}
 }
 }
-}
+private void clear() {
-private void clear() {
+start = end = null;
-start = end = null;
+length = 0;
-length = 0;
+}
-}
+/**
-/**
+* Delete contents of list. Provides better memory utilization, because the
-* Delete contents of list. Provides besser memory utilization,
+* system then may reuse the instruction handles. This method is typically
-* because the system then may reuse the instruction handles. This
+* called right after {@link MethodGen#getMethod()}.
-* method is typically called right after
+*/
-* <href="MethodGen.html#getMethod()">MethodGen.getMethod()</a>.
+public void dispose() {
-*/
+// Traverse in reverse order, because ih.next is overwritten
-public void dispose() {
+for (InstructionHandle ih = end; ih != null; ih = ih.getPrev()) {
-// Traverse in reverse order, because ih.next is overwritten
+/*
-for(InstructionHandle ih=end; ih != null; ih = ih.prev)
+* Causes BranchInstructions to release target and targeters,
-/* Causes BranchInstructions to release target and targeters, because it
+* because it calls dispose() on the contained instruction.
-* calls dispose() on the contained instruction.
+*/
-*/
+ih.dispose();
-ih.dispose();
+}
+clear();
-clear();
+}
-}
+/**
-/**
+* @return start of list
-* @return start of list
+*/
-*/
+public InstructionHandle getStart() {
-public InstructionHandle getStart() { return start; }
+return start;
+}
-/**
-* @return end of list
+/**
-*/
+* @return end of list
-public InstructionHandle getEnd()   { return end; }
+*/
+public InstructionHandle getEnd() {
-/**
+return end;
-* @return length of list (Number of instructions, not bytes)
+}
-*/
-public int getLength() { return length; }
+/**
+* @return length of list (Number of instructions, not bytes)
-/**
+*/
-* @return length of list (Number of instructions, not bytes)
+public int getLength() {
-*/
+return length;
-public int size() { return length; }
+}
 /**
-* Redirect all references from old_target to new_target, i.e., update targets
+* @return length of list (Number of instructions, not bytes)
-* of branch instructions.
+*/
-*
+public int size() {
-* @param old_target the old target instruction handle
+return length;
-* @param new_target the new target instruction handle
+}
-*/
-public void redirectBranches(InstructionHandle old_target,
+/**
-InstructionHandle new_target) {
+* Redirect all references from old_target to new_target, i.e., update
-for(InstructionHandle ih = start; ih != null; ih = ih.next) {
+* targets of branch instructions.
-Instruction i  = ih.getInstruction();
+*
+* @param old_target the old target instruction handle
-if(i instanceof BranchInstruction) {
+* @param new_target the new target instruction handle
-BranchInstruction b      = (BranchInstruction)i;
+*/
-InstructionHandle target = b.getTarget();
+public void redirectBranches(final InstructionHandle old_target,
+final InstructionHandle new_target) {
-if(target == old_target)
+for (InstructionHandle ih = start; ih != null; ih = ih.getNext()) {
-b.setTarget(new_target);
+final Instruction i = ih.getInstruction();
+if (i instanceof BranchInstruction) {
-if(b instanceof Select) { // Either LOOKUPSWITCH or TABLESWITCH
+final BranchInstruction b = (BranchInstruction) i;
-InstructionHandle[] targets = ((Select)b).getTargets();
+final InstructionHandle target = b.getTarget();
+if (target == old_target) {
-for(int j=0; j < targets.length; j++) // Update targets
+b.setTarget(new_target);
-if(targets[j] == old_target)
+}
-((Select)b).setTarget(j, new_target);
+if (b instanceof Select) { // Either LOOKUPSWITCH or TABLESWITCH
-}
+final InstructionHandle[] targets = ((Select) b).getTargets();
-}
+for (int j = 0; j < targets.length; j++) {
-}
+if (targets[j] == old_target) {
-}
+((Select) b).setTarget(j, new_target);
+}
-/**
+}
-* Redirect all references of local variables from old_target to new_target.
+}
-*
+}
-* @param lg array of local variables
+}
-* @param old_target the old target instruction handle
+}
-* @param new_target the new target instruction handle
-* @see MethodGen
+/**
-*/
+* Redirect all references of local variables from old_target to new_target.
-public void redirectLocalVariables(LocalVariableGen[] lg,
+*
-InstructionHandle old_target,
+* @param lg array of local variables
-InstructionHandle new_target) {
+* @param old_target the old target instruction handle
-for(int i=0; i < lg.length; i++) {
+* @param new_target the new target instruction handle
-InstructionHandle start = lg[i].getStart();
+* @see MethodGen
-InstructionHandle end   = lg[i].getEnd();
+*/
+public void redirectLocalVariables(final LocalVariableGen[] lg,
-if(start == old_target)
+final InstructionHandle old_target, final InstructionHandle new_target) {
-lg[i].setStart(new_target);
+for (final LocalVariableGen element : lg) {
+final InstructionHandle start = element.getStart();
-if(end == old_target)
+final InstructionHandle end = element.getEnd();
-lg[i].setEnd(new_target);
+if (start == old_target) {
-}
+element.setStart(new_target);
 }
+if (end == old_target) {
-/**
+element.setEnd(new_target);
-* Redirect all references of exception handlers from old_target to new_target.
+}
-*
+}
-* @param exceptions array of exception handlers
+}
-* @param old_target the old target instruction handle
-* @param new_target the new target instruction handle
+/**
-* @see MethodGen
+* Redirect all references of exception handlers from old_target to
-*/
+* new_target.
-public void redirectExceptionHandlers(CodeExceptionGen[] exceptions,
+*
-InstructionHandle old_target,
+* @param exceptions array of exception handlers
-InstructionHandle new_target) {
+* @param old_target the old target instruction handle
-for(int i=0; i < exceptions.length; i++) {
+* @param new_target the new target instruction handle
-if(exceptions[i].getStartPC() == old_target)
+* @see MethodGen
-exceptions[i].setStartPC(new_target);
+*/
+public void redirectExceptionHandlers(final CodeExceptionGen[] exceptions,
-if(exceptions[i].getEndPC() == old_target)
+final InstructionHandle old_target, final InstructionHandle new_target) {
-exceptions[i].setEndPC(new_target);
+for (final CodeExceptionGen exception : exceptions) {
+if (exception.getStartPC() == old_target) {
-if(exceptions[i].getHandlerPC() == old_target)
+exception.setStartPC(new_target);
-exceptions[i].setHandlerPC(new_target);
+}
-}
+if (exception.getEndPC() == old_target) {
-}
+exception.setEndPC(new_target);
+}
-private ArrayList observers;
+if (exception.getHandlerPC() == old_target) {
+exception.setHandlerPC(new_target);
-/** Add observer for this object.
+}
-*/
+}
-public void addObserver(InstructionListObserver o) {
+}
-if(observers == null)
-observers = new ArrayList();
+private List<InstructionListObserver> observers;
-observers.add(o);
+/**
-}
+* Add observer for this object.
+*/
-/** Remove observer for this object.
+public void addObserver(final InstructionListObserver o) {
-*/
+if (observers == null) {
-public void removeObserver(InstructionListObserver o) {
+observers = new ArrayList<>();
-if(observers != null)
+}
-observers.remove(o);
+observers.add(o);
 }
-/** Call notify() method on all observers. This method is not called
+/**
-* automatically whenever the state has changed, but has to be
+* Remove observer for this object.
-* called by the user after he has finished editing the object.
+*/
-*/
+public void removeObserver(final InstructionListObserver o) {
-public void update() {
+if (observers != null) {
-if(observers != null)
+observers.remove(o);
-for(Iterator e = observers.iterator(); e.hasNext(); )
+}
-((InstructionListObserver)e.next()).notify(this);
+}
-}
+/**
+* Call notify() method on all observers. This method is not called
+* automatically whenever the state has changed, but has to be called by the
+* user after he has finished editing the object.
+*/
+public void update() {
+if (observers != null) {
+for (final InstructionListObserver observer : observers) {
+observer.notify(this);
+}
+}
+}
 }

changeset 46174	5611d2529b49
parent 44797	8b3b3b911b8a