public void outAFieldSignature(AFieldSignature node) {
String className, fieldName;
Type t;
fieldName = (String) mProductions.removeLast();
t = (Type) mProductions.removeLast();
className = (String) mProductions.removeLast();
SootClass cl = mResolver.makeClassRef(className);
SootFieldRef field = Scene.v().makeFieldRef(cl, fieldName, t, false);
mProductions.addLast(field);
}
public void outAFile(AFile node) {
// not not pop members; they have been taken care of.
List implementsList = null;
String superClass = null;
String classType = null;
if (node.getImplementsClause() != null) {
implementsList = (List) mProductions.removeLast();
}
if (node.getExtendsClause() != null) {
superClass = (String) mProductions.removeLast();
}
classType = (String) mProductions.removeLast();
int modifierCount = node.getModifier().size();
int modifierFlags = processModifiers(node.getModifier());
if (classType.equals("interface")) modifierFlags |= Modifier.INTERFACE;
mSootClass.setModifiers(modifierFlags);
if (superClass != null) {
mSootClass.setSuperclass(mResolver.makeClassRef(superClass));
}
if (implementsList != null) {
Iterator implIt = implementsList.iterator();
while (implIt.hasNext()) {
SootClass interfaceClass = mResolver.makeClassRef((String) implIt.next());
mSootClass.addInterface(interfaceClass);
}
}
mProductions.addLast(mSootClass);
}
/*
throws_clause =
throws class_name_list;
*/
public void outAThrowsClause(AThrowsClause node) {
List l = (List) mProductions.removeLast();
Iterator it = l.iterator();
List exceptionClasses = new ArrayList(l.size());
while (it.hasNext()) {
String className = (String) it.next();
exceptionClasses.add(mResolver.makeClassRef(className));
}
mProductions.addLast(exceptionClasses);
}
private Type signatureToType(String desc) {
String rawDesc = desc.replaceAll("<.*>", "");
String internalName = rawDesc.replaceAll("^\\[*", "");
int dims = rawDesc.length() - internalName.length();
internalName = Types.getInternalNameFromDescriptor(internalName);
soot.Type sootType = SootResolver.v().makeClassRef(internalName.replace('/', '.')).getType();
for (int i = 0; i < dims; i++) {
sootType = sootType.makeArrayType();
}
SootMethod m = new SootMethod("foo", Arrays.asList(sootType), VoidType.v());
m.addTag(new SignatureTag("(" + desc + ")V"));
SootMethodType mType = new SootMethodType(m);
return mType.getGenericParameterTypes()[0];
}
/*
method_signature =
cmplt [class_name]:class_name [first]:colon type [method_name]:name l_paren parameter_list? r_paren cmpgt;
*/
public void outAMethodSignature(AMethodSignature node) {
String className, methodName;
List parameterList = new ArrayList();
Type returnType;
if (node.getParameterList() != null) parameterList = (List) mProductions.removeLast();
methodName = (String) mProductions.removeLast();
Type type = (Type) mProductions.removeLast();
className = (String) mProductions.removeLast();
SootClass sootClass = mResolver.makeClassRef(className);
SootMethodRef sootMethod =
Scene.v().makeMethodRef(sootClass, methodName, parameterList, type, false);
mProductions.addLast(sootMethod);
}
public void outACatchClause(ACatchClause node) {
String exceptionName;
UnitBox withUnit, fromUnit, toUnit;
withUnit = Jimple.v().newStmtBox(null);
addBoxToPatch((String) mProductions.removeLast(), withUnit);
toUnit = Jimple.v().newStmtBox(null);
addBoxToPatch((String) mProductions.removeLast(), toUnit);
fromUnit = Jimple.v().newStmtBox(null);
addBoxToPatch((String) mProductions.removeLast(), fromUnit);
exceptionName = (String) mProductions.removeLast();
Trap trap =
Jimple.v().newTrap(mResolver.makeClassRef(exceptionName), fromUnit, toUnit, withUnit);
mProductions.addLast(trap);
}
/**
* @param annotations
* @return
*/
private List<Tag> handleAnnotation(
Set<? extends org.jf.dexlib2.iface.Annotation> annotations, String classType) {
if (annotations == null || annotations.size() == 0) return null;
List<Tag> tags = new ArrayList<Tag>();
VisibilityAnnotationTag[] vatg =
new VisibilityAnnotationTag[3]; // RUNTIME_VISIBLE, RUNTIME_INVISIBLE, SOURCE_VISIBLE, see
// soot.tagkit.AnnotationConstants
for (Annotation a : annotations) {
int v = getVisibility(a.getVisibility());
Tag t = null;
Type atype = DexType.toSoot(a.getType());
String atypes = atype.toString();
int eSize = a.getElements().size();
Debug.printDbg("annotation type: ", atypes, " elements: ", eSize);
if (atypes.equals("dalvik.annotation.AnnotationDefault")) {
if (eSize != 1)
throw new RuntimeException(
"error: expected 1 element for annotation Default. Got " + eSize + " instead.");
// get element
AnnotationElem e = getElements(a.getElements()).get(0);
AnnotationTag adt = new AnnotationTag(a.getType());
adt.addElem(e);
if (vatg[v] == null) vatg[v] = new VisibilityAnnotationTag(v);
vatg[v].addAnnotation(adt);
} else if (atypes.equals("dalvik.annotation.EnclosingClass")) {
if (eSize != 1)
throw new RuntimeException(
"error: expected 1 element for annotation EnclosingClass. Got "
+ eSize
+ " instead.");
for (AnnotationElement elem : a.getElements()) {
String outerClass = ((TypeEncodedValue) elem.getValue()).getValue();
outerClass = Util.dottedClassName(outerClass);
deps.typesToSignature.add(RefType.v(outerClass));
clazz.setOuterClass(SootResolver.v().makeClassRef(outerClass));
assert clazz.getOuterClass() != clazz;
}
// EnclosingClass comes in pair with InnerClass.
// Those are generated from a single InnerClassTag,
// that is re-constructed only for the InnerClass Dalvik
// annotation.
continue;
} else if (atypes.equals("dalvik.annotation.EnclosingMethod")) {
if (eSize != 1)
throw new RuntimeException(
"error: expected 1 element for annotation EnclosingMethod. Got "
+ eSize
+ " instead.");
AnnotationStringElem e = (AnnotationStringElem) getElements(a.getElements()).get(0);
String[] split1 = e.getValue().split("\\ \\|");
String classString = split1[0];
String methodString = split1[1];
String parameters = split1[2];
String returnType = split1[3];
String methodSigString = "(" + parameters + ")" + returnType;
t = new EnclosingMethodTag(classString, methodString, methodSigString);
String outerClass = classString.replace("/", ".");
deps.typesToSignature.add(RefType.v(outerClass));
clazz.setOuterClass(SootResolver.v().makeClassRef(outerClass));
assert clazz.getOuterClass() != clazz;
} else if (atypes.equals("dalvik.annotation.InnerClass")) {
int accessFlags = -1; // access flags of the inner class
String name = null; // name of the inner class
for (AnnotationElem ele : getElements(a.getElements())) {
if (ele instanceof AnnotationIntElem && ele.getName().equals("accessFlags"))
accessFlags = ((AnnotationIntElem) ele).getValue();
else if (ele instanceof AnnotationStringElem && ele.getName().equals("name"))
name = ((AnnotationStringElem) ele).getValue();
else throw new RuntimeException("Unexpected inner class annotation element");
}
String outerClass; // outer class name
if (name == null) outerClass = classType.replaceAll("\\$[0-9,a-z,A-Z]*;$", ";");
else outerClass = classType.replaceFirst("\\$" + name + ";$", ";");
// Make sure that no funny business is going on if the
// annotation is broken and does not end in $nn.
if (outerClass.equals(classType)) {
outerClass = null;
}
Tag innerTag =
new InnerClassTag(
DexType.toSootICAT(classType),
outerClass == null ? null : DexType.toSootICAT(outerClass),
name,
accessFlags);
tags.add(innerTag);
if (outerClass != null && !clazz.hasOuterClass()) {
String sootOuterClass = Util.dottedClassName(outerClass);
deps.typesToSignature.add(RefType.v(sootOuterClass));
clazz.setOuterClass(SootResolver.v().makeClassRef(sootOuterClass));
assert clazz.getOuterClass() != clazz;
}
continue;
} else if (atypes.equals("dalvik.annotation.MemberClasses")) {
AnnotationArrayElem e = (AnnotationArrayElem) getElements(a.getElements()).get(0);
for (AnnotationElem ae : e.getValues()) {
AnnotationClassElem c = (AnnotationClassElem) ae;
String innerClass = c.getDesc();
String outerClass = innerClass.replaceAll("\\$[^\\$]*$", "");
String name = innerClass.replaceAll("^.*\\$", "").replaceAll(";$", "");
if (name.replaceAll("[0-9].*", "").equals("")) { // anonymous or local inner classes
name = null;
}
int accessFlags =
0; // seems like this information is lost during the .class -- dx --> .dex process.
Tag innerTag =
new InnerClassTag(
DexType.toSootICAT(innerClass),
DexType.toSootICAT(outerClass),
name,
accessFlags);
tags.add(innerTag);
}
continue;
} else if (atypes.equals("dalvik.annotation.Signature")) {
if (eSize != 1)
throw new RuntimeException(
"error: expected 1 element for annotation Signature. Got " + eSize + " instead.");
AnnotationArrayElem e = (AnnotationArrayElem) getElements(a.getElements()).get(0);
String sig = "";
for (AnnotationElem ae : e.getValues()) {
AnnotationStringElem s = (AnnotationStringElem) ae;
sig += s.getValue();
}
t = new SignatureTag(sig);
} else if (atypes.equals("dalvik.annotation.Throws")) {
// this is handled in soot.dexpler.DexMethod
continue;
} else if (atypes.equals("java.lang.Deprecated")) {
if (eSize != 0)
throw new RuntimeException(
"error: expected 1 element for annotation Deprecated. Got " + eSize + " instead.");
t = new DeprecatedTag();
AnnotationTag adt = new AnnotationTag("Ljava/lang/Deprecated;");
if (vatg[v] == null) vatg[v] = new VisibilityAnnotationTag(v);
vatg[v].addAnnotation(adt);
} else {
Debug.printDbg("read visibility tag: ", a.getType());
if (vatg[v] == null) vatg[v] = new VisibilityAnnotationTag(v);
AnnotationTag tag = new AnnotationTag(a.getType());
for (AnnotationElem e : getElements(a.getElements())) tag.addElem(e);
vatg[v].addAnnotation(tag);
}
tags.add(t);
}
for (VisibilityAnnotationTag vat : vatg) if (vat != null) tags.add(vat);
return tags;
}
private Type classNameToType(String name) {
return new SootClassType(SootResolver.v().makeClassRef(name));
}
private SootClass toSootClass(Class<?> cls) {
return SootResolver.v().resolveClass(cls.getName(), SootClass.SIGNATURES);
}