org.eclipse.equinox.p2.repository.tools_2.0.100.v20110815-1438

tion = relativeOffset + structOffset;
    return ((reference[(position++)] & 0xFF) << 56) + ((reference[(position++)] & 0xFF) << 48) + ((reference[(position++)] & 0xFF) << 40) + ((reference[(position++)] & 0xFF) << 32) + ((reference[(position++)] & 0xFF) << 24) + ((reference[(position++)] & 0xFF) << 16) + ((reference[(position++)] & 0xFF) << 8) + (reference[(position++)] & 0xFF);
  }
  
  protected int u1At(byte[] reference, int relativeOffset, int structOffset)
  {
    return reference[(relativeOffset + structOffset)] & 0xFF;
  }
  
  protected int u2At(byte[] reference, int relativeOffset, int structOffset)
  {
    int position = relativeOffset + structOffset;
    return ((reference[(position++)] & 0xFF) << 8) + (reference[position] & 0xFF);
  }
  
  protected long u4At(byte[] reference, int relativeOffset, int structOffset)
  {
    int position = relativeOffset + structOffset;
    return ((reference[(position++)] & 0xFF) << 24) + ((reference[(position++)] & 0xFF) << 16) + ((reference[(position++)] & 0xFF) << 8) + (reference[position] & 0xFF);
  }
  
  protected char[] utf8At(byte[] reference, int relativeOffset, int structOffset, int bytesAvailable)
  {
    int length = bytesAvailable;
    char[] outputBuf = new char[bytesAvailable];
    int outputPos = 0;
    int readOffset = structOffset + relativeOffset;
    while (length != 0)
    {
      int x = reference[(readOffset++)] & 0xFF;
      length--;
      if ((0x80 & x) != 0) {
        if ((x & 0x20) != 0)
        {
          length -= 2;
          x = ((x & 0xF) << 12) + ((reference[(readOffset++)] & 0x3F) << 6) + (reference[(readOffset++)] & 0x3F);
        }
        else
        {
          length--;
          x = ((x & 0x1F) << 6) + (reference[(readOffset++)] & 0x3F);
        }
      }
      outputBuf[(outputPos++)] = ((char)x);
    }
    if (outputPos != bytesAvailable) {
      System.arraycopy(outputBuf, 0, outputBuf = new char[outputPos], 0, outputPos);
    }
    return outputBuf;
  }
}

/* Location:
 * Qualified Name:     org.eclipse.equinox.p2.internal.repository.comparator.java.ClassFileStruct
 * Java Class Version: 1.4 (48.0)
 * JD-Core Version:    0.7.1
 */
package org.eclipse.equinox.p2.internal.repository.comparator.java;

public class ClassFormatException
  extends Exception
{
  public static final int ERROR_MALFORMED_UTF8 = 1;
  public static final int ERROR_TRUNCATED_INPUT = 2;
  public static final int INVALID_CONSTANT_POOL_ENTRY = 3;
  public static final int TOO_MANY_BYTES = 4;
  public static final int INVALID_ARGUMENTS_FOR_INVOKEINTERFACE = 5;
  public static final int INVALID_BYTECODE = 6;
  public static final int INVALID_TAG_CONSTANT = 7;
  public static final int INVALID_MAGIC_NUMBER = 8;
  private static final long serialVersionUID = 6582900558320612988L;
  
  public ClassFormatException(int errorID) {}
  
  public ClassFormatException(String message)
  {
    super(message);
  }
  
  public ClassFormatException(String message, Throwable cause)
  {
    super(message, cause);
  }
}

/* Location:
 * Qualified Name:     org.eclipse.equinox.p2.internal.repository.comparator.java.ClassFormatException
 * Java Class Version: 1.4 (48.0)
 * JD-Core Version:    0.7.1
 */
package org.eclipse.equinox.p2.internal.repository.comparator.java;

