Added: incubator/jdo/trunk/ri11/src/java/org/apache/jdo/impl/enhancer/classfile/InsnLookupSwitch.java
URL: http://svn.apache.org/viewcvs/incubator/jdo/trunk/ri11/src/java/org/apache/jdo/impl/enhancer/classfile/InsnLookupSwitch.java?view=auto&rev=158176
==============================================================================
--- incubator/jdo/trunk/ri11/src/java/org/apache/jdo/impl/enhancer/classfile/InsnLookupSwitch.java (added)
+++ incubator/jdo/trunk/ri11/src/java/org/apache/jdo/impl/enhancer/classfile/InsnLookupSwitch.java Fri Mar 18 17:02:29 2005
@@ -0,0 +1,227 @@
+/*
+ * Copyright 2005 The Apache Software Foundation.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+package org.apache.jdo.impl.enhancer.classfile;
+
+import java.io.PrintStream;
+import java.util.Stack;
+
+/**
+ * Special instruction form for the opc_lookupswitch instruction
+ */
+public class InsnLookupSwitch extends Insn {
+ /* The target for the default case */
+ private InsnTarget defaultOp;
+
+ /* The int constants against which to perform the lookup */
+ private int[] matchesOp;
+
+ /* The branch targets for the cases corresponding to the entries in
+ * the matchesOp array */
+ private InsnTarget[] targetsOp;
+
+ /* public accessors */
+
+ public int nStackArgs() {
+ return 1;
+ }
+
+ public int nStackResults() {
+ return 0;
+ }
+
+ /**
+ * What are the types of the stack operands ?
+ */
+ public String argTypes() {
+ return "I";
+ }
+
+ /**
+ * What are the types of the stack results?
+ */
+ public String resultTypes() {
+ return "";
+ }
+
+ public boolean branches() {
+ return true;
+ }
+
+ /**
+ * Mark possible branch targets
+ */
+ public void markTargets() {
+ defaultOp.setBranchTarget();
+ for (int i=0; i<targetsOp.length; i++)
+ targetsOp[i].setBranchTarget();
+ }
+
+
+ /**
+ * Return the defaultTarget for the switch
+ */
+ public InsnTarget defaultTarget() {
+ return defaultOp;
+ }
+
+ /**
+ * Return the case values of the switch.
+ */
+ public int[] switchCases() {
+ return matchesOp;
+ }
+
+ /**
+ * Return the targets for the cases of the switch.
+ */
+ public InsnTarget[] switchTargets() {
+ return targetsOp;
+ }
+
+ /**
+ * Constructor for opc_lookupswitch
+ */
+ public InsnLookupSwitch(InsnTarget defaultOp, int[] matchesOp,
+ InsnTarget[] targetsOp) {
+ this(defaultOp, matchesOp, targetsOp, NO_OFFSET);
+ }
+
+ /**
+ * Compares this instance with another for structural equality.
+ */
+ //@olsen: added method
+ public boolean isEqual(Stack msg, Object obj) {
+ if (!(obj instanceof InsnLookupSwitch)) {
+ msg.push("obj/obj.getClass() = "
+ + (obj == null ? null : obj.getClass()));
+ msg.push("this.getClass() = "
+ + this.getClass());
+ return false;
+ }
+ InsnLookupSwitch other = (InsnLookupSwitch)obj;
+
+ if (!super.isEqual(msg, other)) {
+ return false;
+ }
+
+ if (!this.defaultOp.isEqual(msg, other.defaultOp)) {
+ msg.push(String.valueOf("defaultOp = "
+ + other.defaultOp));
+ msg.push(String.valueOf("defaultOp = "
+ + this.defaultOp));
+ return false;
+ }
+
+ if (this.matchesOp.length != other.matchesOp.length) {
+ msg.push("matchesOp.length "
+ + String.valueOf(other.matchesOp.length));
+ msg.push("matchesOp.length "
+ + String.valueOf(this.matchesOp.length));
+ return false;
+ }
+ for (int i = 0; i < matchesOp.length; i++) {
+ int m1 = this.matchesOp[i];
+ int m2 = other.matchesOp[i];
+ if (m1 != m2) {
+ msg.push("matchesOp[" + i + "] = " + String.valueOf(m2));
+ msg.push("matchesOp[" + i + "] = " + String.valueOf(m1));
+ return false;
+ }
+ }
+
+ if (this.targetsOp.length != other.targetsOp.length) {
+ msg.push("targetsOp.length "
+ + String.valueOf(other.targetsOp.length));
+ msg.push("targetsOp.length "
+ + String.valueOf(this.targetsOp.length));
+ return false;
+ }
+ for (int i = 0; i < targetsOp.length; i++) {
+ InsnTarget t1 = this.targetsOp[i];
+ InsnTarget t2 = other.targetsOp[i];
+ if (!t1.isEqual(msg, t2)) {
+ msg.push("targetsOp[" + i + "] = " + String.valueOf(t2));
+ msg.push("targetsOp[" + i + "] = " + String.valueOf(t1));
+ return false;
+ }
+ }
+ return true;
+ }
+
+ /* package local methods */
+
+ InsnLookupSwitch(InsnTarget defaultOp, int[] matchesOp,
+ InsnTarget[] targetsOp, int offset) {
+ super(opc_lookupswitch, offset);
+
+ this.defaultOp = defaultOp;
+ this.matchesOp = matchesOp;
+ this.targetsOp = targetsOp;
+
+ if (defaultOp == null || targetsOp == null || matchesOp == null ||
+ targetsOp.length != matchesOp.length)
+ throw new InsnError ("attempt to create an opc_lookupswitch" +
+ " with invalid operands");
+ }
+
+ void print(PrintStream out, int indent) {
+ ClassPrint.spaces(out, indent);
+ out.println(offset() + " opc_lookupswitch ");
+ for (int i=0; i<matchesOp.length; i++) {
+ ClassPrint.spaces(out, indent+2);
+ out.println(matchesOp[i] + " -> " + targetsOp[i].offset());
+ }
+ ClassPrint.spaces(out, indent+2);
+ out.println("default -> " + defaultOp.offset());
+ }
+
+ int store(byte[] buf, int index) {
+ buf[index++] = (byte) opcode();
+ index = (index + 3) & ~3;
+ index = storeInt(buf, index, defaultOp.offset() - offset());
+ index = storeInt(buf, index, targetsOp.length);
+ for (int i=0; i<targetsOp.length; i++) {
+ index = storeInt(buf, index, matchesOp[i]);
+ index = storeInt(buf, index, targetsOp[i].offset() - offset());
+ }
+ return index;
+ }
+
+ int size() {
+ /* account for the instruction, 0-3 bytes of pad, 2 ints */
+ int basic = ((offset() + 4) & ~3) - offset() + 8;
+ /* Add 8*number of offsets */
+ return basic + targetsOp.length*8;
+ }
+
+ static InsnLookupSwitch read (InsnReadEnv insnEnv, int myPC) {
+ /* eat up any padding */
+ int thisPC = myPC +1;
+ for (int pads = ((thisPC + 3) & ~3) - thisPC; pads > 0; pads--)
+ insnEnv.getByte();
+ InsnTarget defaultTarget = insnEnv.getTarget(insnEnv.getInt() + myPC);
+ int npairs = insnEnv.getInt();
+ int matches[] = new int[npairs];
+ InsnTarget[] offsets = new InsnTarget[npairs];
+ for (int i=0; i<npairs; i++) {
+ matches[i] = insnEnv.getInt();
+ offsets[i] = insnEnv.getTarget(insnEnv.getInt() + myPC);
+ }
+ return new InsnLookupSwitch(defaultTarget, matches, offsets, myPC);
+ }
+}
Added: incubator/jdo/trunk/ri11/src/java/org/apache/jdo/impl/enhancer/classfile/InsnMultiDimArrayNew.java
URL: http://svn.apache.org/viewcvs/incubator/jdo/trunk/ri11/src/java/org/apache/jdo/impl/enhancer/classfile/InsnMultiDimArrayNew.java?view=auto&rev=158176
==============================================================================
--- incubator/jdo/trunk/ri11/src/java/org/apache/jdo/impl/enhancer/classfile/InsnMultiDimArrayNew.java (added)
+++ incubator/jdo/trunk/ri11/src/java/org/apache/jdo/impl/enhancer/classfile/InsnMultiDimArrayNew.java Fri Mar 18 17:02:29 2005
@@ -0,0 +1,170 @@
+/*
+ * Copyright 2005 The Apache Software Foundation.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+package org.apache.jdo.impl.enhancer.classfile;
+
+import java.io.PrintStream;
+import java.util.Stack;
+
+/**
+ * Special instruction form for the opc_multianewarray instruction
+ */
+public class InsnMultiDimArrayNew extends Insn {
+ /* The array class for creation */
+ private ConstClass classOp;
+
+ /* The number of dimensions present on the stack */
+ private int nDimsOp;
+
+ /* public accessors */
+
+ public boolean isSimpleLoad() {
+ return false;
+ }
+
+ public int nStackArgs() {
+ return nDimsOp;
+ }
+
+ public int nStackResults() {
+ return 1;
+ }
+
+ /**
+ * What are the types of the stack operands ?
+ */
+ public String argTypes() {
+ StringBuffer buf = new StringBuffer();
+ for (int i=0; i<nDimsOp; i++) {
+ buf.append("I");
+ }
+ return buf.toString();
+ }
+
+ /**
+ * What are the types of the stack results?
+ */
+ public String resultTypes() {
+ return "A";
+ }
+
+ public boolean branches() {
+ return false;
+ }
+
+ /**
+ * Return the array class being created
+ */
+ public ConstClass arrayClass() {
+ return classOp;
+ }
+
+ /**
+ * Sets the array class being created
+ */
+ public void setArrayClass(ConstClass classOp) {
+ this.classOp = classOp;
+ }
+
+ /**
+ * Return the number of dimensions of the array class being created
+ */
+ public int nDims() {
+ return nDimsOp;
+ }
+
+ /**
+ * Constructor for opc_multianewarray.
+ * classOp must be an array class
+ * nDimsOp must be > 0 and <= number of array dimensions for classOp
+ */
+ public InsnMultiDimArrayNew (ConstClass classOp, int nDimsOp) {
+ this(classOp, nDimsOp, NO_OFFSET);
+ }
+
+ /**
+ * Compares this instance with another for structural equality.
+ */
+ //@olsen: added method
+ public boolean isEqual(Stack msg, Object obj) {
+ if (!(obj instanceof InsnMultiDimArrayNew)) {
+ msg.push("obj/obj.getClass() = "
+ + (obj == null ? null : obj.getClass()));
+ msg.push("this.getClass() = "
+ + this.getClass());
+ return false;
+ }
+ InsnMultiDimArrayNew other = (InsnMultiDimArrayNew)obj;
+
+ if (!super.isEqual(msg, other)) {
+ return false;
+ }
+
+ if (!this.classOp.isEqual(msg, other.classOp)) {
+ msg.push(String.valueOf("classOp = "
+ + other.classOp));
+ msg.push(String.valueOf("classOp = "
+ + this.classOp));
+ return false;
+ }
+ if (this.nDimsOp != other.nDimsOp) {
+ msg.push(String.valueOf("nDimsOp = "
+ + other.nDimsOp));
+ msg.push(String.valueOf("nDimsOp = "
+ + this.nDimsOp));
+ return false;
+ }
+ return true;
+ }
+
+ /* package local methods */
+
+ InsnMultiDimArrayNew (ConstClass classOp, int nDimsOp, int offset) {
+ super(opc_multianewarray, offset);
+
+ this.classOp = classOp;
+ this.nDimsOp = nDimsOp;
+
+ if (classOp == null || nDimsOp < 1)
+ throw new InsnError ("attempt to create an opc_multianewarray" +
+ " with invalid operands");
+ }
+
+ void print (PrintStream out, int indent) {
+ ClassPrint.spaces(out, indent);
+ out.println(offset() + " opc_multianewarray pool(" +
+ classOp.getIndex() + ")," + nDimsOp);
+ }
+
+ int store(byte[] buf, int index) {
+ buf[index++] = (byte) opcode();
+ index = storeShort(buf, index, (short) classOp.getIndex());
+ buf[index++] = (byte) nDimsOp;
+ return index;
+ }
+
+ int size() {
+ return 4;
+ }
+
+ static InsnMultiDimArrayNew read (InsnReadEnv insnEnv, int myPC) {
+ ConstClass classOp = (ConstClass)
+ insnEnv.pool().constantAt(insnEnv.getUShort());
+ int nDims = insnEnv.getUByte();
+ return new InsnMultiDimArrayNew(classOp, nDims, myPC);
+ }
+}
Added: incubator/jdo/trunk/ri11/src/java/org/apache/jdo/impl/enhancer/classfile/InsnReadEnv.java
URL: http://svn.apache.org/viewcvs/incubator/jdo/trunk/ri11/src/java/org/apache/jdo/impl/enhancer/classfile/InsnReadEnv.java?view=auto&rev=158176
==============================================================================
--- incubator/jdo/trunk/ri11/src/java/org/apache/jdo/impl/enhancer/classfile/InsnReadEnv.java (added)
+++ incubator/jdo/trunk/ri11/src/java/org/apache/jdo/impl/enhancer/classfile/InsnReadEnv.java Fri Mar 18 17:02:29 2005
@@ -0,0 +1,116 @@
+/*
+ * Copyright 2005 The Apache Software Foundation.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+package org.apache.jdo.impl.enhancer.classfile;
+
+/**
+ * Environment for decoding byte codes into instructions
+ */
+class InsnReadEnv {
+
+ /* The parent method environment */
+ private CodeEnv codeEnv;
+
+ /* The byte codes to be decoded */
+ private byte[] byteCodes;
+
+ /* The index into byteCodes for the next instruction to be decoded */
+ private int currPc;
+
+ /**
+ * Constructor
+ */
+ InsnReadEnv(byte[] bytes, CodeEnv codeEnv) {
+ this.byteCodes = bytes;
+ this.currPc = 0;
+ this.codeEnv = codeEnv;
+ }
+
+ /**
+ * Return the index of the next instruction to decode
+ */
+ int currentPC() {
+ return currPc;
+ }
+
+ /**
+ * Are there more byte codes to decode?
+ */
+ boolean more() {
+ return currPc < byteCodes.length;
+ }
+
+ /**
+ * Get a single byte from the byte code stream
+ */
+ byte getByte() {
+ if (!more())
+ throw new InsnError("out of byte codes");
+
+ return byteCodes[currPc++];
+ }
+
+ /**
+ * Get a single unsigned byte from the byte code stream
+ */
+ int getUByte() {
+ return getByte() & 0xff;
+ }
+
+ /**
+ * Get a short from the byte code stream
+ */
+ int getShort() {
+ byte byte1 = byteCodes[currPc++];
+ byte byte2 = byteCodes[currPc++];
+ return (byte1 << 8) | (byte2 & 0xff);
+ }
+
+ /**
+ * Get an unsigned short from the byte code stream
+ */
+ int getUShort() {
+ return getShort() & 0xffff;
+ }
+
+ /**
+ * Get an int from the byte code stream
+ */
+ int getInt() {
+ byte byte1 = byteCodes[currPc++];
+ byte byte2 = byteCodes[currPc++];
+ byte byte3 = byteCodes[currPc++];
+ byte byte4 = byteCodes[currPc++];
+ return (byte1 << 24) | ((byte2 & 0xff) << 16) |
+ ((byte3 & 0xff) << 8) | (byte4 & 0xff);
+ }
+
+ /**
+ * Get the constant pool which applies to the method being decoded
+ */
+ ConstantPool pool() {
+ return codeEnv.pool();
+ }
+
+ /**
+ * Get the canonical InsnTarget instance for the specified
+ * pc within the method.
+ */
+ InsnTarget getTarget(int targ) {
+ return codeEnv.getTarget(targ);
+ }
+}
Added: incubator/jdo/trunk/ri11/src/java/org/apache/jdo/impl/enhancer/classfile/InsnSingle.java
URL: http://svn.apache.org/viewcvs/incubator/jdo/trunk/ri11/src/java/org/apache/jdo/impl/enhancer/classfile/InsnSingle.java?view=auto&rev=158176
==============================================================================
--- incubator/jdo/trunk/ri11/src/java/org/apache/jdo/impl/enhancer/classfile/InsnSingle.java (added)
+++ incubator/jdo/trunk/ri11/src/java/org/apache/jdo/impl/enhancer/classfile/InsnSingle.java Fri Mar 18 17:02:29 2005
@@ -0,0 +1,269 @@
+/*
+ * Copyright 2005 The Apache Software Foundation.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+package org.apache.jdo.impl.enhancer.classfile;
+
+import java.io.PrintStream;
+import java.util.Stack;
+
+/**
+ * A java VM instruction which takes no immediate operands.
+ */
+public class InsnSingle extends Insn {
+
+ public int nStackArgs() {
+ return VMOp.ops[opcode()].nStackArgs();
+ }
+
+ public int nStackResults() {
+ return VMOp.ops[opcode()].nStackResults();
+ }
+
+ /**
+ * What are the types of the stack operands ?
+ */
+ public String argTypes() {
+ return VMOp.ops[opcode()].argTypes();
+ }
+
+ /**
+ * What are the types of the stack results?
+ */
+ public String resultTypes() {
+ return VMOp.ops[opcode()].resultTypes();
+ }
+
+ public boolean branches() {
+ switch (opcode()) {
+ case opc_ireturn:
+ case opc_lreturn:
+ case opc_freturn:
+ case opc_dreturn:
+ case opc_areturn:
+ case opc_return:
+ case opc_athrow:
+ return true;
+ default:
+ return false;
+ }
+ }
+
+ /**
+ * Compares this instance with another for structural equality.
+ */
+ //@olsen: added method
+ public boolean isEqual(Stack msg, Object obj) {
+ if (!(obj instanceof InsnSingle)) {
+ msg.push("obj/obj.getClass() = "
+ + (obj == null ? null : obj.getClass()));
+ msg.push("this.getClass() = "
+ + this.getClass());
+ return false;
+ }
+ InsnSingle other = (InsnSingle)obj;
+
+ if (!super.isEqual(msg, other)) {
+ return false;
+ }
+ return true;
+ }
+
+ /* package local methods */
+
+ void print (PrintStream out, int indent) {
+ ClassPrint.spaces(out, indent);
+ out.println(offset() + " " + opName(opcode()));
+ }
+
+ int store(byte[] buf, int index) {
+ buf[index] = (byte) opcode();
+ return index+1;
+ }
+
+ int size() {
+ return 1;
+ }
+
+ /* Construct an instruction. The opcode must be one which requires
+ no operands */
+
+ InsnSingle(int theOpcode) {
+ this(theOpcode, NO_OFFSET);
+ }
+
+ /* The no-check constructor */
+
+ InsnSingle(int theOpcode, int theOffset) {
+ super(theOpcode, theOffset);
+
+ switch (theOpcode) {
+ case opc_nop:
+ case opc_aconst_null:
+ case opc_iconst_m1:
+ case opc_iconst_0:
+ case opc_iconst_1:
+ case opc_iconst_2:
+ case opc_iconst_3:
+ case opc_iconst_4:
+ case opc_iconst_5:
+ case opc_lconst_0:
+ case opc_lconst_1:
+ case opc_fconst_0:
+ case opc_fconst_1:
+ case opc_fconst_2:
+ case opc_dconst_0:
+ case opc_dconst_1:
+ case opc_iload_0:
+ case opc_iload_1:
+ case opc_iload_2:
+ case opc_iload_3:
+ case opc_lload_0:
+ case opc_lload_1:
+ case opc_lload_2:
+ case opc_lload_3:
+ case opc_fload_0:
+ case opc_fload_1:
+ case opc_fload_2:
+ case opc_fload_3:
+ case opc_dload_0:
+ case opc_dload_1:
+ case opc_dload_2:
+ case opc_dload_3:
+ case opc_aload_0:
+ case opc_aload_1:
+ case opc_aload_2:
+ case opc_aload_3:
+ case opc_iaload:
+ case opc_laload:
+ case opc_faload:
+ case opc_daload:
+ case opc_aaload:
+ case opc_baload:
+ case opc_caload:
+ case opc_saload:
+ case opc_istore_0:
+ case opc_istore_1:
+ case opc_istore_2:
+ case opc_istore_3:
+ case opc_lstore_0:
+ case opc_lstore_1:
+ case opc_lstore_2:
+ case opc_lstore_3:
+ case opc_fstore_0:
+ case opc_fstore_1:
+ case opc_fstore_2:
+ case opc_fstore_3:
+ case opc_dstore_0:
+ case opc_dstore_1:
+ case opc_dstore_2:
+ case opc_dstore_3:
+ case opc_astore_0:
+ case opc_astore_1:
+ case opc_astore_2:
+ case opc_astore_3:
+ case opc_iastore:
+ case opc_lastore:
+ case opc_fastore:
+ case opc_dastore:
+ case opc_aastore:
+ case opc_bastore:
+ case opc_castore:
+ case opc_sastore:
+ case opc_pop:
+ case opc_pop2:
+ case opc_dup:
+ case opc_dup_x1:
+ case opc_dup_x2:
+ case opc_dup2:
+ case opc_dup2_x1:
+ case opc_dup2_x2:
+ case opc_swap:
+ case opc_iadd:
+ case opc_ladd:
+ case opc_fadd:
+ case opc_dadd:
+ case opc_isub:
+ case opc_lsub:
+ case opc_fsub:
+ case opc_dsub:
+ case opc_imul:
+ case opc_lmul:
+ case opc_fmul:
+ case opc_dmul:
+ case opc_idiv:
+ case opc_ldiv:
+ case opc_fdiv:
+ case opc_ddiv:
+ case opc_irem:
+ case opc_lrem:
+ case opc_frem:
+ case opc_drem:
+ case opc_ineg:
+ case opc_lneg:
+ case opc_fneg:
+ case opc_dneg:
+ case opc_ishl:
+ case opc_lshl:
+ case opc_ishr:
+ case opc_lshr:
+ case opc_iushr:
+ case opc_lushr:
+ case opc_iand:
+ case opc_land:
+ case opc_ior:
+ case opc_lor:
+ case opc_ixor:
+ case opc_lxor:
+ case opc_i2l:
+ case opc_i2f:
+ case opc_i2d:
+ case opc_l2i:
+ case opc_l2f:
+ case opc_l2d:
+ case opc_f2i:
+ case opc_f2l:
+ case opc_f2d:
+ case opc_d2i:
+ case opc_d2l:
+ case opc_d2f:
+ case opc_i2b:
+ case opc_i2c:
+ case opc_i2s:
+ case opc_lcmp:
+ case opc_fcmpl:
+ case opc_fcmpg:
+ case opc_dcmpl:
+ case opc_dcmpg:
+ case opc_ireturn:
+ case opc_lreturn:
+ case opc_freturn:
+ case opc_dreturn:
+ case opc_areturn:
+ case opc_return:
+ case opc_xxxunusedxxx:
+ case opc_arraylength:
+ case opc_athrow:
+ case opc_monitorenter:
+ case opc_monitorexit:
+ break;
+
+ default:
+ throw new InsnError ("attempt to create an " + opName(opcode()) +
+ " without specifying the required operands");
+ }
+ }
+}
Added: incubator/jdo/trunk/ri11/src/java/org/apache/jdo/impl/enhancer/classfile/InsnTableSwitch.java
URL: http://svn.apache.org/viewcvs/incubator/jdo/trunk/ri11/src/java/org/apache/jdo/impl/enhancer/classfile/InsnTableSwitch.java?view=auto&rev=158176
==============================================================================
--- incubator/jdo/trunk/ri11/src/java/org/apache/jdo/impl/enhancer/classfile/InsnTableSwitch.java (added)
+++ incubator/jdo/trunk/ri11/src/java/org/apache/jdo/impl/enhancer/classfile/InsnTableSwitch.java Fri Mar 18 17:02:29 2005
@@ -0,0 +1,213 @@
+/*
+ * Copyright 2005 The Apache Software Foundation.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+package org.apache.jdo.impl.enhancer.classfile;
+
+
+import java.io.PrintStream;
+import java.util.Stack;
+
+/**
+ * Special instruction form for the opc_tableswitch instruction
+ */
+public class InsnTableSwitch extends Insn {
+ /* The lowest value in the jump table */
+ private int lowOp;
+
+ /* The default target for the switch */
+ private InsnTarget defaultOp;
+
+ /* The targets for the switch - a switch value of lowOp dispatches
+ * to targetsOp[0], lowOp+1 dispatches to targetsOp[1], etc. */
+ private InsnTarget[] targetsOp;
+
+ /* public accessors */
+
+ public int nStackArgs() {
+ return 1;
+ }
+
+ public int nStackResults() {
+ return 0;
+ }
+
+ public String argTypes() {
+ return "I";
+ }
+
+ public String resultTypes() {
+ return "";
+ }
+
+ public boolean branches() {
+ return true;
+ }
+
+ /**
+ * Mark possible branch targets
+ */
+ public void markTargets() {
+ defaultOp.setBranchTarget();
+ for (int i=0; i<targetsOp.length; i++)
+ targetsOp[i].setBranchTarget();
+ }
+
+ /**
+ * Return the lowest case for the switch
+ */
+ public int lowCase() {
+ return lowOp;
+ }
+
+ /**
+ * Return the defaultTarget for the switch
+ */
+ public InsnTarget defaultTarget() {
+ return defaultOp;
+ }
+
+ /**
+ * Return the targets for the cases of the switch.
+ */
+ public InsnTarget[] switchTargets() {
+ return targetsOp;
+ }
+
+ /**
+ * Constructor for opc_tableswitch
+ */
+ //@olsen: made public
+ public InsnTableSwitch(int lowOp, InsnTarget defaultOp,
+ InsnTarget[] targetsOp) {
+ this(lowOp, defaultOp, targetsOp, NO_OFFSET);
+ }
+
+ /**
+ * Compares this instance with another for structural equality.
+ */
+ //@olsen: added method
+ public boolean isEqual(Stack msg, Object obj) {
+ if (!(obj instanceof InsnTableSwitch)) {
+ msg.push("obj/obj.getClass() = "
+ + (obj == null ? null : obj.getClass()));
+ msg.push("this.getClass() = "
+ + this.getClass());
+ return false;
+ }
+ InsnTableSwitch other = (InsnTableSwitch)obj;
+
+ if (!super.isEqual(msg, other)) {
+ return false;
+ }
+
+ if (this.lowOp != other.lowOp) {
+ msg.push(String.valueOf("lowOp = "
+ + other.lowOp));
+ msg.push(String.valueOf("lowOp = "
+ + this.lowOp));
+ return false;
+ }
+
+ if (!this.defaultOp.isEqual(msg, other.defaultOp)) {
+ msg.push(String.valueOf("defaultOp = "
+ + other.defaultOp));
+ msg.push(String.valueOf("defaultOp = "
+ + this.defaultOp));
+ return false;
+ }
+
+ if (this.targetsOp.length != other.targetsOp.length) {
+ msg.push("targetsOp.length "
+ + String.valueOf(other.targetsOp.length));
+ msg.push("targetsOp.length "
+ + String.valueOf(this.targetsOp.length));
+ return false;
+ }
+ for (int i = 0; i < targetsOp.length; i++) {
+ InsnTarget t1 = this.targetsOp[i];
+ InsnTarget t2 = other.targetsOp[i];
+ if (!t1.isEqual(msg, t2)) {
+ msg.push("targetsOp[" + i + "] = " + String.valueOf(t2));
+ msg.push("targetsOp[" + i + "] = " + String.valueOf(t1));
+ return false;
+ }
+ }
+ return true;
+ }
+
+ /* package local methods */
+
+ void print (PrintStream out, int indent) {
+ ClassPrint.spaces(out, indent);
+ out.println(offset() + " opc_tableswitch ");
+ for (int i=0; i<targetsOp.length; i++) {
+ int index = i + lowOp;
+ if (targetsOp[i].offset() != defaultOp.offset()) {
+ ClassPrint.spaces(out, indent+2);
+ out.println(index + " -> " + targetsOp[i].offset());
+ }
+ }
+ ClassPrint.spaces(out, indent+2);
+ out.println("default -> " + defaultOp.offset());
+ }
+
+ int store(byte[] buf, int index) {
+ buf[index++] = (byte) opcode();
+ index = (index + 3) & ~3;
+ index = storeInt(buf, index, defaultOp.offset() - offset());
+ index = storeInt(buf, index, lowOp);
+ index = storeInt(buf, index, lowOp+targetsOp.length-1);
+ for (int i=0; i<targetsOp.length; i++)
+ index = storeInt(buf, index, targetsOp[i].offset() - offset());
+ return index;
+ }
+
+ int size() {
+ /* account for the instruction, 0-3 bytes of pad, 3 ints */
+ int basic = ((offset() + 4) & ~3) - offset() + 12;
+ /* Add 4*number of offsets */
+ return basic + targetsOp.length*4;
+ }
+
+
+ InsnTableSwitch(int lowOp, InsnTarget defaultOp,
+ InsnTarget[] targetsOp, int offset) {
+ super(opc_tableswitch, offset);
+
+ this.lowOp = lowOp;
+ this.defaultOp = defaultOp;
+ this.targetsOp = targetsOp;
+
+ if (defaultOp == null || targetsOp == null)
+ throw new InsnError ("attempt to create an opc_tableswitch" +
+ " with invalid operands");
+ }
+
+ static InsnTableSwitch read (InsnReadEnv insnEnv, int myPC) {
+ /* eat up any padding */
+ int thisPC = myPC +1;
+ for (int pads = ((thisPC + 3) & ~3) - thisPC; pads > 0; pads--)
+ insnEnv.getByte();
+ InsnTarget defaultTarget = insnEnv.getTarget(insnEnv.getInt() + myPC);
+ int low = insnEnv.getInt();
+ int high = insnEnv.getInt();
+ InsnTarget[] offsets = new InsnTarget[high - low + 1];
+ for (int i=0; i<offsets.length; i++)
+ offsets[i] = insnEnv.getTarget(insnEnv.getInt() + myPC);
+ return new InsnTableSwitch(low, defaultTarget, offsets, myPC);
+ }
+}
Added: incubator/jdo/trunk/ri11/src/java/org/apache/jdo/impl/enhancer/classfile/InsnTarget.java
URL: http://svn.apache.org/viewcvs/incubator/jdo/trunk/ri11/src/java/org/apache/jdo/impl/enhancer/classfile/InsnTarget.java?view=auto&rev=158176
==============================================================================
--- incubator/jdo/trunk/ri11/src/java/org/apache/jdo/impl/enhancer/classfile/InsnTarget.java (added)
+++ incubator/jdo/trunk/ri11/src/java/org/apache/jdo/impl/enhancer/classfile/InsnTarget.java Fri Mar 18 17:02:29 2005
@@ -0,0 +1,113 @@
+/*
+ * Copyright 2005 The Apache Software Foundation.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+package org.apache.jdo.impl.enhancer.classfile;
+
+import java.io.PrintStream;
+import java.util.Stack;
+
+/**
+ * InsnTarget is a pseudo-instruction which represents a branch target
+ * in an instruction stream.
+ */
+public class InsnTarget extends Insn {
+
+ private boolean branchTarget = false;
+
+ public int nStackArgs() {
+ return 0;
+ }
+
+ public int nStackResults() {
+ return 0;
+ }
+
+ public String argTypes() {
+ return "";
+ }
+
+ public String resultTypes() {
+ return "";
+ }
+
+ public boolean branches() {
+ return false;
+ }
+
+ public void setBranchTarget() {
+ branchTarget = true;
+ }
+
+ /* not valid unless method instructions processed specially */
+ public boolean isBranchTarget() {
+ return branchTarget;
+ }
+
+ /**
+ * Constructor
+ */
+ public InsnTarget() {
+ super(opc_target, NO_OFFSET);
+ }
+
+ /**
+ * Compares this instance with another for structural equality.
+ */
+ //@olsen: added method
+ public boolean isEqual(Stack msg, Object obj) {
+ if (!(obj instanceof InsnTarget)) {
+ msg.push("obj/obj.getClass() = "
+ + (obj == null ? null : obj.getClass()));
+ msg.push("this.getClass() = "
+ + this.getClass());
+ return false;
+ }
+ InsnTarget other = (InsnTarget)obj;
+
+ if (!super.isEqual(msg, other)) {
+ return false;
+ }
+
+ if (this.branchTarget != other.branchTarget) {
+ msg.push(String.valueOf("branchTarget = "
+ + other.branchTarget));
+ msg.push(String.valueOf("branchTarget = "
+ + this.branchTarget));
+ return false;
+ }
+ return true;
+ }
+
+ /* package local methods */
+
+ void print (PrintStream out, int indent) {
+ ClassPrint.spaces(out, indent);
+ out.println(offset() + ":");
+ }
+
+ int store(byte buf[], int index) {
+ return index;
+ }
+
+ int size() {
+ return 0;
+ }
+
+ InsnTarget(int offset) {
+ super(opc_target, offset);
+ }
+}
Added: incubator/jdo/trunk/ri11/src/java/org/apache/jdo/impl/enhancer/classfile/InsnTargetOp.java
URL: http://svn.apache.org/viewcvs/incubator/jdo/trunk/ri11/src/java/org/apache/jdo/impl/enhancer/classfile/InsnTargetOp.java?view=auto&rev=158176
==============================================================================
--- incubator/jdo/trunk/ri11/src/java/org/apache/jdo/impl/enhancer/classfile/InsnTargetOp.java (added)
+++ incubator/jdo/trunk/ri11/src/java/org/apache/jdo/impl/enhancer/classfile/InsnTargetOp.java Fri Mar 18 17:02:29 2005
@@ -0,0 +1,162 @@
+/*
+ * Copyright 2005 The Apache Software Foundation.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+package org.apache.jdo.impl.enhancer.classfile;
+
+
+import java.io.PrintStream;
+import java.util.Stack;
+
+/**
+ * An instruction which requires a single branch offset
+ * as an immediate operand .
+ */
+public class InsnTargetOp extends Insn {
+ /* The branch target */
+ InsnTarget targetOp;
+
+ /* public accessors */
+
+ public int nStackArgs() {
+ return VMOp.ops[opcode()].nStackArgs();
+ }
+
+ public int nStackResults() {
+ return VMOp.ops[opcode()].nStackResults();
+ }
+
+ public String argTypes() {
+ return VMOp.ops[opcode()].argTypes();
+ }
+
+ public String resultTypes() {
+ return VMOp.ops[opcode()].resultTypes();
+ }
+
+ public boolean branches() {
+ return true;
+ }
+
+ /**
+ * Mark possible branch targets
+ */
+ public void markTargets() {
+ targetOp.setBranchTarget();
+ }
+
+ /**
+ * Return the branch target which is the immediate operand
+ */
+ public InsnTarget target() {
+ return targetOp;
+ }
+
+ /**
+ * Compares this instance with another for structural equality.
+ */
+ //@olsen: added method
+ public boolean isEqual(Stack msg, Object obj) {
+ if (!(obj instanceof InsnTargetOp)) {
+ msg.push("obj/obj.getClass() = "
+ + (obj == null ? null : obj.getClass()));
+ msg.push("this.getClass() = "
+ + this.getClass());
+ return false;
+ }
+ InsnTargetOp other = (InsnTargetOp)obj;
+
+ if (!super.isEqual(msg, other)) {
+ return false;
+ }
+
+ if (!this.targetOp.isEqual(msg, other.targetOp)) {
+ msg.push(String.valueOf("targetOp = "
+ + other.targetOp));
+ msg.push(String.valueOf("targetOp = "
+ + this.targetOp));
+ return false;
+ }
+ return true;
+ }
+
+ /* package local methods */
+
+ void print (PrintStream out, int indent) {
+ ClassPrint.spaces(out, indent);
+ /* print offset in non-relative form for readability */
+ out.println(offset() + " " + opName(opcode()) + " " +
+ targetOp.offset());
+ }
+
+ int store(byte[] buf, int index) {
+ buf[index++] = (byte) opcode();
+ int off = targetOp.offset() - offset();
+ if (opcode() == opc_goto_w || opcode() == opc_jsr_w)
+ return storeInt(buf, index, off);
+ else
+ return storeShort(buf, index, (short)off);
+ }
+
+ int size() {
+ if (opcode() == opc_goto_w || opcode() == opc_jsr_w)
+ return 5;
+ return 3;
+ }
+
+ InsnTargetOp (int theOpcode, InsnTarget theOperand, int pc) {
+ super(theOpcode, pc);
+ targetOp = theOperand;
+ }
+
+ InsnTargetOp (int theOpcode, InsnTarget theOperand) {
+ super(theOpcode, NO_OFFSET);
+
+ targetOp = theOperand;
+
+ switch(theOpcode) {
+ case opc_ifeq:
+ case opc_ifne:
+ case opc_iflt:
+ case opc_ifge:
+ case opc_ifgt:
+ case opc_ifle:
+ case opc_if_icmpeq:
+ case opc_if_icmpne:
+ case opc_if_icmplt:
+ case opc_if_icmpge:
+ case opc_if_icmpgt:
+ case opc_if_icmple:
+ case opc_if_acmpeq:
+ case opc_if_acmpne:
+ case opc_goto:
+ case opc_jsr:
+ case opc_ifnull:
+ case opc_ifnonnull:
+ case opc_goto_w:
+ case opc_jsr_w:
+ /* Target */
+ if (theOperand == null)
+ throw new InsnError ("attempt to create an " + opName(theOpcode) +
+ " with a null Target operand");
+ break;
+
+ default:
+ throw new InsnError ("attempt to create an " + opName(theOpcode) +
+ " with an InsnTarget operand");
+ }
+ }
+}
Added: incubator/jdo/trunk/ri11/src/java/org/apache/jdo/impl/enhancer/classfile/InsnUtils.java
URL: http://svn.apache.org/viewcvs/incubator/jdo/trunk/ri11/src/java/org/apache/jdo/impl/enhancer/classfile/InsnUtils.java?view=auto&rev=158176
==============================================================================
--- incubator/jdo/trunk/ri11/src/java/org/apache/jdo/impl/enhancer/classfile/InsnUtils.java (added)
+++ incubator/jdo/trunk/ri11/src/java/org/apache/jdo/impl/enhancer/classfile/InsnUtils.java Fri Mar 18 17:02:29 2005
@@ -0,0 +1,351 @@
+/*
+ * Copyright 2005 The Apache Software Foundation.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+package org.apache.jdo.impl.enhancer.classfile;
+
+/**
+ * InsnUtils provides a set of static methods which serve to
+ * select vm instructions during code annotation.
+ */
+public
+class InsnUtils implements VMConstants {
+
+ /**
+ * Return the best instruction for loading a value from the constant
+ * pool onto the stack - hopefully use short form
+ */
+ //@olsen: added method
+ public static Insn constantValue(ConstValue value) {
+ int tag = value.tag();
+ switch (tag) {
+ case CONSTANTInteger :
+ case CONSTANTFloat :
+ case CONSTANTString :
+ //@olsen: check index range to select opc_ldc vs. opc_ldc_w
+ int opcode = (value.getIndex() <= 0xFF ? opc_ldc : opc_ldc_w);
+ return Insn.create(opcode, value);
+ case CONSTANTLong :
+ case CONSTANTDouble :
+ //@olsen: require opc_ldc2_w (there's no short form: opc_ldc2)
+ return Insn.create(opc_ldc2_w, value);
+ default:
+ throw new InsnError("bad constant tag");
+ }
+ }
+
+ /**
+ * Return the best instruction for loading the specified String
+ * constant onto the stack - hopefully use short form
+ */
+ //@olsen: added method
+ public static Insn stringConstant(String s, ConstantPool pool) {
+ //@olsen: need to carefully select opc_ldc/opc_ldc_w/opc_ldc2_w
+ return constantValue(pool.addString(s));
+ }
+
+ /**
+ * Return the best instruction for loading the specified integer
+ * constant onto the stack - hopefully use short form
+ */
+ public static Insn integerConstant(int i, ConstantPool pool) {
+ //@olsen: removed redundant 'else's
+ //@olsen: added use of opc_iconst_m1
+ if (i == -1)
+ return Insn.create(opc_iconst_m1);
+ if (i == 0)
+ return Insn.create(opc_iconst_0);
+ if (i == 1)
+ return Insn.create(opc_iconst_1);
+ if (i == 2)
+ return Insn.create(opc_iconst_2);
+ if (i == 3)
+ return Insn.create(opc_iconst_3);
+ if (i == 4)
+ return Insn.create(opc_iconst_4);
+ if (i == 5)
+ return Insn.create(opc_iconst_5);
+ if (i >= -128 && i < 128)
+ return Insn.create(opc_bipush, i);
+ //@olsen: added use of opc_sipush
+ if (i >= -32768 && i < 32768)
+ return Insn.create(opc_sipush, i);
+ //@olsen: need to carefully select opc_ldc/opc_ldc_w/opc_ldc2_w
+ //return Insn.create(opc_ldc, pool.addInteger(i));
+ return constantValue(pool.addInteger(i));
+ }
+
+ /**
+ * Return the best instruction for loading the specified long constant onto
+ * the stack.
+ */
+ public static Insn longConstant(long l, ConstantPool pool) {
+ //@olsen: removed redundant 'else's
+ if (l == 0)
+ return Insn.create(opc_lconst_0);
+ if (l == 1)
+ return Insn.create(opc_lconst_1);
+ //@olsen: need to carefully select opc_ldc/opc_ldc_w/opc_ldc2_w
+ //return Insn.create(opc_ldc2_w, pool.addLong(l));
+ return constantValue(pool.addLong(l));
+ }
+
+ /**
+ * Return the best instruction for loading the specified float constant onto
+ * the stack.
+ */
+ public static Insn floatConstant(float f, ConstantPool pool) {
+ //@olsen: removed redundant 'else's
+ if (f == 0)
+ return Insn.create(opc_fconst_0);
+ if (f == 1)
+ return Insn.create(opc_fconst_1);
+ if (f == 2)
+ return Insn.create(opc_fconst_2);
+ //@olsen: need to carefully select opc_ldc/opc_ldc_w/opc_ldc2_w
+ //return Insn.create(opc_ldc, pool.addFloat(f));
+ return constantValue(pool.addFloat(f));
+ }
+
+ /**
+ * Return the best instruction for loading the specified double constant onto
+ * the stack.
+ */
+ public static Insn doubleConstant(double d, ConstantPool pool) {
+ //@olsen: removed redundant 'else's
+ if (d == 0)
+ return Insn.create(opc_dconst_0);
+ if (d == 1)
+ return Insn.create(opc_dconst_1);
+ //@olsen: need to carefully select opc_ldc/opc_ldc_w/opc_ldc2_w
+ //return Insn.create(opc_ldc2_w, pool.addDouble(d));
+ return constantValue(pool.addDouble(d));
+ }
+
+ /**
+ * Return the best instruction for storing a reference to a local
+ * variable slot
+ */
+ public static Insn aStore(int i, ConstantPool pool) {
+ if (i == 0)
+ return Insn.create(opc_astore_0);
+ else if (i == 1)
+ return Insn.create(opc_astore_1);
+ else if (i == 2)
+ return Insn.create(opc_astore_2);
+ else if (i == 3)
+ return Insn.create(opc_astore_3);
+ return Insn.create(opc_astore, i);
+ }
+
+ /**
+ * Return the best instruction for storing an int to a local
+ * variable slot
+ */
+ public static Insn iStore(int i, ConstantPool pool) {
+ if (i == 0)
+ return Insn.create(opc_istore_0);
+ else if (i == 1)
+ return Insn.create(opc_istore_1);
+ else if (i == 2)
+ return Insn.create(opc_istore_2);
+ else if (i == 3)
+ return Insn.create(opc_istore_3);
+ return Insn.create(opc_istore, i);
+ }
+
+ /**
+ * Return the best instruction for storing a float to a local
+ * variable slot
+ */
+ public static Insn fStore(int i, ConstantPool pool) {
+ if (i == 0)
+ return Insn.create(opc_fstore_0);
+ else if (i == 1)
+ return Insn.create(opc_fstore_1);
+ else if (i == 2)
+ return Insn.create(opc_fstore_2);
+ else if (i == 3)
+ return Insn.create(opc_fstore_3);
+ return Insn.create(opc_fstore, i);
+ }
+
+ /**
+ * Return the best instruction for storing a long to a local
+ * variable slot
+ */
+ public static Insn lStore(int i, ConstantPool pool) {
+ if (i == 0)
+ return Insn.create(opc_lstore_0);
+ else if (i == 1)
+ return Insn.create(opc_lstore_1);
+ else if (i == 2)
+ return Insn.create(opc_lstore_2);
+ else if (i == 3)
+ return Insn.create(opc_lstore_3);
+ return Insn.create(opc_lstore, i);
+ }
+
+ /**
+ * Return the best instruction for storing a double to a local
+ * variable slot
+ */
+ public static Insn dStore(int i, ConstantPool pool) {
+ if (i == 0)
+ return Insn.create(opc_dstore_0);
+ else if (i == 1)
+ return Insn.create(opc_dstore_1);
+ else if (i == 2)
+ return Insn.create(opc_dstore_2);
+ else if (i == 3)
+ return Insn.create(opc_dstore_3);
+ return Insn.create(opc_dstore, i);
+ }
+
+ /**
+ * Return the best instruction for loading a reference from a local
+ * variable slot
+ */
+ public static Insn aLoad(int i, ConstantPool pool) {
+ if (i == 0)
+ return Insn.create(opc_aload_0);
+ else if (i == 1)
+ return Insn.create(opc_aload_1);
+ else if (i == 2)
+ return Insn.create(opc_aload_2);
+ else if (i == 3)
+ return Insn.create(opc_aload_3);
+ return Insn.create(opc_aload, i);
+ }
+
+ /**
+ * Return the best instruction for loading an int from a local
+ * variable slot
+ */
+ public static Insn iLoad(int i, ConstantPool pool) {
+ if (i == 0)
+ return Insn.create(opc_iload_0);
+ else if (i == 1)
+ return Insn.create(opc_iload_1);
+ else if (i == 2)
+ return Insn.create(opc_iload_2);
+ else if (i == 3)
+ return Insn.create(opc_iload_3);
+ return Insn.create(opc_iload, i);
+ }
+
+ /**
+ * Return the best instruction for loading a float from a local
+ * variable slot
+ */
+ public static Insn fLoad(int i, ConstantPool pool) {
+ if (i == 0)
+ return Insn.create(opc_fload_0);
+ else if (i == 1)
+ return Insn.create(opc_fload_1);
+ else if (i == 2)
+ return Insn.create(opc_fload_2);
+ else if (i == 3)
+ return Insn.create(opc_fload_3);
+ return Insn.create(opc_fload, i);
+ }
+
+ /**
+ * Return the best instruction for loading a long from a local
+ * variable slot
+ */
+ public static Insn lLoad(int i, ConstantPool pool) {
+ if (i == 0)
+ return Insn.create(opc_lload_0);
+ else if (i == 1)
+ return Insn.create(opc_lload_1);
+ else if (i == 2)
+ return Insn.create(opc_lload_2);
+ else if (i == 3)
+ return Insn.create(opc_lload_3);
+ return Insn.create(opc_lload, i);
+ }
+
+ /**
+ * Return the best instruction for loading a double from a local
+ * variable slot
+ */
+ public static Insn dLoad(int i, ConstantPool pool) {
+ if (i == 0)
+ return Insn.create(opc_dload_0);
+ else if (i == 1)
+ return Insn.create(opc_dload_1);
+ else if (i == 2)
+ return Insn.create(opc_dload_2);
+ else if (i == 3)
+ return Insn.create(opc_dload_3);
+ return Insn.create(opc_dload, i);
+ }
+
+ /**
+ * Return the best instruction for loading a value from a local
+ * variable slot
+ */
+ public static Insn load(int tp, int i, ConstantPool pool) {
+ switch(tp) {
+ //@olsen: added these cases:
+ case T_BOOLEAN:
+ case T_CHAR:
+ case T_BYTE:
+ case T_SHORT:
+ //@olsen: end added cases
+ case T_INT:
+ return iLoad(i, pool);
+ case T_FLOAT:
+ return fLoad(i, pool);
+ case T_DOUBLE:
+ return dLoad(i, pool);
+ case T_LONG:
+ return lLoad(i, pool);
+ case TC_OBJECT:
+ return aLoad(i, pool);
+ default:
+ throw new InsnError("bad load type");
+ }
+ }
+
+ /**
+ * Return the best instruction for storing a value to a local
+ * variable slot
+ */
+ public static Insn store(int tp, int i, ConstantPool pool) {
+ switch(tp) {
+ //@olsen: added these cases:
+ case T_BOOLEAN:
+ case T_CHAR:
+ case T_BYTE:
+ case T_SHORT:
+ //@olsen: end added cases
+ case T_INT:
+ return iStore(i, pool);
+ case T_FLOAT:
+ return fStore(i, pool);
+ case T_DOUBLE:
+ return dStore(i, pool);
+ case T_LONG:
+ return lStore(i, pool);
+ case TC_OBJECT:
+ return aStore(i, pool);
+ default:
+ throw new InsnError("bad store type");
+ }
+ }
+}
Added: incubator/jdo/trunk/ri11/src/java/org/apache/jdo/impl/enhancer/classfile/LineNumberTableAttribute.java
URL: http://svn.apache.org/viewcvs/incubator/jdo/trunk/ri11/src/java/org/apache/jdo/impl/enhancer/classfile/LineNumberTableAttribute.java?view=auto&rev=158176
==============================================================================
--- incubator/jdo/trunk/ri11/src/java/org/apache/jdo/impl/enhancer/classfile/LineNumberTableAttribute.java (added)
+++ incubator/jdo/trunk/ri11/src/java/org/apache/jdo/impl/enhancer/classfile/LineNumberTableAttribute.java Fri Mar 18 17:02:29 2005
@@ -0,0 +1,107 @@
+/*
+ * Copyright 2005 The Apache Software Foundation.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+package org.apache.jdo.impl.enhancer.classfile;
+
+import java.io.*;
+import java.util.Stack;
+
+/**
+ * LineNumberTableAttribute represents a line number table attribute
+ * within a CodeAttribute within a class file
+ */
+public class LineNumberTableAttribute extends ClassAttribute {
+ /* The expected attribute name */
+ public final static String expectedAttrName = "LineNumberTable";
+
+ /* The line numbers */
+ private short lineNumbers[];
+
+ /* The corresponding instructions */
+ private InsnTarget targets[];
+
+ /* public accessors */
+
+ /**
+ * Constructor
+ */
+ public LineNumberTableAttribute(
+ ConstUtf8 nameAttr, short lineNums[], InsnTarget targets[]) {
+ super(nameAttr);
+ lineNumbers = lineNums;
+ this.targets = targets;
+ }
+
+ /**
+ * Compares this instance with another for structural equality.
+ */
+ //@olsen: added method
+ public boolean isEqual(Stack msg, Object obj) {
+ if (!(obj instanceof LineNumberTableAttribute)) {
+ msg.push("obj/obj.getClass() = "
+ + (obj == null ? null : obj.getClass()));
+ msg.push("this.getClass() = "
+ + this.getClass());
+ return false;
+ }
+ LineNumberTableAttribute other = (LineNumberTableAttribute)obj;
+
+ if (!super.isEqual(msg, other)) {
+ return false;
+ }
+
+ // intentionally ingore any linenumber differences
+ return true;
+ }
+
+ /* package local methods */
+
+ static LineNumberTableAttribute read(
+ ConstUtf8 attrName, DataInputStream data, CodeEnv env)
+ throws IOException {
+ int nLnums = data.readUnsignedShort();
+ short lineNums[] = new short[nLnums];
+ InsnTarget targs[] = new InsnTarget[nLnums];
+ for (int i=0; i<nLnums; i++) {
+ targs[i] = env.getTarget(data.readShort());
+ lineNums[i] = data.readShort();
+ }
+ return new LineNumberTableAttribute(attrName, lineNums, targs);
+ }
+
+ void write(DataOutputStream out) throws IOException {
+ out.writeShort(attrName().getIndex());
+ int nlines = lineNumbers.length;
+ out.writeInt(2+4*nlines);
+ out.writeShort(nlines);
+ for (int i=0; i<nlines; i++) {
+ out.writeShort(targets[i].offset());
+ out.writeShort(lineNumbers[i]);
+ }
+ }
+
+ void print(PrintStream out, int indent) {
+ ClassPrint.spaces(out, indent);
+ out.println("Line Numbers: ");
+ for (int i=0; i<lineNumbers.length; i++) {
+ ClassPrint.spaces(out, indent+2);
+ out.println(Integer.toString(lineNumbers[i]) + " @ " +
+ Integer.toString(targets[i].offset()));
+ }
+ }
+}
+
Added: incubator/jdo/trunk/ri11/src/java/org/apache/jdo/impl/enhancer/classfile/LocalVariable.java
URL: http://svn.apache.org/viewcvs/incubator/jdo/trunk/ri11/src/java/org/apache/jdo/impl/enhancer/classfile/LocalVariable.java?view=auto&rev=158176
==============================================================================
--- incubator/jdo/trunk/ri11/src/java/org/apache/jdo/impl/enhancer/classfile/LocalVariable.java (added)
+++ incubator/jdo/trunk/ri11/src/java/org/apache/jdo/impl/enhancer/classfile/LocalVariable.java Fri Mar 18 17:02:29 2005
@@ -0,0 +1,89 @@
+/*
+ * Copyright 2005 The Apache Software Foundation.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+package org.apache.jdo.impl.enhancer.classfile;
+
+import java.io.*;
+
+/**
+ * Represents a local variable within a LocalVariableTable within
+ * a CodeAttribute in a class file.
+ */
+public class LocalVariable {
+ /* The pc at which the variable becomes effecive */
+ private InsnTarget varStartPC; /* inclusive */
+
+ /* The pc at which the variable becomes in-effecive */
+ private InsnTarget varEndPC; /* exclusive */
+
+ /* The name of the variable */
+ private ConstUtf8 varName;
+
+ /* The type signature of the variable */
+ private ConstUtf8 varSig;
+
+ /* The slot to which the variable is assigned */
+ private int varSlot;
+
+ /* public accessors */
+
+ /**
+ * Constructor for a local variable
+ */
+ public LocalVariable(InsnTarget startPC, InsnTarget endPC,
+ ConstUtf8 name, ConstUtf8 sig, int slot) {
+ varStartPC = startPC;
+ varEndPC = endPC;
+ varName = name;
+ varSig = sig;
+ varSlot = slot;
+ }
+
+ /* package local methods */
+
+ static LocalVariable read(DataInputStream data, CodeEnv env)
+ throws IOException {
+ int startPC = data.readUnsignedShort();
+ InsnTarget startPCTarget = env.getTarget(startPC);
+ int length = data.readUnsignedShort();
+ InsnTarget endPCTarget = env.getTarget(startPC+length);
+ ConstUtf8 name =
+ (ConstUtf8) env.pool().constantAt(data.readUnsignedShort());
+ ConstUtf8 sig =
+ (ConstUtf8) env.pool().constantAt(data.readUnsignedShort());
+ int slot = data.readUnsignedShort();
+ return new LocalVariable(startPCTarget, endPCTarget, name, sig, slot);
+ }
+
+ void write(DataOutputStream out) throws IOException {
+ out.writeShort(varStartPC.offset());
+ out.writeShort(varEndPC.offset() - varStartPC.offset());
+ out.writeShort((varName == null) ? 0 : varName.getIndex());
+ out.writeShort((varSig == null) ? 0 : varSig.getIndex());
+ out.writeShort(varSlot);
+ }
+
+ public void print(PrintStream out, int indent) {
+ ClassPrint.spaces(out, indent);
+ out.print("'" + ((varName == null) ? "(null)" : varName.asString()) + "'");
+ out.print(" sig = " + ((varSig == null) ? "(null)" : varSig.asString()));
+ out.print(" start_pc = " + Integer.toString(varStartPC.offset()));
+ out.print(" length = " +
+ Integer.toString(varEndPC.offset() - varStartPC.offset()));
+ out.println(" slot = " + Integer.toString(varSlot));
+ }
+}
Added: incubator/jdo/trunk/ri11/src/java/org/apache/jdo/impl/enhancer/classfile/LocalVariableTableAttribute.java
URL: http://svn.apache.org/viewcvs/incubator/jdo/trunk/ri11/src/java/org/apache/jdo/impl/enhancer/classfile/LocalVariableTableAttribute.java?view=auto&rev=158176
==============================================================================
--- incubator/jdo/trunk/ri11/src/java/org/apache/jdo/impl/enhancer/classfile/LocalVariableTableAttribute.java (added)
+++ incubator/jdo/trunk/ri11/src/java/org/apache/jdo/impl/enhancer/classfile/LocalVariableTableAttribute.java Fri Mar 18 17:02:29 2005
@@ -0,0 +1,90 @@
+/*
+ * Copyright 2005 The Apache Software Foundation.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+package org.apache.jdo.impl.enhancer.classfile;
+
+import java.io.*;
+import java.util.Vector;
+import java.util.Enumeration;
+
+/**
+ * Represents the LocalVariableTable attribute within a
+ * method in a class file.
+ */
+public class LocalVariableTableAttribute extends ClassAttribute {
+ /* The expected attribute name */
+ public static final String expectedAttrName = "LocalVariableTable";
+
+ /* The list of local variables */
+ private Vector localTable;
+
+ /* public accessors */
+
+ /**
+ * Returns an enumeration of the local variables in the table
+ * Each element is a LocalVariable
+ */
+ Enumeration variables() {
+ return localTable.elements();
+ }
+
+ /**
+ * Constructor for a local variable table
+ */
+ public LocalVariableTableAttribute(
+ ConstUtf8 nameAttr, Vector lvarTable) {
+ super(nameAttr);
+ localTable = lvarTable;
+ }
+
+ /* package local methods */
+
+ static LocalVariableTableAttribute read(
+ ConstUtf8 attrName, DataInputStream data, CodeEnv env)
+ throws IOException {
+ int nVars = data.readUnsignedShort();
+ Vector lvarTable = new Vector();
+ while (nVars-- > 0) {
+ lvarTable.addElement(LocalVariable.read(data, env));
+ }
+
+ return new LocalVariableTableAttribute(attrName, lvarTable);
+ }
+
+ void write(DataOutputStream out) throws IOException {
+ out.writeShort(attrName().getIndex());
+ ByteArrayOutputStream baos = new ByteArrayOutputStream();
+ DataOutputStream tmp_out = new DataOutputStream(baos);
+ tmp_out.writeShort(localTable.size());
+ for (int i=0; i<localTable.size(); i++)
+ ((LocalVariable) localTable.elementAt(i)).write(tmp_out);
+
+ tmp_out.flush();
+ byte tmp_bytes[] = baos.toByteArray();
+ out.writeInt(tmp_bytes.length);
+ out.write(tmp_bytes, 0, tmp_bytes.length);
+ }
+
+ void print(PrintStream out, int indent) {
+ ClassPrint.spaces(out, indent);
+ out.println("LocalVariables: ");
+ for (int i=0; i<localTable.size(); i++) {
+ ((LocalVariable) localTable.elementAt(i)).print(out, indent+2);
+ }
+ }
+}
+
Added: incubator/jdo/trunk/ri11/src/java/org/apache/jdo/impl/enhancer/classfile/SourceFileAttribute.java
URL: http://svn.apache.org/viewcvs/incubator/jdo/trunk/ri11/src/java/org/apache/jdo/impl/enhancer/classfile/SourceFileAttribute.java?view=auto&rev=158176
==============================================================================
--- incubator/jdo/trunk/ri11/src/java/org/apache/jdo/impl/enhancer/classfile/SourceFileAttribute.java (added)
+++ incubator/jdo/trunk/ri11/src/java/org/apache/jdo/impl/enhancer/classfile/SourceFileAttribute.java Fri Mar 18 17:02:29 2005
@@ -0,0 +1,78 @@
+/*
+ * Copyright 2005 The Apache Software Foundation.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+package org.apache.jdo.impl.enhancer.classfile;
+
+import java.io.*;
+
+/**
+ * Represents the source file attribute in a class file
+ */
+public class SourceFileAttribute extends ClassAttribute {
+ /* The expected attribute name */
+ public static final String expectedAttrName = "SourceFile";
+
+ /* The source file name */
+ private ConstUtf8 sourceFileName;
+
+ /* public accessors */
+
+ /**
+ * Returns the source file name
+ * The file name should not include directories
+ */
+ public ConstUtf8 fileName() {
+ return sourceFileName;
+ }
+
+ /**
+ * Sets the source file name
+ */
+ public void setFileName(ConstUtf8 name) {
+ sourceFileName = name;
+ }
+
+ /**
+ * Constructor for a source file attribute
+ */
+ public SourceFileAttribute(ConstUtf8 attrName, ConstUtf8 sourceName) {
+ super(attrName);
+ sourceFileName = sourceName;
+ }
+
+ /* package local methods */
+ static SourceFileAttribute read(ConstUtf8 attrName,
+ DataInputStream data, ConstantPool pool)
+ throws IOException {
+ int index = 0;
+ index = data.readUnsignedShort();
+
+ return new SourceFileAttribute(attrName,
+ (ConstUtf8) pool.constantAt(index));
+ }
+
+ void write(DataOutputStream out) throws IOException {
+ out.writeShort(attrName().getIndex());
+ out.writeInt(2);
+ out.writeShort(sourceFileName.getIndex());
+ }
+
+ void print(PrintStream out, int indent) {
+ ClassPrint.spaces(out, indent);
+ out.println("SourceFile: " + sourceFileName.asString());
+ }
+}
Added: incubator/jdo/trunk/ri11/src/java/org/apache/jdo/impl/enhancer/classfile/SyntheticAttribute.java
URL: http://svn.apache.org/viewcvs/incubator/jdo/trunk/ri11/src/java/org/apache/jdo/impl/enhancer/classfile/SyntheticAttribute.java?view=auto&rev=158176
==============================================================================
--- incubator/jdo/trunk/ri11/src/java/org/apache/jdo/impl/enhancer/classfile/SyntheticAttribute.java (added)
+++ incubator/jdo/trunk/ri11/src/java/org/apache/jdo/impl/enhancer/classfile/SyntheticAttribute.java Fri Mar 18 17:02:29 2005
@@ -0,0 +1,62 @@
+/*
+ * Copyright 2005 The Apache Software Foundation.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+package org.apache.jdo.impl.enhancer.classfile;
+
+import java.io.*;
+
+//@olsen: fix 4467428, added class for synthetic attribute to be added
+// to generated jdo fields and methods
+
+/**
+ * A SyntheticAttribute is a fixed-length attribute in the attributes table
+ * of ClassFile, ClassField, and ClassMethod structures. A class member
+ * that does not appear in the source code must be marked using a
+ * SyntheticAttribute.
+ */
+public class SyntheticAttribute extends ClassAttribute {
+ /* The expected name of this attribute */
+ public static final String expectedAttrName = "Synthetic";
+
+ /**
+ * Construct a constant value attribute
+ */
+ public SyntheticAttribute(ConstUtf8 attrName) {
+ super(attrName);
+ //System.out.println("new SyntheticAttribute()");
+ }
+
+ /* package local methods */
+
+ static SyntheticAttribute read(ConstUtf8 attrName,
+ DataInputStream data,
+ ConstantPool pool)
+ throws IOException {
+ return new SyntheticAttribute(attrName);
+ }
+
+ void write(DataOutputStream out) throws IOException {
+ out.writeShort(attrName().getIndex());
+ final int attributeBytesLength = 0;
+ out.writeInt(attributeBytesLength);
+ }
+
+ void print(PrintStream out, int indent) {
+ ClassPrint.spaces(out, indent);
+ out.println(expectedAttrName);
+ }
+}
Added: incubator/jdo/trunk/ri11/src/java/org/apache/jdo/impl/enhancer/classfile/VMConstants.java
URL: http://svn.apache.org/viewcvs/incubator/jdo/trunk/ri11/src/java/org/apache/jdo/impl/enhancer/classfile/VMConstants.java?view=auto&rev=158176
==============================================================================
--- incubator/jdo/trunk/ri11/src/java/org/apache/jdo/impl/enhancer/classfile/VMConstants.java (added)
+++ incubator/jdo/trunk/ri11/src/java/org/apache/jdo/impl/enhancer/classfile/VMConstants.java Fri Mar 18 17:02:29 2005
@@ -0,0 +1,282 @@
+/*
+ * Copyright 2005 The Apache Software Foundation.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+package org.apache.jdo.impl.enhancer.classfile;
+
+/**
+ * VMConstants is a collection of the constants defined in the
+ * virtual machine spec.
+ * Also included are several assorted constants of our own which
+ * seem logical to define here.
+ */
+public interface VMConstants {
+ /* Access types */
+ static final int ACCPublic = 0x0001;
+ static final int ACCPrivate = 0x0002;
+ static final int ACCProtected = 0x0004;
+ static final int ACCStatic = 0x0008;
+ static final int ACCFinal = 0x0010;
+ static final int ACCSuper = 0x0020; /* For Class file */
+ static final int ACCSynchronized = 0x0020; /* For methods */
+ static final int ACCVolatile = 0x0040;
+ static final int ACCTransient = 0x0080;
+ static final int ACCNative = 0x0100;
+ static final int ACCInterface = 0x0200;
+ static final int ACCAbstract = 0x0400;
+
+
+ /* Primitive Types */
+ /* These correspond to the values used by newarray */
+ static final int T_BOOLEAN = 4;
+ static final int T_CHAR = 5;
+ static final int T_FLOAT = 6;
+ static final int T_DOUBLE = 7;
+ static final int T_BYTE = 8;
+ static final int T_SHORT = 9;
+ static final int T_INT = 10;
+ static final int T_LONG = 11;
+
+ /* Class types - Not really part of the VM spec */
+ static final int TC_OBJECT = 12;
+ static final int TC_INTERFACE = 13;
+ static final int TC_STRING = 14;
+
+ /* Special pseudo types - Not really part of the VM spec */
+ static final int T_UNKNOWN = 15;
+ static final int T_WORD = 16;
+ static final int T_TWOWORD = 17;
+
+ /* Constant pool types */
+ static final int CONSTANTUtf8 = 1;
+ static final int CONSTANTUnicode = 2; /* Def.in Beta doc - not in 1.0.2 */
+ static final int CONSTANTInteger = 3;
+ static final int CONSTANTFloat = 4;
+ static final int CONSTANTLong = 5;
+ static final int CONSTANTDouble = 6;
+ static final int CONSTANTClass = 7;
+ static final int CONSTANTString = 8;
+ static final int CONSTANTFieldRef = 9;
+ static final int CONSTANTMethodRef = 10;
+ static final int CONSTANTInterfaceMethodRef = 11;
+ static final int CONSTANTNameAndType = 12;
+
+
+
+ /* Java VM opcodes */
+ final static int opc_nop = 0;
+ final static int opc_aconst_null = 1;
+ final static int opc_iconst_m1 = 2;
+ final static int opc_iconst_0 = 3;
+ final static int opc_iconst_1 = 4;
+ final static int opc_iconst_2 = 5;
+ final static int opc_iconst_3 = 6;
+ final static int opc_iconst_4 = 7;
+ final static int opc_iconst_5 = 8;
+ final static int opc_lconst_0 = 9;
+ final static int opc_lconst_1 = 10;
+ final static int opc_fconst_0 = 11;
+ final static int opc_fconst_1 = 12;
+ final static int opc_fconst_2 = 13;
+ final static int opc_dconst_0 = 14;
+ final static int opc_dconst_1 = 15;
+ final static int opc_bipush = 16;
+ final static int opc_sipush = 17;
+ final static int opc_ldc = 18;
+ final static int opc_ldc_w = 19;
+ final static int opc_ldc2_w = 20;
+ final static int opc_iload = 21;
+ final static int opc_lload = 22;
+ final static int opc_fload = 23;
+ final static int opc_dload = 24;
+ final static int opc_aload = 25;
+ final static int opc_iload_0 = 26;
+ final static int opc_iload_1 = 27;
+ final static int opc_iload_2 = 28;
+ final static int opc_iload_3 = 29;
+ final static int opc_lload_0 = 30;
+ final static int opc_lload_1 = 31;
+ final static int opc_lload_2 = 32;
+ final static int opc_lload_3 = 33;
+ final static int opc_fload_0 = 34;
+ final static int opc_fload_1 = 35;
+ final static int opc_fload_2 = 36;
+ final static int opc_fload_3 = 37;
+ final static int opc_dload_0 = 38;
+ final static int opc_dload_1 = 39;
+ final static int opc_dload_2 = 40;
+ final static int opc_dload_3 = 41;
+ final static int opc_aload_0 = 42;
+ final static int opc_aload_1 = 43;
+ final static int opc_aload_2 = 44;
+ final static int opc_aload_3 = 45;
+ final static int opc_iaload = 46;
+ final static int opc_laload = 47;
+ final static int opc_faload = 48;
+ final static int opc_daload = 49;
+ final static int opc_aaload = 50;
+ final static int opc_baload = 51;
+ final static int opc_caload = 52;
+ final static int opc_saload = 53;
+ final static int opc_istore = 54;
+ final static int opc_lstore = 55;
+ final static int opc_fstore = 56;
+ final static int opc_dstore = 57;
+ final static int opc_astore = 58;
+ final static int opc_istore_0 = 59;
+ final static int opc_istore_1 = 60;
+ final static int opc_istore_2 = 61;
+ final static int opc_istore_3 = 62;
+ final static int opc_lstore_0 = 63;
+ final static int opc_lstore_1 = 64;
+ final static int opc_lstore_2 = 65;
+ final static int opc_lstore_3 = 66;
+ final static int opc_fstore_0 = 67;
+ final static int opc_fstore_1 = 68;
+ final static int opc_fstore_2 = 69;
+ final static int opc_fstore_3 = 70;
+ final static int opc_dstore_0 = 71;
+ final static int opc_dstore_1 = 72;
+ final static int opc_dstore_2 = 73;
+ final static int opc_dstore_3 = 74;
+ final static int opc_astore_0 = 75;
+ final static int opc_astore_1 = 76;
+ final static int opc_astore_2 = 77;
+ final static int opc_astore_3 = 78;
+ final static int opc_iastore = 79;
+ final static int opc_lastore = 80;
+ final static int opc_fastore = 81;
+ final static int opc_dastore = 82;
+ final static int opc_aastore = 83;
+ final static int opc_bastore = 84;
+ final static int opc_castore = 85;
+ final static int opc_sastore = 86;
+ final static int opc_pop = 87;
+ final static int opc_pop2 = 88;
+ final static int opc_dup = 89;
+ final static int opc_dup_x1 = 90;
+ final static int opc_dup_x2 = 91;
+ final static int opc_dup2 = 92;
+ final static int opc_dup2_x1 = 93;
+ final static int opc_dup2_x2 = 94;
+ final static int opc_swap = 95;
+ final static int opc_iadd = 96;
+ final static int opc_ladd = 97;
+ final static int opc_fadd = 98;
+ final static int opc_dadd = 99;
+ final static int opc_isub = 100;
+ final static int opc_lsub = 101;
+ final static int opc_fsub = 102;
+ final static int opc_dsub = 103;
+ final static int opc_imul = 104;
+ final static int opc_lmul = 105;
+ final static int opc_fmul = 106;
+ final static int opc_dmul = 107;
+ final static int opc_idiv = 108;
+ final static int opc_ldiv = 109;
+ final static int opc_fdiv = 110;
+ final static int opc_ddiv = 111;
+ final static int opc_irem = 112;
+ final static int opc_lrem = 113;
+ final static int opc_frem = 114;
+ final static int opc_drem = 115;
+ final static int opc_ineg = 116;
+ final static int opc_lneg = 117;
+ final static int opc_fneg = 118;
+ final static int opc_dneg = 119;
+ final static int opc_ishl = 120;
+ final static int opc_lshl = 121;
+ final static int opc_ishr = 122;
+ final static int opc_lshr = 123;
+ final static int opc_iushr = 124;
+ final static int opc_lushr = 125;
+ final static int opc_iand = 126;
+ final static int opc_land = 127;
+ final static int opc_ior = 128;
+ final static int opc_lor = 129;
+ final static int opc_ixor = 130;
+ final static int opc_lxor = 131;
+ final static int opc_iinc = 132;
+ final static int opc_i2l = 133;
+ final static int opc_i2f = 134;
+ final static int opc_i2d = 135;
+ final static int opc_l2i = 136;
+ final static int opc_l2f = 137;
+ final static int opc_l2d = 138;
+ final static int opc_f2i = 139;
+ final static int opc_f2l = 140;
+ final static int opc_f2d = 141;
+ final static int opc_d2i = 142;
+ final static int opc_d2l = 143;
+ final static int opc_d2f = 144;
+ final static int opc_i2b = 145;
+ final static int opc_i2c = 146;
+ final static int opc_i2s = 147;
+ final static int opc_lcmp = 148;
+ final static int opc_fcmpl = 149;
+ final static int opc_fcmpg = 150;
+ final static int opc_dcmpl = 151;
+ final static int opc_dcmpg = 152;
+ final static int opc_ifeq = 153;
+ final static int opc_ifne = 154;
+ final static int opc_iflt = 155;
+ final static int opc_ifge = 156;
+ final static int opc_ifgt = 157;
+ final static int opc_ifle = 158;
+ final static int opc_if_icmpeq = 159;
+ final static int opc_if_icmpne = 160;
+ final static int opc_if_icmplt = 161;
+ final static int opc_if_icmpge = 162;
+ final static int opc_if_icmpgt = 163;
+ final static int opc_if_icmple = 164;
+ final static int opc_if_acmpeq = 165;
+ final static int opc_if_acmpne = 166;
+ final static int opc_goto = 167;
+ final static int opc_jsr = 168;
+ final static int opc_ret = 169;
+ final static int opc_tableswitch = 170;
+ final static int opc_lookupswitch = 171;
+ final static int opc_ireturn = 172;
+ final static int opc_lreturn = 173;
+ final static int opc_freturn = 174;
+ final static int opc_dreturn = 175;
+ final static int opc_areturn = 176;
+ final static int opc_return = 177;
+ final static int opc_getstatic = 178;
+ final static int opc_putstatic = 179;
+ final static int opc_getfield = 180;
+ final static int opc_putfield = 181;
+ final static int opc_invokevirtual = 182;
+ final static int opc_invokespecial = 183;
+ final static int opc_invokestatic = 184;
+ final static int opc_invokeinterface = 185;
+ final static int opc_xxxunusedxxx = 186;
+ final static int opc_new = 187;
+ final static int opc_newarray = 188;
+ final static int opc_anewarray = 189;
+ final static int opc_arraylength = 190;
+ final static int opc_athrow = 191;
+ final static int opc_checkcast = 192;
+ final static int opc_instanceof = 193;
+ final static int opc_monitorenter = 194;
+ final static int opc_monitorexit = 195;
+ final static int opc_wide = 196;
+ final static int opc_multianewarray = 197;
+ final static int opc_ifnull = 198;
+ final static int opc_ifnonnull = 199;
+ final static int opc_goto_w = 200;
+ final static int opc_jsr_w = 201;
+}
|