/* ====================================================================
 * Trove - Copyright (c) 1997-2000 Walt Disney Internet Group
 * ====================================================================
 * The Tea Software License, Version 1.1
 *
 * Copyright (c) 2000 Walt Disney Internet Group. All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 *
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in
 *    the documentation and/or other materials provided with the
 *    distribution.
 *
 * 3. The end-user documentation included with the redistribution,
 *    if any, must include the following acknowledgment:
 *       "This product includes software developed by the
 *        Walt Disney Internet Group (http://opensource.go.com/)."
 *    Alternately, this acknowledgment may appear in the software itself,
 *    if and wherever such third-party acknowledgments normally appear.
 *
 * 4. The names "Tea", "TeaServlet", "Kettle", "Trove" and "BeanDoc" must
 *    not be used to endorse or promote products derived from this
 *    software without prior written permission. For written
 *    permission, please contact opensource@dig.com.
 *
 * 5. Products derived from this software may not be called "Tea",
 *    "TeaServlet", "Kettle" or "Trove", nor may "Tea", "TeaServlet",
 *    "Kettle", "Trove" or "BeanDoc" appear in their name, without prior
 *    written permission of the Walt Disney Internet Group.
 *
 * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED
 * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
 * DISCLAIMED.  IN NO EVENT SHALL THE WALT DISNEY INTERNET GROUP OR ITS
 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR 
 * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
 * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 * ====================================================================
 *
 * For more information about Tea, please see http://opensource.go.com/.
 */

package com.go.trove.classfile;

import java.util.*;
import java.io.*;

/******************************************************************************
 * The InstructionList class is used by the CodeBuilder to perform lower-level
 * bookkeeping operations and flow analysis.
 * 
 * @author Brian S O'Neill
 * @version
 * <!--$$Revision: 1.1 $-->, <!--$$JustDate:--> 01/05/14 <!-- $-->
 * @see CodeBuilder
 */
class InstructionList implements CodeBuffer {
    private static final boolean DEBUG = false;

    Instruction mFirst;
    Instruction mLast;

    boolean mResolved = false;

    private List mExceptionHandlers = new ArrayList(4);
    private List mLocalVariables = new ArrayList();

    private int mMaxStack;
    private int mMaxLocals;

    private byte[] mByteCodes;
    private int mBufferLength;

    protected InstructionList() {
        super();
    }

    /**
     * Returns an immutable collection of all the instructions in this
     * InstructionList.
     */
    public Collection getInstructions() {
        return new AbstractCollection() {
            public Iterator iterator() {
                return new Iterator() {
                    private Instruction mNext = mFirst;

                    public boolean hasNext() {
                        return mNext != null;
                    }

                    public Object next() {
                        if (mNext == null) {
                            throw new NoSuchElementException();
                        }

                        Instruction current = mNext;
                        mNext = mNext.mNext;
                        return current;
                    }

                    public void remove() {
                        throw new UnsupportedOperationException();
                    }
                };
            }

            public int size() {
                int count = 0;
                for (Instruction i = mFirst; i != null; i = i.mNext) {
                    count++;
                }
                return count;
            }
        };
    }

    public int getMaxStackDepth() {
        resolve();
        return mMaxStack;
    }

    public int getMaxLocals() {
        resolve();
        return mMaxLocals;
    }

    public byte[] getByteCodes() {
        resolve();
        return mByteCodes;
    }

    public ExceptionHandler[] getExceptionHandlers() {
        resolve();

        ExceptionHandler[] handlers = 
            new ExceptionHandler[mExceptionHandlers.size()];
        return (ExceptionHandler[])mExceptionHandlers.toArray(handlers);
    }

    public void addExceptionHandler(ExceptionHandler handler) {
        mExceptionHandlers.add(handler);
    }

    public LocalVariable createLocalVariable(String name,
                                             TypeDescriptor type) {
        LocalVariable var = new LocalVariableImpl(name, type, -1);
        mLocalVariables.add(var);
        return var;
    }

    public LocalVariable createLocalParameter(String name,
                                              TypeDescriptor type,
                                              int number) {
        LocalVariableImpl var = new LocalVariableImpl(name, type, number);
        mLocalVariables.add(var);
        if (mFirst == null) {
            // Make sure there is an initial instruction. Create a pseudo one.
            LabelInstruction label = new LabelInstruction();
            label.setLocation();
            mFirst = label;
        }
        
        // Parameters are initialized first, so ensure flow analysis starts
        // at the beginning.
        var.addStoreInstruction(mFirst);

        return var;
    }

    private void resolve() {
        if (mResolved) {
            return;
        }

        if (!DEBUG) {
            resolve0();
        }
        else {
            try {
                resolve0();
            }
            finally {
                System.out.println("-- Instructions --");
                
                Iterator it = getInstructions().iterator();
                while (it.hasNext()) {
                    System.out.println(it.next());
                }
            }
        }
    }

