/** Prints the given <code>JimpleBody</code> to the specified <code>PrintWriter</code>. */
private void printLocalsInBody(Body body, UnitPrinter up) {
// Print out local variables
{
Map typeToLocals = new DeterministicHashMap(body.getLocalCount() * 2 + 1, 0.7f);
// Collect locals
{
Iterator localIt = body.getLocals().iterator();
while (localIt.hasNext()) {
Local local = (Local) localIt.next();
List localList;
Type t = local.getType();
if (typeToLocals.containsKey(t)) localList = (List) typeToLocals.get(t);
else {
localList = new ArrayList();
typeToLocals.put(t, localList);
}
localList.add(local);
}
}
// Print locals
{
Iterator typeIt = typeToLocals.keySet().iterator();
while (typeIt.hasNext()) {
Type type = (Type) typeIt.next();
List localList = (List) typeToLocals.get(type);
Object[] locals = localList.toArray();
up.type(type);
up.literal(" ");
for (int k = 0; k < locals.length; k++) {
if (k != 0) up.literal(", ");
up.local((Local) locals[k]);
}
up.literal(";");
up.newline();
}
}
if (!typeToLocals.isEmpty()) {
up.newline();
}
}
}
/**
* @ast method
* @aspect Expressions
* @declaredat
* /Users/eric/Documents/workspaces/clara-soot/JastAddExtensions/JimpleBackend/Expressions.jrag:84
*/
public soot.Value eval(Body b) {
TypeDecl dest = getDest().type();
TypeDecl source = getSource().type();
if (dest.isString()) {
Value lvalue = getDest().eval(b);
Value v = asImmediate(b, lvalue);
// new StringBuffer(left)
Local local =
b.newTemp(b.newNewExpr(lookupType("java.lang", "StringBuffer").sootRef(), this));
b.setLine(this);
b.add(
b.newInvokeStmt(
b.newSpecialInvokeExpr(
local,
Scene.v()
.getMethod("<java.lang.StringBuffer: void <init>(java.lang.String)>")
.makeRef(),
v,
this),
this));
// append right
Local rightResult =
b.newTemp(
b.newVirtualInvokeExpr(
local,
lookupType("java.lang", "StringBuffer")
.methodWithArgs("append", new TypeDecl[] {source.stringPromotion()})
.sootRef(),
asImmediate(b, getSource().eval(b)),
this));
// toString
Local result =
b.newTemp(
b.newVirtualInvokeExpr(
rightResult,
Scene.v()
.getMethod("<java.lang.StringBuffer: java.lang.String toString()>")
.makeRef(),
this));
Value v2 = lvalue instanceof Local ? lvalue : (Value) lvalue.clone();
getDest().emitStore(b, v2, result, this);
return result;
} else {
return super.eval(b);
}
}
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();
}
}
/**
* Prints out the method corresponding to b Body, (declaration and body), in the textual format
* corresponding to the IR used to encode b body.
*
* @param out a PrintWriter instance to print to.
*/
public void printTo(Body b, PrintWriter out) {
b.validate();
boolean isPrecise = !useAbbreviations();
String decl = b.getMethod().getDeclaration();
out.println(" " + decl);
// incJimpleLnNum();
// only print tags if not printing attributes in a file
if (!addJimpleLn()) {
/*for( Iterator tIt = b.getMethod().getTags().iterator(); tIt.hasNext(); ) { final Tag t = (Tag) tIt.next();
out.println(t);
incJimpleLnNum();
}*/
}
if (addJimpleLn()) {
setJimpleLnNum(addJimpleLnTags(getJimpleLnNum(), b.getMethod()));
// G.v().out.println("added jimple ln tag for method: "+b.getMethod().toString()+"
// "+b.getMethod().getDeclaringClass().getName());
}
out.println(" {");
incJimpleLnNum();
UnitGraph unitGraph = new soot.toolkits.graph.BriefUnitGraph(b);
LabeledUnitPrinter up;
if (isPrecise) up = new NormalUnitPrinter(b);
else up = new BriefUnitPrinter(b);
if (addJimpleLn()) {
up.setPositionTagger(new AttributesUnitPrinter(getJimpleLnNum()));
}
printLocalsInBody(b, up);
printStatementsInBody(b, out, up, unitGraph);
out.println(" }");
incJimpleLnNum();
}
/**
* What happens with the widget when another widget touches it.
*
* @param other_body The body that touched it.
* @param f The x,y coordinate that is the contact point.
*/
public void reactToTouchingBody(CollisionEvent e) {
float speed = MOVEMENT_SPEED + (MOVEMENT_SPEED * bounces * 0.05f);
if (currentDirection == Direction.WEST) {
currentDirection = direction.EAST;
body.setForce(2 * speed, 0);
} else if (currentDirection == Direction.EAST) {
currentDirection = Direction.WEST;
body.setForce(-2 * speed, 0);
} else if (currentDirection == Direction.NORTH) {
currentDirection = Direction.SOUTH;
body.setForce(0, 2 * speed);
} else if (currentDirection == Direction.SOUTH) {
currentDirection = direction.NORTH;
body.setForce(0, -2 * speed);
}
bounces++;
}
/** Activates the widget. */
public void activateWidget() {
// Enforce that reset is called at least once before activation.
if (!reset) {
return;
}
// Make active.
active = true;
body.setEnabled(true);
}
public void writeTo(OutputStream out) throws IOException, MessagingException {
BufferedWriter writer = new BufferedWriter(new OutputStreamWriter(out), 1024);
mHeader.writeTo(out);
writer.write("\r\n");
writer.flush();
if (mBody != null) {
mBody.writeTo(out);
}
}
/**
* Gets the boundary of the widget, should be used as a way to detect overlapping widgets.
*
* @return The four corners x,y coordinates.
*/
public Vector2f[] getBoundary() {
Box box = (Box) body.getShape();
Vector2f[] bounds = new Vector2f[4];
bounds[0] = new Vector2f(position.x, position.y);
bounds[1] = new Vector2f(position.x + WIDTH, position.y);
bounds[2] = new Vector2f(position.x + WIDTH, position.y + HEIGHT);
bounds[3] = new Vector2f(position.x, position.y + HEIGHT);
return bounds;
}
private static List<Unit> searchIfStmts(Body b) {
List<Unit> searchResult = new ArrayList<Unit>();
PatchingChain<Unit> statements = b.getUnits();
Iterator<Unit> unitIt = statements.iterator();
// iterate through the Units of the body
while (unitIt.hasNext()) {
Unit tempUnit = unitIt.next();
// if the unit is a "if statement"
if (tempUnit instanceof soot.jimple.internal.JIfStmt) searchResult.add(tempUnit);
}
return searchResult;
}
/**
* Draws the widget.
*
* @param g The object that draws things.
*/
public void draw(Graphics2D screen) {
// Animate!
if (System.nanoTime() - timestamp >= CENTISECOND * 50) {
timestamp = System.nanoTime();
if (image == frames.get(0)) {
image = frames.get(1);
} else {
image = frames.get(0);
}
}
ROVector2f position = body.getPosition();
float angle = body.getRotation();
boolean hflip = false;
boolean vflip = false;
if (currentDirection == Direction.WEST) {
hflip = false;
} else if (currentDirection == Direction.EAST) {
hflip = true;
} else if (currentDirection == Direction.NORTH) {
angle += Math.PI / 2;
vflip = false;
} else if (currentDirection == Direction.SOUTH) {
angle += Math.PI / 2;
vflip = true;
}
drawImage(
position.getX(),
position.getY(),
getWidth(),
getHeight(),
angle,
hflip,
vflip,
image,
screen);
}
/**
* Constructs a graph for the units found in the provided Body instance. Each node in the graph
* corresponds to a unit. The edges are derived from the control flow.
*
* @param body The underlying body we want to make a graph for.
* @param addExceptionEdges If true then the control flow edges associated with exceptions are
* added.
* @param dontAddEdgeFromStmtBeforeAreaOfProtectionToCatchBlock This was added for Dava. If true,
* edges are not added from statement before area of protection to catch. If false, edges ARE
* added. For Dava, it should be true. For flow analyses, it should be false.
* @param Hierarchy Using class hierarchy analysis to find the run method of started thread
* @param PointsToAnalysis Using point to analysis (SPARK package) to improve the precision of
* results
*/
public PegGraph(
CallGraph callGraph,
Hierarchy hierarchy,
PAG pag,
Set methodsNeedingInlining,
Set allocNodes,
List<List> inlineSites,
Map<SootMethod, String> synchObj,
Set multiRunAllocNodes,
Map<AllocNode, String> allocNodeToObj,
Body unitBody,
String threadName,
SootMethod sm,
boolean addExceEdge,
boolean dontAddEdgeFromStmtBeforeAreaOfProtectionToCatchBlock) {
this.allocNodeToObj = allocNodeToObj;
this.multiRunAllocNodes = multiRunAllocNodes;
this.synchObj = synchObj;
this.inlineSites = inlineSites;
this.allocNodes = allocNodes;
this.methodsNeedingInlining = methodsNeedingInlining;
logFile = new File("log.txt");
try {
fileWriter = new FileWriter(logFile);
} catch (IOException io) {
System.err.println("Errors occur during create FileWriter !");
// throw io;
}
body = unitBody;
synch = new HashSet<List>();
exceHandlers = new HashSet<Unit>();
needInlining = true;
monitorObjs = new HashSet<Object>();
startToBeginNodes = new HashMap();
unitChain = body.getUnits();
int size = unitChain.size();
// initial unitToSuccs, unitToPreds, unitToPegMap, and startToThread
unitToSuccs = new HashMap(size * 2 + 1, 0.7f);
unitToPreds = new HashMap(size * 2 + 1, 0.7f);
// unitToPegMap is the map of a chain to its corresponding (cfg node --> peg node ) map.
unitToPegMap = new HashMap(size * 2 + 1, 0.7f);
startToThread = new HashMap(size * 2 + 1, 0.7f);
startToAllocNodes = new HashMap(size * 2 + 1, 0.7f);
waitingNodes = new HashMap<String, FlowSet>(size * 2 + 1, 0.7f);
joinStmtToThread = new HashMap<JPegStmt, Chain>();
threadNo = new HashMap();
threadNameToStart = new HashMap();
this.allocNodeToObj = new HashMap<AllocNode, String>(size * 2 + 1, 0.7f);
allocNodeToThread = new HashMap<AllocNode, PegChain>(size * 2 + 1, 0.7f);
notifyAll = new HashMap<String, Set<JPegStmt>>(size * 2 + 1, 0.7f);
methodsNeedingInlining = new HashSet();
allNodes = new ArraySparseSet();
canNotBeCompacted = new HashSet();
threadAllocSites = new HashSet();
specialJoin = new HashSet<JPegStmt>();
// if(Main.isVerbose)
// System.out.println(" Constructing PegGraph...");
// if(Main.isProfilingOptimization)
// Main.graphTimer.start();
// make a peg for debug
/*
mainPegChain = new HashChain();
specialTreatment1();
*/
// end make a peg
UnitGraph mainUnitGraph = new CompleteUnitGraph(body);
// mainPegChain = new HashChain();
mainPegChain =
new PegChain(
callGraph,
hierarchy,
pag,
threadAllocSites,
methodsNeedingInlining,
allocNodes,
inlineSites,
synchObj,
multiRunAllocNodes,
allocNodeToObj,
body,
sm,
threadName,
true,
this);
// testPegChain();
// System.out.println("finish building chain");
// testStartToThread();
// buildSuccessor(mainUnitGraph, mainPegChain,addExceptionEdges);
// buildSuccessorForExtendingMethod(mainPegChain);
// testSet(exceHandlers, "exceHandlers");
buildSuccessor(mainPegChain);
// System.out.println("finish building successors");
// unmodifiableSuccs(mainPegChain);
// testUnitToSucc );
buildPredecessor(mainPegChain);
// System.out.println("finish building predcessors");
// unmodifiablePreds(mainPegChain);
// testSynch();
addMonitorStmt();
addTag();
// System.out.println(this.toString());
buildHeadsAndTails();
// testIterator();
// testWaitingNodes();
// System.out.println("finish building heads and tails");
// testSet(canNotBeCompacted, "canNotBeCompacted");
// computeEdgeAndThreadNo();
// testExtendingPoints();
// testUnitToSucc();
// testPegChain();
/* if (print) {
PegToDotFile printer1 = new PegToDotFile(this, false, sm.getName());
}
*/
try {
fileWriter.flush();
fileWriter.close();
} catch (IOException io) {
System.err.println("Errors occur during close file " + logFile.getName());
// throw io;
}
// System.out.println("==threadAllocaSits==\n"+threadAllocSites.toString());
}
/** Prints the given <code>JimpleBody</code> to the specified <code>PrintWriter</code>. */
private void printStatementsInBody(
Body body, java.io.PrintWriter out, LabeledUnitPrinter up, UnitGraph unitGraph) {
Chain units = body.getUnits();
Iterator unitIt = units.iterator();
Unit currentStmt = null, previousStmt;
while (unitIt.hasNext()) {
previousStmt = currentStmt;
currentStmt = (Unit) unitIt.next();
// Print appropriate header.
{
// Put an empty line if the previous node was a branch node, the current node is a join node
// or the previous statement does not have body statement as a successor, or if
// body statement has a label on it
if (currentStmt != units.getFirst()) {
if (unitGraph.getSuccsOf(previousStmt).size() != 1
|| unitGraph.getPredsOf(currentStmt).size() != 1
|| up.labels().containsKey(currentStmt)) {
up.newline();
} else {
// Or if the previous node does not have body statement as a successor.
List succs = unitGraph.getSuccsOf(previousStmt);
if (succs.get(0) != currentStmt) {
up.newline();
}
}
}
if (up.labels().containsKey(currentStmt)) {
up.unitRef(currentStmt, true);
up.literal(":");
up.newline();
}
if (up.references().containsKey(currentStmt)) {
up.unitRef(currentStmt, false);
}
}
up.startUnit(currentStmt);
currentStmt.toString(up);
up.endUnit(currentStmt);
up.literal(";");
up.newline();
// only print them if not generating attributes files
// because they mess up line number
// if (!addJimpleLn()) {
if (Options.v().print_tags_in_output()) {
Iterator tagIterator = currentStmt.getTags().iterator();
while (tagIterator.hasNext()) {
Tag t = (Tag) tagIterator.next();
up.noIndent();
up.literal("/*");
up.literal(t.toString());
up.literal("*/");
up.newline();
}
/*Iterator udIt = currentStmt.getUseAndDefBoxes().iterator();
while (udIt.hasNext()) {
ValueBox temp = (ValueBox)udIt.next();
Iterator vbtags = temp.getTags().iterator();
while (vbtags.hasNext()) {
Tag t = (Tag) vbtags.next();
up.noIndent();
up.literal("VB Tag: "+t.toString());
up.newline();
}
}*/
}
}
out.print(up.toString());
if (addJimpleLn()) {
setJimpleLnNum(up.getPositionTagger().getEndLn());
}
// Print out exceptions
{
Iterator trapIt = body.getTraps().iterator();
if (trapIt.hasNext()) {
out.println();
incJimpleLnNum();
}
while (trapIt.hasNext()) {
Trap trap = (Trap) trapIt.next();
out.println(
" catch "
+ Scene.v().quotedNameOf(trap.getException().getName())
+ " from "
+ up.labels().get(trap.getBeginUnit())
+ " to "
+ up.labels().get(trap.getEndUnit())
+ " with "
+ up.labels().get(trap.getHandlerUnit())
+ ";");
incJimpleLnNum();
}
}
}
/**
* @ast method
* @aspect Expressions
* @declaredat
* /Users/eric/Documents/workspaces/clara-soot/JastAddExtensions/JimpleBackend/Expressions.jrag:183
*/
public soot.Value createAssignOp(Body b, soot.Value fst, soot.Value snd) {
return b.newXorExpr(asImmediate(b, fst), asImmediate(b, snd), this);
}
public void addBody(Body body)
throws SAXException, WingException, UIException, SQLException, IOException,
AuthorizeException {
// If we are actually editing information of an uploaded file,
// then display that body instead!
if (this.editFile != null) {
editFile.addBody(body);
return;
}
// Get a list of all files in the original bundle
Item item = submission.getItem();
Collection collection = submission.getCollection();
String actionURL =
contextPath + "/handle/" + collection.getHandle() + "/submit/" + knot.getId() + ".continue";
boolean disableFileEditing =
(submissionInfo.isInWorkflow())
&& !ConfigurationManager.getBooleanProperty("workflow", "reviewer.file-edit");
Bundle[] bundles = item.getBundles("ORIGINAL");
Bitstream[] bitstreams = new Bitstream[0];
if (bundles.length > 0) {
bitstreams = bundles[0].getBitstreams();
}
// Part A:
// First ask the user if they would like to upload a new file (may be the first one)
Division div =
body.addInteractiveDivision(
"submit-upload", actionURL, Division.METHOD_MULTIPART, "primary submission");
div.setHead(T_submission_head);
addSubmissionProgressList(div);
List upload = null;
if (!disableFileEditing) {
// Only add the upload capabilities for new item submissions
upload = div.addList("submit-upload-new", List.TYPE_FORM);
upload.setHead(T_head);
addRioxxVersionSection(upload, item);
File file = upload.addItem().addFile("file");
file.setLabel(T_file);
file.setHelp(T_file_help);
file.setRequired();
// if no files found error was thrown by processing class, display it!
if (this.errorFlag == org.dspace.submit.step.UploadStep.STATUS_NO_FILES_ERROR) {
file.addError(T_file_error);
}
// if an upload error was thrown by processing class, display it!
if (this.errorFlag == org.dspace.submit.step.UploadStep.STATUS_UPLOAD_ERROR) {
file.addError(T_upload_error);
}
// if virus checking was attempted and failed in error then let the user know
if (this.errorFlag == org.dspace.submit.step.UploadStep.STATUS_VIRUS_CHECKER_UNAVAILABLE) {
file.addError(T_virus_checker_error);
}
// if virus checking was attempted and a virus found then let the user know
if (this.errorFlag == org.dspace.submit.step.UploadStep.STATUS_CONTAINS_VIRUS) {
file.addError(T_virus_error);
}
Text description = upload.addItem().addText("description");
description.setLabel(T_description);
description.setHelp(T_description_help);
Button uploadSubmit = upload.addItem().addButton("submit_upload");
uploadSubmit.setValue(T_submit_upload);
}
make_sherpaRomeo_submission(item, div);
// Part B:
// If the user has already uploaded files provide a list for the user.
if (bitstreams.length > 0 || disableFileEditing) {
Table summary = div.addTable("submit-upload-summary", (bitstreams.length * 2) + 2, 7);
summary.setHead(T_head2);
Row header = summary.addRow(Row.ROLE_HEADER);
header.addCellContent(T_column0); // primary bitstream
header.addCellContent(T_column1); // select checkbox
header.addCellContent(T_column2); // file name
header.addCellContent(T_column3); // size
header.addCellContent(T_column4); // description
header.addCellContent(T_column5); // format
header.addCellContent(T_column6); // edit button
for (Bitstream bitstream : bitstreams) {
int id = bitstream.getID();
String name = bitstream.getName();
String url = makeBitstreamLink(item, bitstream);
long bytes = bitstream.getSize();
String desc = bitstream.getDescription();
String algorithm = bitstream.getChecksumAlgorithm();
String checksum = bitstream.getChecksum();
Row row = summary.addRow();
// Add radio-button to select this as the primary bitstream
Radio primary = row.addCell().addRadio("primary_bitstream_id");
primary.addOption(String.valueOf(id));
// If this bitstream is already marked as the primary bitstream
// mark it as such.
if (bundles[0].getPrimaryBitstreamID() == id) {
primary.setOptionSelected(String.valueOf(id));
}
if (!disableFileEditing) {
// Workflow users can not remove files.
CheckBox remove = row.addCell().addCheckBox("remove");
remove.setLabel("remove");
remove.addOption(id);
} else {
row.addCell();
}
row.addCell().addXref(url, name);
row.addCellContent(bytes + " bytes");
if (desc == null || desc.length() == 0) {
row.addCellContent(T_unknown_name);
} else {
row.addCellContent(desc);
}
BitstreamFormat format = bitstream.getFormat();
if (format == null) {
row.addCellContent(T_unknown_format);
} else {
int support = format.getSupportLevel();
Cell cell = row.addCell();
cell.addContent(format.getMIMEType());
cell.addContent(" ");
switch (support) {
case 1:
cell.addContent(T_supported);
break;
case 2:
cell.addContent(T_known);
break;
case 3:
cell.addContent(T_unsupported);
break;
}
}
Button edit = row.addCell().addButton("submit_edit_" + id);
edit.setValue(T_submit_edit);
Row checksumRow = summary.addRow();
checksumRow.addCell();
Cell checksumCell = checksumRow.addCell(null, null, 0, 6, null);
checksumCell.addHighlight("bold").addContent(T_checksum);
checksumCell.addContent(" ");
checksumCell.addContent(algorithm + ":" + checksum);
}
if (!disableFileEditing) {
// Workflow users can not remove files.
Row actionRow = summary.addRow();
actionRow.addCell();
Button removeSeleceted =
actionRow.addCell(null, null, 0, 6, null).addButton("submit_remove_selected");
removeSeleceted.setValue(T_submit_remove);
}
upload = div.addList("submit-upload-new-part2", List.TYPE_FORM);
}
// Part C:
// add standard control/paging buttons
addControlButtons(upload);
}
/**
* Get the position of the widget.
*
* @return The x,y coordinates within the container.
*/
public Vector2f getPosition() {
return new Vector2f(body.getPosition());
}
/*
* Generates the sequence of instructions needed to instrument ifStmtUnit
*
* @param ifStmtUnit: the unit to be instrumented
* @return A Chain of Units that represent the instrumentation of ifStmtUnit
*/
private static Chain<Unit> generateInstrumentationUnits(Unit ifStmtUnit, Body b) {
AbstractBinopExpr expression =
(AbstractBinopExpr)
((JIfStmt) ifStmtUnit).getCondition(); // implementation of AbstractBinopExpr
Value operand1 = expression.getOp1();
Value operand2 = expression.getOp2();
JimpleLocal op1Local = (JimpleLocal) operand1;
// Local localOperand = Jimple.v().newLocal("op1", operand1.getType());
// b.getLocals().add(localOperand);
// We need to use these operand as Locals or constants
/**
* JimpleLocal test; if(operand1 instanceof soot.jimple.internal.JimpleLocal) test =
* (JimpleLocal)operand1; else test = null;
*/
String op = expression.getClass().toString();
Chain<Unit> resultUnits = new HashChain<Unit>();
Local tmpRef;
// Add locals directely on the top of the body, java.io.printStream tmpRef
tmpRef = Jimple.v().newLocal("tmpRef", RefType.v("java.io.PrintStream"));
b.getLocals().addFirst(tmpRef);
// add "tmpRef = java.lang.System.out"
resultUnits.add(
Jimple.v()
.newAssignStmt(
tmpRef,
Jimple.v()
.newStaticFieldRef(
Scene.v()
.getField("<java.lang.System: java.io.PrintStream out>")
.makeRef())));
{
SootMethod toCall =
Scene.v().getMethod("<java.io.PrintStream: void println(java.lang.String)>");
resultUnits.add(
Jimple.v()
.newInvokeStmt(
Jimple.v()
.newVirtualInvokeExpr(
tmpRef, toCall.makeRef(), StringConstant.v("Operande 1: "))));
resultUnits.add(
Jimple.v()
.newInvokeStmt(
Jimple.v()
.newVirtualInvokeExpr(
tmpRef,
toCall.makeRef(),
StringConstant.v(operand1.getClass().toString()))));
resultUnits.add(
Jimple.v()
.newInvokeStmt(
Jimple.v()
.newVirtualInvokeExpr(
tmpRef, toCall.makeRef(), StringConstant.v("Operande 2:"))));
resultUnits.add(
Jimple.v()
.newInvokeStmt(
Jimple.v()
.newVirtualInvokeExpr(
tmpRef,
toCall.makeRef(),
StringConstant.v(operand2.getClass().toString()))));
resultUnits.add(
Jimple.v()
.newInvokeStmt(
Jimple.v()
.newVirtualInvokeExpr(
tmpRef, toCall.makeRef(), StringConstant.v("Operateur: "))));
resultUnits.add(
Jimple.v()
.newInvokeStmt(
Jimple.v().newVirtualInvokeExpr(tmpRef, toCall.makeRef(), StringConstant.v(op))));
}
return resultUnits;
}
/**
* Retrieves the height of the widget based on the specified boundary.
*
* @return The height of the widget (based on the boundary).
*/
private float getHeight() {
return ((Box) body.getShape()).getSize().getY();
}
/**
* Retrieves the width of the widget based on the specified boundary.
*
* @return The width of the widget (based on the boundary).
*/
private float getWidth() {
return ((Box) body.getShape()).getSize().getX();
}
/** Resets the widget to start state. */
public void resetWidget() {
// Reset has been made, so we CAN activate this later.
reset = true;
// Make inactive
active = false;
// Not collided.
collided = false;
bounces = 0;
currentDirection = direction;
image = frames.get(0);
body.setEnabled(false);
// Move to initial position.
body.set(shape, MASS);
body.setPosition(position.x + WIDTH / 2, position.y + HEIGHT / 2);
// Make sure the gameplay didn't mess with any initial properties.
body.setCanRest(true);
body.setDamping(0.0f);
body.setFriction(0.01f);
body.setGravityEffected(false);
body.setIsResting(true);
body.setMoveable(true);
body.setRestitution(1.5f);
body.setRotatable(true);
body.setRotation(0.0f);
body.setRotDamping(0.0f);
body.setMaxVelocity(50f, 50f);
body.setForce(-body.getForce().getX(), -body.getForce().getY());
if (currentDirection == Direction.WEST) {
body.setForce(-MOVEMENT_SPEED, 0);
} else if (currentDirection == Direction.EAST) {
body.setForce(MOVEMENT_SPEED, 0);
}
if (currentDirection == Direction.NORTH) {
body.setForce(0, -MOVEMENT_SPEED);
} else if (currentDirection == Direction.SOUTH) {
body.setForce(0, MOVEMENT_SPEED);
}
body.adjustVelocity(new Vector2f(-body.getVelocity().getX(), -body.getVelocity().getY()));
body.adjustAngularVelocity(-body.getAngularVelocity());
}
/**
* @ast method
* @aspect Statements
* @declaredat
* /Users/eric/Documents/workspaces/clara-soot/JastAddExtensions/JimpleBackend/Statements.jrag:312
*/
public void jimplify2(Body b) {
b.setLine(this);
b.add(b.newThrowStmt(asImmediate(b, getExpr().eval(b)), this));
}
/**
* Set the position of the widget.
*
* @param f The x,y coordinates within the container.
*/
public void setPosition(Vector2f f) {
body.setPosition(f.x + WIDTH / 2, f.y + HEIGHT / 2);
position = f;
}