public class CodeAttribute
  extends ClassFileAttribute
{
  private static final ExceptionTableEntry[] NO_EXCEPTION_TABLE = new ExceptionTableEntry[0];
  private ClassFileAttribute[] attributes;
  private int attributesCount;
  private byte[] bytecodes;
  private byte[] classFileBytes;
  private long codeLength;
  private int codeOffset;
  private ConstantPool constantPool;
  private ExceptionTableEntry[] exceptionTableEntries;
  private int exceptionTableLength;
  private int maxLocals;
  private int maxStack;
  
  CodeAttribute(byte[] classFileBytes, ConstantPool constantPool, int offset)
    throws ClassFormatException
  {
    super(classFileBytes, constantPool, offset);
    this.classFileBytes = classFileBytes;
    this.constantPool = constantPool;
    maxStack = u2At(classFileBytes, 6, offset);
    maxLocals = u2At(classFileBytes, 8, offset);
    codeLength = u4At(classFileBytes, 10, offset);
    codeOffset = (offset + 14);
    int readOffset = (int)(14L + codeLength);
    exceptionTableLength = u2At(classFileBytes, readOffset, offset);
    readOffset += 2;
    exceptionTableEntries = NO_EXCEPTION_TABLE;
    if (exceptionTableLength != 0)
    {
      exceptionTableEntries = new ExceptionTableEntry[exceptionTableLength];
      for (int i = 0; i < exceptionTableLength; i++)
      {
        exceptionTableEntries[i] = new ExceptionTableEntry(classFileBytes, constantPool, offset + readOffset);
        readOffset += 8;
      }
    }
    attributesCount = u2At(classFileBytes, readOffset, offset);
    attributes = ClassFileAttribute.NO_ATTRIBUTES;
    if (attributesCount != 0) {
      attributes = new ClassFileAttribute[attributesCount];
    }
    readOffset += 2;
    for (int i = 0; i < attributesCount; i++)
    {
      ConstantPoolEntry constantPoolEntry = constantPool.decodeEntry(u2At(classFileBytes, readOffset, offset));
      if (constantPoolEntry.getKind() != 1) {
        throw new ClassFormatException(3);
      }
      readOffset = (int)(readOffset + (6L + u4At(classFileBytes, readOffset + 2, offset)));
    }
  }
  
  public ClassFileAttribute[] getAttributes()
  {
    return attributes;
  }
  
  public int getAttributesCount()
  {
    return attributesCount;
  }
  
  public byte[] getBytecodes()
  {
    if (bytecodes == null) {
      System.arraycopy(classFileBytes, codeOffset, bytecodes = new byte[(int)codeLength], 0, (int)codeLength);
    }
    return bytecodes;
  }
  
  public long getCodeLength()
  {
    return codeLength;
  }
  
  public ExceptionTableEntry[] getExceptionTable()
  {
    return exceptionTableEntries;
  }
  
  public int getExceptionTableLength()
  {
    return exceptionTableLength;
  }
  
  public int getMaxLocals()
  {
    return maxLocals;
  }
  
  public int getMaxStack()
  {
    return maxStack;
  }
  
  public void traverse(DefaultBytecodeVisitor visitor)
    throws ClassFormatException
  {
    int pc = codeOffset;
    do
    {
      int opcode = u1At(classFileBytes, 0, pc);
      switch (opcode)
      {
      case 0: 
        visitor._nop(pc - codeOffset);
        pc++;
        break;
      case 1: 
        visitor._aconst_null(pc - codeOffset);
        pc++;
        break;
      case 2: 
        visitor._iconst_m1(pc - codeOffset);
        pc++;
        break;
      case 3: 
        visitor._iconst_0(pc - codeOffset);
        pc++;
        break;
      case 4: 
        visitor._iconst_1(pc - codeOffset);
        pc++;
        break;
      case 5: 
        visitor._iconst_2(pc - codeOffset);
        pc++;
        break;
      case 6: 
        visitor._iconst_3(pc - codeOffset);
        pc++;
        break;
      case 7: 
        visitor._iconst_4(pc - codeOffset);
        pc++;
        break;
      case 8: 
        visitor._iconst_5(pc - codeOffset);
        pc++;
        break;
      case 9: 
        visitor._lconst_0(pc - codeOffset);
        pc++;
        break;
      case 10: 
        visitor._lconst_1(pc - codeOffset);
        pc++;
        break;
      case 11: 
        visitor._fconst_0(pc - codeOffset);
        pc++;
        break;
      case 12: 
        visitor._fconst_1(pc - codeOffset);
        pc++;
        break;
      case 13: 
        visitor._fconst_2(pc - codeOffset);
        pc++;
        break;
      case 14: 
        visitor._dconst_0(pc - codeOffset);
        pc++;
        break;
      case 15: 
        visitor._dconst_1(pc - codeOffset);
        pc++;
        break;
      case 16: 
        visitor._bipush(pc - codeOffset, (byte)i1At(classFileBytes, 1, pc));
        pc += 2;
        break;
      case 17: 
        visitor._sipush(pc - codeOffset, (short)i2At(classFileBytes, 1, pc));
        pc += 3;
        break;
      case 18: 
        int index = u1At(classFileBytes, 1, pc);
        ConstantPoolEntry constantPoolEntry = constantPool.decodeEntry(index);
        if ((constantPoolEntry.getKind() != 4) && (constantPoolEntry.getKind() != 3) && (constantPoolEntry.getKind() != 8) && (constantPoolEntry.getKind() != 7)) {
          throw new ClassFormatException(3);
        }
        visitor._ldc(pc - codeOffset, index, constantPoolEntry);
        pc += 2;
        break;
      case 19: 
        int index = u2At(classFileBytes, 1, pc);
        ConstantPoolEntry constantPoolEntry = constantPool.decodeEntry(index);
        if ((constantPoolEntry.getKind() != 4) && (constantPoolEntry.getKind() != 3) && (constantPoolEntry.getKind() != 8) && (constantPoolEntry.getKind() != 7)) {
          throw new ClassFormatException(3);
        }
        visitor._ldc_w(pc - codeOffset, index, constantPoolEntry);
        pc += 3;
        break;
      case 20: 
        int index = u2At(classFileBytes, 1, pc);
        ConstantPoolEntry constantPoolEntry = constantPool.decodeEntry(index);
        if ((constantPoolEntry.getKind() != 6) && (constantPoolEntry.getKind() != 5)) {
          throw new ClassFormatException(3);
        }
        visitor._ldc2_w(pc - codeOffset, index, constantPoolEntry);
        pc += 3;
        break;
      case 21: 
        int index = u1At(classFileBytes, 1, pc);
        visitor._iload(pc - codeOffset, index);
        pc += 2;
        break;
      case 22: 
        int index = u1At(classFileBytes, 1, pc);
        visitor._lload(pc - codeOffset, index);
        pc += 2;
        break;
      case 23: 
        int index = u1At(classFileBytes, 1, pc);
        visitor._fload(pc - codeOffset, index);
        pc += 2;
        break;
      case 24: 
        int index = u1At(classFileBytes, 1, pc);
        visitor._dload(pc - codeOffset, index);
        pc += 2;
        break;
      case 25: 
        int index = u1At(classFileBytes, 1, pc);
        visitor._aload(pc - codeOffset, index);
        pc += 2;
        break;
      case 26: 
        visitor._iload_0(pc - codeOffset);
        pc++;
        break;
      case 27: 
        visitor._iload_1(pc - codeOffset);
        pc++;
        break;
      case 28: 
        visitor._iload_2(pc - codeOffset);
        pc++;
        break;
      case 29: 
        visitor._iload_3(pc - codeOffset);
        pc++;
        break;
      case 30: 
        visitor._lload_0(pc - codeOffset);
        pc++;
        break;
      case 31: 
        visitor._lload_1(pc - codeOffset);
        pc++;
        break;
      case 32: 
        visitor._lload_2(pc - codeOffset);
        pc++;
        break;
      case 33: 
        visitor._lload_3(pc - codeOffset);
        pc++;
        break;
      case 34: 
        visitor._fload_0(pc - codeOffset);
        pc++;
        break;
      case 35: 
        visitor._fload_1(pc - codeOffset);
        pc++;
        break;
      case 36: 
        visitor._fload_2(pc - codeOffset);
        pc++;
        break;
      case 37: 
        visitor._fload_3(pc - codeOffset);
        pc++;
        break;
      case 38: 
        visitor._dload_0(pc - codeOffset);
        pc++;
        break;
      case 39: 
        visitor._dload_1(pc - codeOffset);
        pc++;
        break;
      case 40: 
        visitor._dload_2(pc - codeOffset);
        pc++;
        break;
      case 41: 
        visitor._dload_3(pc - codeOffset);
        pc++;
        break;
      case 42: 
        visitor._aload_0(pc - codeOffset);
        pc++;
        break;
      case 43: 
        visitor._aload_1(pc - codeOffset);
        pc++;
        break;
      case 44: 
        visitor._aload_2(pc - codeOffset);
        pc++;
        break;
      case 45: 
        visitor._aload_3(pc - codeOffset);
        pc++;
        break;
      case 46: 
        visitor._iaload(pc - codeOffset);
        pc++;
        break;
      case 47: 
        visitor._laload(pc - codeOffset);
        pc++;
        break;
      case 48: 
        visitor._faload(pc - codeOffset);
        pc++;
        break;
      case 49: 
        visitor._daload(pc - codeOffset);
        pc++;
        break;
      case 50: 
        visitor._aaload(pc - codeOffset);
        pc++;
        break;
      case 51: 
        visitor._baload(pc - codeOffset);
        pc++;
        break;
      case 52: 
        visitor._caload(pc - codeOffset);
        pc++;
        break;
      case 53: 
        visitor._saload(pc - codeOffset);
        pc++;
        break;
      case 54: 
        int index = u1At(classFileBytes, 1, pc);
        visitor._istore(pc - codeOffset, index);
        pc += 2;
        break;
      case 55: 
        int index = u1At(classFileBytes, 1, pc);
        visitor._lstore(pc - codeOffset, index);
        pc += 2;
        break;
      case 56: 
        int index = u1At(classFileBytes, 1, pc);
        visitor._fstore(pc - codeOffset, index);
        pc += 2;
        break;
      case 57: 
        int index = u1At(classFileBytes, 1, pc);
        visitor._dstore(pc - codeOffset, index);
        pc += 2;
        break;
      case 58: 
        int index = u1At(classFileBytes, 1, pc);
        visitor._astore(pc - codeOffset, index);
        pc += 2;
        break;
      case 59: 
        visitor._istore_0(pc - codeOffset);
        pc++;
        break;
      case 60: 
        visitor._istore_1(pc - codeOffset);
        pc++;
        break;
      case 61: 
        visitor._istore_2(pc - codeOffset);
        pc++;
        break;
      case 62: 
        visitor._istore_3(pc - codeOffset);
        pc++;
        break;
      case 63: 
        visitor._lstore_0(pc - codeOffset);
        pc++;
        break;
      case 64: 
        visitor._lstore_1(pc - codeOffset);
        pc++;
        break;
      case 65: 
        visitor._lstore_2(pc - codeOffset);
        pc++;
        break;
      case 66: 
        visitor._lstore_3(pc - codeOffset);
        pc++;
        break;
      case 67: 
        visitor._fstore_0(pc - codeOffset);
        pc++;
        break;
      case 68: 
        visitor._fstore_1(pc - codeOffset);
        pc++;
        break;
      case 69: 
        visitor._fstore_2(pc - codeOffset);
        pc++;
        break;
      case 70: 
        visitor._fstore_3(pc - codeOffset);
        pc++;
        break;
      case 71: 
        visitor._dstore_0(pc - codeOffset);
        pc++;
        break;
      case 72: 
        visitor._dstore_1(pc - codeOffset);
        pc++;
        break;
      case 73: 
        visitor._dstore_2(pc - codeOffset);
        pc++;
        break;
      case 74: 
        visitor._dstore_3(pc - codeOffset);
        pc++;
        break;
      case 75: 
        visitor._astore_0(pc - codeOffset);
        pc++;
        break;
      case 76: 
        visitor._astore_1(pc - codeOffset);
        pc++;
        break;
      case 77: 
        visitor._astore_2(pc - codeOffset);
        pc++;
        break;
      case 78: 
        visitor._astore_3(pc - codeOffset);
        pc++;
        break;
      case 79: 
        visitor._iastore(pc - codeOffset);
        pc++;
        break;
      case 80: 
        visitor._lastore(pc - codeOffset);
        pc++;
        break;
      case 81: 
        visitor._fastore(pc - codeOffset);
        pc++;
        break;
      case 82: 
        visitor._dastore(pc - codeOffset);
        pc++;
        break;
      case 83: 
        visitor._aastore(pc - codeOffset);
        pc++;
        break;
      case 84: 
        visitor._bastore(pc - codeOffset);
        pc++;
        break;
      case 85: 
        visitor._castore(pc - codeOffset);
        pc++;
        break;
      case 86: 
        visitor._sastore(pc - codeOffset);
        pc++;
        break;
      case 87: 
        visitor._pop(pc - codeOffset);
        pc++;
        break;
      case 88: 
        visitor._pop2(pc - codeOffset);
        pc++;
        break;
      case 89: 
        visitor._dup(pc - codeOffset);
        pc++;
        break;
      case 90: 
        visitor._dup_x1(pc - codeOffset);
        pc++;
        break;
      case 91: 
        visitor._dup_x2(pc - codeOffset);
        pc++;
        break;
      case 92: 
        visitor._dup2(pc - codeOffset);
        pc++;
        break;
      case 93: 
        visitor._dup2_x1(pc - codeOffset);
        pc++;
        break;
      case 94: 
        visitor._dup2_x2(pc - codeOffset);
        pc++;
        break;
      case 95: 
        visitor._swap(pc - codeOffset);
        pc++;
        break;
      case 96: 
        visitor._iadd(pc - codeOffset);
        pc++;
        break;
      case 97: 
        visitor._ladd(pc - codeOffset);
        pc++;
        break;
      case 98: 
        visitor._fadd(pc - codeOffset);
        pc++;
        break;
      case 99: 
        visitor._dadd(pc - codeOffset);
        pc++;
        break;
      case 100: 
        visitor._isub(pc - codeOffset);
        pc++;
        break;
      case 101: 
        visitor._lsub(pc - codeOffset);
        pc++;
        break;
      case 102: 
        visitor._fsub(pc - codeOffset);
        pc++;
        break;
      case 103: 
        visitor._dsub(pc - codeOffset);
        pc++;
        break;
      case 104: 
        visitor._imul(pc - codeOffset);
        pc++;
        break;
      case 105: 
        visitor._lmul(pc - codeOffset);
        pc++;
        break;
      case 106: 
        visitor._fmul(pc - codeOffset);
        pc++;
        break;
      case 107: 
        visitor._dmul(pc - codeOffset);
        pc++;
        break;
      case 108: 
        visitor._idiv(pc - codeOffset);
        pc++;
        break;
      case 109: 
        visitor._ldiv(pc - codeOffset);
        pc++;
        break;
      case 110: 
        visitor._fdiv(pc - codeOffset);
        pc++;
        break;
      case 111: 
        visitor._ddiv(pc - codeOffset);
        pc++;
        break;
      case 112: 
        visitor._irem(pc - codeOffset);
        pc++;
        break;
      case 113: 
        visitor._lrem(pc - codeOffset);
        pc++;
        break;
      case 114: 
        visitor._frem(pc - codeOffset);
        pc++;
        break;
      case 115: 
        visitor._drem(pc - codeOffset);
        pc++;
        break;
      case 116: 
        visitor._ineg(pc - codeOffset);
        pc++;
        break;
      case 117: 
        visitor._lneg(pc - codeOffset);
        pc++;
        break;
      case 118: 
        visitor._fneg(pc - codeOffset);
        pc++;
        break;
      case 119: 
        visitor._dneg(pc - codeOffset);
        pc++;
        break;
      case 120: 
        visitor._ishl(pc - codeOffset);
        pc++;
        break;
      case 121: 
        visitor._lshl(pc - codeOffset);
        pc++;
        break;
      case 122: 
        visitor._ishr(pc - codeOffset);
        pc++;
        break;
      case 123: 
        visitor._lshr(pc - codeOffset);
        pc++;
        break;
      case 124: 
        visitor._iushr(pc - codeOffset);
        pc++;
        break;
      case 125: 
        visitor._lushr(pc - codeOffset);
        pc++;
        break;
      case 126: 
        visitor._iand(pc - codeOffset);
        pc++;
        break;
      case 127: 
        visitor._land(pc - codeOffset);
        pc++;
        break;
      case 128: 
        visitor._ior(pc - codeOffset);
        pc++;
        break;
      case 129: 
        visitor._lor(pc - codeOffset);
        pc++;
        break;
      case 130: 
        visitor._ixor(pc - codeOffset);
        pc++;
        break;
      case 131: 
        visitor._lxor(pc - codeOffset);
        pc++;
        break;
      case 132: 
        int index = u1At(classFileBytes, 1, pc);
        int _const = i1At(classFileBytes, 2, pc);
        visitor._iinc(pc - codeOffset, index, _const);
        pc += 3;
        break;
      case 133: 
        visitor._i2l(pc - codeOffset);
        pc++;
        break;
      case 134: 
        visitor._i2f(pc - codeOffset);
        pc++;
        break;
      case 135: 
        visitor._i2d(pc - codeOffset);
        pc++;
        break;
      case 136: 
        visitor._l2i(pc - codeOffset);
        pc++;
        break;
      case 137: 
        visitor._l2f(pc - codeOffset);
        pc++;
        break;
      case 138: 
        visitor._l2d(pc - codeOffset);
        pc++;
        break;
      case 139: 
        visitor._f2i(pc - codeOffset);
        pc++;
        break;
      case 140: 
        visitor._f2l(pc - codeOffset);
        pc++;
        break;
      case 141: 
        visitor._f2d(pc - codeOffset);
        pc++;
        break;
      case 142: 
        visitor._d2i(pc - codeOffset);
        pc++;
        break;
      case 143: 
        visitor._d2l(pc - codeOffset);
        pc++;
        break;
      case 144: 
        visitor._d2f(pc - codeOffset);
        pc++;
        break;
      case 145: 
        visitor._i2b(pc - codeOffset);
        pc++;
        break;
      case 146: 
        visitor._i2c(pc - codeOffset);
        pc++;
        break;
      case 147: 
        visitor._i2s(pc - codeOffset);
        pc++;
        break;
      case 148: 
        visitor._lcmp(pc - codeOffset);
        pc++;
        break;
      case 149: 
        visitor._fcmpl(pc - codeOffset);
        pc++;
        break;
      case 150: 
        visitor._fcmpg(pc - codeOffset);
        pc++;
        break;
      case 151: 
        visitor._dcmpl(pc - codeOffset);
        pc++;
        break;
      case 152: 
        visitor._dcmpg(pc - codeOffset);
        pc++;
        break;
      case 153: 
        int branchOffset = i2At(classFileBytes, 1, pc);
        visitor._ifeq(pc - codeOffset, branchOffset);
        pc += 3;
        break;
      case 154: 
        int branchOffset = i2At(classFileBytes, 1, pc);
        visitor._ifne(pc - codeOffset, branchOffset);
        pc += 3;
        break;
      case 155: 
        int branchOffset = i2At(classFileBytes, 1, pc);
        visitor._iflt(pc - codeOffset, branchOffset);
        pc += 3;
        break;
      case 156: 
        int branchOffset = i2At(classFileBytes, 1, pc);
        visitor._ifge(pc - codeOffset, branchOffset);
        pc += 3;
        break;
      case 157: 
        int branchOffset = i2At(classFileBytes, 1, pc);
        visitor._ifgt(pc - codeOffset, branchOffset);
        pc += 3;
        break;
      case 158: 
        int branchOffset = i2At(classFileBytes, 1, pc);
        visitor._ifle(pc - codeOffset, branchOffset);
        pc += 3;
        break;
      case 159: 
        int branchOffset = i2At(classFileBytes, 1, pc);
        visitor._if_icmpeq(pc - codeOffset, branchOffset);
        pc += 3;
        break;
      case 160: 
        int branchOffset = i2At(classFileBytes, 1, pc);
        visitor._if_icmpne(pc - codeOffset, branchOffset);
        pc += 3;
        break;
      case 161: 
        int branchOffset = i2At(classFileBytes, 1, pc);
        visitor._if_icmplt(pc - codeOffset, branchOffset);
        pc += 3;
        break;
      case 162: 
        int branchOffset = i2At(classFileBytes, 1, pc);
        visitor._if_icmpge(pc - codeOffset, branchOffset);
        pc += 3;
        break;
      case 163: 
        int branchOffset = i2At(classFileBytes, 1, pc);
        visitor._if_icmpgt(pc - codeOffset, branchOffset);
        pc += 3;
        break;
      case 164: 
        int branchOffset = i2At(classFileBytes, 1, pc);
        visitor._if_icmple(pc - codeOffset, branchOffset);
        pc += 3;
        break;
      case 165: 
        int branchOffset = i2At(classFileBytes, 1, pc);
        visitor._if_acmpeq(pc - codeOffset, branchOffset);
        pc += 3;
        break;
      case 166: 
        int branchOffset = i2At(classFileBytes, 1, pc);
        visitor._if_acmpne(pc - codeOffset, branchOffset);
        pc += 3;
        break;
      case 167: 
        int branchOffset = i2At(classFileBytes, 1, pc);
        visitor._goto(pc - codeOffset, branchOffset);
        pc += 3;
        break;
      case 168: 
        int branchOffset = i2At(classFileBytes, 1, pc);
        visitor._jsr(pc - codeOffset, branchOffset);
        pc += 3;
        break;
      case 169: 
        int index = u1At(classFileBytes, 1, pc);
        visitor._ret(pc - codeOffset, index);
        pc += 2;
        break;
      case 170: 
        int startpc = pc;
        pc++;
        while ((pc - codeOffset & 0x3) != 0) {
          pc++;
        }
        int defaultOffset = i4At(classFileBytes, 0, pc);
        pc += 4;
        int low = i4At(classFileBytes, 0, pc);
        pc += 4;
        int high = i4At(classFileBytes, 0, pc);
        pc += 4;
        int length = high - low + 1;
        int[] jumpOffsets = new int[length];
        for (int i = 0; i < length; i++)
        {
          jumpOffsets[i] = i4At(classFileBytes, 0, pc);
          pc += 4;
        }
        visitor._tableswitch(startpc - codeOffset, defaultOffset, low, high, jumpOffsets);
        break;
      case 171: 
        int startpc = pc;
        pc++;
        while ((pc - codeOffset & 0x3) != 0) {
          pc++;
        }
        int defaultOffset = i4At(classFileBytes, 0, pc);
        pc += 4;
        int npairs = (int)u4At(classFileBytes, 0, pc);
        int[][] offset_pairs = new int[npairs][2];
        pc += 4;
        for (int i = 0; i < npairs; i++)
        {
          offset_pairs[i][0] = i4At(classFileBytes, 0, pc);
          pc += 4;
          offset_pairs[i][1] = i4At(classFileBytes, 0, pc);
          pc += 4;
        }
        visitor._lookupswitch(startpc - codeOffset, defaultOffset, npairs, offset_pairs);
        break;
      case 172: 
        visitor._ireturn(pc - codeOffset);
        pc++;
        break;
      case 173: 
        visitor._lreturn(pc - codeOffset);
        pc++;
        break;
      case 174: 
        visitor._freturn(pc - codeOffset);
        pc++;
        break;
      case 175: 
        visitor._dreturn(pc - codeOffset);
        pc++;
        break;
      case 176: 
        visitor._areturn(pc - codeOffset);
        pc++;
        break;
      case 177: 
        visitor._return(pc - codeOffset);
        pc++;
        break;
      case 178: 
        int index = u2At(classFileBytes, 1, pc);
        ConstantPoolEntry constantPoolEntry = constantPool.decodeEntry(index);
        if (constantPoolEntry.getKind() != 9) {
          throw new ClassFormatException(3);
        }
        visitor._getstatic(pc - codeOffset, index, constantPoolEntry);
        pc += 3;
        break;
      case 179: 
        int index = u2At(classFileBytes, 1, pc);
        ConstantPoolEntry constantPoolEntry = constantPool.decodeEntry(index);
        if (constantPoolEntry.getKind() != 9) {
          throw new ClassFormatException(3);
        }
        visitor._putstatic(pc - codeOffset, index, constantPoolEntry);
        pc += 3;
        break;
      case 180: 
        int index = u2At(classFileBytes, 1, pc);
        ConstantPoolEntry constantPoolEntry = constantPool.decodeEntry(index);
        if (constantPoolEntry.getKind() != 9) {
          throw new ClassFormatException(3);
        }
        visitor._getfield(pc - codeOffset, index, constantPoolEntry);
        pc += 3;
        break;
      case 181: 
        int index = u2At(classFileBytes, 1, pc);
        ConstantPoolEntry constantPoolEntry = constantPool.decodeEntry(index);
        if (constantPoolEntry.getKind() != 9) {
          throw new ClassFormatException(3);
        }
        visitor._putfield(pc - codeOffset, index, constantPoolEntry);
        pc += 3;
        break;
      case 182: 
        int index = u2At(classFileBytes, 1, pc);
        ConstantPoolEntry constantPoolEntry = constantPool.decodeEntry(index);
        if (constantPoolEntry.getKind() != 10) {
          throw new ClassFormatException(3);
        }
        visitor._invokevirtual(pc - codeOffset, index, constantPoolEntry);
        pc += 3;
        break;
      case 183: 
        int index = u2At(classFileBytes, 1, pc);
        ConstantPoolEntry constantPoolEntry = constantPool.decodeEntry(index);
        if (constantPoolEntry.getKind() != 10) {
          throw new ClassFormatException(3);
        }
        visitor._invokespecial(pc - codeOffset, index, constantPoolEntry);
        pc += 3;
        break;
      case 184: 
        int index = u2At(classFileBytes, 1, pc);
        ConstantPoolEntry constantPoolEntry = constantPool.decodeEntry(index);
        if (constantPoolEntry.getKind() != 10) {
          throw new ClassFormatException(3);
        }
        visitor._invokestatic(pc - codeOffset, index, constantPoolEntry);
        pc += 3;
        break;
      case 185: 
        int index = u2At(classFileBytes, 1, pc);
        ConstantPoolEntry constantPoolEntry = constantPool.decodeEntry(index);
        if (constantPoolEntry.getKind() != 11) {
          throw new ClassFormatException(3);
        }
        byte count = (byte)u1At(classFileBytes, 3, pc);
        int extraArgs = u1At(classFileBytes, 4, pc);
        if (extraArgs != 0) {
          throw new ClassFormatException(5);
        }
        visitor._invokeinterface(pc - codeOffset, index, count, constantPoolEntry);
        pc += 5;
        break;
      case 187: 
        int index = u2At(classFileBytes, 1, pc);
        ConstantPoolEntry constantPoolEntry = constantPool.decodeEntry(index);
        if (constantPoolEntry.getKind() != 7) {
          throw new ClassFormatException(3);
        }
        visitor._new(pc - codeOffset, index, constantPoolEntry);
        pc += 3;
        break;
      case 188: 
        int atype = u1At(classFileBytes, 1, pc);
        visitor._newarray(pc - codeOffset, atype);
        pc += 2;
        break;
      case 189: 
        int index = u2At(classFileBytes, 1, pc);
        ConstantPoolEntry constantPoolEntry = constantPool.decodeEntry(index);
        if (constantPoolEntry.getKind() != 7) {
          throw new ClassFormatException(3);
        }
        visitor._anewarray(pc - codeOffset, index, constantPoolEntry);
        pc += 3;
        break;
      case 190: 
        visitor._arraylength(pc - codeOffset);
        pc++;
        break;
      case 191: 
        visitor._athrow(pc - codeOffset);
        pc++;
        break;
      case 192: 
        int index = u2At(classFileBytes, 1, pc);
        ConstantPoolEntry constantPoolEntry = constantPool.decodeEntry(index);
        if (constantPoolEntry.getKind() != 7) {
          throw new ClassFormatException(3);
        }
        visitor._checkcast(pc - codeOffset, index, constantPoolEntry);
        pc += 3;
        break;
      case 193: 
        int index = u2At(classFileBytes, 1, pc);
        ConstantPoolEntry constantPoolEntry = constantPool.decodeEntry(index);
        if (constantPoolEntry.getKind() != 7) {
          throw new ClassFormatException(3);
        }
        visitor._instanceof(pc - codeOffset, index, constantPoolEntry);
        pc += 3;
        break;
      case 194: 
        visitor._monitorenter(pc - codeOffset);
        pc++;
        break;
      case 195: 
        visitor._monitorexit(pc - codeOffset);
        pc++;
        break;
      case 196: 
        opcode = u1At(classFileBytes, 1, pc);
        if (opcode == 132)
        {
          int index = u2At(classFileBytes, 2, pc);
          int _const = i2At(classFileBytes, 4, pc);
          visitor._wide(pc - codeOffset, opcode, index, _const);
          pc += 6;
        }
        else
        {
          int index = u2At(classFileBytes, 2, pc);
          visitor._wide(pc - codeOffset, opcode, index);
          pc += 4;
        }
        break;
      case 197: 
        int index = u2At(classFileBytes, 1, pc);
        ConstantPoolEntry constantPoolEntry = constantPool.decodeEntry(index);
        if (constantPoolEntry.getKind() != 7) {
          throw new ClassFormatException(3);
        }
        int dimensions = u1At(classFileBytes, 3, pc);
        visitor._multianewarray(pc - codeOffset, index, dimensions, constantPoolEntry);
        pc += 4;
        break;
      case 198: 
        int branchOffset = i2At(classFileBytes, 1, pc);
        visitor._ifnull(pc - codeOffset, branchOffset);
        pc += 3;
        break;
      case 199: 
        int branchOffset = i2At(classFileBytes, 1, pc);
        visitor._ifnonnull(pc - codeOffset, branchOffset);
        pc += 3;
        break;
      case 200: 
        int branchOffset = i4At(classFileBytes, 1, pc);
        visitor._goto_w(pc - codeOffset, branchOffset);
        pc += 5;
        break;
      case 201: 
        int branchOffset = i4At(classFileBytes, 1, pc);
        visitor._jsr_w(pc - codeOffset, branchOffset);
        pc += 5;
        break;
      case 202: 
        visitor._breakpoint(pc - codeOffset);
        pc++;
        break;
      case 254: 
        visitor._impdep1(pc - codeOffset);
        pc++;
        break;
      case 255: 
        visitor._impdep2(pc - codeOffset);
        pc++;
        break;
      case 186: 
      case 203: 
      case 204: 
      case 205: 
      case 206: 
      case 207: 
      case 208: 
      case 209: 
      case 210: 
      case 211: 
      case 212: 
      case 213: 
      case 214: 
      case 215: 
      case 216: 
      case 217: 
      case 218: 
      case 219: 
      case 220: 
      case 221: 
      case 222: 
      case 223: 
      case 224: 
      case 225: 
      case 226: 
      case 227: 
      case 228: 
      case 229: 
      case 230: 
      case 231: 
      case 232: 
      case 233: 
      case 234: 
      case 235: 
      case 236: 
      case 237: 
      case 238: 
      case 239: 
      case 240: 
      case 241: 
      case 242: 
      case 243: 
      case 244: 
      case 245: 
      case 246: 
      case 247: 
      case 248: 
      case 249: 
      case 250: 
      case 251: 
      case 252: 
      case 253: 
      default: 
        throw new ClassFormatException(6);
      }
    } while (pc < codeLength + codeOffset);
  }
}