    private void resolve0() {
        mMaxStack = 0;
        mMaxLocals = 0;

        Instruction instr;

        // Sweep through the instructions, marking them as not being
        // visted by flow analysis and set fake locations.
        int instrCount = 0;
        for (instr = mFirst; instr != null; instr = instr.mNext) {
            instr.mStackDepth = -1;
            instr.mLocation = instrCount++;
        }

        // Assign variable numbers using the simplest technique.

        int size = mLocalVariables.size();
        List activeLocationBits = new ArrayList(size);
        for (int i=0; i<size; i++) {
            LocalVariableImpl var = (LocalVariableImpl)mLocalVariables.get(i);
            if (var.getNumber() < 0) {
                var.setNumber(mMaxLocals);
            }
            
            int max = var.getNumber() + (var.isDoubleWord() ? 2 : 1);
            if (max > mMaxLocals) {
                mMaxLocals = max;
            }
        }

        /*
        // Perform variable flow analysis for each local variable, in order to
        // determine which register it should be assigned.

        int size = mLocalVariables.size();
        List activeLocationBits = new ArrayList(size);
        for (int i=0; i<size; i++) {
            LocalVariableImpl var = (LocalVariableImpl)mLocalVariables.get(i);
            BitList activeLocations = new BitList(instrCount);
            activeLocationBits.add(activeLocations);

            // Start flow analysis at store variable instructions.
            Iterator it = var.iterateStoreInstructions();
            while (it.hasNext()) {
                Instruction enter = (Instruction)it.next();
                variableResolve(var, enter, activeLocations,
                                new BitList(instrCount), false);
            }
            
            // Continue flow analysis into all exception handlers that wrap
            // the active locations.
            boolean passAgain;
            do {
                passAgain = false;
                it = mExceptionHandlers.iterator();
                while (it.hasNext()) {
                    ExceptionHandler handler = (ExceptionHandler)it.next();
                    if (!isIntersecting(activeLocations, handler)) {
                        continue;
                    }
                    Instruction enter = 
                        (Instruction)handler.getCatchLocation();
                    passAgain =
                        variableResolve(var, enter, activeLocations,
                                        new BitList(instrCount), false);
                    passAgain = false;
                }
            } while (passAgain);

            if (!var.isFixedNumber()) {
                var.setNumber(-1);

                // Assign variable number by checking first if it can be shared
                // with another variable of the same size.

                boolean[] conflicts = new boolean[mMaxLocals];

                for (int j=0; j<i; j++) {
                    LocalVariable av = (LocalVariable)mLocalVariables.get(j);
                    if (av.getNumber() < 0 ||
                        av.isDoubleWord() != var.isDoubleWord()) {
                        continue;
                    }
                    BitList alocs = (BitList)activeLocationBits.get(j);
                    if (isIntersecting(alocs, activeLocations)) {
                        conflicts[av.getNumber()] = true;
                        if (av.getNumber() == var.getNumber()) {
                            var.setNumber(-1);
                        }
                    }
                    else if (conflicts[av.getNumber()]) {
                        var.setNumber(-1);
                    }
                    else {
                        var.setNumber(av.getNumber());
                    }
                }
                
                if (var.getNumber() < 0) {
                    var.setNumber(mMaxLocals);
                }
            }

            int max = var.getNumber() + (var.isDoubleWord() ? 2 : 1);
            if (max > mMaxLocals) {
                mMaxLocals = max;
            }

            // TODO
            //var.setLocations(activeLocations);
        }

        activeLocationBits = null;
        */

        // Perform stack flow analysis to determine the max stack size.

        // Start the flow analysis at the first instruction.
        Map subAdjustMap = new HashMap(11);
        stackResolve(0, mFirst, subAdjustMap);

        // Continue flow analysis into exception handler entry points.
        Iterator it = mExceptionHandlers.iterator();
        while (it.hasNext()) {
            ExceptionHandler handler = (ExceptionHandler)it.next();
            Instruction enter = (Instruction)handler.getCatchLocation();
            stackResolve(1, enter, subAdjustMap);
        }

        // Okay, build up the byte code and set real instruction locations.
        // Multiple passes may be required because instructions may adjust
        // their size as locations are set. Changing size affects the
        // locations of other instructions, so that is why additional passes
        // are required.
        
        boolean passAgain;
        do {
            passAgain = false;

            mByteCodes = new byte[16];
            mBufferLength = 0;

            for (instr = mFirst; instr != null; instr = instr.mNext) {
                if (!instr.isResolved()) {
                    passAgain = true;
                }

                if (instr instanceof Label) {
                    if (instr.mLocation != mBufferLength) {
                        if (instr.mLocation >= 0) {
                            // If the location of this label is not where it
                            // should be, (most likely because an instruction
                            // needed to expand in size) then do another pass.
                            passAgain = true;
                        }

                        instr.mLocation = mBufferLength;
                    }
                }
                else {
                    instr.mLocation = mBufferLength;

                    byte[] bytes = instr.getBytes();
                    if (bytes != null) {
                        if (passAgain) {
                            // If there is going to be another pass, don't 
                            // bother collecting bytes into the array. Just 
                            // expand the the length variable.
                            mBufferLength += bytes.length;
                        }
                        else {
                            addBytes(bytes);
                        }
                    }
                }
            }
        } while (passAgain); // do {} while ();

        if (mBufferLength != mByteCodes.length) {
            byte[] newBytes = new byte[mBufferLength];
            System.arraycopy(mByteCodes, 0, newBytes, 0, mBufferLength);
            mByteCodes = newBytes;
        }

        // Set resolved at end because during resolution, this field gets
        // set false again while changes are being made to the list
        // of instructions.
        mResolved = true;
    }

    private void addBytes(byte[] code) {
        growBuffer(code.length);
        System.arraycopy(code, 0, mByteCodes, mBufferLength, code.length);
        mBufferLength += code.length;
    }

    private void growBuffer(int amount) {
        if ((mBufferLength + amount) > mByteCodes.length) {
            int newCapacity = mByteCodes.length * 2;
            if ((mBufferLength + amount) > newCapacity) {
                newCapacity = mBufferLength + amount;
            }

            byte[] newBuffer = new byte[newCapacity];
            System.arraycopy(mByteCodes, 0, newBuffer, 0, mBufferLength);
            mByteCodes = newBuffer;
        }
    }

    /*
    private boolean variableResolve(LocalVariableImpl var,
                                    Instruction instr,
                                    BitList activeLocations,
                                    BitList possibleLocations,
                                    boolean fork) {
        while (instr != null) {
            int instrLoc = instr.getLocation();

            if (activeLocations.get(instrLoc)) {
                activeLocations.or(possibleLocations);
                if (possibleLocations.isAllClear()) {
                    return false;
                }
                else {
                    possibleLocations.clear();
                    return true;
                }
            }

            if (possibleLocations.get(instrLoc)) {
                return false;
            }

            possibleLocations.set(instrLoc);

            if (instr instanceof LocalOperandInstruction &&
                ((LocalOperandInstruction)instr).getLocalVariable() == var) {

                if (instr instanceof StoreLocalInstruction) {
                    activeLocations.set(instrLoc);
                    if (fork) {
                        possibleLocations.clear(instrLoc);
                    }
                    else {
                        possibleLocations.clear();
                    }
                }
                else {
                    activeLocations.or(possibleLocations);
                    possibleLocations.clear();
                }
            }

            // Determine the next instruction to flow down to.
            Instruction next = null;

            if (instr.isFlowThrough()) {
                if ((next = instr.mNext) == null) {
                    throw new RuntimeException
                        ("Execution flows through end of method");
                }
            }

            Location[] targets = instr.getBranchTargets();
            if (targets != null) {
                for (int i=0; i<targets.length; i++) {
                    LabelInstruction targetInstr = 
                        (LabelInstruction)targets[i];

                    if (i == 0 && next == null) {
                        // Flow to the first target if instruction doesn't
                        // flow to its next instruction.
                        next = targetInstr;
                        continue;
                    }

                    variableResolve
                        (var, targetInstr, activeLocations,
                         possibleLocations, true);
                }
            }

            instr = next;
        }

        return true;
    }

    private boolean isIntersecting(BitList a, BitList b) {
        a = (BitList)a.clone();
        a.and(b);
        return !a.isAllClear();
    }

    private boolean isIntersecting(BitList bits, LocationRange range) {
        // TODO: how efficient is this?
        int start = range.getStartLocation().getLocation();
        int end = range.getEndLocation().getLocation();

        for (int i=start; i<end; i++) {
            if (bits.get(i)) {
                return true;
            }
        }

        return false;
    }
    */

