How to use

putInt

method

in

org.mvel2.asm.ByteVector

public void visitLookupSwitchInsn(
    final Label dflt,
    final int keys[],
    final Label labels[]) {
  // adds the instruction to the bytecode of the method
  int source = code.length;
  code.putByte(Opcodes.LOOKUPSWITCH);
  code.length += (4 - code.length % 4) % 4;
  dflt.put(this, code, source, true);
  code.putInt(labels.length);
  for (int i = 0; i < labels.length; ++i) {
    code.putInt(keys[i]);
    labels[i].put(this, code, source, true);
  }
  // updates currentBlock
  visitSwitchInsn(dflt, labels);
}

public void visitTableSwitchInsn(
    final int min,
    final int max,
    final Label dflt,
    final Label labels[]) {
  // adds the instruction to the bytecode of the method
  int source = code.length;
  code.putByte(Opcodes.TABLESWITCH);
  code.length += (4 - code.length % 4) % 4;
  dflt.put(this, code, source, true);
  code.putInt(min).putInt(max);
  for (int i = 0; i < labels.length; ++i) {
    labels[i].put(this, code, source, true);
  }
  // updates currentBlock
  visitSwitchInsn(dflt, labels);
}

@Override
public void visitLookupSwitchInsn(final Label dflt, final int[] keys, final Label[] labels) {
 lastBytecodeOffset = code.length;
 // Add the instruction to the bytecode of the method.
 code.putByte(Opcodes.LOOKUPSWITCH).putByteArray(null, 0, (4 - code.length % 4) % 4);
 dflt.put(code, lastBytecodeOffset, true);
 code.putInt(labels.length);
 for (int i = 0; i < labels.length; ++i) {
  code.putInt(keys[i]);
  labels[i].put(code, lastBytecodeOffset, true);
 }
 // If needed, update the maximum stack size and number of locals, and stack map frames.
 visitSwitchInsn(dflt, labels);
}

@Override
public void visitTableSwitchInsn(
  final int min, final int max, final Label dflt, final Label... labels) {
 lastBytecodeOffset = code.length;
 // Add the instruction to the bytecode of the method.
 code.putByte(Opcodes.TABLESWITCH).putByteArray(null, 0, (4 - code.length % 4) % 4);
 dflt.put(code, lastBytecodeOffset, true);
 code.putInt(min).putInt(max);
 for (Label label : labels) {
  label.put(code, lastBytecodeOffset, true);
 }
 // If needed, update the maximum stack size and number of locals, and stack map frames.
 visitSwitchInsn(dflt, labels);
}

@Override
public void visitTableSwitchInsn(final int min, final int max,
    final Label dflt, final Label... labels) {
  lastCodeOffset = code.length;
  // adds the instruction to the bytecode of the method
  int source = code.length;
  code.putByte(Opcodes.TABLESWITCH);
  code.putByteArray(null, 0, (4 - code.length % 4) % 4);
  dflt.put(this, code, source, true);
  code.putInt(min).putInt(max);
  for (int i = 0; i < labels.length; ++i) {
    labels[i].put(this, code, source, true);
  }
  // updates currentBlock
  visitSwitchInsn(dflt, labels);
}

@Override
public void visitLookupSwitchInsn(final Label dflt, final int[] keys,
    final Label[] labels) {
  lastCodeOffset = code.length;
  // adds the instruction to the bytecode of the method
  int source = code.length;
  code.putByte(Opcodes.LOOKUPSWITCH);
  code.putByteArray(null, 0, (4 - code.length % 4) % 4);
  dflt.put(this, code, source, true);
  code.putInt(labels.length);
  for (int i = 0; i < labels.length; ++i) {
    code.putInt(keys[i]);
    labels[i].put(this, code, source, true);
  }
  // updates currentBlock
  visitSwitchInsn(dflt, labels);
}

/**
 * Puts a reference to this label in the bytecode of a method. If the bytecode offset of the label
 * is known, the relative bytecode offset between the label and the instruction referencing it is
 * computed and written directly. Otherwise, a null relative offset is written and a new forward
 * reference is declared for this label.
 *
 * @param code the bytecode of the method. This is where the reference is appended.
 * @param sourceInsnBytecodeOffset the bytecode offset of the instruction that contains the
 *     reference to be appended.
 * @param wideReference whether the reference must be stored in 4 bytes (instead of 2 bytes).
 */
final void put(
  final ByteVector code, final int sourceInsnBytecodeOffset, final boolean wideReference) {
 if ((flags & FLAG_RESOLVED) == 0) {
  if (wideReference) {
   addForwardReference(sourceInsnBytecodeOffset, FORWARD_REFERENCE_TYPE_WIDE, code.length);
   code.putInt(-1);
  } else {
   addForwardReference(sourceInsnBytecodeOffset, FORWARD_REFERENCE_TYPE_SHORT, code.length);
   code.putShort(-1);
  }
 } else {
  if (wideReference) {
   code.putInt(bytecodeOffset - sourceInsnBytecodeOffset);
  } else {
   code.putShort(bytecodeOffset - sourceInsnBytecodeOffset);
  }
 }
}

void putAttributes(ByteVector out) {
  if (mainClass != 0) {
    out.putShort(cw.newUTF8("ModuleMainClass")).putInt(2).putShort(mainClass);
  }
  if (packages != null) {
    out.putShort(cw.newUTF8("ModulePackages"))
      .putInt(2 + 2 * packageCount)
      .putShort(packageCount)
      .putByteArray(packages.data, 0, packages.length);
  }
}

/**
 * Puts this symbol table's BootstrapMethods attribute in the given ByteVector. This includes the
 * 6 attribute header bytes and the num_bootstrap_methods value.
 *
 * @param output where the JVMS BootstrapMethods attribute must be put.
 */
