Source code: com/techtrader/modules/tools/bytecode/Code.java

   package com.techtrader.modules.tools.bytecode;
   
   
   import java.util.List;
   import java.util.LinkedList;
   import java.util.ListIterator;
   import java.util.Iterator;
   import java.io.IOException;
   import java.io.DataInput;
  import java.io.DataOutput;
  import java.io.DataInputStream;
  import java.io.DataOutputStream;
  import java.io.ByteArrayInputStream;
  import java.io.ByteArrayOutputStream;
  
  import com.techtrader.modules.tools.bytecode.visitor.BCVisitor;
  
  
  /**
   *  Representation of a code block of a class.
   *  The methods of this class mimic those of
   *  the same name in the {@link java.util.ListIterator} class.  Note that 
   *  the size and index information of the Code block will change as opcodes
   *  are added.  
   *  <p>
   *  Code blocks are usually obtained from a BCMethod, but can also be
   *  constructed via the default Constructor.  Blocks created this way can
   *  be used to provide template instructions to the various search/replace
   *  methods in this class.
   *  <p>
   *  The Code class contains methods named after each JVM instruction, each
   *  of which adds the matching opcode to the code block at the 
   *  current iterator position.  There are also many pseudo-instruction
   *  methods that do not have a corresponding JVM opcode, but are provided
   *  for convenience when the exact opcode is difficult to determine at 
   *  compile time.  Unlike the other opcode methods, these convenience 
   *  methods have javadoc comments so that they are easy to pick out; 
   *  they should be skimmed to get an idea of the functionality that each 
   *  provides.  Also note that many Instructions are able to 'morph' their
   *  opcode on the fly as the arguments to the instruction change.  Thus
   *  the developer can initially call, for example, the aload_1 opcode, but
   *  later change the type to load to 'int', and the opcode will automatically
   *  morph to iload_1.
   *  
   *  @author    Abe White
   */
  public class Code
    extends Attribute
    implements Constants
  {
    private int       _maxStack  = 0;
    private int       _maxLocals  = 0;
    private List      _opcodes  = new LinkedList ();
    private List       _handlers   = new LinkedList ();
    private ListIterator  _li      = _opcodes.listIterator ();
  
  
    protected Code (int nameIndex, BCEntity owner)
    {
      super (nameIndex, owner);
    }
  
  
    /**
     *  The public constructor is for creating template code modules  
      *  that can be used to produce Instructions to be used in 
     *  matching for various search() and replace() methods.
     */
    public Code ()
    {
      // create a new empty anon class so we can use its
      // constant pool to track the code we create
      super (0, new BCClass ().addMethod ());
      _nameIndex = getPool ().setUTF (0, ATTR_CODE);
    }
  
  
    /**
     *  Get the maximum stack depth for this code block.
     */
    public int getMaxStack ()
    {
      return _maxStack;
    }
  
  
    /**
     *  Set the maximum stack depth for this code block.
     */
    public void setMaxStack (int max)
    {
      _maxStack = max;
    }
  
  
    /**
     *  Get the maximum number of local variables (including params)
     *  in this method.
     */
   public int getMaxLocals ()
   {
     return _maxLocals;
   }
 
   
   /**
    *  Set the maximum number of local variables (including params) in 
    *  this method.
    */
   public void setMaxLocals (int max)
   {
     _maxLocals = max;
   }
 
 
   /**
    *  Get the local variable index for the paramIndex'th parameter to 
    *  the method.   These numbers are different because 
    *  a) non-static methods use the 0th local variable for the 'this' ptr, and
    *  b) double and long values occupy two spots in the local 
    *  variable array.
    */
   public int getLocalsIndex (int paramIndex)
   {
     if (paramIndex < 0)
       return -1;
 
     int pos = 0;
     if (!((BCMethod) _owner).isStatic ())
       pos = 1;
 
     String[] params = ((BCMethod) _owner).getParamTypeNames ();
     for (int i = 0; i < paramIndex; i++, pos++)
       if (params[i].equals ("long") || params[i].equals ("double"))
         pos++;
 
     return pos;
   }
 
 
   /**
    *  Get the next next available local variable index.
    */
   public int getNextLocalsIndex ()
   {
     calculateMaxLocals ();
     return getMaxLocals ();
   }
 
 
   /**
    *  Ask the code to figure out the number of locals it needs based on
    *  the instructions used and the parameters of the method this code
    *  block is a part of.
    */
   public void calculateMaxLocals ()
   {
     // start off assuming the max number needed is the 
     // number for all the params
     String[] params = ((BCMethod) _owner).getParamTypeNames ();
     int max = 0;
     if (params.length == 0 && !((BCMethod) _owner).isStatic ())
       max = 1;
     else if (params.length > 0)
     {
       max = getLocalsIndex (params.length - 1) + 1;
       if (params[params.length-1].equals ("long")
         || params[params.length-1].equals ("double"))
         max++;
     }  
 
     // check to see if there are any store instructions that
     // try to reference beyond that point
     Instruction ins;
     StoreInstruction store;
     int current;
     for (Iterator i = _opcodes.iterator (); i.hasNext ();)
     {
       current = 0;
       ins = (Instruction) i.next ();
 
       if (ins instanceof StoreInstruction)
       {
         store = (StoreInstruction) ins;
         current = store.getIndex () + 1;
         if (store.getType ().equals (long.class) 
           || store.getType ().equals (double.class))  
           current++;
 
         if (current > max)
           max = current;
       }
     }
 
     setMaxLocals (max);
   }
 
 
   /**
    *  Ask the code to figure out the maximum stack depth it needs
    *  the instructions used.
    */
   public void calculateMaxStack ()
   {
     int stack = 0;
     int max = 0;
 
     ExceptionHandler[] handlers = getExceptionHandlers ();
     Instruction ins;
     for (Iterator i = _opcodes.iterator (); i.hasNext ();)
     {
       ins = (Instruction) i.next ();
       stack += ins.getStackChange ();
 
       // if this is the start of a try, the exception will be placed
       // on the stack
       for (int j = 0; j < handlers.length; j++)
         if (handlers[j].getTryStart () == ins)
           stack++;
 
       if (stack > max)
         max = stack;
     }
 
     setMaxStack (max);
   }
 
 
   /**
    *  Get the exception handlers active in this code block, or an
    *  empty array if none.
    */
   public ExceptionHandler[] getExceptionHandlers ()
   {
     return (ExceptionHandler[]) _handlers.toArray 
       (new ExceptionHandler[_handlers.size ()]);
   }
 
 
   /**
    *  Get the exception handler that catches the given exception type;
    *  if multiple handlers catch the given type, which is returned is
    *  undefined.
    */
   public ExceptionHandler getExceptionHandler (Class catchType)
   {
     return getExceptionHandler (catchType.getName ());
   }
 
 
   /**
    *  Get the exception handler that catches the given exception type;
    *  if multiple handlers catch the given type, which is returned is
    *  undefined.
    */
   public ExceptionHandler getExceptionHandler (String catchType)
   {
     ExceptionHandler next;
     for (Iterator i = _handlers.iterator (); i.hasNext ();)
     {
       next = (ExceptionHandler) i.next ();
       if (next.getCatchTypeName ().equals (catchType))
         return next;
     }
 
     return null;
   }
 
 
   /**
    *  Get all exception handlers that catch the given exception type.
    */
   public ExceptionHandler[] getExceptionHandlers (Class catchType)
   {
     return getExceptionHandlers (catchType.getName ());
   }
 
 
   /**
    *  Get all exception handlers that catch the given exception type.
    */
   public ExceptionHandler[] getExceptionHandlers (String catchType)
   {
     List matches = new LinkedList ();
 
     ExceptionHandler next;
     for (Iterator i = _handlers.iterator (); i.hasNext ();)
     {
       next = (ExceptionHandler) i.next ();
       if (next.getCatchTypeName ().equals (catchType))
         matches.add (next);
     }
 
     return (ExceptionHandler[]) matches.toArray 
       (new ExceptionHandler[matches.size ()]);
   }
 
 
   /**
    *  Add an exception handler to this code block.
    */
   public ExceptionHandler addExceptionHandler ()  
   {
     ExceptionHandler handler = new ExceptionHandler (this);
     _handlers.add (handler);
 
     return handler;
   }
 
 
   /**
    *  Add an exception handler to this code block.
    *
    *  @param  tryStart    the first instruction of the try {} block
     *  @param  tryEnd      the last instruction of the try {} block
    *  @param  handlerStart  the first instruction of the catch {} block
    *  @param  catchType    the type of Exception being caught
    */
   public ExceptionHandler addExceptionHandler (Instruction tryStart,
     Instruction tryEnd, Instruction handlerStart, Class catchType)
   {
     String catchName = null;
     if (catchType != null)
       catchName = catchType.getName ();
       
     return addExceptionHandler (tryStart, tryEnd, handlerStart, catchName);
   }
 
 
   /**
    *  Add an exception handler to this code block.
    *
    *  @param  tryStart    the first instruction of the try {} block
     *  @param  tryEnd      the last instruction of the try {} block
    *  @param  handlerStart  the first instruction of the catch {} block
    *  @param  catchType    the type of Exception being caught
     */
   public ExceptionHandler addExceptionHandler (Instruction tryStart,
     Instruction tryEnd, Instruction handlerStart, String catchType)
   {
     ExceptionHandler handler = addExceptionHandler ();
     handler.setTryStart (tryStart);
     handler.setTryEnd (tryEnd);
     handler.setHandlerStart (handlerStart);
     handler.setCatchTypeName (catchType);
 
     return handler;
   }
 
 
   /**
    *  Clear all exception handlers.
    */
   public void clearExceptionHandlers ()
   {
     _handlers.clear ();
   }
 
 
   /**
    *  Remove all exception handlers that catch the given type.
    */
   public boolean removeExceptionHandler (Class catchType)
   {
     ExceptionHandler[] matches = getExceptionHandlers (catchType);
     for (int i = 0; i < matches.length; i++)
       removeExceptionHandler (matches[i]);
 
     return (matches.length > 0);
   }
 
 
   /**
    *  Remove all exception handlers that catch the given type.
    */
   public boolean removeExceptionHandler (String catchType)
   {
     ExceptionHandler[] matches = getExceptionHandlers (catchType);
     for (int i = 0; i < matches.length; i++)
       removeExceptionHandler (matches[i]);
 
     return (matches.length > 0);
   }
 
 
   /**
    *  Remove an exception handler from this code block.
    */
   public boolean removeExceptionHandler (ExceptionHandler handler)
   {
     if (handler == null || !_handlers.remove (handler))
       return false;
 
     handler.invalidate ();
     return true;
   }
 
 
   /**
    *  Return the number of instructions in the method.
    */
   public int size ()
   {
     return _opcodes.size ();
   }
 
 
   /**
     *  Reset the position of the instruction iterator to the first opcode.
    */
   public void beforeFirst ()
   {
     _li = _opcodes.listIterator ();
   }
 
 
   /**
    *  Set the position of the instruction iterator to after the last opcode.
    */
   public void afterLast ()
   {
     _li = _opcodes.listIterator (_opcodes.size ());
   }
 
 
   /**
    *  Position the iterator just before the given instruction.  The 
     *  instruction must belong to this method.
    */
   public void before (Instruction ins)
   {
     Iterator instructions = _opcodes.iterator ();
     int pos = 0;
     for (; instructions.hasNext (); pos++)
       if (instructions.next () == ins)
         break;
 
     _li = _opcodes.listIterator (pos);
   }
 
 
   /**
    *  Position the iterator just after the given instruction.  The 
     *  instruction must belong to this method.
    */
   public void after (Instruction ins)
   {
     before (ins);
     next ();
   }
 
 
   /**
    *  Return true if a subsequent call to next() will return an instruction.
    */
   public boolean hasNext ()
   {
     return _li.hasNext ();
   }
 
 
   /**
    *  Return true if a subsequent call to previous() will return an
    *  instruction.
    */
   public boolean hasPrevious ()
   {
     return _li.hasPrevious ();
   }
 
 
   /**
    *  Return the next instruction.
    */
   public Instruction next ()
   {
     return (Instruction) _li.next ();
   }
 
 
   /**
    *  Return the index of the next instruction, or size() if at end.
    */
   public int nextIndex ()
   {
     return _li.nextIndex ();
   }
 
 
   /**
    *  Return the previous instruction.
    */
   public Instruction previous ()
   {
     return (Instruction) _li.previous ();
   }
 
 
   /**
    *  Return the index of the previous instruction, or -1 if at beginning.
    */
   public int previousIndex ()
   {
     return _li.previousIndex ();
   }
 
 
   /**
    *  Place the iterator before the given list index.
    */
   public void before (int index)
   {
     _li = _opcodes.listIterator (index);
   }
 
 
   /**
    *  Place the iterator after the given list index.
    */
   public void after (int index)
   {
     before (index);
     next ();
   }
 
 
   /**
    *  Find the next Instruction from the current iterator position that 
    *  matches the given one, according to  the equals() methods of the 
    *  Instruction types.  This allows for matching based on template
    *  instructions, as the equals() methods of most Instructions return
    *  true if the information for the given Instruction has not been filled
    *  in.  If a match is found, the iterator is placed after the matching
     *  Instruction.  If no match is found, moves the iterator to afterLast().
     *
    *  @return    true if match found  
    */
   public boolean searchForward (Instruction template)
   {
     Instruction next;
     while (hasNext ())
     {
       next = next ();
       if (next.equals (template))
         return true;
     }
     return false;
   }
 
 
   /**
    *  Find the closest previous Instruction from the current iterator 
    *  position that matches the given one, according to the equals() 
     *  methods of the Instruction types.  This allows for matching based on 
    *  template instructions, as the equals() methods of most Instructions 
    *  returns true if the information for the given Instruction has not been 
    *  filled in.  If a match is found, the iterator is placed before the 
    *  matching Instruction.  If no match is found, moves the iterator to 
    *  beforeFirst().
     *
    *  @return    true if match found  
    */
   public boolean searchBackward (Instruction template)
   {
     Instruction prev;
     while (hasPrevious ())
     {
       prev = previous ();
       if (prev.equals (template))
         return true;
     }
     return false;
   }
 
 
   /**
    *  Replaces the next Instruction with the given one.  It is an error to
    *  call this method if the iterator is afterLast().  After this 
    *  method, the iterator will be after the newly added Instruction.
    *  This method will also make sure that all jump points
    *  that referenced the old opcode are updated correctly.
     *
    *  @return    the newly added Instruction
    */
   public Instruction replaceNext (Instruction with)
   {
     Instruction  orig = (Instruction) _li.next ();
     Instruction  ins   = null;
 
     _li.remove ();
     if (with != null)
     {
       // create the new Instruction and copy import the given info
       ins = getInstruction (with.getOpCode ());
       ins.copy (with);
 
       // update all jump points
       updateJumpPoints (orig, ins);
     }
 
     return ins;
   }
 
 
   /**
    *  Replaces the previous Instruction with the given one.  It is an
    *  error to call this method if the iterator is beforeFirst().
     *  After this method, the iterator will be before the newly added
    *  Instruction.  This method will also make sure that all jump points
    *  that referenced the old opcode are updated correctly.
    *
    *  @return    the newly added Instruction
    */
   public Instruction replacePrevious (Instruction with)
   {
     Instruction  orig = (Instruction) _li.previous ();
     Instruction  ins   = null;
 
     _li.remove ();
     if (with != null)
     {
       // create the new Instruction and copy import the given info
       ins = getInstruction (with.getOpCode ());
       ins.copy (with);
 
       // update all jump points
       updateJumpPoints (orig, ins);
     }
 
     return ins;
   }
 
 
   /**
    *  Replaces all the Instructions in this code block that match the
    *  given template with the given Instruction.  After this method,
    *  the iterator will be in its original position.
    *
    *  @return    the number of substitutions made
    */
   public int replaceAll (Instruction template, Instruction with)
   {
     // remember the iterator position
     int pos = nextIndex ();
 
     beforeFirst ();
     int count;
     for (count = 0; searchForward (template); count++)
       replacePrevious (with);
 
     before (pos);
     return count;
   }
 
 
   /**
    *  Equivalent to looping over each given template/replacement
    *  pair and calling replaceAll(Instruction, Instruction) for each.
    */
   public int replaceAll (Instruction[] templates, Instruction[] with)
   {
     if (templates == null && with == null)
       return 0;
 
     int count = 0;
     for (int i = 0; i < templates.length; i++)
     {
       if (with == null)
         count += replaceAll (templates[i], null);
       else
         count += replaceAll (templates[i], with[i]);
     }
 
     return count;
   }
 
 
   /**
    *  Update all jump points that reference the original opcode
    *  to reference the new one.
    */
   private void updateJumpPoints (Instruction orig, Instruction ins)
   {
     ListIterator li = _opcodes.listIterator ();
 
     for (Instruction next; li.hasNext ();)
     {
       next = (Instruction) li.next ();
       if (next instanceof JumpInstruction)
       {
         if (orig.equals (((JumpInstruction) next).getTarget ()))
           ((JumpInstruction) next).setTarget (ins);
 
         if (next.getOpCode () == TABLESWITCH)
           updateJumpPoints (orig, ins, (TableSwitchInstruction) next);
         else if (next.getOpCode () == LOOKUPSWITCH)
           updateJumpPoints (orig, ins, (LookupSwitchInstruction)next);
       }
     }    
   }
 
 
   private void updateJumpPoints (Instruction orig, Instruction ins,
     TableSwitchInstruction update)
   {  
     Instruction[] jumps = update.getTargets ();
 
     for (int i = 0; i < jumps.length; i++)
       if (orig == jumps[i])
         jumps[i] = ins;
 
     update.setTargets (jumps);
   }
 
 
   private void updateJumpPoints (Instruction orig, Instruction ins,
     LookupSwitchInstruction update)
   {  
     Instruction[] jumps = update.getTargets ();
 
     for (int i = 0; i < jumps.length; i++)
       if (orig == jumps[i])
         jumps[i] = ins;
 
     update.setCases (update.getMatches (), jumps);
   }
 
 
   /**
     *  Remove the current instruction.
    */
   public void remove ()
   {
     _li.remove ();
   }
 
 
   public Instruction nop ()
   {
     return addInstruction (NOP);
   }
 
 
   /**
    *  Load some constant onto the stack.  The ConstantInstruction type
    *  takes any constant and correctly translates it into the proper
    *  opcode, depending on the constant type and value.  For example, 
    *  if the constant value is set to 0L, the opcode will be set to
    *  lconst_0.
    */
   public ConstantInstruction constant ()
   {
     return (ConstantInstruction) addInstruction 
       (new ConstantInstruction (this));
   }
 
   
   /**
    *  Loads a Class constant onto the stack.
    *  For primitive types, this translates into a 
    *  getstatic() for the TYPE field of the primitive's wrapper type.
    *  For non-primitives, things get much more complex.  Suffice it to
    *  say that the operation involves adding synthetic static fields
    *  and even methods to the class.  Note that this instruction requires
    *  up to 3 stack positions to execute.
    */
   public ClassConstantInstruction classconstant ()
   {
     return new ClassConstantInstruction 
       (((BCMethod) _owner).getOwner (), this, nop ());
   }
 
 
   public ConstantInstruction aconst_null ()
   {
     return (ConstantInstruction) addInstruction (new ConstantInstruction 
       (this, ACONST_NULL, null));
   }
 
 
   public ConstantInstruction iconst_m1 ()
   {
     return (ConstantInstruction) addInstruction (new ConstantInstruction 
       (this, ICONST_M1, new Integer (-1)));
   }
 
 
   public ConstantInstruction iconst_0 ()
   {
     return (ConstantInstruction) addInstruction (new ConstantInstruction 
       (this, ICONST_0, new Integer (0)));
   }
 
 
   public ConstantInstruction iconst_1 ()
   {
     return (ConstantInstruction) addInstruction (new ConstantInstruction 
       (this, ICONST_1, new Integer (1)));
   }
 
 
   public ConstantInstruction iconst_2 ()
   {
     return (ConstantInstruction) addInstruction (new ConstantInstruction 
       (this, ICONST_2, new Integer (2)));
   }
 
 
   public ConstantInstruction iconst_3 ()
   {
     return (ConstantInstruction) addInstruction (new ConstantInstruction 
       (this, ICONST_3, new Integer (3)));
   }
 
 
   public ConstantInstruction iconst_4 ()
   {
     return (ConstantInstruction) addInstruction (new ConstantInstruction 
       (this, ICONST_4, new Integer (4)));
   }
 
 
   public ConstantInstruction iconst_5 ()
   {
     return (ConstantInstruction) addInstruction (new ConstantInstruction 
       (this, ICONST_5, new Integer (5)));
   }
 
 
   public ConstantInstruction lconst_0 ()
   {
     return (ConstantInstruction) addInstruction (new ConstantInstruction 
       (this, LCONST_0, new Long (0)));
   }
 
 
   public ConstantInstruction lconst_1 ()
   {
     return (ConstantInstruction) addInstruction (new ConstantInstruction 
       (this, LCONST_1, new Long (1)));
   }
 
 
   public ConstantInstruction fconst_0 ()
   {
     return (ConstantInstruction) addInstruction (new ConstantInstruction 
       (this, FCONST_0, new Float (0)));
   }
 
 
   public ConstantInstruction fconst_1 ()
   {
     return (ConstantInstruction) addInstruction (new ConstantInstruction 
       (this, FCONST_1, new Float (1)));
   }
 
 
   public ConstantInstruction fconst_2 ()
   {
     return (ConstantInstruction) addInstruction (new ConstantInstruction 
       (this, FCONST_2, new Float (2)));
   }
 
 
   public ConstantInstruction dconst_0 ()
   {
     return (ConstantInstruction) addInstruction (new ConstantInstruction 
       (this, DCONST_0, new Double (0)));
   }
 
 
   public ConstantInstruction dconst_1 ()
   {
     return (ConstantInstruction) addInstruction (new ConstantInstruction 
       (this, DCONST_1, new Double (1)));
   }
 
 
   public ConstantInstruction bipush ()
   {
     return (ConstantInstruction) addInstruction (new ConstantInstruction 
       (this, BIPUSH, null));
   }
 
 
   public ConstantInstruction sipush ()
   {
     return (ConstantInstruction) addInstruction (new ConstantInstruction 
       (this, SIPUSH, null));
   }
 
 
   public ConstantInstruction ldc ()
   {
     return (ConstantInstruction) addInstruction (new ConstantInstruction 
       (this, LDC, null));
   }
 
 
   public ConstantInstruction ldc_w ()
   {
     return (ConstantInstruction) addInstruction (new ConstantInstruction 
       (this, LDC_W, null));
   }
 
 
   public ConstantInstruction ldc2_w ()
   {
     return (ConstantInstruction) addInstruction (new ConstantInstruction 
       (this, LDC2_W, null));
   }
 
 
   /**
    *  This is a convenience method to load a local variable onto the stack,
    *  if the type and index to load is not known at compile time.
    */
   public LoadInstruction load ()
   {
     return (LoadInstruction) addInstruction (new LoadInstruction (this));
   }
 
 
   public LoadInstruction iload ()
   {
     return (LoadInstruction) addInstruction (new LoadInstruction
       (this, ILOAD, int.class, -1));
   }
 
 
   public LoadInstruction iload_0 ()
   {
     return (LoadInstruction) addInstruction (new LoadInstruction 
       (this, ILOAD_0, int.class, 0));
   }
 
 
   public LoadInstruction iload_1 ()
   {
     return (LoadInstruction) addInstruction (new LoadInstruction 
       (this, ILOAD_1, int.class, 1));
   }
 
 
   public LoadInstruction iload_2 ()
   {
     return (LoadInstruction) addInstruction (new LoadInstruction 
       (this, ILOAD_2, int.class, 2));
   }
 
 
   public LoadInstruction iload_3 ()
   {
     return (LoadInstruction) addInstruction (new LoadInstruction 
       (this, ILOAD_3, int.class, 3));
   }
 
 
   public LoadInstruction lload ()
   {
     return (LoadInstruction) addInstruction (new LoadInstruction
       (this, LLOAD, long.class, -1));
   }
 
 
   public LoadInstruction lload_0 ()
   {
     return (LoadInstruction) addInstruction (new LoadInstruction
       (this, LLOAD_0, long.class, 0));
   }
 
 
   public LoadInstruction lload_1 ()
   {
     return (LoadInstruction) addInstruction (new LoadInstruction
       (this, LLOAD_1, long.class, 1));
   }
 
 
   public LoadInstruction lload_2 ()
   {
     return (LoadInstruction) addInstruction (new LoadInstruction
       (this, LLOAD_2, long.class, 2));
   }
 
 
   public LoadInstruction lload_3 ()
   {
     return (LoadInstruction) addInstruction (new LoadInstruction
       (this, LLOAD_3, long.class, 3));
   }
 
 
   public LoadInstruction fload ()
   {
     return (LoadInstruction) addInstruction (new LoadInstruction
       (this, FLOAD, float.class, -1));
   }
 

  public LoadInstruction fload_0 ()
  {
    return (LoadInstruction) addInstruction (new LoadInstruction
      (this, FLOAD_0, float.class, 0));
  }


  public LoadInstruction fload_1 ()
  {
    return (LoadInstruction) addInstruction (new LoadInstruction
      (this, FLOAD_1, float.class, 1));
  }


  public LoadInstruction fload_2 ()
  {
    return (LoadInstruction) addInstruction (new LoadInstruction
      (this, FLOAD_2, float.class, 2));
  }


  public LoadInstruction fload_3 ()
  {
    return (LoadInstruction) addInstruction (new LoadInstruction
      (this, FLOAD_3, float.class, 3));
  }


  public LoadInstruction dload ()
  {
    return (LoadInstruction) addInstruction (new LoadInstruction
      (this, DLOAD, double.class, -1));
  }


  public LoadInstruction dload_0 ()
  {
    return (LoadInstruction) addInstruction (new LoadInstruction
      (this, DLOAD_0, double.class, 0));
  }


  public LoadInstruction dload_1 ()
  {
    return (LoadInstruction) addInstruction (new LoadInstruction
      (this, DLOAD_1, double.class, 1));
  }


  public LoadInstruction dload_2 ()
  {
    return (LoadInstruction) addInstruction (new LoadInstruction
      (this, DLOAD_2, double.class, 2));
  }


  public LoadInstruction dload_3 ()
  {
    return (LoadInstruction) addInstruction (new LoadInstruction
      (this, DLOAD_3, double.class, 3));
  }


  public LoadInstruction aload ()
  {
    return (LoadInstruction) addInstruction (new LoadInstruction
      (this, ALOAD, Object.class, -1));
  }


  public LoadInstruction aload_0 ()
  {
    return (LoadInstruction) addInstruction (new LoadInstruction
      (this, ALOAD_0, Object.class, 0));
  }


  public LoadInstruction aload_1 ()
  {
    return (LoadInstruction) addInstruction (new LoadInstruction
      (this, ALOAD_1, Object.class, 1));
  }


  public LoadInstruction aload_2 ()
  {
    return (LoadInstruction) addInstruction (new LoadInstruction
      (this, ALOAD_2, Object.class, 2));
  }


  public LoadInstruction aload_3 ()
  {
    return (LoadInstruction) addInstruction (new LoadInstruction
      (this, ALOAD_3, Object.class, 3));
  }


  /**
   *  This is a convenience method to store a stack value into a local
   *  variable if the type and index to store is not known at compile time.
   */
  public StoreInstruction store ()
  {
    return (StoreInstruction) addInstruction (new StoreInstruction (this));
  }


  public StoreInstruction istore ()
  {
    return (StoreInstruction) addInstruction (new StoreInstruction
      (this, ISTORE, int.class, -1));
  }


  public StoreInstruction istore_0 ()
  {
    return (StoreInstruction) addInstruction (new StoreInstruction 
      (this, ISTORE_0, int.class, 0));
  }


  public StoreInstruction istore_1 ()
  {
    return (StoreInstruction) addInstruction (new StoreInstruction 
      (this, ISTORE_1, int.class, 1));
  }


  public StoreInstruction istore_2 ()
  {
    return (StoreInstruction) addInstruction (new StoreInstruction 
      (this, ISTORE_2, int.class, 2));
  }


  public StoreInstruction istore_3 ()
  {
    return (StoreInstruction) addInstruction (new StoreInstruction 
      (this, ISTORE_3, int.class, 3));
  }


  public StoreInstruction lstore ()
  {
    return (StoreInstruction) addInstruction (new StoreInstruction
      (this, LSTORE, long.class, -1));
  }


  public StoreInstruction lstore_0 ()
  {
    return (StoreInstruction) addInstruction (new StoreInstruction
      (this, LSTORE_0, long.class, 0));
  }


  public StoreInstruction lstore_1 ()
  {
    return (StoreInstruction) addInstruction (new StoreInstruction
      (this, LSTORE_1, long.class, 1));
  }


  public StoreInstruction lstore_2 ()
  {
    return (StoreInstruction) addInstruction (new StoreInstruction
      (this, LSTORE_2, long.class, 2));
  }


  public StoreInstruction lstore_3 ()
  {
    return (StoreInstruction) addInstruction (new StoreInstruction
      (this, LSTORE_3, long.class, 3));
  }


  public StoreInstruction fstore ()
  {
    return (StoreInstruction) addInstruction (new StoreInstruction
      (this, FSTORE, float.class, -1));
  }


  public StoreInstruction fstore_0 ()
  {
    return (StoreInstruction) addInstruction (new StoreInstruction
      (this, FSTORE_0, float.class, 0));
  }


  public StoreInstruction fstore_1 ()
  {
    return (StoreInstruction) addInstruction (new StoreInstruction
      (this, FSTORE_1, float.class, 1));
  }


  public StoreInstruction fstore_2 ()
  {
    return (StoreInstruction) addInstruction (new StoreInstruction
      (this, FSTORE_2, float.class, 2));
  }


  public StoreInstruction fstore_3 ()
  {
    return (StoreInstruction) addInstruction (new StoreInstruction
      (this, FSTORE_3, float.class, 3));
  }


  public StoreInstruction dstore ()
  {
    return (StoreInstruction) addInstruction (new StoreInstruction
      (this, DSTORE, double.class, -1));
  }


  public StoreInstruction dstore_0 ()
  {
    return (StoreInstruction) addInstruction (new StoreInstruction
      (this, DSTORE_0, double.class, 0));
  }


  public StoreInstruction dstore_1 ()
  {
    return (StoreInstruction) addInstruction (new StoreInstruction
      (this, DSTORE_1, double.class, 1));
  }


  public StoreInstruction dstore_2 ()
  {
    return (StoreInstruction) addInstruction (new StoreInstruction
      (this, DSTORE_2, double.class, 2));
  }


  public StoreInstruction dstore_3 ()
  {
    return (StoreInstruction) addInstruction (new StoreInstruction
      (this, DSTORE_3, double.class, 3));
  }


  public StoreInstruction astore ()
  {
    return (StoreInstruction) addInstruction (new StoreInstruction
      (this, ASTORE, Object.class, -1));
  }


  public StoreInstruction astore_0 ()
  {
    return (StoreInstruction) addInstruction (new StoreInstruction
      (this, ASTORE_0, Object.class, 0));
  }


  public StoreInstruction astore_1 ()
  {
    return (StoreInstruction) addInstruction (new StoreInstruction
      (this, ASTORE_1, Object.class, 1));
  }


  public StoreInstruction astore_2 ()
  {
    return (StoreInstruction) addInstruction (new StoreInstruction
      (this, ASTORE_2, Object.class, 2));
  }


  public StoreInstruction astore_3 ()
  {
    return (StoreInstruction) addInstruction (new StoreInstruction
      (this, ASTORE_3, Object.class, 3));
  }


  public RetInstruction ret ()
  {
    return (RetInstruction) addInstruction (new RetInstruction (this));
  }


  public IIncInstruction iinc ()
  {
    return (IIncInstruction) addInstruction (new IIncInstruction (this));
  }


  public WideInstruction wide ()
  {
    return (WideInstruction) addInstruction (new WideInstruction (this));
  }


  /**
   *  This is a convenience method to invoke the proper array load instruction
   *  if the type is not known at compile time.
   */
  public ArrayLoadInstruction arrayload ()
  {
    return (ArrayLoadInstruction) addInstruction 
      (new ArrayLoadInstruction (this));
  }


  public ArrayLoadInstruction iaload ()
  {
    return (ArrayLoadInstruction) addInstruction 
      (new ArrayLoadInstruction (this, IALOAD, int.class));
  }


  public ArrayLoadInstruction laload ()
  {
    return (ArrayLoadInstruction) addInstruction 
      (new ArrayLoadInstruction (this, LALOAD, long.class));
  }


  public ArrayLoadInstruction faload ()
  {
    return (ArrayLoadInstruction) addInstruction 
      (new ArrayLoadInstruction (this, FALOAD, float.class));
  }


  public ArrayLoadInstruction daload ()
  {
    return (ArrayLoadInstruction) addInstruction 
      (new ArrayLoadInstruction (this, DALOAD, double.class));
  }


  public ArrayLoadInstruction aaload ()
  {
    return (ArrayLoadInstruction) addInstruction 
      (new ArrayLoadInstruction (this, AALOAD, Object.class));
  }


  public ArrayLoadInstruction baload ()
  {
    return (ArrayLoadInstruction) addInstruction 
      (new ArrayLoadInstruction (this, BALOAD, byte.class));
  }


  public ArrayLoadInstruction caload ()
  {
    return (ArrayLoadInstruction) addInstruction 
      (new