    private int stackResolve(int stackDepth, 
                             Instruction instr, 
                             Map subAdjustMap) {
        while (instr != null) {
            // Set the stack depth, marking this instruction as being visited.
            // If already visited, break out of this flow.
            if (instr.mStackDepth < 0) {
                instr.mStackDepth = stackDepth;
            }
            else {
                if (instr.mStackDepth != stackDepth) {
                    throw new RuntimeException
                        ("Stack depth different at previously visited " +
                         "instruction: " + instr.mStackDepth + 
                         " != " + stackDepth);
                }

                break;
            }

            // Determine the next instruction to flow down to.
            Instruction next = null;

            if (instr.isFlowThrough()) {
                if ((next = instr.mNext) == null) {
                    throw new RuntimeException
                        ("Execution flows through end of method");
                }
            }

            stackDepth += instr.getStackAdjustment();
            if (stackDepth > mMaxStack) {
                mMaxStack = stackDepth;
            }
            else if (stackDepth < 0) {
                throw new RuntimeException("Stack depth is negative: " + 
                                           stackDepth);
            }

            Location[] targets = instr.getBranchTargets();
            if (targets != null) {
                for (int i=0; i<targets.length; i++) {
                    LabelInstruction targetInstr = 
                        (LabelInstruction)targets[i];

                    if (i == 0 && next == null) {
                        // Flow to the first target if instruction doesn't
                        // flow to its next instruction.
                        next = targetInstr;
                        continue;
                    }

                    if (!instr.isSubroutineCall()) {
                        stackResolve
                            (stackDepth, targetInstr, subAdjustMap);
                    }
                    else {
                        Integer subAdjust =
                            (Integer)subAdjustMap.get(targetInstr);
                        
                        if (subAdjust == null) {
                            int newDepth =
                                stackResolve(stackDepth, targetInstr,
                                             subAdjustMap);
                            subAdjust = new Integer(newDepth - stackDepth);
                            subAdjustMap.put(targetInstr, subAdjust);
                        }
                        
                        stackDepth += subAdjust.intValue();
                    }
                }
            }

            instr = next;
        }

        return stackDepth;
    }

    private class LocalVariableImpl implements LocalVariable {
        private String mName;
        private TypeDescriptor mType;
        private boolean mIsDoubleWord;
        
        private int mNumber;
        private boolean mFixed;

        private List mStoreInstructions;
        private SortedSet mLocationRangeSet;

        public LocalVariableImpl(String name, TypeDescriptor type,
                                 int number) {
            mName = name;
            mType = type;
            Class clazz = type.getClassArg();
            mIsDoubleWord = clazz == long.class || clazz == double.class;
            mNumber = number;
            if (number >= 0) {
                mFixed = true;
            }
            mStoreInstructions = new ArrayList();
        }
        
        /**
         * May return null if this LocalVariable is unnamed.
         */
        public String getName() {
            return mName;
        }
        
        public void setName(String name) {
            mName = name;
        }
        
        public TypeDescriptor getType() {
            return mType;
        }
        
        public boolean isDoubleWord() {
            return mIsDoubleWord;
        }
        
        public int getNumber() {
            return mNumber;
        }
        
        public void setNumber(int number) {
            mNumber = number;
        }

        public SortedSet getLocationRangeSet() {
            return mLocationRangeSet;
        }
        
        public void setLocations(Set locations) {
            /* TODO
            List sortedLocations = new ArrayList(locations);
            Collections.sort(sortedLocations);

            mLocationRangeSet = new TreeSet();
            
            Iterator it = sortedLocations.iterator();
            Instruction first = null;
            Instruction last = null;
            while (it.hasNext()) {
                Instruction instr = (Instruction)it.next();
                if (first == null) {
                    first = last = instr;
                }
                else if (last.mNext == instr) {
                    last = instr;
                }
                else {
                    if (last.mNext != null) {
                        last = last.mNext;
                    }
                    mLocationRangeSet.add(new LocationRangeImpl(first, last));
                    first = last = instr;
                }
            }

            if (first != null && last != null) {
                if (last.mNext != null) {
                    last = last.mNext;
                }
                mLocationRangeSet.add(new LocationRangeImpl(first, last));
            }

            mLocationRangeSet =
                Collections.unmodifiableSortedSet(mLocationRangeSet);
            */
        }

        public boolean isFixedNumber() {
            return mFixed;
        }

        public void addStoreInstruction(Instruction instr) {
            mStoreInstructions.add(instr);
        }

        public Iterator iterateStoreInstructions() {
            return mStoreInstructions.iterator();
        }

        public String toString() {
            if (getName() != null) {
                return String.valueOf(getType()) + ' ' + getName();
            }
            else {
                return String.valueOf(getType());
            }
        }
    }

    /////////////////////////////////////////////////////////////////////////
    //
    // Begin inner class definitions for instructions of the InstructionList.
    //
    /////////////////////////////////////////////////////////////////////////

    /**************************************************************************
     * An Instruction is an element in an InstructionList, and represents a 
     * Java byte code instruction.
     * 
     * @author Brian S O'Neill
     * @version
     * <!--$$Revision: 1.1 $-->, <!--$$JustDate:--> 01/05/14 <!-- $-->
     */
    public abstract class Instruction implements Location {
        private int mStackAdjust;

        Instruction mPrev;
        Instruction mNext;
    
        // Indicates what the stack depth is when this instruction is reached.
        // Is -1 if not reached. Flow analysis sets this value.
        int mStackDepth = -1;

        // Indicates the address of this instruction is, or -1 if not known.
        int mLocation = -1;

        /**
         * Newly created instructions are automatically added to the
         * InstructionList.
         */
        public Instruction(int stackAdjust) {
            mStackAdjust = stackAdjust;
            add();
        }

        /**
         * This constructor allows sub-classes to disable auto-adding to the
         * InstructionList.
         */
        protected Instruction(int stackAdjust, boolean addInstruction) {
            mStackAdjust = stackAdjust;

            if (addInstruction) {
                add();
            }
        }

