// This method is deprecated. Use soot.util.JasminOutputStream instead.
public void writeXXXDeprecated(SootClass cl, String outputDir) {
String outputDirWithSep = "";
if (!outputDir.equals("")) outputDirWithSep = outputDir + fileSeparator;
try {
File tempFile = new File(outputDirWithSep + cl.getName() + ".jasmin");
FileOutputStream streamOut = new FileOutputStream(tempFile);
PrintWriter writerOut = new PrintWriter(new EscapedWriter(new OutputStreamWriter(streamOut)));
if (cl.containsBafBody()) new soot.baf.JasminClass(cl).print(writerOut);
else new soot.jimple.JasminClass(cl).print(writerOut);
writerOut.close();
if (Options.v().time()) Timers.v().assembleJasminTimer.start();
// Invoke jasmin
{
String[] args;
if (outputDir.equals("")) {
args = new String[1];
args[0] = cl.getName() + ".jasmin";
} else {
args = new String[3];
args[0] = "-d";
args[1] = outputDir;
args[2] = outputDirWithSep + cl.getName() + ".jasmin";
}
jasmin.Main.main(args);
}
tempFile.delete();
if (Options.v().time()) Timers.v().assembleJasminTimer.end();
} catch (IOException e) {
throw new RuntimeException("Could not produce new classfile! (" + e + ")");
}
}
public static void main(String args[]) {
// Set classPath
String exemplePath = "/Users/gamyot/Documents/workspace/Soot_Exemples/src/";
String objectPath = "/System/Library/Frameworks/JavaVM.framework/Classes/classes.jar";
String tracePath = "/Users/gamyot/Documents/workspace/SootInstrumenter/src/";
Scene.v().setSootClassPath(".:" + objectPath + ":" + exemplePath + ":" + tracePath);
Scene.v().loadClassAndSupport("java.lang.Object");
Scene.v().loadClassAndSupport("java.lang.System");
// Set up the class we’re working with
SootClass c = Scene.v().loadClassAndSupport("MyExemples.ExempleBasic");
c.setApplicationClass();
// Get methods
Iterator<SootMethod> methodIterator = c.methodIterator();
while (methodIterator.hasNext()) methodList.add(methodIterator.next());
// Iterate through the method list
for (SootMethod m : methodList) {
Body body = m.retrieveActiveBody();
PatchingChain<Unit> unitList = body.getUnits();
// get the all the "if statements" Units
List<Unit> ifStmtList = searchIfStmts(body);
// for each "if statement" unit, instrument and add the instrumentation code right after
for (Unit ifStmtUnit : ifStmtList) {
// Chain<Unit> instrumentedChain = generateInstrumentationUnits(ifStmtUnit, body);
// unitList.insertAfter(instrumentedChain, ifStmtUnit);
Chain<Unit> testChain = generateInstrumentationUnits(ifStmtUnit, body);
unitList.insertAfter(testChain, ifStmtUnit);
}
// Output all the units for this method on terminal
String methodName = m.getName();
System.out.println(
"____Method: \"" + methodName + "\"__________________________________________________");
LoadAndGenerate.printAllUnits(body);
}
try {
LoadAndGenerate.outputClassToBinary(c);
} catch (IOException e) {
e.printStackTrace();
}
}
public void caseAFile(AFile node) {
inAFile(node);
{
Object temp[] = node.getModifier().toArray();
for (int i = 0; i < temp.length; i++) {
((PModifier) temp[i]).apply(this);
}
}
if (node.getFileType() != null) {
node.getFileType().apply(this);
}
if (node.getClassName() != null) {
node.getClassName().apply(this);
}
String className = (String) mProductions.removeLast();
if (mSootClass == null) {
mSootClass = new SootClass(className);
mSootClass.setResolvingLevel(SootClass.BODIES);
} else {
if (!mSootClass.getName().equals(className))
throw new RuntimeException(
"Invalid SootClass for this JimpleAST. The SootClass provided is of type: >"
+ mSootClass.getName()
+ "< whereas this parse tree is for type: >"
+ className
+ "<");
}
if (node.getExtendsClause() != null) {
node.getExtendsClause().apply(this);
}
if (node.getImplementsClause() != null) {
node.getImplementsClause().apply(this);
}
if (node.getFileBody() != null) {
node.getFileBody().apply(this);
}
outAFile(node);
}
/*
member =
{field} modifier* type name semicolon |
{method} modifier* type name l_paren parameter_list? r_paren throws_clause? method_body;
*/
public void outAFieldMember(AFieldMember node) {
int modifier = 0;
Type type = null;
String name = null;
name = (String) mProductions.removeLast();
type = (Type) mProductions.removeLast();
modifier = processModifiers(node.getModifier());
SootField f = new SootField(name, type, modifier);
mSootClass.addField(f);
}
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);
}
public void outAMethodMember(AMethodMember node) {
int modifier = 0;
Type type;
String name;
List parameterList = null;
List throwsClause = null;
JimpleBody methodBody = null;
if (node.getMethodBody() instanceof AFullMethodBody)
methodBody = (JimpleBody) mProductions.removeLast();
if (node.getThrowsClause() != null) throwsClause = (List) mProductions.removeLast();
if (node.getParameterList() != null) {
parameterList = (List) mProductions.removeLast();
} else {
parameterList = new ArrayList();
}
Object o = mProductions.removeLast();
name = (String) o;
type = (Type) mProductions.removeLast();
modifier = processModifiers(node.getModifier());
SootMethod method;
if (throwsClause != null)
method = new SootMethod(name, parameterList, type, modifier, throwsClause);
else method = new SootMethod(name, parameterList, type, modifier);
mSootClass.addMethod(method);
if (method.isConcrete()) {
methodBody.setMethod(method);
method.setActiveBody(methodBody);
} else if (node.getMethodBody() instanceof AFullMethodBody)
throw new RuntimeException("Impossible: !concrete => ! instanceof");
}
public void printTo(SootClass cl, PrintWriter out) {
// add jimple line number tags
setJimpleLnNum(1);
// Print class name + modifiers
{
StringTokenizer st = new StringTokenizer(Modifier.toString(cl.getModifiers()));
while (st.hasMoreTokens()) {
String tok = (String) st.nextToken();
if (cl.isInterface() && tok.equals("abstract")) continue;
out.print(tok + " ");
}
String classPrefix = "";
if (!cl.isInterface()) {
classPrefix = classPrefix + " class";
classPrefix = classPrefix.trim();
}
out.print(classPrefix + " " + Scene.v().quotedNameOf(cl.getName()) + "");
}
// Print extension
{
if (cl.hasSuperclass())
out.print(" extends " + Scene.v().quotedNameOf(cl.getSuperclass().getName()) + "");
}
// Print interfaces
{
Iterator interfaceIt = cl.getInterfaces().iterator();
if (interfaceIt.hasNext()) {
out.print(" implements ");
out.print("" + Scene.v().quotedNameOf(((SootClass) interfaceIt.next()).getName()) + "");
while (interfaceIt.hasNext()) {
out.print(",");
out.print(" " + Scene.v().quotedNameOf(((SootClass) interfaceIt.next()).getName()) + "");
}
}
}
out.println();
incJimpleLnNum();
/* if (!addJimpleLn()) {
Iterator clTagsIt = cl.getTags().iterator();
while (clTagsIt.hasNext()) {
final Tag t = (Tag)clTagsIt.next();
out.println(t);
}
}*/
out.println("{");
incJimpleLnNum();
if (Options.v().print_tags_in_output()) {
Iterator cTagIterator = cl.getTags().iterator();
while (cTagIterator.hasNext()) {
Tag t = (Tag) cTagIterator.next();
out.print("/*");
out.print(t.toString());
out.println("*/");
}
}
// Print fields
{
Iterator fieldIt = cl.getFields().iterator();
if (fieldIt.hasNext()) {
while (fieldIt.hasNext()) {
SootField f = (SootField) fieldIt.next();
if (f.isPhantom()) continue;
if (Options.v().print_tags_in_output()) {
Iterator fTagIterator = f.getTags().iterator();
while (fTagIterator.hasNext()) {
Tag t = (Tag) fTagIterator.next();
out.print("/*");
out.print(t.toString());
out.println("*/");
}
}
out.println(" " + f.getDeclaration() + ";");
if (addJimpleLn()) {
setJimpleLnNum(addJimpleLnTags(getJimpleLnNum(), f));
}
// incJimpleLnNum();
}
}
}
// Print methods
{
Iterator methodIt = cl.methodIterator();
if (methodIt.hasNext()) {
if (cl.getMethodCount() != 0) {
out.println();
incJimpleLnNum();
}
while (methodIt.hasNext()) {
SootMethod method = (SootMethod) methodIt.next();
if (method.isPhantom()) continue;
if (!Modifier.isAbstract(method.getModifiers())
&& !Modifier.isNative(method.getModifiers())) {
if (!method.hasActiveBody())
throw new RuntimeException("method " + method.getName() + " has no active body!");
else if (Options.v().print_tags_in_output()) {
Iterator mTagIterator = method.getTags().iterator();
while (mTagIterator.hasNext()) {
Tag t = (Tag) mTagIterator.next();
out.print("/*");
out.print(t.toString());
out.println("*/");
}
}
printTo(method.getActiveBody(), out);
if (methodIt.hasNext()) {
out.println();
incJimpleLnNum();
}
} else {
if (Options.v().print_tags_in_output()) {
Iterator mTagIterator = method.getTags().iterator();
while (mTagIterator.hasNext()) {
Tag t = (Tag) mTagIterator.next();
out.print("/*");
out.print(t.toString());
out.println("*/");
}
}
out.print(" ");
out.print(method.getDeclaration());
out.println(";");
incJimpleLnNum();
if (methodIt.hasNext()) {
out.println();
incJimpleLnNum();
}
}
}
}
}
out.println("}");
incJimpleLnNum();
}