/* Location:
 * Qualified Name:     org.eclipse.equinox.p2.internal.repository.comparator.java.CodeAttribute
 * Java Class Version: 1.4 (48.0)
 * JD-Core Version:    0.7.1
 */
package org.eclipse.equinox.p2.internal.repository.comparator.java;

public class ConstantPool
  extends ClassFileStruct
{
  private int constantPoolCount;
  private int[] constantPoolOffset;
  private byte[] classFileBytes;
  
  ConstantPool(byte[] reference, int[] constantPoolOffset)
  {
    constantPoolCount = constantPoolOffset.length;
    this.constantPoolOffset = constantPoolOffset;
    classFileBytes = reference;
  }
  
  public ConstantPoolEntry decodeEntry(int index)
  {
    ConstantPoolEntry constantPoolEntry = new ConstantPoolEntry();
    constantPoolEntry.reset();
    int kind = getEntryKind(index);
    constantPoolEntry.setKind(kind);
    switch (kind)
    {
    case 7: 
      constantPoolEntry.setClassInfoNameIndex(u2At(classFileBytes, 1, constantPoolOffset[index]));
      constantPoolEntry.setClassInfoName(getUtf8ValueAt(constantPoolEntry.getClassInfoNameIndex()));
      break;
    case 6: 
      constantPoolEntry.setDoubleValue(doubleAt(classFileBytes, 1, constantPoolOffset[index]));
      break;
    case 9: 
      constantPoolEntry.setClassIndex(u2At(classFileBytes, 1, constantPoolOffset[index]));
      int declaringClassIndex = u2At(classFileBytes, 1, constantPoolOffset[constantPoolEntry.getClassIndex()]);
      constantPoolEntry.setClassName(getUtf8ValueAt(declaringClassIndex));
      constantPoolEntry.setNameAndTypeIndex(u2At(classFileBytes, 3, constantPoolOffset[index]));
      int fieldNameIndex = u2At(classFileBytes, 1, constantPoolOffset[constantPoolEntry.getNameAndTypeIndex()]);
      int fieldDescriptorIndex = u2At(classFileBytes, 3, constantPoolOffset[constantPoolEntry.getNameAndTypeIndex()]);
      constantPoolEntry.setFieldName(getUtf8ValueAt(fieldNameIndex));
      constantPoolEntry.setFieldDescriptor(getUtf8ValueAt(fieldDescriptorIndex));
      break;
    case 10: 
    case 11: 
      constantPoolEntry.setClassIndex(u2At(classFileBytes, 1, constantPoolOffset[index]));
      int declaringClassIndex = u2At(classFileBytes, 1, constantPoolOffset[constantPoolEntry.getClassIndex()]);
      constantPoolEntry.setClassName(getUtf8ValueAt(declaringClassIndex));
      constantPoolEntry.setNameAndTypeIndex(u2At(classFileBytes, 3, constantPoolOffset[index]));
      int methodNameIndex = u2At(classFileBytes, 1, constantPoolOffset[constantPoolEntry.getNameAndTypeIndex()]);
      int methodDescriptorIndex = u2At(classFileBytes, 3, constantPoolOffset[constantPoolEntry.getNameAndTypeIndex()]);
      constantPoolEntry.setMethodName(getUtf8ValueAt(methodNameIndex));
      constantPoolEntry.setMethodDescriptor(getUtf8ValueAt(methodDescriptorIndex));
      break;
    case 4: 
      constantPoolEntry.setFloatValue(floatAt(classFileBytes, 1, constantPoolOffset[index]));
      break;
    case 3: 
      constantPoolEntry.setIntegerValue(i4At(classFileBytes, 1, constantPoolOffset[index]));
      break;
    case 5: 
      constantPoolEntry.setLongValue(i8At(classFileBytes, 1, constantPoolOffset[index]));
      break;
    case 12: 
      constantPoolEntry.setNameAndTypeNameIndex(u2At(classFileBytes, 1, constantPoolOffset[index]));
      constantPoolEntry.setNameAndTypeDescriptorIndex(u2At(classFileBytes, 3, constantPoolOffset[index]));
      break;
    case 8: 
      constantPoolEntry.setStringIndex(u2At(classFileBytes, 1, constantPoolOffset[index]));
      constantPoolEntry.setStringValue(getUtf8ValueAt(constantPoolEntry.getStringIndex()));
      break;
    case 1: 
      constantPoolEntry.setUtf8Length(u2At(classFileBytes, 1, constantPoolOffset[index]));
      constantPoolEntry.setUtf8Value(getUtf8ValueAt(index));
    }
    return constantPoolEntry;
  }
  
  public int getConstantPoolCount()
  {
    return constantPoolCount;
  }
  
  public int getEntryKind(int index)
  {
    return u1At(classFileBytes, 0, constantPoolOffset[index]);
  }
  
  private char[] getUtf8ValueAt(int utf8Index)
  {
    int utf8Offset = constantPoolOffset[utf8Index];
    return utf8At(classFileBytes, 0, utf8Offset + 3, u2At(classFileBytes, 0, utf8Offset + 1));
  }
}