        /**
         * Add this instruction to the end of the InstructionList. If the
         * Instruction is already in the list, then it is moved to the end.
         */
        protected void add() {
            InstructionList.this.mResolved = false;

            if (mPrev != null) {
                mPrev.mNext = mNext;
            }

            if (mNext != null) {
                mNext.mPrev = mPrev;
            }

            mNext = null;
            
            if (InstructionList.this.mFirst == null) {
                mPrev = null;
                InstructionList.this.mFirst = this;
            }
            else {
                mPrev = InstructionList.this.mLast;
                InstructionList.this.mLast.mNext = this;
            }
            
            InstructionList.this.mLast = this;
        }

        /**
         * Insert an Instruction immediately following this one.
         */
        public void insert(Instruction instr) {
            InstructionList.this.mResolved = false;

            instr.mPrev = this;
            instr.mNext = mNext;

            mNext = instr;

            if (this == InstructionList.this.mLast) {
                InstructionList.this.mLast = instr;
            }
        }

        /**
         * Removes this Instruction from its parent InstructionList.
         */
        public void remove() {
            InstructionList.this.mResolved = false;
            
            if (mPrev != null) {
                mPrev.mNext = mNext;
            }
            
            if (mNext != null) {
                mNext.mPrev = mPrev;
            }
            
            if (this == InstructionList.this.mFirst) {
                InstructionList.this.mFirst = mNext;
            }
            
            if (this == InstructionList.this.mLast) {
                InstructionList.this.mLast = mPrev;
            }
            
            mPrev = null;
            mNext = null;
        }

        /**
         * Replace this Instruction with another one.
         */
        public void replace(Instruction replacement) {
            if (replacement == null) {
                remove();
                return;
            }

            InstructionList.this.mResolved = false;

            replacement.mPrev = mPrev;
            replacement.mNext = mNext;

            if (mPrev != null) {
                mPrev.mNext = replacement;
            }
            
            if (mNext != null) {
                mNext.mPrev = replacement;
            }
            
            if (this == InstructionList.this.mFirst) {
                InstructionList.this.mFirst = replacement;
            }
            
            if (this == InstructionList.this.mLast) {
                InstructionList.this.mLast = replacement;
            }
        }
        
        /**
         * Returns a positive, negative or zero value indicating what affect
         * this generated instruction has on the runtime stack.
         */
        public int getStackAdjustment() {
            return mStackAdjust;
        }
        
        /**
         * Returns the stack depth for when this instruction is reached. If the
         * value is negative, then this instruction is never reached.
         */
        public int getStackDepth() {
            return mStackDepth;
        }
        
        /**
         * Returns the address of this instruction or -1 if not known.
         */
        public int getLocation() {
            return mLocation;
        }
        
        /**
         * Returns all of the targets that this instruction may branch to. Not
         * all instructions support branching, and null is returned by default.
         */
        public Location[] getBranchTargets() {
            return null;
        }
        
        /**
         * Returns true if execution flow may continue after this instruction.
         * It may be a goto, a method return, an exception throw or a
         * subroutine return. Default implementation returns true.
         */
        public boolean isFlowThrough() {
            return true;
        }

        public boolean isSubroutineCall() {
            return false;
        }
        
        /**
         * Returns null if this is a pseudo instruction and no bytes are
         * generated.
         */
        public abstract byte[] getBytes();
        
        /**
         * An instruction is resolved when it has all information needed to
         * generate correct byte code.
         */
        public abstract boolean isResolved();

        public int compareTo(Object obj) {
            if (this == obj) {
                return 0;
            }
            Location other = (Location)obj;

            int loca = getLocation();
            int locb = other.getLocation();

            if (loca < locb) {
                return -1;
            }
            else if (loca > locb) {
                return 1;
            }
            else {
                return 0;
            }
        }

        /**
         * Returns a string containing the type of this instruction, the stack
         * adjustment and the list of byte codes. Unvisted instructions are
         * marked with an asterisk.
         */
        public String toString() {
            String name = getClass().getName();
            int index = name.lastIndexOf('.');
            if (index >= 0) {
                name = name.substring(index + 1);
            }
            index = name.lastIndexOf('$');
            if (index >= 0) {
                name = name.substring(index + 1);
            }
            
            StringBuffer buf = new StringBuffer(name.length() + 20);
            
            int adjust = getStackAdjustment();
            int depth = getStackDepth();

            if (depth >= 0) {
                buf.append(' ');
            }
            else {
                buf.append('*');
            }
            
            buf.append('[');
            buf.append(mLocation);
            buf.append("] ");
            
            buf.append(name);
            buf.append(" (");
            
            if (depth >= 0) {
                buf.append(depth);
                buf.append(" + ");
                buf.append(adjust);
                buf.append(" = ");
                buf.append(depth + adjust);
            }
            else {
                buf.append(adjust);
            }
            
            buf.append(") ");
            
            try {
                byte[] bytes = getBytes();
                boolean wide = false;
                if (bytes != null) {
                    for (int i=0; i<bytes.length; i++) {
                        if (i > 0) {
                            buf.append(',');
                        }
                        
                        byte code = bytes[i];
                        
                        if (i == 0 || wide) {
                            buf.append(Opcode.getMnemonic(code));
                            wide = code == Opcode.WIDE;
                        }
                        else {
                            buf.append(code & 0xff);
                        }
                    }
                }
            }
            catch (Exception e) {
            }

            return buf.toString();
        }
    }

    /**************************************************************************
     * Defines a psuedo instruction for a label. No byte code is ever generated
     * from a label. Labels are not automatically added to the list.
     * 
     * @author Brian S O'Neill
     * @version
     * <!--$$Revision: 1.1 $-->, <!--$$JustDate:--> 01/05/14 <!-- $-->
     */
    public class LabelInstruction extends Instruction implements Label {
        public LabelInstruction() {
            super(0, false);
        }

        /**
         * Set this label's branch location to be the current address
         * in this label's parent CodeBuilder or InstructionList.
         *
         * @return This Label.
         */
        public Label setLocation() {
            add();
            return this;
        }

        /**
         * @return -1 when not resolved yet
         */ 
        public int getLocation() throws IllegalStateException {
            int loc; 
            if ((loc = mLocation) < 0) {
                if (mPrev == null && mNext == null) {
                    throw new IllegalStateException
                        ("Label location is not set");
                }
            }

            return loc;
        }