void putBootstrapMethods(final ByteVector output) {
 if (bootstrapMethods != null) {
  output
    .putShort(addConstantUtf8(Constants.BOOTSTRAP_METHODS))
    .putInt(bootstrapMethods.length + 2)
    .putShort(bootstrapMethodCount)
    .putByteArray(bootstrapMethods.data, 0, bootstrapMethods.length);
 }
}

/**
 * Puts the annotations of this annotation writer list into the given byte
 * vector.
 * 
 * @param out
 *            where the annotations must be put.
 */
void put(final ByteVector out) {
  int n = 0;
  int size = 2;
  AnnotationWriter aw = this;
  AnnotationWriter last = null;
  while (aw != null) {
    ++n;
    size += aw.bv.length;
    aw.visitEnd(); // in case user forgot to call visitEnd
    aw.prev = last;
    last = aw;
    aw = aw.next;
  }
  out.putInt(size);
  out.putShort(n);
  aw = last;
  while (aw != null) {
    out.putByteArray(aw.bv.data, 0, aw.bv.length);
    aw = aw.prev;
  }
}

/**
 * Puts the annotations of this annotation writer list into the given byte
 * vector.
 *
 * @param out where the annotations must be put.
 */
void put(final ByteVector out) {
  int n = 0;
  int size = 2;
  AnnotationWriter aw = this;
  AnnotationWriter last = null;
  while (aw != null) {
    ++n;
    size += aw.bv.length;
    aw.visitEnd(); // in case user forgot to call visitEnd
    aw.prev = last;
    last = aw;
    aw = aw.next;
  }
  out.putInt(size);
  out.putShort(n);
  aw = last;
  while (aw != null) {
    out.putByteArray(aw.bv.data, 0, aw.bv.length);
    aw = aw.prev;
  }
}

/**
 * Adds a float to the constant pool of the class being build. Does nothing
 * if the constant pool already contains a similar item.
 *
 * @param value the float value.
 * @return a new or already existing float item.
 */
Item newFloat(final float value) {
  key.set(value);
  Item result = get(key);
  if (result == null) {
    pool.putByte(FLOAT).putInt(key.intVal);
    result = new Item(index++, key);
    put(result);
  }
  return result;
}

output.putInt(attributeLength);
output.putShort(numAnnotations);
annotationWriter = firstAnnotation;

/**
 * Adds an integer to the constant pool of the class being build. Does
 * nothing if the constant pool already contains a similar item.
 *
 * @param value the int value.
 * @return a new or already existing int item.
 */
Item newInteger(final int value) {
  key.set(value);
  Item result = get(key);
  if (result == null) {
    pool.putByte(INT).putInt(value);
    result = new Item(index++, key);
    put(result);
  }
  return result;
}

/**
 * Adds an integer to the constant pool of the class being build. Does
 * nothing if the constant pool already contains a similar item.
 * 
 * @param value
 *            the int value.
 * @return a new or already existing int item.
 */
Item newInteger(final int value) {
  key.set(value);
  Item result = get(key);
  if (result == null) {
    pool.putByte(INT).putInt(value);
    result = new Item(index++, key);
    put(result);
  }
  return result;
}

  attribute.write(classWriter, code, codeLength, maxStack, maxLocals);
output.putShort(symbolTable.addConstantUtf8(attribute.type)).putInt(attributeContent.length);
output.putByteArray(attributeContent.data, 0, attributeContent.length);
attribute = attribute.nextAttribute;

/**
 * Adds a float to the constant pool of the class being build. Does nothing
 * if the constant pool already contains a similar item.
 * 
 * @param value
 *            the float value.
 * @return a new or already existing float item.
 */
Item newFloat(final float value) {
  key.set(value);
  Item result = get(key);
  if (result == null) {
    pool.putByte(FLOAT).putInt(key.intVal);
    result = new Item(index++, key);
    put(result);
  }
  return result;
}

/**
 * Adds a CONSTANT_Integer_info or CONSTANT_Float_info to the constant pool of this symbol table.
 * Does nothing if the constant pool already contains a similar item.
 *
 * @param tag one of {@link Symbol#CONSTANT_INTEGER_TAG} or {@link Symbol#CONSTANT_FLOAT_TAG}.
 * @param value an int or float.
 * @return a constant pool constant with the given tag and primitive values.
 */
private Symbol addConstantIntegerOrFloat(final int tag, final int value) {
 int hashCode = hash(tag, value);
 Entry entry = get(hashCode);
 while (entry != null) {
  if (entry.tag == tag && entry.hashCode == hashCode && entry.data == value) {
   return entry;
  }
  entry = entry.next;
 }
 constantPool.putByte(tag).putInt(value);
 return put(new Entry(constantPoolCount++, tag, value, hashCode));
}

  size += panns[i] == null ? 0 : panns[i].getSize();
out.putInt(size).putByte(panns.length);
for (int i = 0; i < panns.length; ++i) {
  AnnotationWriter aw = panns[i];

  void put(ByteVector out) {
    out.putInt(size);
    out.putShort(name).putShort(access).putShort(version);
    out.putShort(requireCount);
    if (requires != null) {
      out.putByteArray(requires.data, 0, requires.length);
    }
    out.putShort(exportCount);
    if (exports != null) {
      out.putByteArray(exports.data, 0, exports.length);
    }
    out.putShort(openCount);
    if (opens != null) {
      out.putByteArray(opens.data, 0, opens.length);
    }
    out.putShort(useCount);
    if (uses != null) {
      out.putByteArray(uses.data, 0, uses.length);
    }
    out.putShort(provideCount);
    if (provides != null) {
      out.putByteArray(provides.data, 0, provides.length);
    }
  }    
}