Examples of VerificationTypeInfo


Examples of org.aspectj.org.eclipse.jdt.internal.compiler.codegen.VerificationTypeInfo

              int numberOfLocals = currentFrame.getNumberOfLocals();
              for (int i = index; i < currentFrame.locals.length && numberOfDifferentLocals > 0; i++) {
                if (localContentsOffset + 6 >= this.contents.length) {
                  resizeContents(6);
                }
                VerificationTypeInfo info = currentFrame.locals[i];
                if (info == null) {
                  this.contents[localContentsOffset++] = (byte) VerificationTypeInfo.ITEM_TOP;
                } else {
                  switch(info.id()) {
                    case T_boolean :
                    case T_byte :
                    case T_char :
                    case T_int :
                    case T_short :
                      this.contents[localContentsOffset++] = (byte) VerificationTypeInfo.ITEM_INTEGER;
                      break;
                    case T_float :
                      this.contents[localContentsOffset++] = (byte) VerificationTypeInfo.ITEM_FLOAT;
                      break;
                    case T_long :
                      this.contents[localContentsOffset++] = (byte) VerificationTypeInfo.ITEM_LONG;
                      i++;
                      break;
                    case T_double :
                      this.contents[localContentsOffset++] = (byte) VerificationTypeInfo.ITEM_DOUBLE;
                      i++;
                      break;
                    case T_null :
                      this.contents[localContentsOffset++] = (byte) VerificationTypeInfo.ITEM_NULL;
                      break;
                    default:
                      this.contents[localContentsOffset++] = (byte) info.tag;
                      switch (info.tag) {
                        case VerificationTypeInfo.ITEM_UNINITIALIZED :
                          int offset = info.offset;
                          this.contents[localContentsOffset++] = (byte) (offset >> 8);
                          this.contents[localContentsOffset++] = (byte) offset;
                          break;
                        case VerificationTypeInfo.ITEM_OBJECT :
                          int indexForType = constantPool.literalIndexForType(info.constantPoolName());
                          this.contents[localContentsOffset++] = (byte) (indexForType >> 8);
                          this.contents[localContentsOffset++] = (byte) indexForType;
                      }
                  }
                  numberOfDifferentLocals--;
                }
              }
              break;
            case StackMapFrame.SAME_FRAME :
              if (localContentsOffset + 1 >= this.contents.length) {
                resizeContents(1);
              }             
              this.contents[localContentsOffset++] = (byte) offsetDelta;
              break;
            case StackMapFrame.SAME_FRAME_EXTENDED :
              if (localContentsOffset + 3 >= this.contents.length) {
                resizeContents(3);
              }             
              this.contents[localContentsOffset++] = (byte) 251;
              this.contents[localContentsOffset++] = (byte) (offsetDelta >> 8);
              this.contents[localContentsOffset++] = (byte) offsetDelta;
              break;
            case StackMapFrame.CHOP_FRAME :
              if (localContentsOffset + 3 >= this.contents.length) {
                resizeContents(3);
              }             
              numberOfDifferentLocals = -currentFrame.numberOfDifferentLocals(prevFrame);
              this.contents[localContentsOffset++] = (byte) (251 - numberOfDifferentLocals);
              this.contents[localContentsOffset++] = (byte) (offsetDelta >> 8);
              this.contents[localContentsOffset++] = (byte) offsetDelta;             
              break;
            case StackMapFrame.SAME_LOCALS_1_STACK_ITEMS :
              if (localContentsOffset + 4 >= this.contents.length) {
                resizeContents(4);
              }             
              this.contents[localContentsOffset++] = (byte) (offsetDelta + 64);
              if (currentFrame.stackItems[0] == null) {
                this.contents[localContentsOffset++] = (byte) VerificationTypeInfo.ITEM_TOP;
              } else {
                switch(currentFrame.stackItems[0].id()) {
                  case T_boolean :
                  case T_byte :
                  case T_char :
                  case T_int :
                  case T_short :
                    this.contents[localContentsOffset++] = (byte) VerificationTypeInfo.ITEM_INTEGER;
                    break;
                  case T_float :
                    this.contents[localContentsOffset++] = (byte) VerificationTypeInfo.ITEM_FLOAT;
                    break;
                  case T_long :
                    this.contents[localContentsOffset++] = (byte) VerificationTypeInfo.ITEM_LONG;
                    break;
                  case T_double :
                    this.contents[localContentsOffset++] = (byte) VerificationTypeInfo.ITEM_DOUBLE;
                    break;
                  case T_null :
                    this.contents[localContentsOffset++] = (byte) VerificationTypeInfo.ITEM_NULL;
                    break;
                  default:
                    VerificationTypeInfo info = currentFrame.stackItems[0];
                    byte tag = (byte) info.tag;
                    this.contents[localContentsOffset++] = tag;
                    switch (tag) {
                      case VerificationTypeInfo.ITEM_UNINITIALIZED :
                        int offset = info.offset;
                        this.contents[localContentsOffset++] = (byte) (offset >> 8);
                        this.contents[localContentsOffset++] = (byte) offset;
                        break;
                      case VerificationTypeInfo.ITEM_OBJECT :
                        int indexForType = constantPool.literalIndexForType(info.constantPoolName());
                        this.contents[localContentsOffset++] = (byte) (indexForType >> 8);
                        this.contents[localContentsOffset++] = (byte) indexForType;
                    }
                }
              }
              break;
            case StackMapFrame.SAME_LOCALS_1_STACK_ITEMS_EXTENDED :
              if (localContentsOffset + 6 >= this.contents.length) {
                resizeContents(6);
              }             
              this.contents[localContentsOffset++] = (byte) 247;
              this.contents[localContentsOffset++] = (byte) (offsetDelta >> 8);
              this.contents[localContentsOffset++] = (byte) offsetDelta;
              if (currentFrame.stackItems[0] == null) {
                this.contents[localContentsOffset++] = (byte) VerificationTypeInfo.ITEM_TOP;
              } else {
                switch(currentFrame.stackItems[0].id()) {
                  case T_boolean :
                  case T_byte :
                  case T_char :
                  case T_int :
                  case T_short :
                    this.contents[localContentsOffset++] = (byte) VerificationTypeInfo.ITEM_INTEGER;
                    break;
                  case T_float :
                    this.contents[localContentsOffset++] = (byte) VerificationTypeInfo.ITEM_FLOAT;
                    break;
                  case T_long :
                    this.contents[localContentsOffset++] = (byte) VerificationTypeInfo.ITEM_LONG;
                    break;
                  case T_double :
                    this.contents[localContentsOffset++] = (byte) VerificationTypeInfo.ITEM_DOUBLE;
                    break;
                  case T_null :
                    this.contents[localContentsOffset++] = (byte) VerificationTypeInfo.ITEM_NULL;
                    break;
                  default:
                    VerificationTypeInfo info = currentFrame.stackItems[0];
                    byte tag = (byte) info.tag;
                    this.contents[localContentsOffset++] = tag;
                    switch (tag) {
                      case VerificationTypeInfo.ITEM_UNINITIALIZED :
                        int offset = info.offset;
                        this.contents[localContentsOffset++] = (byte) (offset >> 8);
                        this.contents[localContentsOffset++] = (byte) offset;
                        break;
                      case VerificationTypeInfo.ITEM_OBJECT :
                        int indexForType = constantPool.literalIndexForType(info.constantPoolName());
                        this.contents[localContentsOffset++] = (byte) (indexForType >> 8);
                        this.contents[localContentsOffset++] = (byte) indexForType;
                    }
                }
              }
              break;
            default :
              // FULL_FRAME
              if (localContentsOffset + 5 >= this.contents.length) {
                resizeContents(5);
              }             
              this.contents[localContentsOffset++] = (byte) 255;
              this.contents[localContentsOffset++] = (byte) (offsetDelta >> 8);
              this.contents[localContentsOffset++] = (byte) offsetDelta;
              int numberOfLocalOffset = localContentsOffset;
              localContentsOffset += 2; // leave two spots for number of locals
              int numberOfLocalEntries = 0;
              numberOfLocals = currentFrame.getNumberOfLocals();
              int numberOfEntries = 0;
              int localsLength = currentFrame.locals == null ? 0 : currentFrame.locals.length;
              for (int i = 0; i < localsLength && numberOfLocalEntries < numberOfLocals; i++) {
                if (localContentsOffset + 3 >= this.contents.length) {
                  resizeContents(3);
                }             
                VerificationTypeInfo info = currentFrame.locals[i];
                if (info == null) {
                  this.contents[localContentsOffset++] = (byte) VerificationTypeInfo.ITEM_TOP;
                } else {
                  switch(info.id()) {
                    case T_boolean :
                    case T_byte :
                    case T_char :
                    case T_int :
                    case T_short :
                      this.contents[localContentsOffset++] = (byte) VerificationTypeInfo.ITEM_INTEGER;
                      break;
                    case T_float :
                      this.contents[localContentsOffset++] = (byte) VerificationTypeInfo.ITEM_FLOAT;
                      break;
                    case T_long :
                      this.contents[localContentsOffset++] = (byte) VerificationTypeInfo.ITEM_LONG;
                      i++;
                      break;
                    case T_double :
                      this.contents[localContentsOffset++] = (byte) VerificationTypeInfo.ITEM_DOUBLE;
                      i++;
                      break;
                    case T_null :
                      this.contents[localContentsOffset++] = (byte) VerificationTypeInfo.ITEM_NULL;
                      break;
                    default:
                      this.contents[localContentsOffset++] = (byte) info.tag;
                      switch (info.tag) {
                        case VerificationTypeInfo.ITEM_UNINITIALIZED :
                          int offset = info.offset;
                          this.contents[localContentsOffset++] = (byte) (offset >> 8);
                          this.contents[localContentsOffset++] = (byte) offset;
                          break;
                        case VerificationTypeInfo.ITEM_OBJECT :
                          int indexForType = constantPool.literalIndexForType(info.constantPoolName());
                          this.contents[localContentsOffset++] = (byte) (indexForType >> 8);
                          this.contents[localContentsOffset++] = (byte) indexForType;
                      }
                  }
                  numberOfLocalEntries++;
                }
                numberOfEntries++;
              }
              if (localContentsOffset + 4 >= this.contents.length) {
                resizeContents(4);
              }             
              this.contents[numberOfLocalOffset++] = (byte) (numberOfEntries >> 8);
              this.contents[numberOfLocalOffset] = (byte) numberOfEntries;
              int numberOfStackItems = currentFrame.numberOfStackItems;
              this.contents[localContentsOffset++] = (byte) (numberOfStackItems >> 8);
              this.contents[localContentsOffset++] = (byte) numberOfStackItems;
              for (int i = 0; i < numberOfStackItems; i++) {
                if (localContentsOffset + 3 >= this.contents.length) {
                  resizeContents(3);
                }
                VerificationTypeInfo info = currentFrame.stackItems[i];
                if (info == null) {
                  this.contents[localContentsOffset++] = (byte) VerificationTypeInfo.ITEM_TOP;
                } else {
                  switch(info.id()) {
                    case T_boolean :
                    case T_byte :
                    case T_char :
                    case T_int :
                    case T_short :
                      this.contents[localContentsOffset++] = (byte) VerificationTypeInfo.ITEM_INTEGER;
                      break;
                    case T_float :
                      this.contents[localContentsOffset++] = (byte) VerificationTypeInfo.ITEM_FLOAT;
                      break;
                    case T_long :
                      this.contents[localContentsOffset++] = (byte) VerificationTypeInfo.ITEM_LONG;
                      break;
                    case T_double :
                      this.contents[localContentsOffset++] = (byte) VerificationTypeInfo.ITEM_DOUBLE;
                      break;
                    case T_null :
                      this.contents[localContentsOffset++] = (byte) VerificationTypeInfo.ITEM_NULL;
                      break;
                    default:
                      this.contents[localContentsOffset++] = (byte) info.tag;
                      switch (info.tag) {
                        case VerificationTypeInfo.ITEM_UNINITIALIZED :
                          int offset = info.offset;
                          this.contents[localContentsOffset++] = (byte) (offset >> 8);
                          this.contents[localContentsOffset++] = (byte) offset;
                          break;
                        case VerificationTypeInfo.ITEM_OBJECT :
                          int indexForType = constantPool.literalIndexForType(info.constantPoolName());
                          this.contents[localContentsOffset++] = (byte) (indexForType >> 8);
                          this.contents[localContentsOffset++] = (byte) indexForType;
                      }
                  }
                }
View Full Code Here

Examples of org.aspectj.org.eclipse.jdt.internal.compiler.codegen.VerificationTypeInfo

              int numberOfLocals = currentFrame.getNumberOfLocals();
              for (int i = index; i < currentFrame.locals.length && numberOfDifferentLocals > 0; i++) {
                if (localContentsOffset + 6 >= this.contents.length) {
                  resizeContents(6);
                }
                VerificationTypeInfo info = currentFrame.locals[i];
                if (info == null) {
                  this.contents[localContentsOffset++] = (byte) VerificationTypeInfo.ITEM_TOP;
                } else {
                  switch(info.id()) {
                    case T_boolean :
                    case T_byte :
                    case T_char :
                    case T_int :
                    case T_short :
                      this.contents[localContentsOffset++] = (byte) VerificationTypeInfo.ITEM_INTEGER;
                      break;
                    case T_float :
                      this.contents[localContentsOffset++] = (byte) VerificationTypeInfo.ITEM_FLOAT;
                      break;
                    case T_long :
                      this.contents[localContentsOffset++] = (byte) VerificationTypeInfo.ITEM_LONG;
                      i++;
                      break;
                    case T_double :
                      this.contents[localContentsOffset++] = (byte) VerificationTypeInfo.ITEM_DOUBLE;
                      i++;
                      break;
                    case T_null :
                      this.contents[localContentsOffset++] = (byte) VerificationTypeInfo.ITEM_NULL;
                      break;
                    default:
                      this.contents[localContentsOffset++] = (byte) info.tag;
                      switch (info.tag) {
                        case VerificationTypeInfo.ITEM_UNINITIALIZED :
                          int offset = info.offset;
                          this.contents[localContentsOffset++] = (byte) (offset >> 8);
                          this.contents[localContentsOffset++] = (byte) offset;
                          break;
                        case VerificationTypeInfo.ITEM_OBJECT :
                          int indexForType = constantPool.literalIndexForType(info.constantPoolName());
                          this.contents[localContentsOffset++] = (byte) (indexForType >> 8);
                          this.contents[localContentsOffset++] = (byte) indexForType;
                      }
                  }
                  numberOfDifferentLocals--;
                }
              }
              break;
            case StackMapFrame.SAME_FRAME :
              if (localContentsOffset + 1 >= this.contents.length) {
                resizeContents(1);
              }             
              this.contents[localContentsOffset++] = (byte) offsetDelta;
              break;
            case StackMapFrame.SAME_FRAME_EXTENDED :
              if (localContentsOffset + 3 >= this.contents.length) {
                resizeContents(3);
              }             
              this.contents[localContentsOffset++] = (byte) 251;
              this.contents[localContentsOffset++] = (byte) (offsetDelta >> 8);
              this.contents[localContentsOffset++] = (byte) offsetDelta;
              break;
            case StackMapFrame.CHOP_FRAME :
              if (localContentsOffset + 3 >= this.contents.length) {
                resizeContents(3);
              }             
              numberOfDifferentLocals = -currentFrame.numberOfDifferentLocals(prevFrame);
              this.contents[localContentsOffset++] = (byte) (251 - numberOfDifferentLocals);
              this.contents[localContentsOffset++] = (byte) (offsetDelta >> 8);
              this.contents[localContentsOffset++] = (byte) offsetDelta;             
              break;
            case StackMapFrame.SAME_LOCALS_1_STACK_ITEMS :
              if (localContentsOffset + 4 >= this.contents.length) {
                resizeContents(4);
              }             
              this.contents[localContentsOffset++] = (byte) (offsetDelta + 64);
              if (currentFrame.stackItems[0] == null) {
                this.contents[localContentsOffset++] = (byte) VerificationTypeInfo.ITEM_TOP;
              } else {
                switch(currentFrame.stackItems[0].id()) {
                  case T_boolean :
                  case T_byte :
                  case T_char :
                  case T_int :
                  case T_short :
                    this.contents[localContentsOffset++] = (byte) VerificationTypeInfo.ITEM_INTEGER;
                    break;
                  case T_float :
                    this.contents[localContentsOffset++] = (byte) VerificationTypeInfo.ITEM_FLOAT;
                    break;
                  case T_long :
                    this.contents[localContentsOffset++] = (byte) VerificationTypeInfo.ITEM_LONG;
                    break;
                  case T_double :
                    this.contents[localContentsOffset++] = (byte) VerificationTypeInfo.ITEM_DOUBLE;
                    break;
                  case T_null :
                    this.contents[localContentsOffset++] = (byte) VerificationTypeInfo.ITEM_NULL;
                    break;
                  default:
                    VerificationTypeInfo info = currentFrame.stackItems[0];
                    this.contents[localContentsOffset++] = (byte) info.tag;
                    switch (info.tag) {
                      case VerificationTypeInfo.ITEM_UNINITIALIZED :
                        int offset = info.offset;
                        this.contents[localContentsOffset++] = (byte) (offset >> 8);
                        this.contents[localContentsOffset++] = (byte) offset;
                        break;
                      case VerificationTypeInfo.ITEM_OBJECT :
                        int indexForType = constantPool.literalIndexForType(info.constantPoolName());
                        this.contents[localContentsOffset++] = (byte) (indexForType >> 8);
                        this.contents[localContentsOffset++] = (byte) indexForType;
                    }
                }
              }
              break;
            case StackMapFrame.SAME_LOCALS_1_STACK_ITEMS_EXTENDED :
              if (localContentsOffset + 6 >= this.contents.length) {
                resizeContents(6);
              }             
              this.contents[localContentsOffset++] = (byte) 247;
              this.contents[localContentsOffset++] = (byte) (offsetDelta >> 8);
              this.contents[localContentsOffset++] = (byte) offsetDelta;
              if (currentFrame.stackItems[0] == null) {
                this.contents[localContentsOffset++] = (byte) VerificationTypeInfo.ITEM_TOP;
              } else {
                switch(currentFrame.stackItems[0].id()) {
                  case T_boolean :
                  case T_byte :
                  case T_char :
                  case T_int :
                  case T_short :
                    this.contents[localContentsOffset++] = (byte) VerificationTypeInfo.ITEM_INTEGER;
                    break;
                  case T_float :
                    this.contents[localContentsOffset++] = (byte) VerificationTypeInfo.ITEM_FLOAT;
                    break;
                  case T_long :
                    this.contents[localContentsOffset++] = (byte) VerificationTypeInfo.ITEM_LONG;
                    break;
                  case T_double :
                    this.contents[localContentsOffset++] = (byte) VerificationTypeInfo.ITEM_DOUBLE;
                    break;
                  case T_null :
                    this.contents[localContentsOffset++] = (byte) VerificationTypeInfo.ITEM_NULL;
                    break;
                  default:
                    VerificationTypeInfo info = currentFrame.stackItems[0];
                    this.contents[localContentsOffset++] = (byte) info.tag;
                    switch (info.tag) {
                      case VerificationTypeInfo.ITEM_UNINITIALIZED :
                        int offset = info.offset;
                        this.contents[localContentsOffset++] = (byte) (offset >> 8);
                        this.contents[localContentsOffset++] = (byte) offset;
                        break;
                      case VerificationTypeInfo.ITEM_OBJECT :
                        int indexForType = constantPool.literalIndexForType(info.constantPoolName());
                        this.contents[localContentsOffset++] = (byte) (indexForType >> 8);
                        this.contents[localContentsOffset++] = (byte) indexForType;
                    }
                }
              }
              break;
            default :
              // FULL_FRAME
              if (localContentsOffset + 5 >= this.contents.length) {
                resizeContents(5);
              }             
              this.contents[localContentsOffset++] = (byte) 255;
              this.contents[localContentsOffset++] = (byte) (offsetDelta >> 8);
              this.contents[localContentsOffset++] = (byte) offsetDelta;
              int numberOfLocalOffset = localContentsOffset;
              localContentsOffset += 2; // leave two spots for number of locals
              int numberOfLocalEntries = 0;
              numberOfLocals = currentFrame.getNumberOfLocals();
              int numberOfEntries = 0;
              int localsLength = currentFrame.locals == null ? 0 : currentFrame.locals.length;
              for (int i = 0; i < localsLength && numberOfLocalEntries < numberOfLocals; i++) {
                if (localContentsOffset + 3 >= this.contents.length) {
                  resizeContents(3);
                }             
                VerificationTypeInfo info = currentFrame.locals[i];
                if (info == null) {
                  this.contents[localContentsOffset++] = (byte) VerificationTypeInfo.ITEM_TOP;
                } else {
                  switch(info.id()) {
                    case T_boolean :
                    case T_byte :
                    case T_char :
                    case T_int :
                    case T_short :
                      this.contents[localContentsOffset++] = (byte) VerificationTypeInfo.ITEM_INTEGER;
                      break;
                    case T_float :
                      this.contents[localContentsOffset++] = (byte) VerificationTypeInfo.ITEM_FLOAT;
                      break;
                    case T_long :
                      this.contents[localContentsOffset++] = (byte) VerificationTypeInfo.ITEM_LONG;
                      i++;
                      break;
                    case T_double :
                      this.contents[localContentsOffset++] = (byte) VerificationTypeInfo.ITEM_DOUBLE;
                      i++;
                      break;
                    case T_null :
                      this.contents[localContentsOffset++] = (byte) VerificationTypeInfo.ITEM_NULL;
                      break;
                    default:
                      this.contents[localContentsOffset++] = (byte) info.tag;
                      switch (info.tag) {
                        case VerificationTypeInfo.ITEM_UNINITIALIZED :
                          int offset = info.offset;
                          this.contents[localContentsOffset++] = (byte) (offset >> 8);
                          this.contents[localContentsOffset++] = (byte) offset;
                          break;
                        case VerificationTypeInfo.ITEM_OBJECT :
                          int indexForType = constantPool.literalIndexForType(info.constantPoolName());
                          this.contents[localContentsOffset++] = (byte) (indexForType >> 8);
                          this.contents[localContentsOffset++] = (byte) indexForType;
                      }
                  }
                  numberOfLocalEntries++;
                }
                numberOfEntries++;
              }
              if (localContentsOffset + 4 >= this.contents.length) {
                resizeContents(4);
              }             
              this.contents[numberOfLocalOffset++] = (byte) (numberOfEntries >> 8);
              this.contents[numberOfLocalOffset] = (byte) numberOfEntries;
              int numberOfStackItems = currentFrame.numberOfStackItems;
              this.contents[localContentsOffset++] = (byte) (numberOfStackItems >> 8);
              this.contents[localContentsOffset++] = (byte) numberOfStackItems;
              for (int i = 0; i < numberOfStackItems; i++) {
                if (localContentsOffset + 3 >= this.contents.length) {
                  resizeContents(3);
                }
                VerificationTypeInfo info = currentFrame.stackItems[i];
                if (info == null) {
                  this.contents[localContentsOffset++] = (byte) VerificationTypeInfo.ITEM_TOP;
                } else {
                  switch(info.id()) {
                    case T_boolean :
                    case T_byte :
                    case T_char :
                    case T_int :
                    case T_short :
                      this.contents[localContentsOffset++] = (byte) VerificationTypeInfo.ITEM_INTEGER;
                      break;
                    case T_float :
                      this.contents[localContentsOffset++] = (byte) VerificationTypeInfo.ITEM_FLOAT;
                      break;
                    case T_long :
                      this.contents[localContentsOffset++] = (byte) VerificationTypeInfo.ITEM_LONG;
                      break;
                    case T_double :
                      this.contents[localContentsOffset++] = (byte) VerificationTypeInfo.ITEM_DOUBLE;
                      break;
                    case T_null :
                      this.contents[localContentsOffset++] = (byte) VerificationTypeInfo.ITEM_NULL;
                      break;
                    default:
                      this.contents[localContentsOffset++] = (byte) info.tag;
                      switch (info.tag) {
                        case VerificationTypeInfo.ITEM_UNINITIALIZED :
                          int offset = info.offset;
                          this.contents[localContentsOffset++] = (byte) (offset >> 8);
                          this.contents[localContentsOffset++] = (byte) offset;
                          break;
                        case VerificationTypeInfo.ITEM_OBJECT :
                          int indexForType = constantPool.literalIndexForType(info.constantPoolName());
                          this.contents[localContentsOffset++] = (byte) (indexForType >> 8);
                          this.contents[localContentsOffset++] = (byte) indexForType;
                      }
                  }
                }
View Full Code Here

Examples of org.aspectj.org.eclipse.jdt.internal.compiler.codegen.VerificationTypeInfo

              int numberOfLocals = currentFrame.getNumberOfLocals();
              for (int i = index; i < currentFrame.locals.length && numberOfDifferentLocals > 0; i++) {
                if (localContentsOffset + 6 >= this.contents.length) {
                  resizeContents(6);
                }
                VerificationTypeInfo info = currentFrame.locals[i];
                if (info == null) {
                  this.contents[localContentsOffset++] = (byte) VerificationTypeInfo.ITEM_TOP;
                } else {
                  switch(info.id()) {
                    case T_boolean :
                    case T_byte :
                    case T_char :
                    case T_int :
                    case T_short :
                      this.contents[localContentsOffset++] = (byte) VerificationTypeInfo.ITEM_INTEGER;
                      break;
                    case T_float :
                      this.contents[localContentsOffset++] = (byte) VerificationTypeInfo.ITEM_FLOAT;
                      break;
                    case T_long :
                      this.contents[localContentsOffset++] = (byte) VerificationTypeInfo.ITEM_LONG;
                      i++;
                      break;
                    case T_double :
                      this.contents[localContentsOffset++] = (byte) VerificationTypeInfo.ITEM_DOUBLE;
                      i++;
                      break;
                    case T_null :
                      this.contents[localContentsOffset++] = (byte) VerificationTypeInfo.ITEM_NULL;
                      break;
                    default:
                      this.contents[localContentsOffset++] = (byte) info.tag;
                      switch (info.tag) {
                        case VerificationTypeInfo.ITEM_UNINITIALIZED :
                          int offset = info.offset;
                          this.contents[localContentsOffset++] = (byte) (offset >> 8);
                          this.contents[localContentsOffset++] = (byte) offset;
                          break;
                        case VerificationTypeInfo.ITEM_OBJECT :
                          int indexForType = constantPool.literalIndexForType(info.constantPoolName());
                          this.contents[localContentsOffset++] = (byte) (indexForType >> 8);
                          this.contents[localContentsOffset++] = (byte) indexForType;
                      }
                  }
                  numberOfDifferentLocals--;
                }
              }
              break;
            case StackMapFrame.SAME_FRAME :
              if (localContentsOffset + 1 >= this.contents.length) {
                resizeContents(1);
              }             
              this.contents[localContentsOffset++] = (byte) offsetDelta;
              break;
            case StackMapFrame.SAME_FRAME_EXTENDED :
              if (localContentsOffset + 3 >= this.contents.length) {
                resizeContents(3);
              }             
              this.contents[localContentsOffset++] = (byte) 251;
              this.contents[localContentsOffset++] = (byte) (offsetDelta >> 8);
              this.contents[localContentsOffset++] = (byte) offsetDelta;
              break;
            case StackMapFrame.CHOP_FRAME :
              if (localContentsOffset + 3 >= this.contents.length) {
                resizeContents(3);
              }             
              numberOfDifferentLocals = -currentFrame.numberOfDifferentLocals(prevFrame);
              this.contents[localContentsOffset++] = (byte) (251 - numberOfDifferentLocals);
              this.contents[localContentsOffset++] = (byte) (offsetDelta >> 8);
              this.contents[localContentsOffset++] = (byte) offsetDelta;             
              break;
            case StackMapFrame.SAME_LOCALS_1_STACK_ITEMS :
              if (localContentsOffset + 4 >= this.contents.length) {
                resizeContents(4);
              }             
              this.contents[localContentsOffset++] = (byte) (offsetDelta + 64);
              if (currentFrame.stackItems[0] == null) {
                this.contents[localContentsOffset++] = (byte) VerificationTypeInfo.ITEM_TOP;
              } else {
                switch(currentFrame.stackItems[0].id()) {
                  case T_boolean :
                  case T_byte :
                  case T_char :
                  case T_int :
                  case T_short :
                    this.contents[localContentsOffset++] = (byte) VerificationTypeInfo.ITEM_INTEGER;
                    break;
                  case T_float :
                    this.contents[localContentsOffset++] = (byte) VerificationTypeInfo.ITEM_FLOAT;
                    break;
                  case T_long :
                    this.contents[localContentsOffset++] = (byte) VerificationTypeInfo.ITEM_LONG;
                    break;
                  case T_double :
                    this.contents[localContentsOffset++] = (byte) VerificationTypeInfo.ITEM_DOUBLE;
                    break;
                  case T_null :
                    this.contents[localContentsOffset++] = (byte) VerificationTypeInfo.ITEM_NULL;
                    break;
                  default:
                    VerificationTypeInfo info = currentFrame.stackItems[0];
                    this.contents[localContentsOffset++] = (byte) info.tag;
                    switch (info.tag) {
                      case VerificationTypeInfo.ITEM_UNINITIALIZED :
                        int offset = info.offset;
                        this.contents[localContentsOffset++] = (byte) (offset >> 8);
                        this.contents[localContentsOffset++] = (byte) offset;
                        break;
                      case VerificationTypeInfo.ITEM_OBJECT :
                        int indexForType = constantPool.literalIndexForType(info.constantPoolName());
                        this.contents[localContentsOffset++] = (byte) (indexForType >> 8);
                        this.contents[localContentsOffset++] = (byte) indexForType;
                    }
                }
              }
              break;
            case StackMapFrame.SAME_LOCALS_1_STACK_ITEMS_EXTENDED :
              if (localContentsOffset + 6 >= this.contents.length) {
                resizeContents(6);
              }             
              this.contents[localContentsOffset++] = (byte) 247;
              this.contents[localContentsOffset++] = (byte) (offsetDelta >> 8);
              this.contents[localContentsOffset++] = (byte) offsetDelta;
              if (currentFrame.stackItems[0] == null) {
                this.contents[localContentsOffset++] = (byte) VerificationTypeInfo.ITEM_TOP;
              } else {
                switch(currentFrame.stackItems[0].id()) {
                  case T_boolean :
                  case T_byte :
                  case T_char :
                  case T_int :
                  case T_short :
                    this.contents[localContentsOffset++] = (byte) VerificationTypeInfo.ITEM_INTEGER;
                    break;
                  case T_float :
                    this.contents[localContentsOffset++] = (byte) VerificationTypeInfo.ITEM_FLOAT;
                    break;
                  case T_long :
                    this.contents[localContentsOffset++] = (byte) VerificationTypeInfo.ITEM_LONG;
                    break;
                  case T_double :
                    this.contents[localContentsOffset++] = (byte) VerificationTypeInfo.ITEM_DOUBLE;
                    break;
                  case T_null :
                    this.contents[localContentsOffset++] = (byte) VerificationTypeInfo.ITEM_NULL;
                    break;
                  default:
                    VerificationTypeInfo info = currentFrame.stackItems[0];
                    this.contents[localContentsOffset++] = (byte) info.tag;
                    switch (info.tag) {
                      case VerificationTypeInfo.ITEM_UNINITIALIZED :
                        int offset = info.offset;
                        this.contents[localContentsOffset++] = (byte) (offset >> 8);
                        this.contents[localContentsOffset++] = (byte) offset;
                        break;
                      case VerificationTypeInfo.ITEM_OBJECT :
                        int indexForType = constantPool.literalIndexForType(info.constantPoolName());
                        this.contents[localContentsOffset++] = (byte) (indexForType >> 8);
                        this.contents[localContentsOffset++] = (byte) indexForType;
                    }
                }
              }
              break;
            default :
              // FULL_FRAME
              if (localContentsOffset + 5 >= this.contents.length) {
                resizeContents(5);
              }             
              this.contents[localContentsOffset++] = (byte) 255;
              this.contents[localContentsOffset++] = (byte) (offsetDelta >> 8);
              this.contents[localContentsOffset++] = (byte) offsetDelta;
              int numberOfLocalOffset = localContentsOffset;
              localContentsOffset += 2; // leave two spots for number of locals
              int numberOfLocalEntries = 0;
              numberOfLocals = currentFrame.getNumberOfLocals();
              int numberOfEntries = 0;
              int localsLength = currentFrame.locals == null ? 0 : currentFrame.locals.length;
              for (int i = 0; i < localsLength && numberOfLocalEntries < numberOfLocals; i++) {
                if (localContentsOffset + 3 >= this.contents.length) {
                  resizeContents(3);
                }             
                VerificationTypeInfo info = currentFrame.locals[i];
                if (info == null) {
                  this.contents[localContentsOffset++] = (byte) VerificationTypeInfo.ITEM_TOP;
                } else {
                  switch(info.id()) {
                    case T_boolean :
                    case T_byte :
                    case T_char :
                    case T_int :
                    case T_short :
                      this.contents[localContentsOffset++] = (byte) VerificationTypeInfo.ITEM_INTEGER;
                      break;
                    case T_float :
                      this.contents[localContentsOffset++] = (byte) VerificationTypeInfo.ITEM_FLOAT;
                      break;
                    case T_long :
                      this.contents[localContentsOffset++] = (byte) VerificationTypeInfo.ITEM_LONG;
                      i++;
                      break;
                    case T_double :
                      this.contents[localContentsOffset++] = (byte) VerificationTypeInfo.ITEM_DOUBLE;
                      i++;
                      break;
                    case T_null :
                      this.contents[localContentsOffset++] = (byte) VerificationTypeInfo.ITEM_NULL;
                      break;
                    default:
                      this.contents[localContentsOffset++] = (byte) info.tag;
                      switch (info.tag) {
                        case VerificationTypeInfo.ITEM_UNINITIALIZED :
                          int offset = info.offset;
                          this.contents[localContentsOffset++] = (byte) (offset >> 8);
                          this.contents[localContentsOffset++] = (byte) offset;
                          break;
                        case VerificationTypeInfo.ITEM_OBJECT :
                          int indexForType = constantPool.literalIndexForType(info.constantPoolName());
                          this.contents[localContentsOffset++] = (byte) (indexForType >> 8);
                          this.contents[localContentsOffset++] = (byte) indexForType;
                      }
                  }
                  numberOfLocalEntries++;
                }
                numberOfEntries++;
              }
              if (localContentsOffset + 4 >= this.contents.length) {
                resizeContents(4);
              }             
              this.contents[numberOfLocalOffset++] = (byte) (numberOfEntries >> 8);
              this.contents[numberOfLocalOffset] = (byte) numberOfEntries;
              int numberOfStackItems = currentFrame.numberOfStackItems;
              this.contents[localContentsOffset++] = (byte) (numberOfStackItems >> 8);
              this.contents[localContentsOffset++] = (byte) numberOfStackItems;
              for (int i = 0; i < numberOfStackItems; i++) {
                if (localContentsOffset + 3 >= this.contents.length) {
                  resizeContents(3);
                }
                VerificationTypeInfo info = currentFrame.stackItems[i];
                if (info == null) {
                  this.contents[localContentsOffset++] = (byte) VerificationTypeInfo.ITEM_TOP;
                } else {
                  switch(info.id()) {
                    case T_boolean :
                    case T_byte :
                    case T_char :
                    case T_int :
                    case T_short :
                      this.contents[localContentsOffset++] = (byte) VerificationTypeInfo.ITEM_INTEGER;
                      break;
                    case T_float :
                      this.contents[localContentsOffset++] = (byte) VerificationTypeInfo.ITEM_FLOAT;
                      break;
                    case T_long :
                      this.contents[localContentsOffset++] = (byte) VerificationTypeInfo.ITEM_LONG;
                      break;
                    case T_double :
                      this.contents[localContentsOffset++] = (byte) VerificationTypeInfo.ITEM_DOUBLE;
                      break;
                    case T_null :
                      this.contents[localContentsOffset++] = (byte) VerificationTypeInfo.ITEM_NULL;
                      break;
                    default:
                      this.contents[localContentsOffset++] = (byte) info.tag;
                      switch (info.tag) {
                        case VerificationTypeInfo.ITEM_UNINITIALIZED :
                          int offset = info.offset;
                          this.contents[localContentsOffset++] = (byte) (offset >> 8);
                          this.contents[localContentsOffset++] = (byte) offset;
                          break;
                        case VerificationTypeInfo.ITEM_OBJECT :
                          int indexForType = constantPool.literalIndexForType(info.constantPoolName());
                          this.contents[localContentsOffset++] = (byte) (indexForType >> 8);
                          this.contents[localContentsOffset++] = (byte) indexForType;
                      }
                  }
                }
View Full Code Here

Examples of org.aspectj.org.eclipse.jdt.internal.compiler.codegen.VerificationTypeInfo

              int numberOfLocals = currentFrame.getNumberOfLocals();
              for (int i = index; i < currentFrame.locals.length && numberOfDifferentLocals > 0; i++) {
                if (localContentsOffset + 6 >= this.contents.length) {
                  resizeContents(6);
                }
                VerificationTypeInfo info = currentFrame.locals[i];
                if (info == null) {
                  this.contents[localContentsOffset++] = (byte) VerificationTypeInfo.ITEM_TOP;
                } else {
                  switch(info.id()) {
                    case T_boolean :
                    case T_byte :
                    case T_char :
                    case T_int :
                    case T_short :
                      this.contents[localContentsOffset++] = (byte) VerificationTypeInfo.ITEM_INTEGER;
                      break;
                    case T_float :
                      this.contents[localContentsOffset++] = (byte) VerificationTypeInfo.ITEM_FLOAT;
                      break;
                    case T_long :
                      this.contents[localContentsOffset++] = (byte) VerificationTypeInfo.ITEM_LONG;
                      i++;
                      break;
                    case T_double :
                      this.contents[localContentsOffset++] = (byte) VerificationTypeInfo.ITEM_DOUBLE;
                      i++;
                      break;
                    case T_null :
                      this.contents[localContentsOffset++] = (byte) VerificationTypeInfo.ITEM_NULL;
                      break;
                    default:
                      this.contents[localContentsOffset++] = (byte) info.tag;
                      switch (info.tag) {
                        case VerificationTypeInfo.ITEM_UNINITIALIZED :
                          int offset = info.offset;
                          this.contents[localContentsOffset++] = (byte) (offset >> 8);
                          this.contents[localContentsOffset++] = (byte) offset;
                          break;
                        case VerificationTypeInfo.ITEM_OBJECT :
                          int indexForType = constantPool.literalIndexForType(info.constantPoolName());
                          this.contents[localContentsOffset++] = (byte) (indexForType >> 8);
                          this.contents[localContentsOffset++] = (byte) indexForType;
                      }
                  }
                  numberOfDifferentLocals--;
                }
              }
              break;
            case StackMapFrame.SAME_FRAME :
              if (localContentsOffset + 1 >= this.contents.length) {
                resizeContents(1);
              }             
              this.contents[localContentsOffset++] = (byte) offsetDelta;
              break;
            case StackMapFrame.SAME_FRAME_EXTENDED :
              if (localContentsOffset + 3 >= this.contents.length) {
                resizeContents(3);
              }             
              this.contents[localContentsOffset++] = (byte) 251;
              this.contents[localContentsOffset++] = (byte) (offsetDelta >> 8);
              this.contents[localContentsOffset++] = (byte) offsetDelta;
              break;
            case StackMapFrame.CHOP_FRAME :
              if (localContentsOffset + 3 >= this.contents.length) {
                resizeContents(3);
              }             
              numberOfDifferentLocals = -currentFrame.numberOfDifferentLocals(prevFrame);
              this.contents[localContentsOffset++] = (byte) (251 - numberOfDifferentLocals);
              this.contents[localContentsOffset++] = (byte) (offsetDelta >> 8);
              this.contents[localContentsOffset++] = (byte) offsetDelta;             
              break;
            case StackMapFrame.SAME_LOCALS_1_STACK_ITEMS :
              if (localContentsOffset + 4 >= this.contents.length) {
                resizeContents(4);
              }             
              this.contents[localContentsOffset++] = (byte) (offsetDelta + 64);
              if (currentFrame.stackItems[0] == null) {
                this.contents[localContentsOffset++] = (byte) VerificationTypeInfo.ITEM_TOP;
              } else {
                switch(currentFrame.stackItems[0].id()) {
                  case T_boolean :
                  case T_byte :
                  case T_char :
                  case T_int :
                  case T_short :
                    this.contents[localContentsOffset++] = (byte) VerificationTypeInfo.ITEM_INTEGER;
                    break;
                  case T_float :
                    this.contents[localContentsOffset++] = (byte) VerificationTypeInfo.ITEM_FLOAT;
                    break;
                  case T_long :
                    this.contents[localContentsOffset++] = (byte) VerificationTypeInfo.ITEM_LONG;
                    break;
                  case T_double :
                    this.contents[localContentsOffset++] = (byte) VerificationTypeInfo.ITEM_DOUBLE;
                    break;
                  case T_null :
                    this.contents[localContentsOffset++] = (byte) VerificationTypeInfo.ITEM_NULL;
                    break;
                  default:
                    VerificationTypeInfo info = currentFrame.stackItems[0];
                    this.contents[localContentsOffset++] = (byte) info.tag;
                    switch (info.tag) {
                      case VerificationTypeInfo.ITEM_UNINITIALIZED :
                        int offset = info.offset;
                        this.contents[localContentsOffset++] = (byte) (offset >> 8);
                        this.contents[localContentsOffset++] = (byte) offset;
                        break;
                      case VerificationTypeInfo.ITEM_OBJECT :
                        int indexForType = constantPool.literalIndexForType(info.constantPoolName());
                        this.contents[localContentsOffset++] = (byte) (indexForType >> 8);
                        this.contents[localContentsOffset++] = (byte) indexForType;
                    }
                }
              }
              break;
            case StackMapFrame.SAME_LOCALS_1_STACK_ITEMS_EXTENDED :
              if (localContentsOffset + 6 >= this.contents.length) {
                resizeContents(6);
              }             
              this.contents[localContentsOffset++] = (byte) 247;
              this.contents[localContentsOffset++] = (byte) (offsetDelta >> 8);
              this.contents[localContentsOffset++] = (byte) offsetDelta;
              if (currentFrame.stackItems[0] == null) {
                this.contents[localContentsOffset++] = (byte) VerificationTypeInfo.ITEM_TOP;
              } else {
                switch(currentFrame.stackItems[0].id()) {
                  case T_boolean :
                  case T_byte :
                  case T_char :
                  case T_int :
                  case T_short :
                    this.contents[localContentsOffset++] = (byte) VerificationTypeInfo.ITEM_INTEGER;
                    break;
                  case T_float :
                    this.contents[localContentsOffset++] = (byte) VerificationTypeInfo.ITEM_FLOAT;
                    break;
                  case T_long :
                    this.contents[localContentsOffset++] = (byte) VerificationTypeInfo.ITEM_LONG;
                    break;
                  case T_double :
                    this.contents[localContentsOffset++] = (byte) VerificationTypeInfo.ITEM_DOUBLE;
                    break;
                  case T_null :
                    this.contents[localContentsOffset++] = (byte) VerificationTypeInfo.ITEM_NULL;
                    break;
                  default:
                    VerificationTypeInfo info = currentFrame.stackItems[0];
                    this.contents[localContentsOffset++] = (byte) info.tag;
                    switch (info.tag) {
                      case VerificationTypeInfo.ITEM_UNINITIALIZED :
                        int offset = info.offset;
                        this.contents[localContentsOffset++] = (byte) (offset >> 8);
                        this.contents[localContentsOffset++] = (byte) offset;
                        break;
                      case VerificationTypeInfo.ITEM_OBJECT :
                        int indexForType = constantPool.literalIndexForType(info.constantPoolName());
                        this.contents[localContentsOffset++] = (byte) (indexForType >> 8);
                        this.contents[localContentsOffset++] = (byte) indexForType;
                    }
                }
              }
              break;
            default :
              // FULL_FRAME
              if (localContentsOffset + 5 >= this.contents.length) {
                resizeContents(5);
              }             
              this.contents[localContentsOffset++] = (byte) 255;
              this.contents[localContentsOffset++] = (byte) (offsetDelta >> 8);
              this.contents[localContentsOffset++] = (byte) offsetDelta;
              int numberOfLocalOffset = localContentsOffset;
              localContentsOffset += 2; // leave two spots for number of locals
              int numberOfLocalEntries = 0;
              numberOfLocals = currentFrame.getNumberOfLocals();
              int numberOfEntries = 0;
              int localsLength = currentFrame.locals == null ? 0 : currentFrame.locals.length;
              for (int i = 0; i < localsLength && numberOfLocalEntries < numberOfLocals; i++) {
                if (localContentsOffset + 3 >= this.contents.length) {
                  resizeContents(3);
                }             
                VerificationTypeInfo info = currentFrame.locals[i];
                if (info == null) {
                  this.contents[localContentsOffset++] = (byte) VerificationTypeInfo.ITEM_TOP;
                } else {
                  switch(info.id()) {
                    case T_boolean :
                    case T_byte :
                    case T_char :
                    case T_int :
                    case T_short :
                      this.contents[localContentsOffset++] = (byte) VerificationTypeInfo.ITEM_INTEGER;
                      break;
                    case T_float :
                      this.contents[localContentsOffset++] = (byte) VerificationTypeInfo.ITEM_FLOAT;
                      break;
                    case T_long :
                      this.contents[localContentsOffset++] = (byte) VerificationTypeInfo.ITEM_LONG;
                      i++;
                      break;
                    case T_double :
                      this.contents[localContentsOffset++] = (byte) VerificationTypeInfo.ITEM_DOUBLE;
                      i++;
                      break;
                    case T_null :
                      this.contents[localContentsOffset++] = (byte) VerificationTypeInfo.ITEM_NULL;
                      break;
                    default:
                      this.contents[localContentsOffset++] = (byte) info.tag;
                      switch (info.tag) {
                        case VerificationTypeInfo.ITEM_UNINITIALIZED :
                          int offset = info.offset;
                          this.contents[localContentsOffset++] = (byte) (offset >> 8);
                          this.contents[localContentsOffset++] = (byte) offset;
                          break;
                        case VerificationTypeInfo.ITEM_OBJECT :
                          int indexForType = constantPool.literalIndexForType(info.constantPoolName());
                          this.contents[localContentsOffset++] = (byte) (indexForType >> 8);
                          this.contents[localContentsOffset++] = (byte) indexForType;
                      }
                  }
                  numberOfLocalEntries++;
                }
                numberOfEntries++;
              }
              if (localContentsOffset + 4 >= this.contents.length) {
                resizeContents(4);
              }             
              this.contents[numberOfLocalOffset++] = (byte) (numberOfEntries >> 8);
              this.contents[numberOfLocalOffset] = (byte) numberOfEntries;
              int numberOfStackItems = currentFrame.numberOfStackItems;
              this.contents[localContentsOffset++] = (byte) (numberOfStackItems >> 8);
              this.contents[localContentsOffset++] = (byte) numberOfStackItems;
              for (int i = 0; i < numberOfStackItems; i++) {
                if (localContentsOffset + 3 >= this.contents.length) {
                  resizeContents(3);
                }
                VerificationTypeInfo info = currentFrame.stackItems[i];
                if (info == null) {
                  this.contents[localContentsOffset++] = (byte) VerificationTypeInfo.ITEM_TOP;
                } else {
                  switch(info.id()) {
                    case T_boolean :
                    case T_byte :
                    case T_char :
                    case T_int :
                    case T_short :
                      this.contents[localContentsOffset++] = (byte) VerificationTypeInfo.ITEM_INTEGER;
                      break;
                    case T_float :
                      this.contents[localContentsOffset++] = (byte) VerificationTypeInfo.ITEM_FLOAT;
                      break;
                    case T_long :
                      this.contents[localContentsOffset++] = (byte) VerificationTypeInfo.ITEM_LONG;
                      break;
                    case T_double :
                      this.contents[localContentsOffset++] = (byte) VerificationTypeInfo.ITEM_DOUBLE;
                      break;
                    case T_null :
                      this.contents[localContentsOffset++] = (byte) VerificationTypeInfo.ITEM_NULL;
                      break;
                    default:
                      this.contents[localContentsOffset++] = (byte) info.tag;
                      switch (info.tag) {
                        case VerificationTypeInfo.ITEM_UNINITIALIZED :
                          int offset = info.offset;
                          this.contents[localContentsOffset++] = (byte) (offset >> 8);
                          this.contents[localContentsOffset++] = (byte) offset;
                          break;
                        case VerificationTypeInfo.ITEM_OBJECT :
                          int indexForType = constantPool.literalIndexForType(info.constantPoolName());
                          this.contents[localContentsOffset++] = (byte) (indexForType >> 8);
                          this.contents[localContentsOffset++] = (byte) indexForType;
                      }
                  }
                }
View Full Code Here

Examples of org.aspectj.org.eclipse.jdt.internal.compiler.codegen.VerificationTypeInfo

              int numberOfLocals = currentFrame.getNumberOfLocals();
              for (int i = index; i < currentFrame.locals.length && numberOfDifferentLocals > 0; i++) {
                if (localContentsOffset + 6 >= this.contents.length) {
                  resizeContents(6);
                }
                VerificationTypeInfo info = currentFrame.locals[i];
                if (info == null) {
                  this.contents[localContentsOffset++] = (byte) VerificationTypeInfo.ITEM_TOP;
                } else {
                  switch(info.id()) {
                    case T_boolean :
                    case T_byte :
                    case T_char :
                    case T_int :
                    case T_short :
                      this.contents[localContentsOffset++] = (byte) VerificationTypeInfo.ITEM_INTEGER;
                      break;
                    case T_float :
                      this.contents[localContentsOffset++] = (byte) VerificationTypeInfo.ITEM_FLOAT;
                      break;
                    case T_long :
                      this.contents[localContentsOffset++] = (byte) VerificationTypeInfo.ITEM_LONG;
                      i++;
                      break;
                    case T_double :
                      this.contents[localContentsOffset++] = (byte) VerificationTypeInfo.ITEM_DOUBLE;
                      i++;
                      break;
                    case T_null :
                      this.contents[localContentsOffset++] = (byte) VerificationTypeInfo.ITEM_NULL;
                      break;
                    default:
                      this.contents[localContentsOffset++] = (byte) info.tag;
                      switch (info.tag) {
                        case VerificationTypeInfo.ITEM_UNINITIALIZED :
                          int offset = info.offset;
                          this.contents[localContentsOffset++] = (byte) (offset >> 8);
                          this.contents[localContentsOffset++] = (byte) offset;
                          break;
                        case VerificationTypeInfo.ITEM_OBJECT :
                          int indexForType = constantPool.literalIndexForType(info.constantPoolName());
                          this.contents[localContentsOffset++] = (byte) (indexForType >> 8);
                          this.contents[localContentsOffset++] = (byte) indexForType;
                      }
                  }
                  numberOfDifferentLocals--;
                }
              }
              break;
            case StackMapFrame.SAME_FRAME :
              if (localContentsOffset + 1 >= this.contents.length) {
                resizeContents(1);
              }             
              this.contents[localContentsOffset++] = (byte) offsetDelta;
              break;
            case StackMapFrame.SAME_FRAME_EXTENDED :
              if (localContentsOffset + 3 >= this.contents.length) {
                resizeContents(3);
              }             
              this.contents[localContentsOffset++] = (byte) 251;
              this.contents[localContentsOffset++] = (byte) (offsetDelta >> 8);
              this.contents[localContentsOffset++] = (byte) offsetDelta;
              break;
            case StackMapFrame.CHOP_FRAME :
              if (localContentsOffset + 3 >= this.contents.length) {
                resizeContents(3);
              }             
              numberOfDifferentLocals = -currentFrame.numberOfDifferentLocals(prevFrame);
              this.contents[localContentsOffset++] = (byte) (251 - numberOfDifferentLocals);
              this.contents[localContentsOffset++] = (byte) (offsetDelta >> 8);
              this.contents[localContentsOffset++] = (byte) offsetDelta;             
              break;
            case StackMapFrame.SAME_LOCALS_1_STACK_ITEMS :
              if (localContentsOffset + 4 >= this.contents.length) {
                resizeContents(4);
              }             
              this.contents[localContentsOffset++] = (byte) (offsetDelta + 64);
              if (currentFrame.stackItems[0] == null) {
                this.contents[localContentsOffset++] = (byte) VerificationTypeInfo.ITEM_TOP;
              } else {
                switch(currentFrame.stackItems[0].id()) {
                  case T_boolean :
                  case T_byte :
                  case T_char :
                  case T_int :
                  case T_short :
                    this.contents[localContentsOffset++] = (byte) VerificationTypeInfo.ITEM_INTEGER;
                    break;
                  case T_float :
                    this.contents[localContentsOffset++] = (byte) VerificationTypeInfo.ITEM_FLOAT;
                    break;
                  case T_long :
                    this.contents[localContentsOffset++] = (byte) VerificationTypeInfo.ITEM_LONG;
                    break;
                  case T_double :
                    this.contents[localContentsOffset++] = (byte) VerificationTypeInfo.ITEM_DOUBLE;
                    break;
                  case T_null :
                    this.contents[localContentsOffset++] = (byte) VerificationTypeInfo.ITEM_NULL;
                    break;
                  default:
                    VerificationTypeInfo info = currentFrame.stackItems[0];
                    this.contents[localContentsOffset++] = (byte) info.tag;
                    switch (info.tag) {
                      case VerificationTypeInfo.ITEM_UNINITIALIZED :
                        int offset = info.offset;
                        this.contents[localContentsOffset++] = (byte) (offset >> 8);
                        this.contents[localContentsOffset++] = (byte) offset;
                        break;
                      case VerificationTypeInfo.ITEM_OBJECT :
                        int indexForType = constantPool.literalIndexForType(info.constantPoolName());
                        this.contents[localContentsOffset++] = (byte) (indexForType >> 8);
                        this.contents[localContentsOffset++] = (byte) indexForType;
                    }
                }
              }
              break;
            case StackMapFrame.SAME_LOCALS_1_STACK_ITEMS_EXTENDED :
              if (localContentsOffset + 6 >= this.contents.length) {
                resizeContents(6);
              }             
              this.contents[localContentsOffset++] = (byte) 247;
              this.contents[localContentsOffset++] = (byte) (offsetDelta >> 8);
              this.contents[localContentsOffset++] = (byte) offsetDelta;
              if (currentFrame.stackItems[0] == null) {
                this.contents[localContentsOffset++] = (byte) VerificationTypeInfo.ITEM_TOP;
              } else {
                switch(currentFrame.stackItems[0].id()) {
                  case T_boolean :
                  case T_byte :
                  case T_char :
                  case T_int :
                  case T_short :
                    this.contents[localContentsOffset++] = (byte) VerificationTypeInfo.ITEM_INTEGER;
                    break;
                  case T_float :
                    this.contents[localContentsOffset++] = (byte) VerificationTypeInfo.ITEM_FLOAT;
                    break;
                  case T_long :
                    this.contents[localContentsOffset++] = (byte) VerificationTypeInfo.ITEM_LONG;
                    break;
                  case T_double :
                    this.contents[localContentsOffset++] = (byte) VerificationTypeInfo.ITEM_DOUBLE;
                    break;
                  case T_null :
                    this.contents[localContentsOffset++] = (byte) VerificationTypeInfo.ITEM_NULL;
                    break;
                  default:
                    VerificationTypeInfo info = currentFrame.stackItems[0];
                    this.contents[localContentsOffset++] = (byte) info.tag;
                    switch (info.tag) {
                      case VerificationTypeInfo.ITEM_UNINITIALIZED :
                        int offset = info.offset;
                        this.contents[localContentsOffset++] = (byte) (offset >> 8);
                        this.contents[localContentsOffset++] = (byte) offset;
                        break;
                      case VerificationTypeInfo.ITEM_OBJECT :
                        int indexForType = constantPool.literalIndexForType(info.constantPoolName());
                        this.contents[localContentsOffset++] = (byte) (indexForType >> 8);
                        this.contents[localContentsOffset++] = (byte) indexForType;
                    }
                }
              }
              break;
            default :
              // FULL_FRAME
              if (localContentsOffset + 5 >= this.contents.length) {
                resizeContents(5);
              }             
              this.contents[localContentsOffset++] = (byte) 255;
              this.contents[localContentsOffset++] = (byte) (offsetDelta >> 8);
              this.contents[localContentsOffset++] = (byte) offsetDelta;
              int numberOfLocalOffset = localContentsOffset;
              localContentsOffset += 2; // leave two spots for number of locals
              int numberOfLocalEntries = 0;
              numberOfLocals = currentFrame.getNumberOfLocals();
              int numberOfEntries = 0;
              int localsLength = currentFrame.locals == null ? 0 : currentFrame.locals.length;
              for (int i = 0; i < localsLength && numberOfLocalEntries < numberOfLocals; i++) {
                if (localContentsOffset + 3 >= this.contents.length) {
                  resizeContents(3);
                }             
                VerificationTypeInfo info = currentFrame.locals[i];
                if (info == null) {
                  this.contents[localContentsOffset++] = (byte) VerificationTypeInfo.ITEM_TOP;
                } else {
                  switch(info.id()) {
                    case T_boolean :
                    case T_byte :
                    case T_char :
                    case T_int :
                    case T_short :
                      this.contents[localContentsOffset++] = (byte) VerificationTypeInfo.ITEM_INTEGER;
                      break;
                    case T_float :
                      this.contents[localContentsOffset++] = (byte) VerificationTypeInfo.ITEM_FLOAT;
                      break;
                    case T_long :
                      this.contents[localContentsOffset++] = (byte) VerificationTypeInfo.ITEM_LONG;
                      i++;
                      break;
                    case T_double :
                      this.contents[localContentsOffset++] = (byte) VerificationTypeInfo.ITEM_DOUBLE;
                      i++;
                      break;
                    case T_null :
                      this.contents[localContentsOffset++] = (byte) VerificationTypeInfo.ITEM_NULL;
                      break;
                    default:
                      this.contents[localContentsOffset++] = (byte) info.tag;
                      switch (info.tag) {
                        case VerificationTypeInfo.ITEM_UNINITIALIZED :
                          int offset = info.offset;
                          this.contents[localContentsOffset++] = (byte) (offset >> 8);
                          this.contents[localContentsOffset++] = (byte) offset;
                          break;
                        case VerificationTypeInfo.ITEM_OBJECT :
                          int indexForType = constantPool.literalIndexForType(info.constantPoolName());
                          this.contents[localContentsOffset++] = (byte) (indexForType >> 8);
                          this.contents[localContentsOffset++] = (byte) indexForType;
                      }
                  }
                  numberOfLocalEntries++;
                }
                numberOfEntries++;
              }
              if (localContentsOffset + 4 >= this.contents.length) {
                resizeContents(4);
              }             
              this.contents[numberOfLocalOffset++] = (byte) (numberOfEntries >> 8);
              this.contents[numberOfLocalOffset] = (byte) numberOfEntries;
              int numberOfStackItems = currentFrame.numberOfStackItems;
              this.contents[localContentsOffset++] = (byte) (numberOfStackItems >> 8);
              this.contents[localContentsOffset++] = (byte) numberOfStackItems;
              for (int i = 0; i < numberOfStackItems; i++) {
                if (localContentsOffset + 3 >= this.contents.length) {
                  resizeContents(3);
                }
                VerificationTypeInfo info = currentFrame.stackItems[i];
                if (info == null) {
                  this.contents[localContentsOffset++] = (byte) VerificationTypeInfo.ITEM_TOP;
                } else {
                  switch(info.id()) {
                    case T_boolean :
                    case T_byte :
                    case T_char :
                    case T_int :
                    case T_short :
                      this.contents[localContentsOffset++] = (byte) VerificationTypeInfo.ITEM_INTEGER;
                      break;
                    case T_float :
                      this.contents[localContentsOffset++] = (byte) VerificationTypeInfo.ITEM_FLOAT;
                      break;
                    case T_long :
                      this.contents[localContentsOffset++] = (byte) VerificationTypeInfo.ITEM_LONG;
                      break;
                    case T_double :
                      this.contents[localContentsOffset++] = (byte) VerificationTypeInfo.ITEM_DOUBLE;
                      break;
                    case T_null :
                      this.contents[localContentsOffset++] = (byte) VerificationTypeInfo.ITEM_NULL;
                      break;
                    default:
                      this.contents[localContentsOffset++] = (byte) info.tag;
                      switch (info.tag) {
                        case VerificationTypeInfo.ITEM_UNINITIALIZED :
                          int offset = info.offset;
                          this.contents[localContentsOffset++] = (byte) (offset >> 8);
                          this.contents[localContentsOffset++] = (byte) offset;
                          break;
                        case VerificationTypeInfo.ITEM_OBJECT :
                          int indexForType = constantPool.literalIndexForType(info.constantPoolName());
                          this.contents[localContentsOffset++] = (byte) (indexForType >> 8);
                          this.contents[localContentsOffset++] = (byte) indexForType;
                      }
                  }
                }
View Full Code Here

Examples of org.aspectj.org.eclipse.jdt.internal.compiler.codegen.VerificationTypeInfo

              int numberOfLocals = currentFrame.getNumberOfLocals();
              for (int i = index; i < currentFrame.locals.length && numberOfDifferentLocals > 0; i++) {
                if (localContentsOffset + 6 >= this.contents.length) {
                  resizeContents(6);
                }
                VerificationTypeInfo info = currentFrame.locals[i];
                if (info == null) {
                  this.contents[localContentsOffset++] = (byte) VerificationTypeInfo.ITEM_TOP;
                } else {
                  switch(info.id()) {
                    case T_boolean :
                    case T_byte :
                    case T_char :
                    case T_int :
                    case T_short :
                      this.contents[localContentsOffset++] = (byte) VerificationTypeInfo.ITEM_INTEGER;
                      break;
                    case T_float :
                      this.contents[localContentsOffset++] = (byte) VerificationTypeInfo.ITEM_FLOAT;
                      break;
                    case T_long :
                      this.contents[localContentsOffset++] = (byte) VerificationTypeInfo.ITEM_LONG;
                      i++;
                      break;
                    case T_double :
                      this.contents[localContentsOffset++] = (byte) VerificationTypeInfo.ITEM_DOUBLE;
                      i++;
                      break;
                    case T_null :
                      this.contents[localContentsOffset++] = (byte) VerificationTypeInfo.ITEM_NULL;
                      break;
                    default:
                      this.contents[localContentsOffset++] = (byte) info.tag;
                      switch (info.tag) {
                        case VerificationTypeInfo.ITEM_UNINITIALIZED :
                          int offset = info.offset;
                          this.contents[localContentsOffset++] = (byte) (offset >> 8);
                          this.contents[localContentsOffset++] = (byte) offset;
                          break;
                        case VerificationTypeInfo.ITEM_OBJECT :
                          int indexForType = constantPool.literalIndexForType(info.constantPoolName());
                          this.contents[localContentsOffset++] = (byte) (indexForType >> 8);
                          this.contents[localContentsOffset++] = (byte) indexForType;
                      }
                  }
                  numberOfDifferentLocals--;
                }
              }
              break;
            case StackMapFrame.SAME_FRAME :
              if (localContentsOffset + 1 >= this.contents.length) {
                resizeContents(1);
              }             
              this.contents[localContentsOffset++] = (byte) offsetDelta;
              break;
            case StackMapFrame.SAME_FRAME_EXTENDED :
              if (localContentsOffset + 3 >= this.contents.length) {
                resizeContents(3);
              }             
              this.contents[localContentsOffset++] = (byte) 251;
              this.contents[localContentsOffset++] = (byte) (offsetDelta >> 8);
              this.contents[localContentsOffset++] = (byte) offsetDelta;
              break;
            case StackMapFrame.CHOP_FRAME :
              if (localContentsOffset + 3 >= this.contents.length) {
                resizeContents(3);
              }             
              numberOfDifferentLocals = -currentFrame.numberOfDifferentLocals(prevFrame);
              this.contents[localContentsOffset++] = (byte) (251 - numberOfDifferentLocals);
              this.contents[localContentsOffset++] = (byte) (offsetDelta >> 8);
              this.contents[localContentsOffset++] = (byte) offsetDelta;             
              break;
            case StackMapFrame.SAME_LOCALS_1_STACK_ITEMS :
              if (localContentsOffset + 4 >= this.contents.length) {
                resizeContents(4);
              }             
              this.contents[localContentsOffset++] = (byte) (offsetDelta + 64);
              if (currentFrame.stackItems[0] == null) {
                this.contents[localContentsOffset++] = (byte) VerificationTypeInfo.ITEM_TOP;
              } else {
                switch(currentFrame.stackItems[0].id()) {
                  case T_boolean :
                  case T_byte :
                  case T_char :
                  case T_int :
                  case T_short :
                    this.contents[localContentsOffset++] = (byte) VerificationTypeInfo.ITEM_INTEGER;
                    break;
                  case T_float :
                    this.contents[localContentsOffset++] = (byte) VerificationTypeInfo.ITEM_FLOAT;
                    break;
                  case T_long :
                    this.contents[localContentsOffset++] = (byte) VerificationTypeInfo.ITEM_LONG;
                    break;
                  case T_double :
                    this.contents[localContentsOffset++] = (byte) VerificationTypeInfo.ITEM_DOUBLE;
                    break;
                  case T_null :
                    this.contents[localContentsOffset++] = (byte) VerificationTypeInfo.ITEM_NULL;
                    break;
                  default:
                    VerificationTypeInfo info = currentFrame.stackItems[0];
                    this.contents[localContentsOffset++] = (byte) info.tag;
                    switch (info.tag) {
                      case VerificationTypeInfo.ITEM_UNINITIALIZED :
                        int offset = info.offset;
                        this.contents[localContentsOffset++] = (byte) (offset >> 8);
                        this.contents[localContentsOffset++] = (byte) offset;
                        break;
                      case VerificationTypeInfo.ITEM_OBJECT :
                        int indexForType = constantPool.literalIndexForType(info.constantPoolName());
                        this.contents[localContentsOffset++] = (byte) (indexForType >> 8);
                        this.contents[localContentsOffset++] = (byte) indexForType;
                    }
                }
              }
              break;
            case StackMapFrame.SAME_LOCALS_1_STACK_ITEMS_EXTENDED :
              if (localContentsOffset + 6 >= this.contents.length) {
                resizeContents(6);
              }             
              this.contents[localContentsOffset++] = (byte) 247;
              this.contents[localContentsOffset++] = (byte) (offsetDelta >> 8);
              this.contents[localContentsOffset++] = (byte) offsetDelta;
              if (currentFrame.stackItems[0] == null) {
                this.contents[localContentsOffset++] = (byte) VerificationTypeInfo.ITEM_TOP;
              } else {
                switch(currentFrame.stackItems[0].id()) {
                  case T_boolean :
                  case T_byte :
                  case T_char :
                  case T_int :
                  case T_short :
                    this.contents[localContentsOffset++] = (byte) VerificationTypeInfo.ITEM_INTEGER;
                    break;
                  case T_float :
                    this.contents[localContentsOffset++] = (byte) VerificationTypeInfo.ITEM_FLOAT;
                    break;
                  case T_long :
                    this.contents[localContentsOffset++] = (byte) VerificationTypeInfo.ITEM_LONG;
                    break;
                  case T_double :
                    this.contents[localContentsOffset++] = (byte) VerificationTypeInfo.ITEM_DOUBLE;
                    break;
                  case T_null :
                    this.contents[localContentsOffset++] = (byte) VerificationTypeInfo.ITEM_NULL;
                    break;
                  default:
                    VerificationTypeInfo info = currentFrame.stackItems[0];
                    this.contents[localContentsOffset++] = (byte) info.tag;
                    switch (info.tag) {
                      case VerificationTypeInfo.ITEM_UNINITIALIZED :
                        int offset = info.offset;
                        this.contents[localContentsOffset++] = (byte) (offset >> 8);
                        this.contents[localContentsOffset++] = (byte) offset;
                        break;
                      case VerificationTypeInfo.ITEM_OBJECT :
                        int indexForType = constantPool.literalIndexForType(info.constantPoolName());
                        this.contents[localContentsOffset++] = (byte) (indexForType >> 8);
                        this.contents[localContentsOffset++] = (byte) indexForType;
                    }
                }
              }
              break;
            default :
              // FULL_FRAME
              if (localContentsOffset + 5 >= this.contents.length) {
                resizeContents(5);
              }             
              this.contents[localContentsOffset++] = (byte) 255;
              this.contents[localContentsOffset++] = (byte) (offsetDelta >> 8);
              this.contents[localContentsOffset++] = (byte) offsetDelta;
              int numberOfLocalOffset = localContentsOffset;
              localContentsOffset += 2; // leave two spots for number of locals
              int numberOfLocalEntries = 0;
              numberOfLocals = currentFrame.getNumberOfLocals();
              int numberOfEntries = 0;
              int localsLength = currentFrame.locals == null ? 0 : currentFrame.locals.length;
              for (int i = 0; i < localsLength && numberOfLocalEntries < numberOfLocals; i++) {
                if (localContentsOffset + 3 >= this.contents.length) {
                  resizeContents(3);
                }             
                VerificationTypeInfo info = currentFrame.locals[i];
                if (info == null) {
                  this.contents[localContentsOffset++] = (byte) VerificationTypeInfo.ITEM_TOP;
                } else {
                  switch(info.id()) {
                    case T_boolean :
                    case T_byte :
                    case T_char :
                    case T_int :
                    case T_short :
                      this.contents[localContentsOffset++] = (byte) VerificationTypeInfo.ITEM_INTEGER;
                      break;
                    case T_float :
                      this.contents[localContentsOffset++] = (byte) VerificationTypeInfo.ITEM_FLOAT;
                      break;
                    case T_long :
                      this.contents[localContentsOffset++] = (byte) VerificationTypeInfo.ITEM_LONG;
                      i++;
                      break;
                    case T_double :
                      this.contents[localContentsOffset++] = (byte) VerificationTypeInfo.ITEM_DOUBLE;
                      i++;
                      break;
                    case T_null :
                      this.contents[localContentsOffset++] = (byte) VerificationTypeInfo.ITEM_NULL;
                      break;
                    default:
                      this.contents[localContentsOffset++] = (byte) info.tag;
                      switch (info.tag) {
                        case VerificationTypeInfo.ITEM_UNINITIALIZED :
                          int offset = info.offset;
                          this.contents[localContentsOffset++] = (byte) (offset >> 8);
                          this.contents[localContentsOffset++] = (byte) offset;
                          break;
                        case VerificationTypeInfo.ITEM_OBJECT :
                          int indexForType = constantPool.literalIndexForType(info.constantPoolName());
                          this.contents[localContentsOffset++] = (byte) (indexForType >> 8);
                          this.contents[localContentsOffset++] = (byte) indexForType;
                      }
                  }
                  numberOfLocalEntries++;
                }
                numberOfEntries++;
              }
              if (localContentsOffset + 4 >= this.contents.length) {
                resizeContents(4);
              }             
              this.contents[numberOfLocalOffset++] = (byte) (numberOfEntries >> 8);
              this.contents[numberOfLocalOffset] = (byte) numberOfEntries;
              int numberOfStackItems = currentFrame.numberOfStackItems;
              this.contents[localContentsOffset++] = (byte) (numberOfStackItems >> 8);
              this.contents[localContentsOffset++] = (byte) numberOfStackItems;
              for (int i = 0; i < numberOfStackItems; i++) {
                if (localContentsOffset + 3 >= this.contents.length) {
                  resizeContents(3);
                }
                VerificationTypeInfo info = currentFrame.stackItems[i];
                if (info == null) {
                  this.contents[localContentsOffset++] = (byte) VerificationTypeInfo.ITEM_TOP;
                } else {
                  switch(info.id()) {
                    case T_boolean :
                    case T_byte :
                    case T_char :
                    case T_int :
                    case T_short :
                      this.contents[localContentsOffset++] = (byte) VerificationTypeInfo.ITEM_INTEGER;
                      break;
                    case T_float :
                      this.contents[localContentsOffset++] = (byte) VerificationTypeInfo.ITEM_FLOAT;
                      break;
                    case T_long :
                      this.contents[localContentsOffset++] = (byte) VerificationTypeInfo.ITEM_LONG;
                      break;
                    case T_double :
                      this.contents[localContentsOffset++] = (byte) VerificationTypeInfo.ITEM_DOUBLE;
                      break;
                    case T_null :
                      this.contents[localContentsOffset++] = (byte) VerificationTypeInfo.ITEM_NULL;
                      break;
                    default:
                      this.contents[localContentsOffset++] = (byte) info.tag;
                      switch (info.tag) {
                        case VerificationTypeInfo.ITEM_UNINITIALIZED :
                          int offset = info.offset;
                          this.contents[localContentsOffset++] = (byte) (offset >> 8);
                          this.contents[localContentsOffset++] = (byte) offset;
                          break;
                        case VerificationTypeInfo.ITEM_OBJECT :
                          int indexForType = constantPool.literalIndexForType(info.constantPoolName());
                          this.contents[localContentsOffset++] = (byte) (indexForType >> 8);
                          this.contents[localContentsOffset++] = (byte) indexForType;
                      }
                  }
                }
View Full Code Here

Examples of org.eclipse.jdt.internal.compiler.codegen.VerificationTypeInfo

          int localsLength = currentFrame.locals == null ? 0 : currentFrame.locals.length;
          for (int i = 0; i < localsLength && numberOfLocalEntries < numberOfLocals; i++) {
            if (localContentsOffset + 3 >= this.contents.length) {
              resizeContents(3);
            }
            VerificationTypeInfo info = currentFrame.locals[i];
            if (info == null) {
              this.contents[localContentsOffset++] = (byte) VerificationTypeInfo.ITEM_TOP;
            } else {
              switch(info.id()) {
                case T_boolean :
                case T_byte :
                case T_char :
                case T_int :
                case T_short :
                  this.contents[localContentsOffset++] = (byte) VerificationTypeInfo.ITEM_INTEGER;
                  break;
                case T_float :
                  this.contents[localContentsOffset++] = (byte) VerificationTypeInfo.ITEM_FLOAT;
                  break;
                case T_long :
                  this.contents[localContentsOffset++] = (byte) VerificationTypeInfo.ITEM_LONG;
                  i++;
                  break;
                case T_double :
                  this.contents[localContentsOffset++] = (byte) VerificationTypeInfo.ITEM_DOUBLE;
                  i++;
                  break;
                case T_null :
                  this.contents[localContentsOffset++] = (byte) VerificationTypeInfo.ITEM_NULL;
                  break;
                default:
                  this.contents[localContentsOffset++] = (byte) info.tag;
                switch (info.tag) {
                  case VerificationTypeInfo.ITEM_UNINITIALIZED :
                    int offset = info.offset;
                    this.contents[localContentsOffset++] = (byte) (offset >> 8);
                    this.contents[localContentsOffset++] = (byte) offset;
                    break;
                  case VerificationTypeInfo.ITEM_OBJECT :
                    int indexForType = this.constantPool.literalIndexForType(info.constantPoolName());
                    this.contents[localContentsOffset++] = (byte) (indexForType >> 8);
                    this.contents[localContentsOffset++] = (byte) indexForType;
                }
              }
              numberOfLocalEntries++;
            }
            numberOfEntries++;
          }
          if (localContentsOffset + 4 >= this.contents.length) {
            resizeContents(4);
          }
          this.contents[numberOfLocalOffset++] = (byte) (numberOfEntries >> 8);
          this.contents[numberOfLocalOffset] = (byte) numberOfEntries;
          int numberOfStackItems = currentFrame.numberOfStackItems;
          this.contents[localContentsOffset++] = (byte) (numberOfStackItems >> 8);
          this.contents[localContentsOffset++] = (byte) numberOfStackItems;
          for (int i = 0; i < numberOfStackItems; i++) {
            if (localContentsOffset + 3 >= this.contents.length) {
              resizeContents(3);
            }
            VerificationTypeInfo info = currentFrame.stackItems[i];
            if (info == null) {
              this.contents[localContentsOffset++] = (byte) VerificationTypeInfo.ITEM_TOP;
            } else {
              switch(info.id()) {
                case T_boolean :
                case T_byte :
                case T_char :
                case T_int :
                case T_short :
                  this.contents[localContentsOffset++] = (byte) VerificationTypeInfo.ITEM_INTEGER;
                  break;
                case T_float :
                  this.contents[localContentsOffset++] = (byte) VerificationTypeInfo.ITEM_FLOAT;
                  break;
                case T_long :
                  this.contents[localContentsOffset++] = (byte) VerificationTypeInfo.ITEM_LONG;
                  break;
                case T_double :
                  this.contents[localContentsOffset++] = (byte) VerificationTypeInfo.ITEM_DOUBLE;
                  break;
                case T_null :
                  this.contents[localContentsOffset++] = (byte) VerificationTypeInfo.ITEM_NULL;
                  break;
                default:
                  this.contents[localContentsOffset++] = (byte) info.tag;
                switch (info.tag) {
                  case VerificationTypeInfo.ITEM_UNINITIALIZED :
                    int offset = info.offset;
                    this.contents[localContentsOffset++] = (byte) (offset >> 8);
                    this.contents[localContentsOffset++] = (byte) offset;
                    break;
                  case VerificationTypeInfo.ITEM_OBJECT :
                    int indexForType = this.constantPool.literalIndexForType(info.constantPoolName());
                    this.contents[localContentsOffset++] = (byte) (indexForType >> 8);
                    this.contents[localContentsOffset++] = (byte) indexForType;
                }
              }
            }
View Full Code Here

Examples of org.eclipse.jdt.internal.compiler.codegen.VerificationTypeInfo

              int numberOfLocals = currentFrame.getNumberOfLocals();
              for (int i = index; i < currentFrame.locals.length && numberOfDifferentLocals > 0; i++) {
                if (localContentsOffset + 6 >= this.contents.length) {
                  resizeContents(6);
                }
                VerificationTypeInfo info = currentFrame.locals[i];
                if (info == null) {
                  this.contents[localContentsOffset++] = (byte) VerificationTypeInfo.ITEM_TOP;
                } else {
                  switch(info.id()) {
                    case T_boolean :
                    case T_byte :
                    case T_char :
                    case T_int :
                    case T_short :
                      this.contents[localContentsOffset++] = (byte) VerificationTypeInfo.ITEM_INTEGER;
                      break;
                    case T_float :
                      this.contents[localContentsOffset++] = (byte) VerificationTypeInfo.ITEM_FLOAT;
                      break;
                    case T_long :
                      this.contents[localContentsOffset++] = (byte) VerificationTypeInfo.ITEM_LONG;
                      i++;
                      break;
                    case T_double :
                      this.contents[localContentsOffset++] = (byte) VerificationTypeInfo.ITEM_DOUBLE;
                      i++;
                      break;
                    case T_null :
                      this.contents[localContentsOffset++] = (byte) VerificationTypeInfo.ITEM_NULL;
                      break;
                    default:
                      this.contents[localContentsOffset++] = (byte) info.tag;
                      switch (info.tag) {
                        case VerificationTypeInfo.ITEM_UNINITIALIZED :
                          int offset = info.offset;
                          this.contents[localContentsOffset++] = (byte) (offset >> 8);
                          this.contents[localContentsOffset++] = (byte) offset;
                          break;
                        case VerificationTypeInfo.ITEM_OBJECT :
                          int indexForType = this.constantPool.literalIndexForType(info.constantPoolName());
                          this.contents[localContentsOffset++] = (byte) (indexForType >> 8);
                          this.contents[localContentsOffset++] = (byte) indexForType;
                      }
                  }
                  numberOfDifferentLocals--;
                }
              }
              break;
            case StackMapFrame.SAME_FRAME :
              if (localContentsOffset + 1 >= this.contents.length) {
                resizeContents(1);
              }
              this.contents[localContentsOffset++] = (byte) offsetDelta;
              break;
            case StackMapFrame.SAME_FRAME_EXTENDED :
              if (localContentsOffset + 3 >= this.contents.length) {
                resizeContents(3);
              }
              this.contents[localContentsOffset++] = (byte) 251;
              this.contents[localContentsOffset++] = (byte) (offsetDelta >> 8);
              this.contents[localContentsOffset++] = (byte) offsetDelta;
              break;
            case StackMapFrame.CHOP_FRAME :
              if (localContentsOffset + 3 >= this.contents.length) {
                resizeContents(3);
              }
              numberOfDifferentLocals = -currentFrame.numberOfDifferentLocals(prevFrame);
              this.contents[localContentsOffset++] = (byte) (251 - numberOfDifferentLocals);
              this.contents[localContentsOffset++] = (byte) (offsetDelta >> 8);
              this.contents[localContentsOffset++] = (byte) offsetDelta;
              break;
            case StackMapFrame.SAME_LOCALS_1_STACK_ITEMS :
              if (localContentsOffset + 4 >= this.contents.length) {
                resizeContents(4);
              }
              this.contents[localContentsOffset++] = (byte) (offsetDelta + 64);
              if (currentFrame.stackItems[0] == null) {
                this.contents[localContentsOffset++] = (byte) VerificationTypeInfo.ITEM_TOP;
              } else {
                switch(currentFrame.stackItems[0].id()) {
                  case T_boolean :
                  case T_byte :
                  case T_char :
                  case T_int :
                  case T_short :
                    this.contents[localContentsOffset++] = (byte) VerificationTypeInfo.ITEM_INTEGER;
                    break;
                  case T_float :
                    this.contents[localContentsOffset++] = (byte) VerificationTypeInfo.ITEM_FLOAT;
                    break;
                  case T_long :
                    this.contents[localContentsOffset++] = (byte) VerificationTypeInfo.ITEM_LONG;
                    break;
                  case T_double :
                    this.contents[localContentsOffset++] = (byte) VerificationTypeInfo.ITEM_DOUBLE;
                    break;
                  case T_null :
                    this.contents[localContentsOffset++] = (byte) VerificationTypeInfo.ITEM_NULL;
                    break;
                  default:
                    VerificationTypeInfo info = currentFrame.stackItems[0];
                    byte tag = (byte) info.tag;
                    this.contents[localContentsOffset++] = tag;
                    switch (tag) {
                      case VerificationTypeInfo.ITEM_UNINITIALIZED :
                        int offset = info.offset;
                        this.contents[localContentsOffset++] = (byte) (offset >> 8);
                        this.contents[localContentsOffset++] = (byte) offset;
                        break;
                      case VerificationTypeInfo.ITEM_OBJECT :
                        int indexForType = this.constantPool.literalIndexForType(info.constantPoolName());
                        this.contents[localContentsOffset++] = (byte) (indexForType >> 8);
                        this.contents[localContentsOffset++] = (byte) indexForType;
                    }
                }
              }
              break;
            case StackMapFrame.SAME_LOCALS_1_STACK_ITEMS_EXTENDED :
              if (localContentsOffset + 6 >= this.contents.length) {
                resizeContents(6);
              }
              this.contents[localContentsOffset++] = (byte) 247;
              this.contents[localContentsOffset++] = (byte) (offsetDelta >> 8);
              this.contents[localContentsOffset++] = (byte) offsetDelta;
              if (currentFrame.stackItems[0] == null) {
                this.contents[localContentsOffset++] = (byte) VerificationTypeInfo.ITEM_TOP;
              } else {
                switch(currentFrame.stackItems[0].id()) {
                  case T_boolean :
                  case T_byte :
                  case T_char :
                  case T_int :
                  case T_short :
                    this.contents[localContentsOffset++] = (byte) VerificationTypeInfo.ITEM_INTEGER;
                    break;
                  case T_float :
                    this.contents[localContentsOffset++] = (byte) VerificationTypeInfo.ITEM_FLOAT;
                    break;
                  case T_long :
                    this.contents[localContentsOffset++] = (byte) VerificationTypeInfo.ITEM_LONG;
                    break;
                  case T_double :
                    this.contents[localContentsOffset++] = (byte) VerificationTypeInfo.ITEM_DOUBLE;
                    break;
                  case T_null :
                    this.contents[localContentsOffset++] = (byte) VerificationTypeInfo.ITEM_NULL;
                    break;
                  default:
                    VerificationTypeInfo info = currentFrame.stackItems[0];
                    byte tag = (byte) info.tag;
                    this.contents[localContentsOffset++] = tag;
                    switch (tag) {
                      case VerificationTypeInfo.ITEM_UNINITIALIZED :
                        int offset = info.offset;
                        this.contents[localContentsOffset++] = (byte) (offset >> 8);
                        this.contents[localContentsOffset++] = (byte) offset;
                        break;
                      case VerificationTypeInfo.ITEM_OBJECT :
                        int indexForType = this.constantPool.literalIndexForType(info.constantPoolName());
                        this.contents[localContentsOffset++] = (byte) (indexForType >> 8);
                        this.contents[localContentsOffset++] = (byte) indexForType;
                    }
                }
              }
              break;
            default :
              // FULL_FRAME
              if (localContentsOffset + 5 >= this.contents.length) {
                resizeContents(5);
              }
              this.contents[localContentsOffset++] = (byte) 255;
              this.contents[localContentsOffset++] = (byte) (offsetDelta >> 8);
              this.contents[localContentsOffset++] = (byte) offsetDelta;
              int numberOfLocalOffset = localContentsOffset;
              localContentsOffset += 2; // leave two spots for number of locals
              int numberOfLocalEntries = 0;
              numberOfLocals = currentFrame.getNumberOfLocals();
              int numberOfEntries = 0;
              int localsLength = currentFrame.locals == null ? 0 : currentFrame.locals.length;
              for (int i = 0; i < localsLength && numberOfLocalEntries < numberOfLocals; i++) {
                if (localContentsOffset + 3 >= this.contents.length) {
                  resizeContents(3);
                }
                VerificationTypeInfo info = currentFrame.locals[i];
                if (info == null) {
                  this.contents[localContentsOffset++] = (byte) VerificationTypeInfo.ITEM_TOP;
                } else {
                  switch(info.id()) {
                    case T_boolean :
                    case T_byte :
                    case T_char :
                    case T_int :
                    case T_short :
                      this.contents[localContentsOffset++] = (byte) VerificationTypeInfo.ITEM_INTEGER;
                      break;
                    case T_float :
                      this.contents[localContentsOffset++] = (byte) VerificationTypeInfo.ITEM_FLOAT;
                      break;
                    case T_long :
                      this.contents[localContentsOffset++] = (byte) VerificationTypeInfo.ITEM_LONG;
                      i++;
                      break;
                    case T_double :
                      this.contents[localContentsOffset++] = (byte) VerificationTypeInfo.ITEM_DOUBLE;
                      i++;
                      break;
                    case T_null :
                      this.contents[localContentsOffset++] = (byte) VerificationTypeInfo.ITEM_NULL;
                      break;
                    default:
                      this.contents[localContentsOffset++] = (byte) info.tag;
                      switch (info.tag) {
                        case VerificationTypeInfo.ITEM_UNINITIALIZED :
                          int offset = info.offset;
                          this.contents[localContentsOffset++] = (byte) (offset >> 8);
                          this.contents[localContentsOffset++] = (byte) offset;
                          break;
                        case VerificationTypeInfo.ITEM_OBJECT :
                          int indexForType = this.constantPool.literalIndexForType(info.constantPoolName());
                          this.contents[localContentsOffset++] = (byte) (indexForType >> 8);
                          this.contents[localContentsOffset++] = (byte) indexForType;
                      }
                  }
                  numberOfLocalEntries++;
                }
                numberOfEntries++;
              }
              if (localContentsOffset + 4 >= this.contents.length) {
                resizeContents(4);
              }
              this.contents[numberOfLocalOffset++] = (byte) (numberOfEntries >> 8);
              this.contents[numberOfLocalOffset] = (byte) numberOfEntries;
              int numberOfStackItems = currentFrame.numberOfStackItems;
              this.contents[localContentsOffset++] = (byte) (numberOfStackItems >> 8);
              this.contents[localContentsOffset++] = (byte) numberOfStackItems;
              for (int i = 0; i < numberOfStackItems; i++) {
                if (localContentsOffset + 3 >= this.contents.length) {
                  resizeContents(3);
                }
                VerificationTypeInfo info = currentFrame.stackItems[i];
                if (info == null) {
                  this.contents[localContentsOffset++] = (byte) VerificationTypeInfo.ITEM_TOP;
                } else {
                  switch(info.id()) {
                    case T_boolean :
                    case T_byte :
                    case T_char :
                    case T_int :
                    case T_short :
                      this.contents[localContentsOffset++] = (byte) VerificationTypeInfo.ITEM_INTEGER;
                      break;
                    case T_float :
                      this.contents[localContentsOffset++] = (byte) VerificationTypeInfo.ITEM_FLOAT;
                      break;
                    case T_long :
                      this.contents[localContentsOffset++] = (byte) VerificationTypeInfo.ITEM_LONG;
                      break;
                    case T_double :
                      this.contents[localContentsOffset++] = (byte) VerificationTypeInfo.ITEM_DOUBLE;
                      break;
                    case T_null :
                      this.contents[localContentsOffset++] = (byte) VerificationTypeInfo.ITEM_NULL;
                      break;
                    default:
                      this.contents[localContentsOffset++] = (byte) info.tag;
                      switch (info.tag) {
                        case VerificationTypeInfo.ITEM_UNINITIALIZED :
                          int offset = info.offset;
                          this.contents[localContentsOffset++] = (byte) (offset >> 8);
                          this.contents[localContentsOffset++] = (byte) offset;
                          break;
                        case VerificationTypeInfo.ITEM_OBJECT :
                          int indexForType = this.constantPool.literalIndexForType(info.constantPoolName());
                          this.contents[localContentsOffset++] = (byte) (indexForType >> 8);
                          this.contents[localContentsOffset++] = (byte) indexForType;
                      }
                  }
                }
View Full Code Here

Examples of org.eclipse.jdt.internal.compiler.codegen.VerificationTypeInfo

        LocalVariableBinding localVariableBinding = new LocalVariableBinding(ConstantPool.This, methodBinding.declaringClass, 0, false);
        localVariableBinding.resolvedPosition = 0;
        this.codeStream.record(localVariableBinding);
        localVariableBinding.recordInitializationStartPC(0);
        localVariableBinding.recordInitializationEndPC(codeLength);
        frame.putLocal(resolvedPosition, new VerificationTypeInfo(
            isConstructor ? VerificationTypeInfo.ITEM_UNINITIALIZED_THIS : VerificationTypeInfo.ITEM_OBJECT,
            methodBinding.declaringClass));
        resolvedPosition++;
      }

      if (isConstructor) {
        if (methodBinding.declaringClass.isEnum()) {
          LocalVariableBinding localVariableBinding = new LocalVariableBinding(" name".toCharArray(), this.referenceBinding.scope.getJavaLangString(), 0, false); //$NON-NLS-1$
          localVariableBinding.resolvedPosition = resolvedPosition;
          this.codeStream.record(localVariableBinding);
          localVariableBinding.recordInitializationStartPC(0);
          localVariableBinding.recordInitializationEndPC(codeLength);

          frame.putLocal(resolvedPosition, new VerificationTypeInfo(
              TypeIds.T_JavaLangString,
              ConstantPool.JavaLangStringConstantPoolName));
          resolvedPosition++;

          localVariableBinding = new LocalVariableBinding(" ordinal".toCharArray(), TypeBinding.INT, 0, false); //$NON-NLS-1$
          localVariableBinding.resolvedPosition = resolvedPosition;
          this.codeStream.record(localVariableBinding);
          localVariableBinding.recordInitializationStartPC(0);
          localVariableBinding.recordInitializationEndPC(codeLength);
          frame.putLocal(resolvedPosition, new VerificationTypeInfo(
              TypeBinding.INT));
          resolvedPosition++;
        }

        // take into account the synthetic parameters
        if (methodBinding.declaringClass.isNestedType()) {
          ReferenceBinding enclosingInstanceTypes[];
          if ((enclosingInstanceTypes = methodBinding.declaringClass.syntheticEnclosingInstanceTypes()) != null) {
            for (int i = 0, max = enclosingInstanceTypes.length; i < max; i++) {
              // an enclosingInstanceType can only be a reference
              // binding. It cannot be
              // LongBinding or DoubleBinding
              LocalVariableBinding localVariableBinding = new LocalVariableBinding((" enclosingType" + i).toCharArray(), enclosingInstanceTypes[i], 0, false); //$NON-NLS-1$
              localVariableBinding.resolvedPosition = resolvedPosition;
              this.codeStream.record(localVariableBinding);
              localVariableBinding.recordInitializationStartPC(0);
              localVariableBinding.recordInitializationEndPC(codeLength);

              frame.putLocal(resolvedPosition,
                  new VerificationTypeInfo(enclosingInstanceTypes[i]));
              resolvedPosition++;
            }
          }

          TypeBinding[] arguments;
          if ((arguments = methodBinding.parameters) != null) {
            for (int i = 0, max = arguments.length; i < max; i++) {
              final TypeBinding typeBinding = arguments[i];
              frame.putLocal(resolvedPosition,
                  new VerificationTypeInfo(typeBinding));
              switch (typeBinding.id) {
                case TypeIds.T_double:
                case TypeIds.T_long:
                  resolvedPosition += 2;
                  break;
                default:
                  resolvedPosition++;
              }
            }
          }

          SyntheticArgumentBinding syntheticArguments[];
          if ((syntheticArguments = methodBinding.declaringClass.syntheticOuterLocalVariables()) != null) {
            for (int i = 0, max = syntheticArguments.length; i < max; i++) {
              final TypeBinding typeBinding = syntheticArguments[i].type;
              LocalVariableBinding localVariableBinding = new LocalVariableBinding((" synthetic" + i).toCharArray(), typeBinding, 0, false); //$NON-NLS-1$
              localVariableBinding.resolvedPosition = resolvedPosition;
              this.codeStream.record(localVariableBinding);
              localVariableBinding.recordInitializationStartPC(0);
              localVariableBinding.recordInitializationEndPC(codeLength);

              frame.putLocal(resolvedPosition,
                  new VerificationTypeInfo(typeBinding));
              switch (typeBinding.id) {
                case TypeIds.T_double:
                case TypeIds.T_long:
                  resolvedPosition += 2;
                  break;
                default:
                  resolvedPosition++;
              }
            }
          }
        } else {
          TypeBinding[] arguments;
          if ((arguments = methodBinding.parameters) != null) {
            for (int i = 0, max = arguments.length; i < max; i++) {
              final TypeBinding typeBinding = arguments[i];
              frame.putLocal(resolvedPosition,
                  new VerificationTypeInfo(typeBinding));
              switch (typeBinding.id) {
                case TypeIds.T_double:
                case TypeIds.T_long:
                  resolvedPosition += 2;
                  break;
                default:
                  resolvedPosition++;
              }
            }
          }
        }
      } else {
        TypeBinding[] arguments;
        if ((arguments = methodBinding.parameters) != null) {
          for (int i = 0, max = arguments.length; i < max; i++) {
            final TypeBinding typeBinding = arguments[i];
            frame.putLocal(resolvedPosition,
                new VerificationTypeInfo(typeBinding));
            switch (typeBinding.id) {
              case TypeIds.T_double:
              case TypeIds.T_long:
                resolvedPosition += 2;
                break;
View Full Code Here

Examples of org.eclipse.jdt.internal.compiler.codegen.VerificationTypeInfo

          continue inits;
        } else if (currentPC < endPC) {
          // the current local is an active local
          if (currentFrame.locals[resolvedPosition] == null) {
            currentFrame.locals[resolvedPosition] =
                new VerificationTypeInfo(
                    localVariableTypeBinding);
          }
          continue locals;
        }
      }
View Full Code Here
TOP
Copyright © 2018 www.massapi.com. All rights reserved.
All source code are property of their respective owners. Java is a trademark of Sun Microsystems, Inc and owned by ORACLE Inc. Contact coftware#gmail.com.