        /**
         * Always returns null.
         */
        public byte[] getBytes() {
            return null;
        }
        
        public boolean isResolved() {
            return getLocation() >= 0;
        }
    }

    /**************************************************************************
     * Defines a code instruction and has storage for byte codes.
     *
     * @author Brian S O'Neill
     * @version
     * <!--$$Revision: 1.1 $-->, <!--$$JustDate:--> 01/05/14 <!-- $-->
     */
    public class CodeInstruction extends Instruction {
        protected byte[] mBytes;
        
        public CodeInstruction(int stackAdjust) {
            super(stackAdjust);
        }
        
        protected CodeInstruction(int stackAdjust, boolean addInstruction) {
            super(stackAdjust, addInstruction);
        }

        public CodeInstruction(int stackAdjust, byte b) {
            super(stackAdjust);
            mBytes = new byte[] {b};
        }
        
        public CodeInstruction(int stackAdjust, byte[] bytes) {
            super(stackAdjust);
            mBytes = bytes;
        }
        
        public boolean isFlowThrough() {
            if (mBytes != null && mBytes.length > 0) {
                switch (mBytes[0]) {
                case Opcode.GOTO:
                case Opcode.GOTO_W:
                case Opcode.IRETURN:
                case Opcode.LRETURN:
                case Opcode.FRETURN:
                case Opcode.DRETURN:
                case Opcode.ARETURN:
                case Opcode.RETURN:
                case Opcode.ATHROW:
                    return false;
                }
            }
            
            return true;
        }
        
        public byte[] getBytes() {
            return mBytes;
        }
        
        public boolean isResolved() {
            return true;
        }
    }

    /**************************************************************************
     * Defines a branch instruction, like a goto, jsr or any conditional 
     * branch.
     *
     * @author Brian S O'Neill
     * @version
     * <!--$$Revision: 1.1 $-->, <!--$$JustDate:--> 01/05/14 <!-- $-->
     */
    public class BranchInstruction extends CodeInstruction {
        private Location mTarget;
        private boolean mHasShortHop = false;
        private boolean mIsSub = false;

        public BranchInstruction(int stackAdjust, 
                                 byte opcode, Location target) {
            this(stackAdjust, true, opcode, target);
        }

        private BranchInstruction(int stackAdjust, boolean addInstruction,
                                  byte opcode, Location target) {
            super(stackAdjust, addInstruction);
            
            mTarget = target;
            
            switch (opcode) {
            case Opcode.GOTO_W:
            case Opcode.JSR_W:
                mIsSub = true;
                mBytes = new byte[5];
                mBytes[0] = opcode;
                break;
            case Opcode.JSR:
                mIsSub = true;
                // Flow through to next case.
            case Opcode.GOTO:
            case Opcode.IF_ACMPEQ:
            case Opcode.IF_ACMPNE:
            case Opcode.IF_ICMPEQ:
            case Opcode.IF_ICMPNE:
            case Opcode.IF_ICMPLT:
            case Opcode.IF_ICMPGE:
            case Opcode.IF_ICMPGT:
            case Opcode.IF_ICMPLE:
            case Opcode.IFEQ:
            case Opcode.IFNE:
            case Opcode.IFLT:
            case Opcode.IFGE:
            case Opcode.IFGT:
            case Opcode.IFLE:
            case Opcode.IFNONNULL:
            case Opcode.IFNULL:
                mBytes = new byte[3];
                mBytes[0] = opcode;
                break;
            default:
                throw new IllegalArgumentException
                    ("Opcode not a branch instruction: " + 
                     Opcode.getMnemonic(opcode));
            }
        }
        
        public Location[] getBranchTargets() {
            return new Location[] {mTarget};
        }
        
        public boolean isSubroutineCall() {
            return mIsSub;
        }

        public byte[] getBytes() {
            if (!isResolved() || mHasShortHop) {
                return mBytes;
            }
            
            int offset = mTarget.getLocation() - mLocation;
            byte opcode = mBytes[0];
            
            if (opcode == Opcode.GOTO_W || opcode == Opcode.JSR_W) {
                mBytes[1] = (byte)(offset >> 24);
                mBytes[2] = (byte)(offset >> 16);
                mBytes[3] = (byte)(offset >> 8);
                mBytes[4] = (byte)(offset >> 0);
            }
            else if (-32768 <= offset && offset <= 32767) {
                mBytes[1] = (byte)(offset >> 8);
                mBytes[2] = (byte)(offset >> 0);
            }
            else if (opcode == Opcode.GOTO || opcode == Opcode.JSR) {
                mBytes = new byte[5];
                if (opcode == Opcode.GOTO) {
                    mBytes[0] = Opcode.GOTO_W;
                }
                else {
                    mBytes[0] = Opcode.JSR_W;
                }
                mBytes[1] = (byte)(offset >> 24);
                mBytes[2] = (byte)(offset >> 16);
                mBytes[3] = (byte)(offset >> 8);
                mBytes[4] = (byte)(offset >> 0);
            }
            else {
                // The if branch requires a 32 bit offset.
                
                // Convert:
                //
                //           if <cond> goto target
                //           // reached if <cond> false
                // target:   // reached if <cond> true
                
                // to this:
                //
                //           if not <cond> goto shortHop
                //           goto_w target
                // shortHop: // reached if <cond> false
                // target:   // reached if <cond> true
                
                mHasShortHop = true;
                
                opcode = Opcode.reverseIfOpcode(opcode);
                
                mBytes[0] = opcode;
                mBytes[1] = (byte)0;
                mBytes[2] = (byte)8;
                
                // insert goto_w instruction after this one.
                insert
                    (new BranchInstruction(0, false, Opcode.GOTO_W, mTarget));
            }
            
            return mBytes;
        }
        
        public boolean isResolved() {
            return mTarget.getLocation() >= 0;
        }
    }

    /**************************************************************************
     * Defines an instruction that has a single operand which references a
     * constant in the constant pool.
     *
     * @author Brian S O'Neill
     * @version
     * <!--$$Revision: 1.1 $-->, <!--$$JustDate:--> 01/05/14 <!-- $-->
     */
    public class ConstantOperandInstruction extends CodeInstruction {
        private ConstantInfo mInfo;
        
        public ConstantOperandInstruction(int stackAdjust,
                                          byte[] bytes,
                                          ConstantInfo info) {
            super(stackAdjust, bytes);
            mInfo = info;
        }
        
