org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/codegen/StackMapFrame.java - aspectj/org.aspectj.shadows - Git at Google

 /*******************************************************************************
  * Copyright (c) 2005, 2010 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
  *
  * Contributors:
  *     IBM Corporation - initial API and implementation
  *******************************************************************************/
 package org.eclipse.jdt.internal.compiler.codegen;

 import java.text.MessageFormat;

 import org.eclipse.jdt.internal.compiler.lookup.TypeBinding;
 import org.eclipse.jdt.internal.compiler.lookup.TypeIds;

 public class StackMapFrame {
 	public static final int USED = 1;
 	public static final int SAME_FRAME = 0;
 	public static final int CHOP_FRAME = 1;
 	public static final int APPEND_FRAME = 2;
 	public static final int SAME_FRAME_EXTENDED = 3;
 	public static final int FULL_FRAME = 4;
 	public static final int SAME_LOCALS_1_STACK_ITEMS = 5;
 	public static final int SAME_LOCALS_1_STACK_ITEMS_EXTENDED = 6;

 	public int pc;
 	public int numberOfStackItems;
 	private int numberOfLocals;
 	public int localIndex;
 	public VerificationTypeInfo[] locals;
 	public VerificationTypeInfo[] stackItems;
 	private int numberOfDifferentLocals = -1;
 	public int tagBits;

 public StackMapFrame(int initialLocalSize) {
 	this.locals = new VerificationTypeInfo[initialLocalSize];
 	this.numberOfLocals = -1;
 	this.numberOfDifferentLocals = -1;
 }
 public int getFrameType(StackMapFrame prevFrame) {
 	final int offsetDelta = getOffsetDelta(prevFrame);
 	switch(this.numberOfStackItems) {
 		case 0 :
 			switch(numberOfDifferentLocals(prevFrame)) {
 				case 0 :
 					return offsetDelta <= 63 ? SAME_FRAME : SAME_FRAME_EXTENDED;
 				case 1 :
 				case 2 :
 				case 3 :
 					return APPEND_FRAME;
 				case -1 :
 				case -2 :
 				case -3 :
 					return CHOP_FRAME;
 			}
 			break;
 		case 1 :
 			switch(numberOfDifferentLocals(prevFrame)) {
 				case 0 :
 					return offsetDelta <= 63 ? SAME_LOCALS_1_STACK_ITEMS : SAME_LOCALS_1_STACK_ITEMS_EXTENDED;
 			}
 	}
 	return FULL_FRAME;
 }
 public void addLocal(int resolvedPosition, VerificationTypeInfo info) {
 	if (this.locals == null) {
 		this.locals = new VerificationTypeInfo[resolvedPosition + 1];
 		this.locals[resolvedPosition] = info;
 	} else {
 		final int length = this.locals.length;
 		if (resolvedPosition >= length) {
 			System.arraycopy(this.locals, 0, this.locals = new VerificationTypeInfo[resolvedPosition + 1], 0, length);
 		}
 		this.locals[resolvedPosition] = info;
 	}
 }
 public void addStackItem(VerificationTypeInfo info) {
 	if (info == null) {
 		throw new IllegalArgumentException("info cannot be null"); //$NON-NLS-1$
 	}
 	if (this.stackItems == null) {
 		this.stackItems = new VerificationTypeInfo[1];
 		this.stackItems[0] = info;
 		this.numberOfStackItems = 1;
 	} else {
 		final int length = this.stackItems.length;
 		if (this.numberOfStackItems == length) {
 			System.arraycopy(this.stackItems, 0, this.stackItems = new VerificationTypeInfo[length + 1], 0, length);
 		}
 		this.stackItems[this.numberOfStackItems++] = info;
 	}
 }
 public void addStackItem(TypeBinding binding) {
 	if (this.stackItems == null) {
 		this.stackItems = new VerificationTypeInfo[1];
 		this.stackItems[0] = new VerificationTypeInfo(binding);
 		this.numberOfStackItems = 1;
 	} else {
 		final int length = this.stackItems.length;
 		if (this.numberOfStackItems == length) {
 			System.arraycopy(this.stackItems, 0, this.stackItems = new VerificationTypeInfo[length + 1], 0, length);
 		}
 		this.stackItems[this.numberOfStackItems++] = new VerificationTypeInfo(binding);
 	}
 }
 public StackMapFrame duplicate() {
 	int length = this.locals.length;
 	StackMapFrame result = new StackMapFrame(length);
 	result.numberOfLocals = -1;
 	result.numberOfDifferentLocals = -1;
 	result.pc = this.pc;
 	result.numberOfStackItems = this.numberOfStackItems;

 	if (length != 0) {
 		result.locals = new VerificationTypeInfo[length];
 		for (int i = 0; i < length; i++) {
 			final VerificationTypeInfo verificationTypeInfo = this.locals[i];
 			if (verificationTypeInfo != null) {
 				result.locals[i] = verificationTypeInfo.duplicate();
 			}
 		}
 	}
 	length = this.numberOfStackItems;
 	if (length != 0) {
 		result.stackItems = new VerificationTypeInfo[length];
 		for (int i = 0; i < length; i++) {
 			result.stackItems[i] = this.stackItems[i].duplicate();
 		}
 	}
 	return result;
 }
 public int numberOfDifferentLocals(StackMapFrame prevFrame) {
 	if (this.numberOfDifferentLocals != -1) return this.numberOfDifferentLocals;
 	if (prevFrame == null) {
 		this.numberOfDifferentLocals = 0;
 		return 0;
 	}
 	VerificationTypeInfo[] prevLocals = prevFrame.locals;
 	VerificationTypeInfo[] currentLocals = this.locals;
 	int prevLocalsLength = prevLocals == null ? 0 : prevLocals.length;
 	int currentLocalsLength = currentLocals == null ? 0 : currentLocals.length;
 	int prevNumberOfLocals = prevFrame.getNumberOfLocals();
 	int currentNumberOfLocals = getNumberOfLocals();

 	int result = 0;
 	if (prevNumberOfLocals == 0) {
 		if (currentNumberOfLocals != 0) {
 			// need to check if there is a hole in the locals
 			result = currentNumberOfLocals; // append if no hole and currentNumberOfLocals <= 3
 			int counter = 0;
 			for(int i = 0; i < currentLocalsLength && counter < currentNumberOfLocals; i++) {
 				if (currentLocals[i] != null) {
 					switch(currentLocals[i].id()) {
 						case TypeIds.T_double :
 						case TypeIds.T_long :
 							i++;
 					}
 					counter++;
 				} else {
 					result = Integer.MAX_VALUE;
 					this.numberOfDifferentLocals = result;
 					return result;
 				}
 			}
 		}
 	} else if (currentNumberOfLocals == 0) {
 		// need to check if there is a hole in the prev locals
 		int counter = 0;
 		result = -prevNumberOfLocals; // chop frame if no hole and prevNumberOfLocals <= 3
 		for(int i = 0; i < prevLocalsLength && counter < prevNumberOfLocals; i++) {
 			if (prevLocals[i] != null) {
 				switch(prevLocals[i].id()) {
 					case TypeIds.T_double :
 					case TypeIds.T_long :
 						i++;
 				}
 				counter++;
 			} else {
 				result = Integer.MAX_VALUE;
 				this.numberOfDifferentLocals = result;
 				return result;
 			}
 		}
 	} else {
 		// need to see if prevLocals matches with currentLocals
 		int indexInPrevLocals = 0;
 		int indexInCurrentLocals = 0;
 		int currentLocalsCounter = 0;
 		int prevLocalsCounter = 0;
 		currentLocalsLoop: for (;indexInCurrentLocals < currentLocalsLength && currentLocalsCounter < currentNumberOfLocals; indexInCurrentLocals++) {
 			VerificationTypeInfo currentLocal = currentLocals[indexInCurrentLocals];
 			if (currentLocal != null) {
 				currentLocalsCounter++;
 				switch(currentLocal.id()) {
 					case TypeIds.T_double :
 					case TypeIds.T_long :
 						indexInCurrentLocals++; // next entry  is null
 				}
 			}
 			if (indexInPrevLocals < prevLocalsLength && prevLocalsCounter < prevNumberOfLocals) {
 				VerificationTypeInfo prevLocal = prevLocals[indexInPrevLocals];
 				if (prevLocal != null) {
 					prevLocalsCounter++;
 					switch(prevLocal.id()) {
 						case TypeIds.T_double :
 						case TypeIds.T_long :
 							indexInPrevLocals++; // next entry  is null
 					}
 				}
 				// now we need to check if prevLocal matches with currentLocal
 				// the index must be the same
 				if (equals(prevLocal, currentLocal) && indexInPrevLocals == indexInCurrentLocals) {
 					if (result != 0) {
 						result = Integer.MAX_VALUE;
 						this.numberOfDifferentLocals = result;
 						return result;
 					}
 				} else {
 					// locals at the same location are not equals - this has to be a full frame
 					result = Integer.MAX_VALUE;
 					this.numberOfDifferentLocals = result;
 					return result;
 				}
 				indexInPrevLocals++;
 				continue currentLocalsLoop;
 			}
 			// process remaining current locals
 			if (currentLocal != null) {
 				result++;
 			} else {
 				result = Integer.MAX_VALUE;
 				this.numberOfDifferentLocals = result;
 				return result;
 			}
 			indexInCurrentLocals++;
 			break currentLocalsLoop;
 		}
 		if (currentLocalsCounter < currentNumberOfLocals) {
 			for(;indexInCurrentLocals < currentLocalsLength && currentLocalsCounter < currentNumberOfLocals; indexInCurrentLocals++) {
 				VerificationTypeInfo currentLocal = currentLocals[indexInCurrentLocals];
 				if (currentLocal == null) {
 					result = Integer.MAX_VALUE;
 					this.numberOfDifferentLocals = result;
 					return result;
 				}
 				result++;
 				currentLocalsCounter++;
 				switch(currentLocal.id()) {
 					case TypeIds.T_double :
 					case TypeIds.T_long :
 						indexInCurrentLocals++; // next entry  is null
 				}
 			}
 		} else if (prevLocalsCounter < prevNumberOfLocals) {
 			result = -result;
 			// process possible remaining prev locals
 			for(; indexInPrevLocals < prevLocalsLength && prevLocalsCounter < prevNumberOfLocals; indexInPrevLocals++) {
 				VerificationTypeInfo prevLocal = prevLocals[indexInPrevLocals];
 				if (prevLocal == null) {
 					result = Integer.MAX_VALUE;
 					this.numberOfDifferentLocals = result;
 					return result;
 				}
 				result--;
 				prevLocalsCounter++;
 				switch(prevLocal.id()) {
 					case TypeIds.T_double :
 					case TypeIds.T_long :
 						indexInPrevLocals++; // next entry  is null
 				}
 			}
 		}
 	}
 	this.numberOfDifferentLocals = result;
 	return result;
 }
 public int getNumberOfLocals() {
 	if (this.numberOfLocals != -1) {
 		return this.numberOfLocals;
 	}
 	int result = 0;
 	final int length = this.locals == null ? 0 : this.locals.length;
 	for(int i = 0; i < length; i++) {
 		if (this.locals[i] != null) {
 			switch(this.locals[i].id()) {
 				case TypeIds.T_double :
 				case TypeIds.T_long :
 					i++;
 			}
 			result++;
 		}
 	}
 	this.numberOfLocals = result;
 	return result;
 }
 public int getOffsetDelta(StackMapFrame prevFrame) {
 	if (prevFrame == null) return this.pc;
 	return prevFrame.pc == -1 ? this.pc : this.pc - prevFrame.pc - 1;
 }
 public String toString() {
 	StringBuffer buffer = new StringBuffer();
 	printFrame(buffer, this);
 	return String.valueOf(buffer);
 }
 private void printFrame(StringBuffer buffer, StackMapFrame frame) {
 	String pattern = "[pc : {0} locals: {1} stack items: {2}\nlocals: {3}\nstack: {4}\n]"; //$NON-NLS-1$
 	int localsLength = frame.locals == null ? 0 : frame.locals.length;
 	buffer.append(MessageFormat.format(
 		pattern,
 		new String[] {
 			Integer.toString(frame.pc),
 			Integer.toString(frame.getNumberOfLocals()),
 			Integer.toString(frame.numberOfStackItems),
 			print(frame.locals, localsLength),
 			print(frame.stackItems, frame.numberOfStackItems)
 		}
 	));
 }
 private String print(VerificationTypeInfo[] infos, int length) {
 	StringBuffer buffer = new StringBuffer();
 	buffer.append('[');
 	if (infos != null) {
 		for (int i = 0; i < length; i++) {
 			if (i != 0) buffer.append(',');
 			VerificationTypeInfo verificationTypeInfo = infos[i];
 			if (verificationTypeInfo == null) {
 				buffer.append("top"); //$NON-NLS-1$
 				continue;
 			}
 			buffer.append(verificationTypeInfo);
 		}
 	}
 	buffer.append(']');
 	return String.valueOf(buffer);
 }
 public void putLocal(int resolvedPosition, VerificationTypeInfo info) {
 	if (this.locals == null) {
 		this.locals = new VerificationTypeInfo[resolvedPosition + 1];
 		this.locals[resolvedPosition] = info;
 	} else {
 		final int length = this.locals.length;
 		if (resolvedPosition >= length) {
 			System.arraycopy(this.locals, 0, this.locals = new VerificationTypeInfo[resolvedPosition + 1], 0, length);
 		}
 		this.locals[resolvedPosition] = info;
 	}
 }
 public void replaceWithElementType() {
 	VerificationTypeInfo info = this.stackItems[this.numberOfStackItems - 1];
 	VerificationTypeInfo info2 = info.duplicate();
 	info2.replaceWithElementType();
 	this.stackItems[this.numberOfStackItems - 1] = info2;
 }
 public int getIndexOfDifferentLocals(int differentLocalsCount) {
 	for (int i = this.locals.length - 1; i >= 0; i--) {
 		VerificationTypeInfo currentLocal = this.locals[i];
 		if (currentLocal == null) {
 			// check the previous slot
 			continue;
 		} else {
 			differentLocalsCount--;
 		}
 		if (differentLocalsCount == 0) {
 			return i;
 		}
 	}
 	return 0;
 }
 private boolean equals(VerificationTypeInfo info, VerificationTypeInfo info2) {
 	if (info == null) {
 		return info2 == null;
 	}
 	if (info2 == null) return false;
 	return info.equals(info2);
 }
 }
	/*******************************************************************************
	* Copyright (c) 2005, 2010 IBM Corporation and others.
	* All rights reserved. This program and the accompanying materials
	* are made available under the terms of the Eclipse Public License v1.0
	* which accompanies this distribution, and is available at
	* http://www.eclipse.org/legal/epl-v10.html
	*
	* Contributors:
	* IBM Corporation - initial API and implementation
	*******************************************************************************/
	package org.eclipse.jdt.internal.compiler.codegen;

	import java.text.MessageFormat;

	import org.eclipse.jdt.internal.compiler.lookup.TypeBinding;
	import org.eclipse.jdt.internal.compiler.lookup.TypeIds;

	public class StackMapFrame {
	public static final int USED = 1;
	public static final int SAME_FRAME = 0;
	public static final int CHOP_FRAME = 1;
	public static final int APPEND_FRAME = 2;
	public static final int SAME_FRAME_EXTENDED = 3;
	public static final int FULL_FRAME = 4;
	public static final int SAME_LOCALS_1_STACK_ITEMS = 5;
	public static final int SAME_LOCALS_1_STACK_ITEMS_EXTENDED = 6;

	public int pc;
	public int numberOfStackItems;
	private int numberOfLocals;
	public int localIndex;
	public VerificationTypeInfo[] locals;
	public VerificationTypeInfo[] stackItems;
	private int numberOfDifferentLocals = -1;
	public int tagBits;

	public StackMapFrame(int initialLocalSize) {
	this.locals = new VerificationTypeInfo[initialLocalSize];
	this.numberOfLocals = -1;
	this.numberOfDifferentLocals = -1;
	}
	public int getFrameType(StackMapFrame prevFrame) {
	final int offsetDelta = getOffsetDelta(prevFrame);
	switch(this.numberOfStackItems) {
	case 0 :
	switch(numberOfDifferentLocals(prevFrame)) {
	case 0 :
	return offsetDelta <= 63 ? SAME_FRAME : SAME_FRAME_EXTENDED;
	case 1 :
	case 2 :
	case 3 :
	return APPEND_FRAME;
	case -1 :
	case -2 :
	case -3 :
	return CHOP_FRAME;
	}
	break;
	case 1 :
	switch(numberOfDifferentLocals(prevFrame)) {
	case 0 :
	return offsetDelta <= 63 ? SAME_LOCALS_1_STACK_ITEMS : SAME_LOCALS_1_STACK_ITEMS_EXTENDED;
	}
	}
	return FULL_FRAME;
	}
	public void addLocal(int resolvedPosition, VerificationTypeInfo info) {
	if (this.locals == null) {
	this.locals = new VerificationTypeInfo[resolvedPosition + 1];
	this.locals[resolvedPosition] = info;
	} else {
	final int length = this.locals.length;
	if (resolvedPosition >= length) {
	System.arraycopy(this.locals, 0, this.locals = new VerificationTypeInfo[resolvedPosition + 1], 0, length);
	}
	this.locals[resolvedPosition] = info;
	}
	}
	public void addStackItem(VerificationTypeInfo info) {
	if (info == null) {
	throw new IllegalArgumentException("info cannot be null"); //$NON-NLS-1$
	}
	if (this.stackItems == null) {
	this.stackItems = new VerificationTypeInfo[1];
	this.stackItems[0] = info;
	this.numberOfStackItems = 1;
	} else {
	final int length = this.stackItems.length;
	if (this.numberOfStackItems == length) {
	System.arraycopy(this.stackItems, 0, this.stackItems = new VerificationTypeInfo[length + 1], 0, length);
	}
	this.stackItems[this.numberOfStackItems++] = info;
	}
	}
	public void addStackItem(TypeBinding binding) {
	if (this.stackItems == null) {
	this.stackItems = new VerificationTypeInfo[1];
	this.stackItems[0] = new VerificationTypeInfo(binding);
	this.numberOfStackItems = 1;
	} else {
	final int length = this.stackItems.length;
	if (this.numberOfStackItems == length) {
	System.arraycopy(this.stackItems, 0, this.stackItems = new VerificationTypeInfo[length + 1], 0, length);
	}
	this.stackItems[this.numberOfStackItems++] = new VerificationTypeInfo(binding);
	}
	}
	public StackMapFrame duplicate() {
	int length = this.locals.length;
	StackMapFrame result = new StackMapFrame(length);
	result.numberOfLocals = -1;
	result.numberOfDifferentLocals = -1;
	result.pc = this.pc;
	result.numberOfStackItems = this.numberOfStackItems;

	if (length != 0) {
	result.locals = new VerificationTypeInfo[length];
	for (int i = 0; i < length; i++) {
	final VerificationTypeInfo verificationTypeInfo = this.locals[i];
	if (verificationTypeInfo != null) {
	result.locals[i] = verificationTypeInfo.duplicate();
	}
	}
	}
	length = this.numberOfStackItems;
	if (length != 0) {
	result.stackItems = new VerificationTypeInfo[length];
	for (int i = 0; i < length; i++) {
	result.stackItems[i] = this.stackItems[i].duplicate();
	}
	}
	return result;
	}
	public int numberOfDifferentLocals(StackMapFrame prevFrame) {
	if (this.numberOfDifferentLocals != -1) return this.numberOfDifferentLocals;
	if (prevFrame == null) {
	this.numberOfDifferentLocals = 0;
	return 0;
	}
	VerificationTypeInfo[] prevLocals = prevFrame.locals;
	VerificationTypeInfo[] currentLocals = this.locals;
	int prevLocalsLength = prevLocals == null ? 0 : prevLocals.length;
	int currentLocalsLength = currentLocals == null ? 0 : currentLocals.length;
	int prevNumberOfLocals = prevFrame.getNumberOfLocals();
	int currentNumberOfLocals = getNumberOfLocals();

	int result = 0;
	if (prevNumberOfLocals == 0) {
	if (currentNumberOfLocals != 0) {
	// need to check if there is a hole in the locals
	result = currentNumberOfLocals; // append if no hole and currentNumberOfLocals <= 3
	int counter = 0;
	for(int i = 0; i < currentLocalsLength && counter < currentNumberOfLocals; i++) {
	if (currentLocals[i] != null) {
	switch(currentLocals[i].id()) {
	case TypeIds.T_double :
	case TypeIds.T_long :
	i++;
	}
	counter++;
	} else {
	result = Integer.MAX_VALUE;
	this.numberOfDifferentLocals = result;
	return result;
	}
	}
	}
	} else if (currentNumberOfLocals == 0) {
	// need to check if there is a hole in the prev locals
	int counter = 0;
	result = -prevNumberOfLocals; // chop frame if no hole and prevNumberOfLocals <= 3
	for(int i = 0; i < prevLocalsLength && counter < prevNumberOfLocals; i++) {
	if (prevLocals[i] != null) {
	switch(prevLocals[i].id()) {
	case TypeIds.T_double :
	case TypeIds.T_long :
	i++;
	}
	counter++;
	} else {
	result = Integer.MAX_VALUE;
	this.numberOfDifferentLocals = result;
	return result;
	}
	}
	} else {
	// need to see if prevLocals matches with currentLocals
	int indexInPrevLocals = 0;
	int indexInCurrentLocals = 0;
	int currentLocalsCounter = 0;
	int prevLocalsCounter = 0;
	currentLocalsLoop: for (;indexInCurrentLocals < currentLocalsLength && currentLocalsCounter < currentNumberOfLocals; indexInCurrentLocals++) {
	VerificationTypeInfo currentLocal = currentLocals[indexInCurrentLocals];
	if (currentLocal != null) {
	currentLocalsCounter++;
	switch(currentLocal.id()) {
	case TypeIds.T_double :
	case TypeIds.T_long :
	indexInCurrentLocals++; // next entry is null
	}
	}
	if (indexInPrevLocals < prevLocalsLength && prevLocalsCounter < prevNumberOfLocals) {
	VerificationTypeInfo prevLocal = prevLocals[indexInPrevLocals];
	if (prevLocal != null) {
	prevLocalsCounter++;
	switch(prevLocal.id()) {
	case TypeIds.T_double :
	case TypeIds.T_long :
	indexInPrevLocals++; // next entry is null
	}
	}
	// now we need to check if prevLocal matches with currentLocal
	// the index must be the same
	if (equals(prevLocal, currentLocal) && indexInPrevLocals == indexInCurrentLocals) {
	if (result != 0) {
	result = Integer.MAX_VALUE;
	this.numberOfDifferentLocals = result;
	return result;
	}
	} else {
	// locals at the same location are not equals - this has to be a full frame
	result = Integer.MAX_VALUE;
	this.numberOfDifferentLocals = result;
	return result;
	}
	indexInPrevLocals++;
	continue currentLocalsLoop;
	}
	// process remaining current locals
	if (currentLocal != null) {
	result++;
	} else {
	result = Integer.MAX_VALUE;
	this.numberOfDifferentLocals = result;
	return result;
	}
	indexInCurrentLocals++;
	break currentLocalsLoop;
	}
	if (currentLocalsCounter < currentNumberOfLocals) {
	for(;indexInCurrentLocals < currentLocalsLength && currentLocalsCounter < currentNumberOfLocals; indexInCurrentLocals++) {
	VerificationTypeInfo currentLocal = currentLocals[indexInCurrentLocals];
	if (currentLocal == null) {
	result = Integer.MAX_VALUE;
	this.numberOfDifferentLocals = result;
	return result;
	}
	result++;
	currentLocalsCounter++;
	switch(currentLocal.id()) {
	case TypeIds.T_double :
	case TypeIds.T_long :
	indexInCurrentLocals++; // next entry is null
	}
	}
	} else if (prevLocalsCounter < prevNumberOfLocals) {
	result = -result;
	// process possible remaining prev locals
	for(; indexInPrevLocals < prevLocalsLength && prevLocalsCounter < prevNumberOfLocals; indexInPrevLocals++) {
	VerificationTypeInfo prevLocal = prevLocals[indexInPrevLocals];
	if (prevLocal == null) {
	result = Integer.MAX_VALUE;
	this.numberOfDifferentLocals = result;
	return result;
	}
	result--;
	prevLocalsCounter++;
	switch(prevLocal.id()) {
	case TypeIds.T_double :
	case TypeIds.T_long :
	indexInPrevLocals++; // next entry is null
	}
	}
	}
	}
	this.numberOfDifferentLocals = result;
	return result;
	}
	public int getNumberOfLocals() {
	if (this.numberOfLocals != -1) {
	return this.numberOfLocals;
	}
	int result = 0;
	final int length = this.locals == null ? 0 : this.locals.length;
	for(int i = 0; i < length; i++) {
	if (this.locals[i] != null) {
	switch(this.locals[i].id()) {
	case TypeIds.T_double :
	case TypeIds.T_long :
	i++;
	}
	result++;
	}
	}
	this.numberOfLocals = result;
	return result;
	}
	public int getOffsetDelta(StackMapFrame prevFrame) {
	if (prevFrame == null) return this.pc;
	return prevFrame.pc == -1 ? this.pc : this.pc - prevFrame.pc - 1;
	}
	public String toString() {
	StringBuffer buffer = new StringBuffer();
	printFrame(buffer, this);
	return String.valueOf(buffer);
	}
	private void printFrame(StringBuffer buffer, StackMapFrame frame) {
	String pattern = "[pc : {0} locals: {1} stack items: {2}\nlocals: {3}\nstack: {4}\n]"; //$NON-NLS-1$
	int localsLength = frame.locals == null ? 0 : frame.locals.length;
	buffer.append(MessageFormat.format(
	pattern,
	new String[] {
	Integer.toString(frame.pc),
	Integer.toString(frame.getNumberOfLocals()),
	Integer.toString(frame.numberOfStackItems),
	print(frame.locals, localsLength),
	print(frame.stackItems, frame.numberOfStackItems)
	}
	));
	}
	private String print(VerificationTypeInfo[] infos, int length) {
	StringBuffer buffer = new StringBuffer();
	buffer.append('[');
	if (infos != null) {
	for (int i = 0; i < length; i++) {
	if (i != 0) buffer.append(',');
	VerificationTypeInfo verificationTypeInfo = infos[i];
	if (verificationTypeInfo == null) {
	buffer.append("top"); //$NON-NLS-1$
	continue;
	}
	buffer.append(verificationTypeInfo);
	}
	}
	buffer.append(']');
	return String.valueOf(buffer);
	}
	public void putLocal(int resolvedPosition, VerificationTypeInfo info) {
	if (this.locals == null) {
	this.locals = new VerificationTypeInfo[resolvedPosition + 1];
	this.locals[resolvedPosition] = info;
	} else {
	final int length = this.locals.length;
	if (resolvedPosition >= length) {
	System.arraycopy(this.locals, 0, this.locals = new VerificationTypeInfo[resolvedPosition + 1], 0, length);
	}
	this.locals[resolvedPosition] = info;
	}
	}
	public void replaceWithElementType() {
	VerificationTypeInfo info = this.stackItems[this.numberOfStackItems - 1];
	VerificationTypeInfo info2 = info.duplicate();
	info2.replaceWithElementType();
	this.stackItems[this.numberOfStackItems - 1] = info2;
	}
	public int getIndexOfDifferentLocals(int differentLocalsCount) {
	for (int i = this.locals.length - 1; i >= 0; i--) {
	VerificationTypeInfo currentLocal = this.locals[i];
	if (currentLocal == null) {
	// check the previous slot
	continue;
	} else {
	differentLocalsCount--;
	}
	if (differentLocalsCount == 0) {
	return i;
	}
	}
	return 0;
	}
	private boolean equals(VerificationTypeInfo info, VerificationTypeInfo info2) {
	if (info == null) {
	return info2 == null;
	}
	if (info2 == null) return false;
	return info.equals(info2);
	}
	}