Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
   /*
    * fb-contrib - Auxiliary detectors for Java programs
    * Copyright (C) 2005-2015 Dave Brosius
    *
    * This library is free software; you can redistribute it and/or
    * modify it under the terms of the GNU Lesser General Public
    * License as published by the Free Software Foundation; either
    * version 2.1 of the License, or (at your option) any later version.
    *
   * This library is distributed in the hope that it will be useful,
   * but WITHOUT ANY WARRANTY; without even the implied warranty of
   * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
   * Lesser General Public License for more details.
   *
   * You should have received a copy of the GNU Lesser General Public
   * License along with this library; if not, write to the Free Software
   * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
   */
  package com.mebigfatguy.fbcontrib.detect;
  
  import java.util.Arrays;
  import java.util.BitSet;
  import java.util.HashMap;
  import java.util.HashSet;
  import java.util.Map;
  import java.util.Set;
  
  
  
looks for silly bugs that are simple but do not fit into one large pattern.
  
  public class SillynessPotPourri extends BytecodeScanningDetector
  {
  	private static final Set<StringcollectionInterfaces = new HashSet<String>();
  	static {
  		.add("java/util/Collection");
  		.add("java/util/List");
  		.add("java/util/Set");
  		.add("java/util/SortedSet");
  		.add("java/util/Map");
  		.add("java/util/SortedMap");
  	}
  	private static final Set<StringoddMissingEqualsClasses = new HashSet<String>();
  	static {
  		.add("java.lang.StringBuffer");
  		.add("java.lang.StringBuilder");
  	}
  
  	private static final String LITERAL = "literal";
  	private static final Pattern APPEND_PATTERN = Pattern.compile("append:([0-9]+):(.*)");
  
  	private static JavaClass calendarClass;
  	static {
  		try {
  			 = Repository.lookupClass("java/util/Calendar");
  		} catch (ClassNotFoundException cnfe) {
  			 = null;
  		}
  	}
  
  	static {
  		.put("toLowerCase()Ljava/lang/String;".);
  		.put("toUpperCase()Ljava/lang/String;".);
  		.put("toLowerCase(Ljava/util/Locale;)Ljava/lang/String;".);
 		.put("toUpperCase(Ljava/util/Locale;)Ljava/lang/String;".);
 		.put("trim()Ljava/lang/String;".);
 	}
 
 	private final BugReporter bugReporter;
 	private final Set<StringtoStringClasses;
 	private OpcodeStack stack;
 	private int lastPCs[];
 	private int lastOpcode;
 	private int lastReg;
 	private boolean lastIfEqWasBoolean;
 	private boolean lastLoadWasString;
branch targets, to a set of branch instructions
 
 	private Set<StringstaticConstants;

constructs a SPP detector given the reporter to report bugs on

Parameters:
bugReporter the sync of bug reports
 
 	public SillynessPotPourri(BugReporter bugReporter) {
 		this. = bugReporter;
 	}
 
 	public void visitField(Field field) {
 		if ("serialVersionUID".equals(field.getName())
 				&&  ((field.getAccessFlags() & ) != 0)
 				&&  ((field.getAccessFlags() & ) == 0)) {
 			.addClass(this)
 			.addField(this));
 		}
 	}
 
 	public void visitClassContext(ClassContext classContext) {
 		try {
 			 = new OpcodeStack();
 			 = new int[4];
 			super.visitClassContext(classContext);
 		} finally {
 			 = null;
 			 = null;
 			 = null;
 			 = null;
 		}
 	}

implements the visitor to reset the opcode stack

Parameters:
obj the context object for the currently parsed Code
 
 	public void visitCode(Code obj) {
 		 = -1;
 		 = -1;
 		 = false;
 		 = false;
 		Arrays.fill(, -1);
 		super.visitCode(obj);
 	}

implements the visitor to look for various silly bugs