        public byte[] getBytes() {
            int index = mInfo.getIndex();
            
            if (index < 0) {
                throw new RuntimeException("Constant pool index not resolved");
            }
            
            mBytes[1] = (byte)(index >> 8);
            mBytes[2] = (byte)index;
            
            return mBytes;
        }
        
        public boolean isResolved() {
            return mInfo.getIndex() >= 0;
        }
    }

    /**************************************************************************
     * Defines an instruction that loads a constant onto the stack from the
     * constant pool.
     * 
     * @author Brian S O'Neill
     * @version
     * <!--$$Revision: 1.1 $-->, <!--$$JustDate:--> 01/05/14 <!-- $-->
     */
    public class LoadConstantInstruction extends CodeInstruction {
        private ConstantInfo mInfo;
        private boolean mWideOnly;
        
        public LoadConstantInstruction(int stackAdjust,
                                       ConstantInfo info) {
            this(stackAdjust, info, false);
        }

        public LoadConstantInstruction(int stackAdjust,
                                       ConstantInfo info,
                                       boolean wideOnly) {
            super(stackAdjust);
            mInfo = info;
            mWideOnly = wideOnly;
        }
        
        public boolean isFlowThrough() {
            return true;
        }
        
        public byte[] getBytes() {
            int index = mInfo.getIndex();
            
            if (index < 0) {
                throw new RuntimeException("Constant pool index not resolved");
            }
            
            if (mWideOnly) {
                byte[] bytes = new byte[3];
                bytes[0] = Opcode.LDC2_W;
                bytes[1] = (byte)(index >> 8);
                bytes[2] = (byte)index;
                return bytes;
            }
            else if (index <= 255) {
                byte[] bytes = new byte[2];
                bytes[0] = Opcode.LDC;
                bytes[1] = (byte)index;
                return bytes;
            }
            else {
                byte[] bytes = new byte[3];
                bytes[0] = Opcode.LDC_W;
                bytes[1] = (byte)(index >> 8);
                bytes[2] = (byte)index;
                return bytes;
            }
        }
        
        public boolean isResolved() {
            return mInfo.getIndex() >= 0;
        }
    }

    /**************************************************************************
     * Defines an instruction that contains an operand for referencing a
     * LocalVariable.
     *
     * @author Brian S O'Neill
     * @version
     * <!--$$Revision: 1.1 $-->, <!--$$JustDate:--> 01/05/14 <!-- $-->
     */
    public class LocalOperandInstruction extends CodeInstruction {
        protected LocalVariable mLocal;
        
        public LocalOperandInstruction(int stackAdjust,
                                       LocalVariable local) {
            super(stackAdjust);
            mLocal = local;
        }
        
        public boolean isResolved() {
            return mLocal.getNumber() >= 0;
        }
        
        public LocalVariable getLocalVariable() {
            return mLocal;
        }
        
        public int getVariableNumber() {
            int varNum = mLocal.getNumber();
            
            if (varNum < 0) {
                throw new RuntimeException
                    ("Local variable number not resolved");
            }
            
            return varNum;
        }
    }

    /**************************************************************************
     * Defines an instruction that loads a local variable onto the stack.
     *
     * @author Brian S O'Neill
     * @version
     * <!--$$Revision: 1.1 $-->, <!--$$JustDate:--> 01/05/14 <!-- $-->
     */
    public class LoadLocalInstruction extends LocalOperandInstruction {
        public LoadLocalInstruction(int stackAdjust,
                                    LocalVariable local) {
            super(stackAdjust, local);
        }
        
        public boolean isFlowThrough() {
            return true;
        }
        
        public byte[] getBytes() {
            int varNum = getVariableNumber();
            byte opcode;
            boolean writeIndex = false;

            TypeDescriptor type = mLocal.getType();
            Class clazz;
            if (type.getDimensions() > 0) {
                clazz = null;
            }
            else {
                clazz = type.getClassArg();
            }

            switch(varNum) {
            case 0:
                if (clazz == null || !clazz.isPrimitive()) {
                    opcode = Opcode.ALOAD_0;
                }
                else if (clazz == long.class) {
                    opcode = Opcode.LLOAD_0;
                }
                else if (clazz == float.class) {
                    opcode = Opcode.FLOAD_0;
                }
                else if (clazz == double.class) {
                    opcode = Opcode.DLOAD_0;
                }
                else {
                    opcode = Opcode.ILOAD_0;
                }
                break;
            case 1:
                if (clazz == null || !clazz.isPrimitive()) {
                    opcode = Opcode.ALOAD_1;
                }
                else if (clazz == long.class) {
                    opcode = Opcode.LLOAD_1;
                }
                else if (clazz == float.class) {
                    opcode = Opcode.FLOAD_1;
                }
                else if (clazz == double.class) {
                    opcode = Opcode.DLOAD_1;
                }
                else {
                    opcode = Opcode.ILOAD_1;
                }
                break;
            case 2:
                if (clazz == null || !clazz.isPrimitive()) {
                    opcode = Opcode.ALOAD_2;
                }
                else if (clazz == long.class) {
                    opcode = Opcode.LLOAD_2;
                }
                else if (clazz == float.class) {
                    opcode = Opcode.FLOAD_2;
                }
                else if (clazz == double.class) {
                    opcode = Opcode.DLOAD_2;
                }
                else {
                    opcode = Opcode.ILOAD_2;
                }
                break;
            case 3:
                if (clazz == null || !clazz.isPrimitive()) {
                    opcode = Opcode.ALOAD_3;
                }
                else if (clazz == long.class) {
                    opcode = Opcode.LLOAD_3;
                }
                else if (clazz == float.class) {
                    opcode = Opcode.FLOAD_3;
                }
                else if (clazz == double.class) {
                    opcode = Opcode.DLOAD_3;
                }
                else {
                    opcode = Opcode.ILOAD_3;
                }
                break;
            default:
                writeIndex = true;
                
                if (clazz == null || !clazz.isPrimitive()) {
                    opcode = Opcode.ALOAD;
                }
                else if (clazz == long.class) {
                    opcode = Opcode.LLOAD;
                }
                else if (clazz == float.class) {
                    opcode = Opcode.FLOAD;
                }
                else if (clazz == double.class) {
                    opcode = Opcode.DLOAD;
                }
                else {
                    opcode = Opcode.ILOAD;
                }
                break;
            }

            if (!writeIndex) {
                mBytes = new byte[] { opcode };
            }
            else {
                if (varNum <= 255) {
                    mBytes = new byte[] { opcode, (byte)varNum };
                }
                else {
                    mBytes = new byte[] 
                    {
                        Opcode.WIDE,
                        opcode,
                        (byte)(varNum >> 8),
                        (byte)varNum
                    };
                }
            }
            
            return mBytes;
        }
    }

