File	Doc	Category	Size	Date	Package
Machine.java	API Doc	Android 1.5 API	7877	Wed May 06 22:41:02 BST 2009	com.android.dx.cf.code

Machine

Fields Summary

Constructors Summary

Methods Summary
public void	auxCstArg(com.android.dx.rop.cst.Constant cst) Indicates that there is an auxiliary (inline, not stack) object argument, with the value based on the given constant. Note: Some opcodes use both int and constant auxiliary arguments. param cst non-null; the constant containing / referencing the value
public void	auxInitValues(java.util.ArrayList initValues) Indicates that there is an auxiliary (inline, not stack) argument consisting of a list of initial values for a newly created array. param initValues non-null; the list of constant values to initialize the array
public void	auxIntArg(int value) Indicates that there is an auxiliary (inline, not stack) argument of type int, with the given value. Note: Perhaps unintuitively, the stack manipulation ops (e.g., dup and swap) use this to indicate the result stack pattern with a straightforward hex encoding of the push order starting with least-significant nibbles getting pushed first). For example, an all-category-1 dup2_x1 sets this to 0x12312, and the other form of that op sets this to 0x121. Also Note: For switch* instructions, this is used to indicate the padding value (which is only useful for verification). param value the argument value
public void	auxSwitchArg(SwitchList cases) Indicates that there is an auxiliary (inline, not stack) argument consisting of a switch* table. Note: This is generally used in conjunction with {@link #auxIntArg} (which holds the padding). param cases non-null; the list of key-target pairs, plus the default target
public void	auxTargetArg(int target) Indicates that there is an auxiliary (inline, not stack) argument indicating a branch target. param target the argument value
public void	auxType(com.android.dx.rop.type.Type type) Indicates that the salient type of this operation is as given. This differentiates between, for example, the various arithmetic opcodes, which, by the time they hit a Machine are collapsed to the int variant. (See {@link BytecodeArray#parseInstruction} for details.) param type non-null; the salient type of the upcoming operation
public void	clearArgs() Clears the regular and auxiliary arguments area.
public com.android.dx.rop.type.Prototype	getPrototype() Gets the effective prototype of the method that this instance is being used for. The effective prototype includes an initial this argument for instance methods. return non-null; the method prototype
public void	localArg(Frame frame, int idx) Loads the local variable with the given index as the sole argument in the arguments area. Also, clear the auxiliary arguments. param frame non-null; frame to operate on param idx >= 0; the local variable index
public void	localTarget(int idx, com.android.dx.rop.type.Type type, com.android.dx.rop.code.LocalItem local) Indicates that the target of this operation is the given local. param idx >= 0; the local variable index param type non-null; the type of the local param local null-ok; the name and signature of the local, if known
public void	popArgs(Frame frame, int count) Pops the given number of values from the stack (of either category), and store them in the arguments area, indicating that there are now that many arguments. Also, clear the auxiliary arguments. param frame non-null; frame to operate on param count >= 0; number of values to pop
public void	popArgs(Frame frame, com.android.dx.rop.type.Prototype prototype) Pops values from the stack of the types indicated by the given Prototype (popped in reverse of the argument order, so the first prototype argument type is for the deepest element of the stack), and store them in the arguments area, indicating that there are now that many arguments. Also, clear the auxiliary arguments. param frame non-null; frame to operate on param prototype non-null; prototype indicating arguments to pop
public void	popArgs(Frame frame, com.android.dx.rop.type.Type type) Pops a value from the stack of the indicated type, and store it in the arguments area, indicating that there are now that many arguments. Also, clear the auxiliary arguments. param frame non-null; frame to operate on param type non-null; type of the argument
public void	popArgs(Frame frame, com.android.dx.rop.type.Type type1, com.android.dx.rop.type.Type type2) Pops values from the stack of the indicated types (popped in reverse argument order, so the first indicated type is for the deepest element of the stack), and store them in the arguments area, indicating that there are now that many arguments. Also, clear the auxiliary arguments. param frame non-null; frame to operate on param type1 non-null; type of the first argument param type2 non-null; type of the second argument
public void	popArgs(Frame frame, com.android.dx.rop.type.Type type1, com.android.dx.rop.type.Type type2, com.android.dx.rop.type.Type type3) Pops values from the stack of the indicated types (popped in reverse argument order, so the first indicated type is for the deepest element of the stack), and store them in the arguments area, indicating that there are now that many arguments. Also, clear the auxiliary arguments. param frame non-null; frame to operate on param type1 non-null; type of the first argument param type2 non-null; type of the second argument param type3 non-null; type of the third argument
public void	run(Frame frame, int offset, int opcode) "Runs" the indicated opcode in an appropriate way, using the arguments area as appropriate, and modifying the given frame in response. param frame non-null; frame to operate on param offset >= 0; byte offset in the method to the opcode being run param opcode >= 0; the opcode to run