protected void testPegChain(Chain chain) { System.out.println("******** chain********"); Iterator it = chain.iterator(); while (it.hasNext()) { /*Object o = it.next(); System.out.println(o); if (!(o instanceof JPegStmt)) System.out.println("not instanceof JPegStmt: "+o); JPegStmt s = (JPegStmt)o; */ JPegStmt stmt = (JPegStmt) it.next(); System.out.println(stmt.toString()); /*if (stmt.getName().equals("start")){ System.out.println("find start method in : " + stmt.toString() ); List list =(List)startToThread.get(stmt); Iterator chainIt = list.iterator(); while (chainIt.hasNext()){ Chain chain = (Chain)chainIt.next(); Iterator subit = chain.iterator(); while (subit.hasNext()){ System.out.println("**" + ((JPegStmt)subit.next()).toString()); } } System.out.println("$$$$$$returing to main chain"); } */ } }
private boolean removeBeginNode() { List heads = getHeads(); if (heads.size() != 1) { // System.out.println("heads: "+heads); // System.out.println("Error: the size of heads is not equal to 1!"); return false; // System.exit(1); } else { JPegStmt head = (JPegStmt) heads.get(0); // System.out.println("test head: "+head); if (!head.getName().equals("begin")) { System.err.println("Error: the head is not begin node!"); System.exit(1); } // remove begin node from heads list heads.remove(0); // set the preds list of the succs of head to a new list and put succs of head into heads Iterator succOfHeadIt = getSuccsOf(head).iterator(); while (succOfHeadIt.hasNext()) { JPegStmt succOfHead = (JPegStmt) succOfHeadIt.next(); unitToPreds.put(succOfHead, new ArrayList()); // put succs of head into heads heads.add(succOfHead); } // remove begin node from inlinee Peg if (!mainPegChain.remove(head)) { System.err.println("fail to remove begin node in from mainPegChain!"); System.exit(1); } if (!allNodes.contains(head)) { System.err.println("fail to find begin node in FlowSet allNodes!"); System.exit(1); } else { allNodes.remove(head); } // remove begin node from unitToSuccs if (unitToSuccs.containsKey(head)) { unitToSuccs.remove(head); } } return true; }
public boolean addPeg(PegGraph pg, Chain chain) { if (!pg.removeBeginNode()) return false; // System.out.println("adding one peg into another"); // System.out.println("after removeBeginNode==="); // pg.testPegChain(); // System.out.println(pg); // put every node of peg into this Iterator mainIt = pg.mainIterator(); while (mainIt.hasNext()) { JPegStmt s = (JPegStmt) mainIt.next(); // System.out.println("add to mainPegChain: "+s); mainPegChain.addLast(s); // if (chain.contains(s)){ // System.err.println("error! chain contains: "+s); // System.exit(1); // } // else // chain.addLast(s); } Iterator it = pg.iterator(); while (it.hasNext()) { JPegStmt s = (JPegStmt) it.next(); // System.out.println("add to allNodes: "+s); if (allNodes.contains(s)) { System.err.println("error! allNodes contains: " + s); System.exit(1); } else allNodes.add(s); } // testPegChain(); // testIterator(); unitToSuccs.putAll(pg.getUnitToSuccs()); unitToPreds.putAll(pg.getUnitToPreds()); // testUnitToSucc(); // testUnitToPred(); // buildMaps(pg); // RLH return true; }
private void buildHeadsAndTails() { List tailList = new ArrayList(); List headList = new ArrayList(); // Build the sets { Iterator unitIt = mainPegChain.iterator(); while (unitIt.hasNext()) { JPegStmt s = (JPegStmt) unitIt.next(); List succs = unitToSuccs.get(s); if (succs.size() == 0) tailList.add(s); if (!unitToPreds.containsKey(s)) { System.err.println("unitToPreds does not contain key: " + s); System.exit(1); } List preds = unitToPreds.get(s); if (preds.size() == 0) headList.add(s); // System.out.println("head is:"); } } tails = (List) tailList; heads = (List) headList; // tails = Collections.unmodifiableList(tailList); // heads = Collections.unmodifiableList(headList); Iterator tmpIt = heads.iterator(); while (tmpIt.hasNext()) { Object temp = tmpIt.next(); // System.out.println(temp); } buildPredecessor(mainPegChain); }
protected void buildSuccsForInlining(JPegStmt stmt, Chain chain, PegGraph inlinee) { // System.out.println("entering buildSuccsForInlining..."); Tag tag = (Tag) stmt.getTags().get(0); // System.out.println("stmt is: "+tag+" "+stmt); /*connect heads of inlinee with the preds of invokeStmt and * delete stmt from the succs list from the preds */ Iterator predIt = getPredsOf(stmt).iterator(); // System.out.println("preds list: "+getPredsOf(stmt)); // System.out.println("preds size: "+getPredsOf(stmt).size()); Iterator headsIt = inlinee.getHeads().iterator(); { // System.out.println("heads: "+inlinee.getHeads()); while (predIt.hasNext()) { JPegStmt pred = (JPegStmt) predIt.next(); // System.out.println("pred: "+pred); List succList = (List) getSuccsOf(pred); // System.out.println("succList of pred: "+succList); int pos = succList.indexOf(stmt); // System.out.println("remove : "+stmt + " from succList: \n"+succList+ "\n of pred" ); // remove invokeStmt succList.remove(pos); while (headsIt.hasNext()) { succList.add(headsIt.next()); } unitToSuccs.put(pred, succList); } { while (headsIt.hasNext()) { Object head = headsIt.next(); List predsOfHeads = new ArrayList(); predsOfHeads.addAll(getPredsOf(head)); unitToPreds.put(head, predsOfHeads); } } /* { predIt = getPredsOf(stmt).iterator(); while (predIt.hasNext()){ JPegStmt s = (JPegStmt)predIt.next(); if (unitToSuccs.containsKey(s)){ Iterator succIt = ((List) unitToSuccs.get(s)).iterator(); while(succIt.hasNext()){ //Object successor = succIt.next(); JPegStmt successor = (JPegStmt)succIt.next(); List predList = (List) unitToPreds.get(successor); if (predList != null) { try { predList.add(s); } catch(NullPointerException e) { System.out.println(s + "successor: " + successor); throw e; } } } } } }*/ } /*connect tails of inlinee with the succ of invokeStmt and * delete stmt from the */ Iterator tailsIt = inlinee.getTails().iterator(); { // System.out.println("tails: "+inlinee.getTails()); while (tailsIt.hasNext()) { Iterator succIt = getSuccsOf(stmt).iterator(); JPegStmt tail = (JPegStmt) tailsIt.next(); List succList = null; if (unitToSuccs.containsKey(tail)) { // System.out.println("error: unitToSucc containsKey: "+tail); succList = (List) getSuccsOf(tail); // System.out.println("succList: "+succList); } else { succList = new ArrayList(); } while (succIt.hasNext()) { JPegStmt succ = (JPegStmt) succIt.next(); succList.add(succ); // System.out.println("succ: "+succ); // remove stmt from the preds list of the succs of itself. List predListOfSucc = getPredsOf(succ); if (predListOfSucc == null) { System.err.println("Error: predListOfSucc is null!"); System.exit(1); } else { if (predListOfSucc.size() != 0) { int pos = predListOfSucc.indexOf(stmt); if (pos > 0 || pos == 0) { // System.out.println("remove stmt: "+stmt+" from the preds list"+predListOfSucc+" // of the succ"); predListOfSucc.remove(pos); } // System.out.println("remove(from PRED): "); } } unitToPreds.put(succ, predListOfSucc); } unitToSuccs.put(tail, succList); // System.out.println("put: "+tail); // System.out.println("succList: "+succList+ "into unitToSucc"); } } // add Nov 1 { tailsIt = inlinee.getTails().iterator(); while (tailsIt.hasNext()) { JPegStmt s = (JPegStmt) tailsIt.next(); if (unitToSuccs.containsKey(s)) { Iterator succIt = unitToSuccs.get(s).iterator(); while (succIt.hasNext()) { // Object successor = succIt.next(); JPegStmt successor = (JPegStmt) succIt.next(); List<JPegStmt> predList = unitToPreds.get(successor); if (predList != null && !predList.contains(s)) { try { predList.add(s); /* Tag tag = (Tag)successor.getTags().get(0); System.out.println("add "+s+" to predlist of "+tag+" "+successor); */ } catch (NullPointerException e) { System.out.println(s + "successor: " + successor); throw e; } } } } } } // end add Nov 1 // System.out.println("stmt: "+stmt); // remove stmt from allNodes and mainPegChain // System.out.println("mainPegChain contains stmt: "+mainPegChain.contains(stmt)); // testPegChain(); if (!allNodes.contains(stmt)) { System.err.println("fail to find begin node in allNodes!"); System.exit(1); } else { allNodes.remove(stmt); // System.out.println("remove from allNode: "+stmt); } if (!chain.contains(stmt)) { System.err.println("Error! Chain does not contains stmt (extending point)!"); System.exit(1); } else { if (!chain.remove(stmt)) { System.err.println("fail to remove invoke stmt in from Chain!"); System.exit(1); } } /* if (!mainPegChain.contains(stmt)){ boolean find = false; //System.out.println("main chain does not contain AFTER"); Set maps = startToThread.entrySet(); for(Iterator iter=maps.iterator(); iter.hasNext();){ Map.Entry entry = (Map.Entry)iter.next(); Object startNode = entry.getKey(); Iterator runIt = ((List)entry.getValue()).iterator(); while (runIt.hasNext()){ Chain chain=(Chain)runIt.next(); if (chain.contains(stmt)) { find = true; if (!chain.remove(stmt)){ System.err.println("fail to remove begin node in from mainPegChain!"); System.exit(1); } break; } } if (find == false){ System.err.println("fail to find stmt: "+stmt+" in chains!"); System.exit(1); } } //this.toString(); } else{ if (!mainPegChain.remove(stmt)) { System.err.println("fail to remove begin node in from mainPegChain!"); System.exit(1); } else{ // System.out.println("remove(from mainchain): "+stmt); } } */ // remove stmt from unitToSuccs and unitToPreds if (unitToSuccs.containsKey(stmt)) { unitToSuccs.remove(stmt); } if (unitToPreds.containsKey(stmt)) { unitToPreds.remove(stmt); } }
/* private void deleteExitToException(){ Iterator it = iterator(); while (it.hasNext()){ JPegStmt stmt = (JPegStmt)it.next(); Unit unit = stmt.getUnit(); UnitGraph unitGraph = stmt.getUnitGraph(); if (unit instanceof ExitMonitorStmt){ Iterator succIt = unitGraph.getSuccsOf(unit).iterator(); while(succIt.next && exceHandlers.contains(un) ){ System.out.println("====find it! unit: "+unit+"\n un: "+un); continue; } } } */ private void buildPredecessor(Chain pegChain) { // System.out.println("==building predcessor==="); // initialize the pred sets to empty { JPegStmt s = null; Iterator unitIt = pegChain.iterator(); while (unitIt.hasNext()) { s = (JPegStmt) unitIt.next(); unitToPreds.put(s, new ArrayList()); } } // System.out.println("==finish init of unitToPred==="); { Iterator unitIt = pegChain.iterator(); while (unitIt.hasNext()) { Object s = unitIt.next(); // System.out.println("s is: "+s); // Modify preds set for each successor for this statement if (unitToSuccs.containsKey(s)) { List succList = unitToSuccs.get(s); Iterator succIt = succList.iterator(); // System.out.println("unitToSuccs contains "+s); // System.out.println("succList is: "+succList); while (succIt.hasNext()) { // Object successor = succIt.next(); JPegStmt successor = (JPegStmt) succIt.next(); // System.out.println("successor is: "+successor); List<Object> predList = unitToPreds.get(successor); // System.out.println("predList is: "+predList); if (predList != null && !predList.contains(s)) { try { predList.add(s); /* Tag tag1 = (Tag)((JPegStmt)s).getTags().get(0); System.out.println("add "+tag1+" "+s+" to predListof"); Tag tag2 = (Tag)((JPegStmt)successor).getTags().get(0); System.out.println(tag2+" "+successor); */ } catch (NullPointerException e) { System.out.println(s + "successor: " + successor); throw e; } // if (((JPegStmt)successor).getName().equals("start")){ if (successor instanceof StartStmt) { List runMethodChainList = startToThread.get(successor); if (runMethodChainList == null) { throw new RuntimeException("null runmehtodchain: \n" + successor.getUnit()); } Iterator possibleMethodIt = runMethodChainList.iterator(); while (possibleMethodIt.hasNext()) { Chain subChain = (Chain) possibleMethodIt.next(); buildPredecessor(subChain); } } } else { System.err.println("predlist of " + s + " is null"); // System.exit(1); } // unitToPreds.put(successor, predList); } } else { System.err.println("unitToSuccs does not contains key" + s); System.exit(1); } } } }
private void buildSuccessor(Chain pegChain) { // Add regular successors { HashMap unitToPeg = (HashMap) unitToPegMap.get(pegChain); Iterator pegIt = pegChain.iterator(); JPegStmt currentNode, nextNode; currentNode = pegIt.hasNext() ? (JPegStmt) pegIt.next() : null; // June 19 add for begin node if (currentNode != null) { // System.out.println("currentNode: "+currentNode); // if the unit is "begin" node nextNode = pegIt.hasNext() ? (JPegStmt) pegIt.next() : null; if (currentNode.getName().equals("begin")) { List<JPegStmt> successors = new ArrayList<JPegStmt>(); successors.add(nextNode); unitToSuccs.put(currentNode, successors); currentNode = nextNode; } // end June 19 add for begin node while (currentNode != null) { // System.out.println("currentNode: "+currentNode); /* If unitToSuccs contains currentNode, it is the point to inline methods, * we need not compute its successors again */ if (unitToSuccs.containsKey(currentNode) && !currentNode.getName().equals("wait")) { currentNode = pegIt.hasNext() ? (JPegStmt) pegIt.next() : null; continue; } List<JPegStmt> successors = new ArrayList<JPegStmt>(); Unit unit = currentNode.getUnit(); UnitGraph unitGraph = currentNode.getUnitGraph(); List unitSucc = unitGraph.getSuccsOf(unit); Iterator succIt = unitSucc.iterator(); while (succIt.hasNext()) { Unit un = (Unit) succIt.next(); // Don't build the edge from "monitor exit" to exception handler if (unit instanceof ExitMonitorStmt && exceHandlers.contains(un)) { // System.out.println("====find it! unit: "+unit+"\n un: "+un); continue; } else if (unitToPeg.containsKey(un)) { JPegStmt pp = (JPegStmt) (unitToPeg.get(un)); if (pp != null && !successors.contains(pp)) successors.add(pp); } } // end while if (currentNode.getName().equals("wait")) { while (!(currentNode.getName().equals("notified-entry"))) { currentNode = pegIt.hasNext() ? (JPegStmt) pegIt.next() : null; } unitToSuccs.put(currentNode, successors); // System.out.println("put key: "+currentNode+" into unitToSucc"); } else { unitToSuccs.put(currentNode, successors); } if (currentNode.getName().equals("start")) { // System.out.println("-----build succ for start----"); if (startToThread.containsKey(currentNode)) { List runMethodChainList = startToThread.get(currentNode); Iterator possibleMethodIt = runMethodChainList.iterator(); while (possibleMethodIt.hasNext()) { Chain subChain = (Chain) possibleMethodIt.next(); if (subChain != null) { // System.out.println("build succ for subChain"); // buildSuccessor(subGraph, subChain, addExceptionEdges); buildSuccessor(subChain); } else System.out.println("*********subgraph is null!!!"); } } } currentNode = pegIt.hasNext() ? (JPegStmt) pegIt.next() : null; } // while // June 19 add for begin node } // end June 19 add for begin node } }
// This method adds the monitorenter/exit statements into whichever pegChain contains the // corresponding node statement protected void addMonitorStmt() { // System.out.println("====entering addMonitorStmt"); if (synch.size() > 0) { // System.out.println("synch: "+synch); Iterator<List> it = synch.iterator(); while (it.hasNext()) { List list = it.next(); JPegStmt node = (JPegStmt) list.get(0); JPegStmt enter = (JPegStmt) list.get(1); JPegStmt exit = (JPegStmt) list.get(2); // System.out.println("monitor node: "+node); // System.out.println("monitor enter: "+enter); // System.out.println("monitor exit: "+exit); // add for test // System.out.println("allNodes contains node: "+allNodes.contains(node)); // end add for test { if (!mainPegChain.contains(node)) { boolean find = false; // System.out.println("main chain does not contain node"); Set maps = startToThread.entrySet(); // System.out.println("size of startToThread: "+startToThread.size()); for (Iterator iter = maps.iterator(); iter.hasNext(); ) { Map.Entry entry = (Map.Entry) iter.next(); Object startNode = entry.getKey(); Iterator runIt = ((List) entry.getValue()).iterator(); while (runIt.hasNext()) { Chain chain = (Chain) runIt.next(); // testPegChain(chain); if (chain.contains(node)) { find = true; // System.out.println("---find it---"); chain.add(enter); chain.add(exit); break; } } } if (find == false) { System.err.println("fail to find stmt: " + node + " in chains!"); System.exit(1); } // this.toString(); } else { mainPegChain.add(enter); mainPegChain.add(exit); } } allNodes.add(enter); allNodes.add(exit); insertBefore(node, enter); insertAfter(node, exit); } } // add for test /* { // System.out.println("===main peg chain==="); //testPegChain(mainPegChain); //System.out.println("===end main peg chain==="); Set maps = startToThread.entrySet(); for(Iterator iter=maps.iterator(); iter.hasNext();){ Map.Entry entry = (Map.Entry)iter.next(); Object startNode = entry.getKey(); Iterator runIt = ((List)entry.getValue()).iterator(); while (runIt.hasNext()){ Chain chain=(Chain)runIt.next(); testPegChain(chain); } } } */ // System.out.println(this.toString()); // end add for test }
/** * 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()); }
public Iterator mainIterator() { return mainPegChain.iterator(); }
/** 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(); } } }