    /**************************************************************************
     * Defines an instruction that stores a value from the stack into a local 
     * variable.
     * 
     * @author Brian S O'Neill
     * @version
     * <!--$$Revision: 1.1 $-->, <!--$$JustDate:--> 01/05/14 <!-- $-->
     */
    public class StoreLocalInstruction extends LocalOperandInstruction {
        public StoreLocalInstruction(int stackAdjust,
                                     LocalVariable local) {
            super(stackAdjust, local);
            ((LocalVariableImpl)local).addStoreInstruction(this);
        }
        
        public boolean isFlowThrough() {
            return true;
        }
        
        public byte[] getBytes() {
            int varNum = getVariableNumber();
            byte opcode;
            boolean writeIndex = false;

            TypeDescriptor type = mLocal.getType();
            Class clazz;
            if (type.getDimensions() > 0) {
                clazz = null;
            }
            else {
                clazz = type.getClassArg();
            }
            
            switch(varNum) {
            case 0:
                if (clazz == null || !clazz.isPrimitive()) {
                    opcode = Opcode.ASTORE_0;
                }
                else if (clazz == long.class) {
                    opcode = Opcode.LSTORE_0;
                }
                else if (clazz == float.class) {
                    opcode = Opcode.FSTORE_0;
                }
                else if (clazz == double.class) {
                    opcode = Opcode.DSTORE_0;
                }
                else {
                    opcode = Opcode.ISTORE_0;
                }
                break;
            case 1:
                if (clazz == null || !clazz.isPrimitive()) {
                    opcode = Opcode.ASTORE_1;
                }
                else if (clazz == long.class) {
                    opcode = Opcode.LSTORE_1;
                }
                else if (clazz == float.class) {
                    opcode = Opcode.FSTORE_1;
                }
                else if (clazz == double.class) {
                    opcode = Opcode.DSTORE_1;
                }
                else {
                    opcode = Opcode.ISTORE_1;
                }
                break;
            case 2:
                if (clazz == null || !clazz.isPrimitive()) {
                    opcode = Opcode.ASTORE_2;
                }
                else if (clazz == long.class) {
                    opcode = Opcode.LSTORE_2;
                }
                else if (clazz == float.class) {
                    opcode = Opcode.FSTORE_2;
                }
                else if (clazz == double.class) {
                    opcode = Opcode.DSTORE_2;
                }
                else {
                    opcode = Opcode.ISTORE_2;
                }
                break;
            case 3:
                if (clazz == null || !clazz.isPrimitive()) {
                    opcode = Opcode.ASTORE_3;
                }
                else if (clazz == long.class) {
                    opcode = Opcode.LSTORE_3;
                }
                else if (clazz == float.class) {
                    opcode = Opcode.FSTORE_3;
                }
                else if (clazz == double.class) {
                    opcode = Opcode.DSTORE_3;
                }
                else {
                    opcode = Opcode.ISTORE_3;
                }
                break;
            default:
                writeIndex = true;
                
                if (clazz == null || !clazz.isPrimitive()) {
                    opcode = Opcode.ASTORE;
                }
                else if (clazz == long.class) {
                    opcode = Opcode.LSTORE;
                }
                else if (clazz == float.class) {
                    opcode = Opcode.FSTORE;
                }
                else if (clazz == double.class) {
                    opcode = Opcode.DSTORE;
                }
                else {
                    opcode = Opcode.ISTORE;
                }
                break;
            }
            
            if (!writeIndex) {
                mBytes = new byte[] { opcode };
            }
            else {
                if (varNum <= 255) {
                    mBytes = new byte[] { opcode, (byte)varNum };
                }
                else {
                    mBytes = new byte[] 
                    {
                        Opcode.WIDE,
                        opcode,
                        (byte)(varNum >> 8),
                        (byte)varNum
                    };
                }
            }
            
            return mBytes;
        }
    }
    
    /**************************************************************************
     * Defines a ret instruction for returning from a jsr call. 
     *
     * @author Brian S O'Neill
     * @version
     * <!--$$Revision: 1.1 $-->, <!--$$JustDate:--> 01/05/14 <!-- $-->
     */
    public class RetInstruction extends LocalOperandInstruction {
        public RetInstruction(LocalVariable local) {
            super(0, local);
        }
        
        public boolean isFlowThrough() {
            return false;
        }
        
        public byte[] getBytes() {
            int varNum = getVariableNumber();
            
            if (varNum <= 255) {
                mBytes = new byte[] { Opcode.RET, (byte)varNum };
            }
            else {
                mBytes = new byte[] 
                { 
                    Opcode.WIDE, 
                    Opcode.RET, 
                    (byte)(varNum >> 8),
                    (byte)varNum
                };
            }
            
            return mBytes;
        }
    }

    /**************************************************************************
     * Defines a specialized instruction that increments a local variable by
     * a signed 16-bit amount.
     * 
     * @author Brian S O'Neill
     * @version
     * <!--$$Revision: 1.1 $-->, <!--$$JustDate:--> 01/05/14 <!-- $-->
     */
    public class ShortIncrementInstruction extends LocalOperandInstruction {
        private short mAmount;
        
        public ShortIncrementInstruction(LocalVariable local, short amount) {
            super(0, local);
            mAmount = amount;
        }
        
        public boolean isFlowThrough() {
            return true;
        }
        
        public byte[] getBytes() {
            int varNum = getVariableNumber();
            
            if ((-128 <= mAmount && mAmount <= 127) && varNum <= 255) {
                mBytes = new byte[] 
                { Opcode.IINC, 
                  (byte)varNum, 
                  (byte)mAmount 
                };
            }
            else {
                mBytes = new byte[]
                {
                    Opcode.WIDE,
                    Opcode.IINC,
                    (byte)(varNum >> 8),
                    (byte)varNum,
                    (byte)(mAmount >> 8),
                    (byte)mAmount
                };
            }
            
            return mBytes;
        }
    }

    /**************************************************************************
     * Defines a switch instruction. The choice of which actual switch 
     * implementation to use (table or lookup switch) is determined 
     * automatically based on which generates to the smallest amount of bytes.
     *
     * @author Brian S O'Neill
     * @version
     * <!--$$Revision: 1.1 $-->, <!--$$JustDate:--> 01/05/14 <!-- $-->
     */
    public class SwitchInstruction extends CodeInstruction {
        private int[] mCases;
        private Location[] mLocations;
        private Location mDefaultLocation;
        
