public Interface MethodBuilder

Declare the method throws an exception. Must be called before any code is added to the method.

Call a method. The instance (receiver or reference) for non-static methods must be pushed by the caller. The instance (for non-static) and the arguments are popped of the stack, and the return value (if any) is pushed onto the stack.
The type needs to be one of:

• VMOpcode.INVOKESTATIC - call a static method
• VMOpcode.INVOKEVIRTUAL - call method declared in the class or super-class.
• VMOpcode.INVOKEINTERFACE - call a method declared in an interface

static methods

Stack ...,value* => [numArgs number of values will be popped]
      ...,return_value [void methods will not push a value]

non-static methods

Stack ...,ref,value* => [numArgs number of values will be popped]
      ...,return_value [void methods will not push a value]

Parameters

type:short

type of method invocation

declaringClass:String

Class or interface the method is declared in. If it is a non-static method call then if declaringClass is null, the declared type is taken to be the type of the reference that will be popped.

methodName:String

name of the method

returnType:String

class name or primitive type (including "void") of the return type of the method, can not be null.

numArgs:int

number of arguments to the method (can be 0).

Call a method previously described by describeMethod().

static methods

Stack ...,value* => [numArgs number of values will be popped]
      ...,return_value [void methods will not push a value]

non-static methods

Stack ...,ref,value* => [numArgs number of values will be popped]
      ...,return_value [void methods will not push a value]

Call super(). Caller must only add this to a constructor.

Stack ... =>
      ... 

Cast the top stack value. Correctly down-casts a reference or casts a primitive type (e.g. int to short).

Stack ...,value =>
      ...,cast_value

Parameters

className:String

type (primitive, interface or class) to cast to.

Indicate the method is complete. Once this call has been made the caller must discard the reference to this object.

Complete a conditional which completes the false code path.

Initiate a conditional sequence. The top value on the stack must be a boolean and will be popped. If it is true then the code following this call until the startElseCode() will be executed at runtime, otherwise the code following startElseCode() until the completeConditional() is called. See conditionalIfNull() for example and restrictions.

Stack ...,boolean_value =>
      ...

Initiate a conditional sequence. The top value on the stack (a reference) is popped and compared to 'null'. If the value is null then the code following this call until the startElseCode() will be executed at runtime, otherwise the code following startElseCode() until the completeConditional() is called.
E.g.

mb.callMethod(...); // pushes an object onto the stack
mb.conditionalIfNull();
  mb.push(3);
mb.startElseCode();
  mb.push(5);
mb.completeConditional();
// at this point 3 or 5 will be on the stack

Stack ...,ref =>
      ...

Return an object that efficiently (to the implementation) describes a zero-argument method and can be used with the single argument callMethod(). Descriptions for the parameters to this method are the same as the five argument callMethod(). This allows the caller to cache frequently used methods. The returned object is only valid for use by this MethodBuilder.
This call does not affect the Stack.

Duplicate the top value on the stack.

Stack ...,value =>
      ...,value,value

End a statement. Pops the top-word of the stack, if any. Must only be called if zero or one item exists on the stack.

Stack value =>
      :empty:
or

Stack :empty: =>
      :empty:

Pop an array refrence off the stack and push an element from that array.

Stack ...,array_ref =>
      ...,value

Parameters

element:int

Offset into the array (zero based)

Push the contents of the local field onto the stack. This call pushes the this instance required to access the field itself.

Stack ...  =>
      ...,field_value

Push the contents of the described field onto the stack. This call requires the instance (reference) to be pushed by the caller.

Stack ...,field_ref  =>
      ...,field_value

return the name of the method.

Push a parameter value.

Stack ...  =>
      ...,param_value

Parameters

id:int

position of the parameter (zero based).

Push the contents of the described static field onto the stack.

Stack ...  =>
      ...,field_value

Pop the top stack value and push a boolean that is the result of an instanceof check on the popped reference.

Stack ...,ref =>
      ...,boolean_value

Return from a method, optionally with a value. Must only be called if zero or one item exists on the stack. If the stack contains a single value then that is popped and used as the returned value.

Stack value =>
      :empty:
or

Stack :empty: =>
      :empty:

Pop the top value off the stack

Stack ..., value =>
      ...

Push a byte constant onto the stack

Stack ...  =>
      ...,byte_value

Push a boolean constant onto the stack

Stack ...  =>
      ...,boolean_value

Push a short constant onto the stack

Stack ...  =>
      ...,short_value

Push a int constant onto the stack

Stack ...  =>
      ...,int_value

Push a long constant onto the stack

Stack ...  =>
      ...,long_value

Push a float constant onto the stack

Stack ...  =>
      ...,float_value

Push a double constant onto the stack

Stack ...  =>
      ...,double_value

Push a String constant onto the stack

Stack ...  =>
      ...,String_value

Create an instance of an array and push it onto the stack.

Stack ...  =>
      ...,array_ref

Parameters

className:String

- type of array.

size:int

- number of elements in the array

Complete the sequence that was started with pushNewStart(). Pop the arguments to the constructor and push the reference to the newly created object.

Stack ...,value* => [numArgs number of values will be popped]
      ...,new_ref

Parameters

numArgs:int

number of arguments to the constructor (can be 0).

Initiate a sequence that calls a constructor, equivalent to the new operator in Java. After this call, the caller must push any arguments and then complete the construction with a call to pushNewComplete(). Only arguments to the constructor can be pushed onto the stack between the pushNewStart() and pushNewComplete() method calls.

Stack ... => [unchanged]
      ...

Parameters

className:String

class name of object to be created.

Push a typed null onto the stack

Stack ...  =>
      ...,null

Push this onto the stack.

Stack ...  =>
      ...,this_ref

Pop the top stack value and store it in the local field. This call pushes the this instance required to access the field itself. Like the Java language 'field = value', this leaves the value on the stack.

Stack ...,value  =>
      ...,value

Pop the top stack value and store it in the instance field of this class. This call pushes the this instance required to access the field itself. Like the Java language 'field = value', this leaves the value on the stack.

Stack ...,value  =>
      ...,value

Pop the top stack value and store it in the field. This call requires the instance to be pushed by the caller. Like the Java language 'field = value', this leaves the value on the stack.

Stack ...,field_ref,value  =>
      ...,value

Pop an array reference off the stack, store a value in the array at the passed in offset.

Stack ...,array_ref, value =>
      ...

Parameters

element:int

Offset into the array (zero based)

Pop the top stack value and store it in the local field. This call pushes the this instance required to access the field itself. This call does not leave any value on the stack.

Stack ...,value  =>
      ...

Complete the true code path of a conditional.

Tell if statement number in this method builder hits limit. This method builder keeps a counter of how many statements are added to it. Caller should call this function every time it tries to add a statement to this method builder (counter is increased by 1), then the function returns whether the accumulated statement number hits a limit. The reason of doing this is that Java compiler has a limit of 64K code size for each method. We might hit this limit if an extremely long insert statement is issued, for example (see beetle 4293). Counting statement number is an approximation without too much overhead.

Swap the top two values on the stack.

Stack ...,valueA,valueB =>
      ...,valueB,valueA

Upcast the top stack value. This is used for correct method resolution by upcasting method parameters. It does not put any casting code into the byte code stream. Can only be used for refrences.

Stack ...,ref =>
      ...,ref