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();