/** Returns a textual (and quoted as needed) representation of this type for serialization, e.g. to .jimple format */ public String toQuotedString() { return toString(); }
/** * Creates an ArrayType parametrized by a given Type and dimension count. * * @param baseType * a Type to parametrize the ArrayType * @param numDimensions * the dimension count to parametrize the ArrayType. * @return an ArrayType parametrized accrodingly. */ public static ArrayType v(Type baseType, int numDimensions) { if (numDimensions < 0) { throw new RuntimeException("Invalid number of array dimensions: " + numDimensions); } int orgDimensions = numDimensions; Type elementType = baseType; while (numDimensions > 0) { ArrayType ret = elementType.getArrayType(); if (ret == null) { ret = new ArrayType(baseType, orgDimensions - numDimensions + 1); elementType.setArrayType(ret); } elementType = ret; numDimensions--; } return (ArrayType) elementType; }
public void printAssign(String v, Type t) { String oldName = varName; varName = v; t.apply(this); varName = oldName; }
t_ = t_.makeArrayType();
FieldRef ref = s.getFieldRef(); if ((ref instanceof StaticFieldRef) && (Type.toMachineType(((StaticFieldRef) ref).getType()) instanceof RefLikeType)) { isMethodPure = false; // kills purity isMethodConditionallyPure = false; // kills conditional purity while (paramTypesIt.hasNext()) { Type paramType = (Type) paramTypesIt.next(); if (Type.toMachineType(paramType) != IntType.v()) { isMethodPure = false; // kills purity return;
targetType = TypeUtils.buildArrayOrAddDimension(targetType, arrayRef.getType().getArrayType());
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); } } }
DefinitionStmt astmt = (DefinitionStmt) u; if (!(astmt.getRightOp() instanceof CaughtExceptionRef)) { Type leftType = Type.toMachineType(astmt.getLeftOp().getType()); Type rightType = Type.toMachineType(astmt.getRightOp().getType()); } else { for (int i = 0; i < iexpr.getArgCount(); i++) { checkCopy(stmt, body, exception, Type.toMachineType(called.parameterType(i)), Type.toMachineType(iexpr.getArg(i).getType()), " in argument " + i + " of call" + errorSuffix + " (Note: Parameters are zero-indexed)");
if (leftValue instanceof ArrayRef) { ArrayRef arrayRef = (ArrayRef) leftValue; newType = TypeUtils.buildArrayOrAddDimension(newType, arrayRef.getType().getArrayType()); } else if (defStmt.getRightOp() instanceof ArrayRef) { newType = ((ArrayType) newType).getElementType(); ArrayRef arrayRef = (ArrayRef) defStmt.getRightOp(); targetType = TypeUtils.buildArrayOrAddDimension(targetType, arrayRef.getType().getArrayType()); } else if (leftValue instanceof ArrayRef) { assert source.getAccessPath().getBaseType() instanceof ArrayType;
@Override public String toString() { return type.toString() + "(" + id + ")"; }
/** Transform boolean, byte, short and char into int. **/ Type toInt(Type type) { type.apply(this); return result; }
/** * Creates an ArrayType parametrized by a given Type and dimension count. * @param baseType a Type to parametrize the ArrayType * @param numDimensions the dimension count to parametrize the ArrayType. * @return an ArrayType parametrized accrodingly. */ public static ArrayType v(Type baseType, int numDimensions) { if( numDimensions < 1 ) throw new RuntimeException( "attempt to create array with "+numDimensions+" dimensions" ); ArrayType ret; Type elementType; if( numDimensions == 1 ) { elementType = baseType; } else { elementType = ArrayType.v( baseType, numDimensions-1 ); } ret = elementType.getArrayType(); if( ret == null ) { ret = new ArrayType(baseType, numDimensions); elementType.setArrayType( ret ); } return ret; }
} else { for (Type t : ts) { r.add(t.makeArrayType());
Local l = Jimple.v().newLocal(newName, Type.toMachineType(v.getType()));
private String getBaseTypeString() { return baseType.toString(); }
/** Create a new TypeNode instance for the type parameter. **/ TypeNode typeNode(int id, Type type, ClassHierarchy hierarchy) { if (type == null || hierarchy == null) { throw new InternalTypingException(); } this.id = id; this.hierarchy = hierarchy; type.apply(this); return result; }
/** * Creates an ArrayType parametrized by a given Type and dimension count. * @param baseType a Type to parametrize the ArrayType * @param numDimensions the dimension count to parametrize the ArrayType. * @return an ArrayType parametrized accrodingly. */ public static ArrayType v(Type baseType, int numDimensions) { if( numDimensions < 1 ) throw new RuntimeException( "attempt to create array with "+numDimensions+" dimensions" ); ArrayType ret; Type elementType; if( numDimensions == 1 ) { elementType = baseType; } else { elementType = ArrayType.v( baseType, numDimensions-1 ); } ret = elementType.getArrayType(); if( ret == null ) { ret = new ArrayType(baseType, numDimensions); elementType.setArrayType( ret ); } return ret; }
break; case '[': // array type = toSoot(typeDescriptor, pos + 1).makeArrayType(); break; default:
DefinitionStmt astmt=(DefinitionStmt) stmt; if( !(astmt.getRightOp() instanceof CaughtExceptionRef ) ) { Type leftType=Type.toMachineType(astmt.getLeftOp().getType()); Type rightType=Type.toMachineType(astmt.getRightOp().getType()); else for(int i=0;i<iexpr.getArgCount();i++) checkCopy(Type.toMachineType(called.parameterType(i)), Type.toMachineType(iexpr.getArg(i).getType()), " in argument "+i+" of call"+errorSuffix);
public String getTypeString() { return type.toString(); }