How to use

v

method

in

soot.NullType

public Type getType() {
 return NullType.v();
}

public Type getType() {
 return NullType.v();
}

public Type getType() {
 return NullType.v();
}

public void outANullBaseType(ANullBaseType node) {
 mProductions.addLast(NullType.v());
}

public void outANullBaseTypeNoName(ANullBaseTypeNoName node) {
 mProductions.addLast(NullType.v());
}

@Override
public Local createZeroValue() {
 return new JimpleLocal("<<zero>>", NullType.v());
}

@Override
public Local createZeroValue() {
 return new JimpleLocal("zero", NullType.v());
}

public Value createZeroValue() {
 return new JimpleLocal("<<zero>>", NullType.v());
}

@SuppressWarnings("unchecked")
public ArrayTypes getArrayTypesBefore(Stmt s, Local arrayLocal) {
 if (!isConstantBefore(s, arrayLocal)) {
  return null;
 }
 ArrayTypes toRet = new ArrayTypes();
 int varRef = localToInt.get(arrayLocal);
 ArrayTypesInternal ati = getFlowBefore(s).state[varRef];
 toRet.possibleSizes = new HashSet<Integer>();
 toRet.possibleTypes = new Set[ati.typeState.length];
 for (int i = ati.sizeState.nextSetBit(0); i >= 0; i = ati.sizeState.nextSetBit(i + 1)) {
  toRet.possibleSizes.add(rvSizeToInt.get(i));
 }
 for (int i = 0; i < toRet.possibleTypes.length; i++) {
  toRet.possibleTypes[i] = new HashSet<Type>();
  for (int j = ati.typeState[i].nextSetBit(0); j >= 0; j = ati.typeState[i].nextSetBit(j + 1)) {
   toRet.possibleTypes[i].add(rvTypeToInt.get(j));
  }
  if (!ati.mustAssign.get(i)) {
   toRet.possibleTypes[i].add(NullType.v());
  }
 }
 return toRet;
}

public Pair<Value, Set<DefinitionStmt>> createZeroValue() {
 return new Pair<Value, Set<DefinitionStmt>>(new JimpleLocal("<<zero>>", NullType.v()),
   Collections.<DefinitionStmt>emptySet());
}

private Type getTargetType(final Value other) {
 if (other instanceof Constant) {
  if (other.getType() != NullType.v()) {
   return other.getType();
  }
 } else if (other instanceof Local) {
  Type tgTp = tg.get((Local) other);
  if (tgTp instanceof PrimType) {
   return tgTp;
  }
 }
 return null;
}

if (reachingTypes.contains(NullType.v())) {
 return true;

public Type getType() {
 Value base = baseBox.getValue();
 Type type = base.getType();
 if (type.equals(UnknownType.v())) {
  return UnknownType.v();
 } else if (type.equals(NullType.v())) {
  return NullType.v();
 } else {
  // use makeArrayType on non-array type references when they propagate to this point.
  // kludge, most likely not correct.
  // may stop spark from complaining when it gets passed phantoms.
  // ideally I'd want to find out just how they manage to get this far.
  ArrayType arrayType;
  if (type instanceof ArrayType) {
   arrayType = (ArrayType) type;
  } else {
   arrayType = (ArrayType) type.makeArrayType();
  }
  if (arrayType.numDimensions == 1) {
   return arrayType.baseType;
  } else {
   return ArrayType.v(arrayType.baseType, arrayType.numDimensions - 1);
  }
 }
}

private ClassHierarchy(Scene scene) {
 if (scene == null) {
  throw new InternalTypingException();
 }
 G.v().ClassHierarchy_classHierarchyMap.put(scene, this);
 NULL = typeNode(NullType.v());
 OBJECT = typeNode(RefType.v("java.lang.Object"));
 // hack for J2ME library which does not have Cloneable and Serializable
 // reported by Stephen Chen
 if (!Options.v().j2me()) {
  CLONEABLE = typeNode(RefType.v("java.lang.Cloneable"));
  SERIALIZABLE = typeNode(RefType.v("java.io.Serializable"));
 } else {
  CLONEABLE = null;
  SERIALIZABLE = null;
 }
 INT = typeNode(IntType.v());
}

 lop = resolver.typeVariable(LongType.v());
} else if (lv instanceof NullConstant) {
 lop = resolver.typeVariable(NullType.v());
} else if (lv instanceof StringConstant) {
 lop = resolver.typeVariable(RefType.v("java.lang.String"));
 rop = resolver.typeVariable(LongType.v());
} else if (rv instanceof NullConstant) {
 rop = resolver.typeVariable(NullType.v());
} else if (rv instanceof StringConstant) {
 rop = resolver.typeVariable(RefType.v("java.lang.String"));

 lop = resolver.typeVariable(LongType.v());
} else if (lv instanceof NullConstant) {
 lop = resolver.typeVariable(NullType.v());
} else if (lv instanceof StringConstant) {
 lop = resolver.typeVariable(RefType.v("java.lang.String"));
 rop = resolver.typeVariable(LongType.v());
} else if (rv instanceof NullConstant) {
 rop = resolver.typeVariable(NullType.v());
} else if (rv instanceof StringConstant) {
 rop = resolver.typeVariable(RefType.v("java.lang.String"));

 lop = hierarchy.typeNode(LongType.v());
} else if (lv instanceof NullConstant) {
 lop = hierarchy.typeNode(NullType.v());
} else if (lv instanceof StringConstant) {
 lop = hierarchy.typeNode(RefType.v("java.lang.String"));
 rop = hierarchy.typeNode(LongType.v());
} else if (rv instanceof NullConstant) {
 rop = hierarchy.typeNode(NullType.v());
} else if (rv instanceof StringConstant) {
 rop = hierarchy.typeNode(RefType.v("java.lang.String"));

 lop = hierarchy.typeNode(LongType.v());
} else if (lv instanceof NullConstant) {
 lop = hierarchy.typeNode(NullType.v());
} else if (lv instanceof StringConstant) {
 lop = hierarchy.typeNode(RefType.v("java.lang.String"));
 rop = hierarchy.typeNode(LongType.v());
} else if (rv instanceof NullConstant) {
 rop = hierarchy.typeNode(NullType.v());
} else if (rv instanceof StringConstant) {
 rop = hierarchy.typeNode(RefType.v("java.lang.String"));

 TypeVariable.error("Type Error(6):  Array variable without base type");
} else if (element.type().type() instanceof NullType) {
 local.setType(NullType.v());
} else {
 Type t = element.type().type();

 TypeVariableBV.error("Type Error(6):  Array variable without base type");
} else if (element.type().type() instanceof NullType) {
 local.setType(NullType.v());
} else {
 Type t = element.type().type();