        private byte mOpcode;
        
        private int mSmallest;
        private int mLargest;
        
        public SwitchInstruction(int[] casesParam,
                                 Location[] locationsParam,
                                 Location defaultLocation) {
            // A SwitchInstruction always adjusts the stack by -1 because it 
            // pops the switch key off the stack.
            super(-1);

            if (casesParam.length != locationsParam.length) {
                throw new IllegalArgumentException
                    ("Switch cases and locations sizes differ: " + 
                     casesParam.length + ", " + locationsParam.length);
            }
            
            mCases = new int[casesParam.length];
            System.arraycopy(casesParam, 0, mCases, 0, casesParam.length);
            
            mLocations = new Location[locationsParam.length];
            System.arraycopy(locationsParam, 0, mLocations, 
                             0, locationsParam.length);
            
            mDefaultLocation = defaultLocation;
            
            // First sort the cases and locations.
            sort(0, mCases.length - 1);
            
            // Check for duplicate cases.
            int lastCase = 0;
            for (int i=0; i<mCases.length; i++) {
                if (i > 0 && mCases[i] == lastCase) {
                    throw new RuntimeException("Duplicate switch cases: " +
                                               lastCase);
                }
                lastCase = mCases[i];
            }
            
            // Now determine which kind of switch to use.
            
            mSmallest = mCases[0];
            mLargest = mCases[mCases.length - 1];
            int tSize = 12 + 4 * (mLargest - mSmallest + 1);
            
            int lSize = 8 + 8 * mCases.length;
            
            if (tSize <= lSize) {
                mOpcode = Opcode.TABLESWITCH;
            }
            else {
                mOpcode = Opcode.LOOKUPSWITCH;
            }
        }   
        
        public Location[] getBranchTargets() {
            Location[] targets = new Location[mLocations.length + 1];
            System.arraycopy(mLocations, 0, targets, 0, mLocations.length);
            targets[targets.length - 1] = mDefaultLocation;
            
            return targets;
        }
        
        public boolean isFlowThrough() {
            return false;
        }
        
        public byte[] getBytes() {
            int length = 1;
            int pad = 3 - (mLocation & 3);
            length += pad;
            
            if (mOpcode == Opcode.TABLESWITCH) {
                length += 12 + 4 * (mLargest - mSmallest + 1);
            }
            else {
                length += 8 + 8 * mCases.length;
            }
            
            mBytes = new byte[length];
            
            if (!isResolved()) {
                return mBytes;
            }
            
            mBytes[0] = mOpcode;
            int cursor = pad + 1;
            
            int defaultOffset = mDefaultLocation.getLocation() - mLocation;
            mBytes[cursor++] = (byte)(defaultOffset >> 24);
            mBytes[cursor++] = (byte)(defaultOffset >> 16);
            mBytes[cursor++] = (byte)(defaultOffset >> 8);
            mBytes[cursor++] = (byte)(defaultOffset >> 0);
            
            if (mOpcode == Opcode.TABLESWITCH) {
                mBytes[cursor++] = (byte)(mSmallest >> 24);
                mBytes[cursor++] = (byte)(mSmallest >> 16);
                mBytes[cursor++] = (byte)(mSmallest >> 8);
                mBytes[cursor++] = (byte)(mSmallest >> 0);
                
                mBytes[cursor++] = (byte)(mLargest >> 24);
                mBytes[cursor++] = (byte)(mLargest >> 16);
                mBytes[cursor++] = (byte)(mLargest >> 8);
                mBytes[cursor++] = (byte)(mLargest >> 0);
                
                int index = 0;
                for (int case_ = mSmallest; case_ <= mLargest; case_++) {
                    if (case_ == mCases[index]) {
                        int offset = 
                            mLocations[index].getLocation() - mLocation;
                        mBytes[cursor++] = (byte)(offset >> 24);
                        mBytes[cursor++] = (byte)(offset >> 16);
                        mBytes[cursor++] = (byte)(offset >> 8);
                        mBytes[cursor++] = (byte)(offset >> 0);
                        
                        index++;
                    }
                    else {
                        mBytes[cursor++] = (byte)(defaultOffset >> 24);
                        mBytes[cursor++] = (byte)(defaultOffset >> 16);
                        mBytes[cursor++] = (byte)(defaultOffset >> 8);
                        mBytes[cursor++] = (byte)(defaultOffset >> 0);
                    }
                }
            }
            else {
                mBytes[cursor++] = (byte)(mCases.length >> 24);
                mBytes[cursor++] = (byte)(mCases.length >> 16);
                mBytes[cursor++] = (byte)(mCases.length >> 8);
                mBytes[cursor++] = (byte)(mCases.length >> 0);
                
                for (int index = 0; index < mCases.length; index++) {
                    int case_ = mCases[index];
                    
                    mBytes[cursor++] = (byte)(case_ >> 24);
                    mBytes[cursor++] = (byte)(case_ >> 16);
                    mBytes[cursor++] = (byte)(case_ >> 8);
                    mBytes[cursor++] = (byte)(case_ >> 0);
                    
                    int offset = mLocations[index].getLocation() - mLocation;
                    mBytes[cursor++] = (byte)(offset >> 24);
                    mBytes[cursor++] = (byte)(offset >> 16);
                    mBytes[cursor++] = (byte)(offset >> 8);
                    mBytes[cursor++] = (byte)(offset >> 0);
                }
            }
            
            return mBytes;
        }

        public boolean isResolved() {
            if (mDefaultLocation.getLocation() >= 0) {
                for (int i=0; i<mLocations.length; i++) {
                    if (mLocations[i].getLocation() < 0) {
                        break;
                    }
                }
                
                return true;
            }
            
            return false;
        }
        
        private void sort(int left, int right) {
            if (left >= right) {
                return;
            }
            
            swap(left, (left + right) / 2); // move middle element to 0
            
            int last = left;
            
            for (int i = left + 1; i <= right; i++) {
                if (mCases[i] < mCases[left]) {
                    swap(++last, i);
                }
            }
            
            swap(left, last);
            sort(left, last-1);
            sort(last + 1, right);
        }
        
        private void swap(int i, int j) {
            int tempInt = mCases[i];
            mCases[i] = mCases[j];
            mCases[j] = tempInt;
            
            Location tempLocation = mLocations[i];
            mLocations[i] = mLocations[j];
            mLocations[j] = tempLocation;
        }
    }
}