Parameters:
seen the opcode of the currently parsed instruction
 
 	public void sawOpcode(int seen) {
 		int reg = -1;
 		String userValue = null;
 		try {
 
 			if (isBranchByteCode(seen)) {
 				Integer branchTarget = Integer.valueOf(getBranchTarget());
 				BitSet branchInsSet = .get(branchTarget);
 				if (branchInsSet == null)
 				{
 					branchInsSet = new BitSet();
 					.put(branchTargetbranchInsSet);
 				}
 				branchInsSet.set(getPC());
 			}
 			//not an else if, because some of the opcodes in the previous branch also matter here.
 			if ((seen == ) || (seen == ) || (seen == )) {
 			}
 			//see above, several opcodes hit multiple branches.
 			if ((seen == ) || (seen == ) || (seen == )) {
 			}
 			
 			if (seen == ) {
 			}
 
 			if (seen == ) {
 			} else if (seen == ) {
 			} else if ((seen == ) && ) {
 			} else if (seen == ) {
 			} else if (seen == ) {
 			} else if (seen == ) {
 			} else if (OpcodeUtils.isAStore(seen)) {
 				reg = RegisterUtils.getAStoreReg(thisseen);
 			} else if (OpcodeUtils.isALoad(seen)) {
 				sawLoad(seen);
 			} else if ((seen >= ) && (seen <= )) {
 				userValue = sawIntConst(userValue);
 			} else if (seen == ) {
 			} else if (seen == ) {
 				userValue = sawInvokeStatic(userValue);
 			} else if (seen == ) {
 				userValue = sawInvokeVirtual(userValue);
 			} else if (seen == ) {
 			} else if (seen == ) {
 				userValue = sawInvokeInterface(userValue);
 			}
 		} catch (ClassNotFoundException cnfe) {
 		} finally {
 			TernaryPatcher.pre(seen);
 			.sawOpcode(thisseen);
 			TernaryPatcher.post(seen);
 			if ((.getStackDepth() > 0)) {
 				if (userValue != null) {
 					item.setUserValue(userValue);
 				} else if ("iterator".equals(item.getUserValue()) && (seen == ) || (seen == ) || ((seen >= ) && (seen <= ))) {
 					item.setUserValue(null);
 				}
 			}
 
 			 = seen;
 			 = reg;
 			System.arraycopy(, 1, , 0, 3);
 			[3] = getPC();
 		}
 	}
 
 	private void checkImproperToCharArrayUse() {
 		if (.getStackDepth() > 0) {
 			String ic = (String)item.getUserValue();
 			if ("iconst".equals(ic)) {
 				.addClass(this)
 				.addMethod(this)
 				.addSourceLine(this));
 			}
 		}
 	}
 
 	private String sawIntConst(String userValue) {
 		if (.getStackDepth() > 0) {
 			String tca = (String)item.getUserValue();
 			if ("toCharArray".equals(tca)) {
 				userValue = "iconst";
 			}
 		}
 		return userValue;
 	}
 
 	private void sawLoad(int seen) {
 		 = false;
 		if (lvt != null) {
 			LocalVariable lv = LVTHelper.getLocalVariableAtPC(lvt, RegisterUtils.getALoadReg(thisseen), getPC());
 			if (lv != null) {
 				 = "Ljava/lang/String;".equals(lv.getSignature());
 			}
 		}
 	}
 
 	private void checkStutterdAssignment(int seenint reg) {
 		if (seen ==  && reg == ) {
 				.addClass(this)
 				.addMethod(this)
 				.addSourceLine(this));
 		}
 	}
 
 	private void checkImmutableUsageOfStringBuilder(int reg) {
 		if (.getStackDepth() > 0) {
 			String mName = (Stringitem.getUserValue();
 			if (mName != null) {
 				if ("trim".equals(mName)) {
 					item.setUserValue(null);
 				} else {
 					if (m.matches()) {
 						int appendReg = Integer.parseInt(m.group(1));
 						if (reg == appendReg) {
 							.addClass(this)
 							.addMethod(this)
 							.addSourceLine(this));
 						}
 					}
 				}
 			}
 		}
 	}
 
 	private void checkCompareToNaNFloat() {
 		if (.getStackDepth() > 1) {
 			Float f1 = (Float)item.getConstant();
 			item = .getStackItem(1);
 			Float f2 = (Float)item.getConstant();
 
 			if (((f1 != null) && f1.isNaN()) || ((f2 != null) && f2.isNaN())) {
 				.addClass(this)
 				.addMethod(this)
 				.addString("float")
 				.addString("Float"));
 			}
 		}
 	}
 
 	private void checkCompareToNaNDouble() {
 		if (.getStackDepth() > 1) {
 			Double d1 = (Double)item.getConstant();
 			item = .getStackItem(1);
 			Double d2 = (Double)item.getConstant();
 
 			if (((d1 != null) && d1.isNaN()) || ((d2 != null) && d2.isNaN())) {
 				.addClass(this)
 				.addMethod(this)
 				.addString("double")
 				.addString("Double"));
 			}
 		}
 	}
 
 		if (con instanceof ConstantDouble) {
 			double d = ((ConstantDoublecon).getBytes();
 			double piDelta = Math.abs(d - .);
 			double eDelta = Math.abs(d - .);
 
 			if (((piDelta > 0.0) && (piDelta < 0.002))
 					||  ((eDelta > 0.0) && (eDelta < 0.002))) {
 				.addClass(this)
 				.addMethod(this)
 				.addSourceLine(this));
 			}
 		}
 	}
 
 	private void checkForUselessTernaryReturn() {
 		byte[] bytes = getCode().getCode();
 		if (([0] != -1)
 				&&  ((0x00FF & bytes[[3]]) == )
 				&&  ((0x00FF & bytes[[2]]) == )
 				&&  ((0x00FF & bytes[[1]]) == )
 				&&  ((0x00FF & bytes[[0]]) == )) {
 			if (getMethod().getSignature().endsWith("Z")) {
 				boolean bug = true;
 				BitSet branchInsSet = .get(Integer.valueOf([1]));
 				if (branchInsSet != null)
 				{
 					bug = false;
 				}
 				branchInsSet = .get(Integer.valueOf([3]));
 				if ((branchInsSet != null) && (branchInsSet.cardinality() > 1))
 				{
 					bug = false;
 				}
 
 				if (bug) {
 					.addClass(this)
 					.addMethod(this)
 					.addSourceLine(this));
 				}
 			}
 		}
 	}
 
 	private void checkEqualsStringBufferLength() {
 		if (.getStackDepth() > 0) {
 		}
 
 		byte[] bytes = getCode().getCode();
 		if ([1] != -1) {
 			if (CodeByteUtils.getbyte(bytes[3]) == ) {
 				int loadIns = CodeByteUtils.getbyte(bytes[2]);
 				if  (((loadIns == ) || (loadIns == ))
 						&&  (CodeByteUtils.getbyte(bytes[1]) == )) {
 					int toStringIndex = CodeByteUtils.getshort(bytes[1]+1);
 					Constant cmr = pool.getConstant(toStringIndex);
 					if (cmr instanceof ConstantMethodref) {
 						ConstantMethodref toStringMR = (ConstantMethodref)cmr;
 						String toStringCls = toStringMR.getClass(pool);
 						if (toStringCls.startsWith("java.lang.&&StringBu")) {
 							int consIndex = CodeByteUtils.getbyte(bytes[2]+1);
 							Constant c = pool.getConstant(consIndex);
 							if (c instanceof ConstantString) {
 								if ("".equals(((ConstantStringc).getBytes(pool))) {
 									int nandtIndex = toStringMR.getNameAndTypeIndex();
 									if ("toString".equals(cnt.getName(pool))) {
 										int lengthIndex = CodeByteUtils.getshort(bytes[3]+1);
 										ConstantMethodref lengthMR = (ConstantMethodref)pool.getConstant(lengthIndex);
 										nandtIndex = lengthMR.getNameAndTypeIndex();
 										cnt = (ConstantNameAndType)pool.getConstant(nandtIndex);
 										if ("equals".equals(cnt.getName(pool))) {
 											.addClass(this)
 											.addMethod(this)
 											.addSourceLine(this));
 										}
 									}
 								}
 							}
 						}
 					}
 				}
 			}
 		}
 	}
 
 		byte[] bytes = getCode().getCode();
 		if ([2] != -1) {
 			if ((CodeByteUtils.getbyte(bytes[3]) == )
 					&&  (CodeByteUtils.getbyte(bytes[2]) == )) {
 				int toStringIndex = CodeByteUtils.getshort(bytes[2]+1);
 				ConstantMethodref toStringMR = (ConstantMethodref)pool.getConstant(toStringIndex);
 				String toStringCls = toStringMR.getClass(pool);
 				if (toStringCls.startsWith("java.lang.StringBu")) {
 					int nandtIndex = toStringMR.getNameAndTypeIndex();
 					if ("toString".equals(cnt.getName(pool))) {
 						int lengthIndex = CodeByteUtils.getshort(bytes[3]+1);
 						ConstantMethodref lengthMR = (ConstantMethodref)pool.getConstant(lengthIndex);
 						nandtIndex = lengthMR.getNameAndTypeIndex();
 						cnt = (ConstantNameAndType)pool.getConstant(nandtIndex);
 						if ("length".equals(cnt.getName(pool))) {
 							.addClass(this)
 							.addMethod(this)
 							.addSourceLine(this));
 						}
 					}
 				}
 			}
 		}
 	}
 
 	private void checkNullAndInstanceOf() {
 		byte[] bytes = getCode().getCode();
 		if (([0] != -1) && (CodeByteUtils.getbyte(bytes[1]) == ) && (CodeByteUtils.getbyte(bytes[3]) == )) {
 			int ins0 = CodeByteUtils.getbyte(bytes[0]);
 			if ((ins0 == ) || (ins0 == ) || (ins0 == ) || (ins0 == ) || (ins0 == )) {
 				int ins2 = CodeByteUtils.getbyte(bytes[0]);
 				if (ins0 == ins2) {
 					if ((ins0 != ) || (CodeByteUtils.getbyte(bytes[0] + 1) == CodeByteUtils.getbyte(bytes[2] + 1))) {
 						int ifNullTarget = [1] + CodeByteUtils.getshort(bytes[1]+1);
 						if (ifNullTarget == getBranchTarget()) {
 							.addClass(this)
 							.addMethod(this)
 							.addSourceLine(this));
 						}
 					}
 				}
 			}
 		}
 	}
 
 	private void checkSizeEquals0() {
 		if (.getStackDepth() == 1) {
 			if ("size".equals(item.getUserValue())) {
 				.addClass(this)
 				.addMethod(this)
 				.addSourceLine(this));
 			}
 		}
 	}
 
 	private void checkForEmptyStringAndNullChecks(int seen) {
 		if ( && ([0] != -1)) {
 			byte[] bytes = getCode().getCode();
 			int loadIns = CodeByteUtils.getbyte(bytes[2]);
 			int brOffset = (loadIns == ) ? 11 : 10;
 
 			if ((((loadIns >= ) && (loadIns <= )) || (loadIns == ))
 					&&  (CodeByteUtils.getbyte(bytes[3]) == )
 					&&  (CodeByteUtils.getbyte(bytes[2]) == loadIns)
 					&&  (CodeByteUtils.getbyte(bytes[1]) == )
 					&&  (CodeByteUtils.getbyte(bytes[0]) == loadIns)
 					&&  ((loadIns != ) || (CodeByteUtils.getbyte(bytes[2]+1) == CodeByteUtils.getbyte(bytes[0]+1)))
 					&&  ((seen == ) ? CodeByteUtils.getshort(bytes[1]+1) > brOffset : CodeByteUtils.getshort(bytes[1]+1) == brOffset)) {
 				int nextOp = CodeByteUtils.getbyte(bytesgetNextPC());
 				if ((nextOp != ) && (nextOp != )) {
 					int mpoolIndex = CodeByteUtils.getshort(bytes[3]+1);
 					ConstantMethodref cmr = (ConstantMethodref)pool.getConstant(mpoolIndex);
 					int nandtIndex = cmr.getNameAndTypeIndex();
 					if ("length".equals(cnt.getName(pool))) {
 						.addClass(this)
 						.addMethod(this)
 						.addSourceLine(this));
 					}
 				}
 			}
 		}
 	}
 
 	private static boolean isBranchByteCode(int seen) {
 		return ((seen >= ) && (seen <= )) || (seen == ) || (seen == ) || (seen == );
 	}
 
 	private String sawInvokeStatic(String userValue) {
 		String className = getClassConstantOperand();
 		String methodName = getNameConstantOperand();
 		if ("java/lang/System".equals(className)) {
 			if ("getProperties".equals(methodName)) {
 				userValue = "getProperties";
 			} else if ("arraycopy".equals(methodName)) {
 				if (.getStackDepth() >= 5) {
 					String sig = item.getSignature();
 					if ((sig.charAt(0) != '[') && !"Ljava/lang/Object;".equals(sig)) {
 						.addClass(this)
 						.addMethod(this)
 						.addSourceLine(this));
 					}
 					item = .getStackItem(4);
 					sig = item.getSignature();
 					if ((sig.charAt(0) != '[') && !"Ljava/lang/Object;".equals(sig)) {
 						.addClass(this)
 						.addMethod(this)
 						.addSourceLine(this));
 					}
 				}
 			}
 		} else if ("java/lang/reflect/Array".equals(className)) {
 			int offset = -1;
 			if ("getLength".equals(methodName)) {
 				offset = 0;
 			} else if (methodName.startsWith("get")) {
 				offset = 1;
 			} else if (methodName.startsWith("set")) {
 				offset = 2;
 			}
 			if (offset >= 0) {
 				if (.getStackDepth() > offset) {
 					OpcodeStack.Item item = .getStackItem(offset);
 					String sig = item.getSignature();
 					if ((sig.charAt(0) != '[') && !"Ljava/lang/Object;".equals(sig)) {
 						.addClass(this)
 						.addMethod(this)
 						.addSourceLine(this));
 					}
 				}
 			}
 		} else if ("java/lang/String".equals(className)) {
 			if ("format".equals(methodName)) {
 				String format = (Stringitem.getConstant();
 				if ((format != null) && !format.contains("%")) {
 								.addClass(this)
 								.addMethod(this)
 								.addSourceLine(this));
 				}
 			}
 		}
 		return userValue;
 	}
 
 	private String sawInvokeVirtual(String userValuethrows ClassNotFoundException {
 		String className = getClassConstantOperand();
 		String methodName = getNameConstantOperand();
 		if ("java/util/BitSet".equals(className)) {
 			bitSetSilliness(methodName);
 		} else if ("java/lang/StringBuilder".equals(className) || "java/lang/StringBuffer".equals(className)) {
 			userValue = stringBufferSilliness(userValuemethodName);
 		} else if ("java/lang/String".equals(className)) {
 			userValue = stringSilliness(userValuemethodNamegetSigConstantOperand());
 		} else if ("equals(Ljava/lang/Object;)Z".equals(methodName + getSigConstantOperand())) {
 			equalsSilliness(className);      	
 		} else if ("java/lang/Boolean".equals(className) && "booleanValue".equals(methodName)) {
 		} else if (("java/util/GregorianCalendar".equals(className) || "java/util/Calendar".equals(className))
 				&&      ("after".equals(methodName) || "before".equals(methodName))) {
 		} else if ("java/util/Properties".equals(className)) {
 			propertiesSilliness(methodName);
 		} else if ("toString".equals(methodName) && "java/lang/Object".equals(className)) {
 		}
 		return userValue;
 	}
 
 	private void bitSetSilliness(String methodName) {
 		if ("clear".equals(methodName)
 				||  "flip".equals(methodName)
 				||  "get".equals(methodName)
 				||  "set".equals(methodName)) {
 			if (.getStackDepth() > 0) {
 				Object o =item.getConstant();
 				if (o instanceof Integer) {
 					if (((Integero).intValue() < 0) {
 						.addClass(this)
 						.addMethod(this)
 						.addSourceLine(this));
 					}
 				}
 			}
 		}
 	}
 
 	private String stringBufferSilliness(String userValueString methodName) {
 		if ("append".equals(methodName)) {
 			if (.getStackDepth() > 1) {
 				Object constant = valItem.getConstant();
 				boolean argIsLiteralString = (constant instanceof String) && (((Stringconstant).length() > 0);
 				argIsLiteralString = argIsLiteralString && !looksLikeStaticFieldValue((Stringconstant);
 
 				if (argIsLiteralString) {
 					String existingAppend = (StringsbItem.getUserValue();
 					if (existingAppend != null) {
 						Matcher m = .matcher(existingAppend);
 						if (m.matches() && .equals(m.group(2))) {
 							.addClass(this)
 							.addMethod(this)
 							.addSourceLine(this));
 							argIsLiteralString = false;
 						}
 					}
 				}
 
 				String literal = argIsLiteralString ?  : "";
 				if (sbItem.getRegisterNumber() > -1) {
 					userValue = "append:" + sbItem.getRegisterNumber() + ':' + literal;
 				} else {
 					userValue = (StringsbItem.getUserValue();
 					if (userValue != null) {
 						Matcher m = .matcher(userValue);
 						if (m.matches()) {
 							userValue = "append:" + m.group(1) + ':' + literal;
 						}
 					}
 				}
 			}
 		}
 		return userValue;
 	}
 
 	private String stringSilliness(String userValueString methodNameString signature) {
 
 		Integer stackOffset = .get(methodName + signature);
 		if (stackOffset != null) {
 			if (.getStackDepth() > stackOffset.intValue()) {
 			
 				OpcodeStack.Item itm = .getStackItem(stackOffset.intValue());
 				Object constant = itm.getConstant();
 				if ((constant != null) && constant.getClass().equals(String.class) && (itm.getXField() == null)) {
 					int priority = ;
 					if (Type.getArgumentTypes(getSigConstantOperand()).length > 0) {
 						//if an argument is passed in, it may be locale-specific
 						priority = ;
 					}
 					.addClass(this)
 					.addMethod(this)
 					.addCalledMethod(this));
 				}
 			}
 		} 
 		//not an elseif because the below cases might be in the set methodsThatAreSillyOnStringLiterals
 		if ("intern".equals(methodName)) {
 			String owningMethod = getMethod().getName();
 			if (!..equals(owningMethod))
 			{
 				if (.getStackDepth() > 0) {
 					if (item.getConstant() != null) {
 						.addClass(this)
 						.addMethod(this)
 						.addSourceLine(this));
 					}
 				}
 			}
 		} 
 		else if ("toCharArray".equals(methodName)) {
 			userValue = "toCharArray";
 		} else if ("toLowerCase".equals(methodName) ||  "toUpperCase".equals(methodName)) {
 			userValue = "IgnoreCase";
 		} else if ("equalsIgnoreCase".equals(methodName) || "compareToIgnoreCase".equals(methodName)) {
 			if (.getStackDepth() > 1) {
 				if ("IgnoreCase".equals(item.getUserValue())) {
 					.addClass(this)
 					.addMethod(this)
 					.addSourceLine(this));
 				}
 				item = .getStackItem(0);
 				String parm = (String)item.getConstant();
 				if ("".equals(parm)) {
 					.addClass(this)
 					.addMethod(this)
 					.addSourceLine(this));
 				}
 			}
 		} else if ("trim".equals(methodName)) {
 			userValue = "trim";
 		} else if ("length".equals(methodName)) {
 			if (.getStackDepth() > 0) {
 				if ("trim".equals(item.getUserValue())) {
 					.addClass(this)
 					.addMethod(this)
 					.addSourceLine(this));
 				}
 			}
 		} else if ("equals".equals(methodName)) {
 			if (.getStackDepth() > 1) {
 				if ("trim".equals(item.getUserValue())) {
 					.addClass(this)
 					.addMethod(this)
 					.addSourceLine(this));
 				}
 			}
 		}
 		else if ("toString".equals(methodName)) {
 			.addClass(this)
 			.addMethod(this)
 			.addSourceLine(this));
 		}
 		return userValue;
 	}
 
 	private void equalsSilliness(String className) {
 		try {
 			JavaClass cls = Repository.lookupClass(className);
 			if (cls.isEnum()) {
 				.addClass(this)
 				.addMethod(this)
 				.addSourceLine(this));
 			} else {
 				if (.getStackDepth() >= 2) {
 					cls = item.getJavaClass();
 					if (cls != null) {
 						String clsName = cls.getClassName();
 							.addClass(this)
 							.addMethod(this)
 							.addSourceLine(this));
 						}
 					}
 				}
 			}
 		} catch (ClassNotFoundException cnfe) {
 		}     
 	}
 
 	private void booleanSilliness() {
 		if ([0] != -1) {
 			int range1Size = [2] - [0];
 			if (range1Size == (getNextPC() - [3])) {
 				byte[] bytes = getCode().getCode();
 				int ifeq = 0x000000FF & bytes[[2]];
 				if (ifeq == ) {
 					int start1 = [0];
 					int start2 = [3];
 					boolean found = true;
 					for (int i = 0; i < range1Sizei++) {
 						if (bytes[start1+i] != bytes[start2+i]) {
 							found = false;
 							break;
 						}
 					}
 
 					if (found) {
 						.addClass(this)
 						.addMethod(this)
 						.addSourceLine(this));
 					}
 				}
 			}
 		}
 	}
 
 	private void calendarBeforeAfterSilliness() {
 		if (.getStackDepth() > 1) {
 			String itemSig = item.getSignature();
 			//Rule out java.lang.Object as mergeJumps can throw away type info (BUG)
 			if (!"Ljava/lang/Object;".equals(itemSig) && !"Ljava/util/Calendar;".equals(itemSig) && !"Ljava/util/GregorianCalendar;".equals(itemSig)) {
 				try {
 					JavaClass cls = Repository.lookupClass(itemSig.substring(1, itemSig.length() - 1));
 					if (!cls.instanceOf()) {
 						.addClass(this)
 						.addMethod(this)
 						.addSourceLine(this));
 					}
 				} catch (ClassNotFoundException cnfe) {
 				}
 
 			}
 		}
 	}
 
 	private void defaultToStringSilliness() throws ClassNotFoundException {
 		if (.getStackDepth() >= 1) {
 			JavaClass toStringClass = item.getJavaClass();
 			if (toStringClass != null) {
 				String toStringClassName = toStringClass.getClassName();
 				if (!toStringClass.isInterface() && !toStringClass.isAbstract() && !"java.lang.Object".equals(toStringClassName) && !"java.lang.String".equals(toStringClassName) && .add(toStringClassName)) {
 					try {
 						JavaClass cls = Repository.lookupClass(toStringClassName);
 						
 						if (!hasToString(cls)) {
 							.addClass(this)
 							.addMethod(this)
 							.addSourceLine(this));
 						}
 					} catch (ClassNotFoundException cnfe) {
 					}
 				}
 			}
 		}
 	}
 
 	private void propertiesSilliness(String methodName) {
 		if (("get".equals(methodName) || "getProperty".equals(methodName))) {
 			if (.getStackDepth() > 1) {
 				if ("getProperties".equals(item.getUserValue())) {
 					.addClass(this)
 					.addMethod(this)
 					.addSourceLine(this));
 				}
 			}
 		}
 	}
 
 	private String sawInvokeInterface(String userValue) {
 		String className = getClassConstantOperand();
 		if ("java/util/Map".equals(className)) {
 			if ("keySet".equals(method)) {
 				userValue = "keySet";
 			}
 		} else if ("java/util/Set".equals(className)) {
 			if ("contains".equals(method)) {
 				if (.getStackDepth() >= 2) {
 					if ("keySet".equals(item.getUserValue())) {
 						.addClass(this)
 						.addMethod(this)
 						.addSourceLine(this));
 					}
 				}
 			}
 		} else if ("java/util/List".equals(className)) {
 			if ("iterator".equals(method)) {
 				userValue = "iterator";
 			}
 		} else if ("java/util/Iterator".equals(className)) {
 			if ("next".equals(method)) {
 				if (.getStackDepth() >= 1) {
 					if ("iterator".equals(item.getUserValue())) {
 						.addClass(this)
 						.addMethod(this)
 						.addSourceLine(this));
 					}
 				}
 			}
 		}
 
 		if (.contains(className)) {
 			if ("size".equals(method)) {
 				userValue = "size";
 			}
 		}
 		return userValue;
 	}
 
 	private void sawInvokeSpecial() {
 		String className = getClassConstantOperand();
 		if ("java/lang/StringBuffer".equals(className)
 				||  "java/lang/StringBuilder".equals(className)) {
 			String methodName = getNameConstantOperand();
 			if (..equals(methodName)) {
 				String signature = getSigConstantOperand();
 				if ("(I)V".equals(signature)) {
 					if ( == ) {
 						if (.getStackDepth() > 0) {
 							Object o = item.getConstant();
 							if (o instanceof Integer) {
 								int parm = ((Integero).intValue();
 								if ((parm > 32)
 										&&  (parm < 127)
 										&&  (parm != 64)
 										&&  ((parm % 10) != 0)
 										&&  ((parm % 5) != 0)) {
 									.addClass(this)
 									.addMethod(this)
 									.addSourceLine(this));