/* Location:
 * Qualified Name:     org.eclipse.equinox.p2.internal.repository.comparator.java.ConstantPool
 * Java Class Version: 1.4 (48.0)
 * JD-Core Version:    0.7.1
 */
package org.eclipse.equinox.p2.internal.repository.comparator.java;

public abstract interface ConstantPoolConstant
{
  public static final int CONSTANT_Class = 7;
  public static final int CONSTANT_Fieldref = 9;
  public static final int CONSTANT_Methodref = 10;
  public static final int CONSTANT_InterfaceMethodref = 11;
  public static final int CONSTANT_String = 8;
  public static final int CONSTANT_Integer = 3;
  public static final int CONSTANT_Float = 4;
  public static final int CONSTANT_Long = 5;
  public static final int CONSTANT_Double = 6;
  public static final int CONSTANT_NameAndType = 12;
  public static final int CONSTANT_Utf8 = 1;
  public static final int CONSTANT_Methodref_SIZE = 5;
  public static final int CONSTANT_Class_SIZE = 3;
  public static final int CONSTANT_Double_SIZE = 9;
  public static final int CONSTANT_Fieldref_SIZE = 5;
  public static final int CONSTANT_Float_SIZE = 5;
  public static final int CONSTANT_Integer_SIZE = 5;
  public static final int CONSTANT_InterfaceMethodref_SIZE = 5;
  public static final int CONSTANT_Long_SIZE = 9;
  public static final int CONSTANT_String_SIZE = 3;
  public static final int CONSTANT_Utf8_SIZE = 3;
  public static final int CONSTANT_NameAndType_SIZE = 5;
}

/* Location:
 * Qualified Name:     org.eclipse.equinox.p2.internal.repository.comparator.java.ConstantPoolConstant
 * Java Class Version: 1.4 (48.0)
 * JD-Core Version:    0.7.1
 */
package org.eclipse.equinox.p2.internal.repository.comparator.java;

public class ConstantPoolEntry
{
  private int kind;
  private int classInfoNameIndex;
  private int classIndex;
  private int nameAndTypeIndex;
  private int stringIndex;
  private char[] stringValue;
  private int integerValue;
  private float floatValue;
  private double doubleValue;
  private long longValue;
  private int nameAndTypeDescriptorIndex;
  private int nameAndTypeNameIndex;
  private
1 2 3 4 5 6 7 8 9 10 11 12

Further reading...

For more information on Java 1.5 Tiger, you may find Java 1.5 Tiger, A developer's Notebook by D. Flanagan and B. McLaughlin from O'Reilly of interest.

New!JAR listings


Copyright 2006-2019. Infinite Loop Ltd