Fix tabbing.... Please fix your editors so they do tabbing correctly!!! (Spaces...
authorbdemsky <bdemsky>
Wed, 27 Apr 2011 20:34:28 +0000 (20:34 +0000)
committerbdemsky <bdemsky>
Wed, 27 Apr 2011 20:34:28 +0000 (20:34 +0000)
295 files changed:
Robust/src/Analysis/CallGraph/BaseCallGraph.java
Robust/src/Analysis/CallGraph/JavaCallGraph.java
Robust/src/Analysis/Disjoint/AllocSite.java
Robust/src/Analysis/Disjoint/BuildStateMachines.java
Robust/src/Analysis/Disjoint/Canonical.java
Robust/src/Analysis/Disjoint/CanonicalOp.java
Robust/src/Analysis/Disjoint/ChangeSet.java
Robust/src/Analysis/Disjoint/ChangeTuple.java
Robust/src/Analysis/Disjoint/DescriptorComparator.java
Robust/src/Analysis/Disjoint/DescriptorQWrapper.java
Robust/src/Analysis/Disjoint/DisjointAnalysis.java
Robust/src/Analysis/Disjoint/Effect.java
Robust/src/Analysis/Disjoint/EffectsAnalysis.java
Robust/src/Analysis/Disjoint/ExistPred.java
Robust/src/Analysis/Disjoint/ExistPredSet.java
Robust/src/Analysis/Disjoint/HeapRegionNode.java
Robust/src/Analysis/Disjoint/HrnIdOoc.java
Robust/src/Analysis/Disjoint/PointerMethod.java
Robust/src/Analysis/Disjoint/ProcessStateMachines.java
Robust/src/Analysis/Disjoint/ReachGraph.java
Robust/src/Analysis/Disjoint/ReachSet.java
Robust/src/Analysis/Disjoint/ReachState.java
Robust/src/Analysis/Disjoint/ReachTuple.java
Robust/src/Analysis/Disjoint/RefEdge.java
Robust/src/Analysis/Disjoint/RefSrcNode.java
Robust/src/Analysis/Disjoint/SMFEState.java
Robust/src/Analysis/Disjoint/StallSite.java
Robust/src/Analysis/Disjoint/StateMachineForEffects.java
Robust/src/Analysis/Disjoint/Taint.java
Robust/src/Analysis/Disjoint/TaintSet.java
Robust/src/Analysis/Disjoint/VariableNode.java
Robust/src/Analysis/FlatIRGraph/FlatIRGraph.java
Robust/src/Analysis/Locality/BranchAnalysis.java
Robust/src/Analysis/Locality/DCWrapper.java
Robust/src/Analysis/Locality/DelayComputation.java
Robust/src/Analysis/Locality/DiscoverConflicts.java
Robust/src/Analysis/Locality/GenerateConversions.java
Robust/src/Analysis/Locality/LocalityAnalysis.java
Robust/src/Analysis/Locality/LocalityBinding.java
Robust/src/Analysis/Locality/TypeAnalysis.java
Robust/src/Analysis/Loops/CSE.java
Robust/src/Analysis/Loops/CopyPropagation.java
Robust/src/Analysis/Loops/DeadCode.java
Robust/src/Analysis/Loops/DomTree.java
Robust/src/Analysis/Loops/GlobalFieldType.java
Robust/src/Analysis/Loops/LoopFinder.java
Robust/src/Analysis/Loops/LoopInvariant.java
Robust/src/Analysis/Loops/LoopOptimize.java
Robust/src/Analysis/Loops/Loops.java
Robust/src/Analysis/Loops/UseDef.java
Robust/src/Analysis/Loops/WriteBarrier.java
Robust/src/Analysis/Loops/localCSE.java
Robust/src/Analysis/OoOJava/Accessible.java
Robust/src/Analysis/OoOJava/CodePlan.java
Robust/src/Analysis/OoOJava/ConflictEdge.java
Robust/src/Analysis/OoOJava/ConflictGraph.java
Robust/src/Analysis/OoOJava/ConflictNode.java
Robust/src/Analysis/OoOJava/ContextTaskNames.java
Robust/src/Analysis/OoOJava/OoOJavaAnalysis.java
Robust/src/Analysis/OoOJava/RBlockRelationAnalysis.java
Robust/src/Analysis/OoOJava/SESELock.java
Robust/src/Analysis/OoOJava/SESEWaitingQueue.java
Robust/src/Analysis/OoOJava/SESEandAgePair.java
Robust/src/Analysis/OoOJava/SVKey.java
Robust/src/Analysis/OoOJava/VarSrcTokTable.java
Robust/src/Analysis/OoOJava/VariableSourceToken.java
Robust/src/Analysis/OoOJava/WaitingElement.java
Robust/src/Analysis/OwnershipAnalysis/AccessPath.java
Robust/src/Analysis/OwnershipAnalysis/AllocationSite.java
Robust/src/Analysis/OwnershipAnalysis/Canonical.java
Robust/src/Analysis/OwnershipAnalysis/CanonicalWrapper.java
Robust/src/Analysis/OwnershipAnalysis/EffectsKey.java
Robust/src/Analysis/OwnershipAnalysis/EffectsSet.java
Robust/src/Analysis/OwnershipAnalysis/HeapRegionNode.java
Robust/src/Analysis/OwnershipAnalysis/MethodContext.java
Robust/src/Analysis/OwnershipAnalysis/MethodContextQWrapper.java
Robust/src/Analysis/OwnershipAnalysis/MethodEffects.java
Robust/src/Analysis/OwnershipAnalysis/MethodEffectsAnalysis.java
Robust/src/Analysis/OwnershipAnalysis/OwnershipAnalysis.java
Robust/src/Analysis/OwnershipAnalysis/OwnershipGraph.java
Robust/src/Analysis/OwnershipAnalysis/OwnershipNode.java
Robust/src/Analysis/OwnershipAnalysis/ParameterDecomposition.java
Robust/src/Analysis/OwnershipAnalysis/ReachOperation.java
Robust/src/Analysis/OwnershipAnalysis/ReachabilitySet.java
Robust/src/Analysis/OwnershipAnalysis/ReferenceEdge.java
Robust/src/Analysis/OwnershipAnalysis/TokenTuple.java
Robust/src/Analysis/OwnershipAnalysis/TokenTupleSet.java
Robust/src/Analysis/Pointer/AllocFactory.java
Robust/src/Analysis/Pointer/BasicBlock.java
Robust/src/Analysis/Pointer/Delta.java
Robust/src/Analysis/Pointer/Edge.java
Robust/src/Analysis/Pointer/Graph.java
Robust/src/Analysis/Pointer/GraphManip.java
Robust/src/Analysis/Pointer/MySet.java
Robust/src/Analysis/Pointer/Pointer.java
Robust/src/Analysis/Pointer/Util.java
Robust/src/Analysis/Prefetch/IndexDescriptor.java
Robust/src/Analysis/Prefetch/PairMap.java
Robust/src/Analysis/Prefetch/PrefetchAnalysis.java
Robust/src/Analysis/Prefetch/PrefetchPair.java
Robust/src/Analysis/SSJava/CompositeLocation.java
Robust/src/Analysis/SSJava/DefinitelyWrittenCheck.java
Robust/src/Analysis/SSJava/DeltaLocation.java
Robust/src/Analysis/SSJava/FlowDownCheck.java
Robust/src/Analysis/SSJava/Location.java
Robust/src/Analysis/SSJava/NTuple.java
Robust/src/Analysis/Scheduling/ClassNode.java
Robust/src/Analysis/Scheduling/CombinationUtil.java
Robust/src/Analysis/Scheduling/CoreSimulator.java
Robust/src/Analysis/Scheduling/MCImplSynthesis.java
Robust/src/Analysis/Scheduling/ObjectSimulator.java
Robust/src/Analysis/Scheduling/Schedule.java
Robust/src/Analysis/Scheduling/ScheduleAnalysis.java
Robust/src/Analysis/Scheduling/ScheduleEdge.java
Robust/src/Analysis/Scheduling/ScheduleNode.java
Robust/src/Analysis/Scheduling/ScheduleSimulator.java
Robust/src/Analysis/Scheduling/SchedulingUtil.java
Robust/src/Analysis/Scheduling/SimExecutionEdge.java
Robust/src/Analysis/Scheduling/SimExecutionNode.java
Robust/src/Analysis/Scheduling/TaskSimulator.java
Robust/src/Analysis/Scheduling/TransTaskSimulator.java
Robust/src/Analysis/TaskStateAnalysis/ExecutionGraph.java
Robust/src/Analysis/TaskStateAnalysis/FEdge.java
Robust/src/Analysis/TaskStateAnalysis/FlagComparator.java
Robust/src/Analysis/TaskStateAnalysis/FlagInfo.java
Robust/src/Analysis/TaskStateAnalysis/FlagState.java
Robust/src/Analysis/TaskStateAnalysis/GarbageAnalysis.java
Robust/src/Analysis/TaskStateAnalysis/SafetyAnalysis.java
Robust/src/Analysis/TaskStateAnalysis/TagAnalysis.java
Robust/src/Analysis/TaskStateAnalysis/TaskAnalysis.java
Robust/src/Analysis/TaskStateAnalysis/TaskGraph.java
Robust/src/Analysis/TaskStateAnalysis/TaskQueueIterator.java
Robust/src/Analysis/TaskStateAnalysis/TaskTagAnalysis.java
Robust/src/Benchmarks/Distributed/LookUpService/dsm/makefile
Robust/src/Benchmarks/Distributed/RainForest/dsm/makefile
Robust/src/ClassLibrary/Character.java
Robust/src/ClassLibrary/Enumeration.java
Robust/src/ClassLibrary/FileOutputStream.java
Robust/src/ClassLibrary/HashMap.java
Robust/src/ClassLibrary/InetAddress.java
Robust/src/ClassLibrary/Integer.java
Robust/src/ClassLibrary/LinkedList.java
Robust/src/ClassLibrary/Math.java
Robust/src/ClassLibrary/Objectwrapper.java
Robust/src/ClassLibrary/Queue.java
Robust/src/ClassLibrary/String.java
Robust/src/ClassLibrary/StringBuffer.java
Robust/src/ClassLibrary/System.java
Robust/src/ClassLibrary/Vector.java
Robust/src/ClassLibrary/VectorIterator.java
Robust/src/ClassLibrary/bytewrapper.java
Robust/src/ClassLibrary/charwrapper.java
Robust/src/ClassLibrary/doublewrapper.java
Robust/src/ClassLibrary/floatwrapper.java
Robust/src/ClassLibrary/gnu/Double.java
Robust/src/ClassLibrary/gnu/FileDescriptor.java
Robust/src/ClassLibrary/gnu/Number.java
Robust/src/ClassLibrary/gnu/StringTokenizer.java
Robust/src/ClassLibrary/intwrapper.java
Robust/src/IR/AnnotationDescriptor.java
Robust/src/IR/ClassDescriptor.java
Robust/src/IR/FieldDescriptor.java
Robust/src/IR/Flat/AtomicRecord.java
Robust/src/IR/Flat/BuildCode.java
Robust/src/IR/Flat/BuildCodeMGC.java
Robust/src/IR/Flat/BuildCodeMultiCore.java
Robust/src/IR/Flat/BuildCodeTran.java
Robust/src/IR/Flat/BuildFlat.java
Robust/src/IR/Flat/BuildOoOJavaCode.java
Robust/src/IR/Flat/FieldShadow.java
Robust/src/IR/Flat/FlatBackEdge.java
Robust/src/IR/Flat/FlatCall.java
Robust/src/IR/Flat/FlatEdge.java
Robust/src/IR/Flat/FlatFlagActionNode.java
Robust/src/IR/Flat/FlatGenReachNode.java
Robust/src/IR/Flat/FlatMethod.java
Robust/src/IR/Flat/FlatNode.java
Robust/src/IR/Flat/FlatPrefetchNode.java
Robust/src/IR/Flat/FlatSESEEnterNode.java
Robust/src/IR/Flat/FlatSESEExitNode.java
Robust/src/IR/Flat/FlatWriteDynamicVarNode.java
Robust/src/IR/Flat/Inliner.java
Robust/src/IR/Flat/RuntimeConflictResolver.java
Robust/src/IR/Flat/TempObject.java
Robust/src/IR/MethodDescriptor.java
Robust/src/IR/NameDescriptor.java
Robust/src/IR/State.java
Robust/src/IR/SymbolTable.java
Robust/src/IR/Tree/ArrayAccessNode.java
Robust/src/IR/Tree/ArrayInitializerNode.java
Robust/src/IR/Tree/AssignmentNode.java
Robust/src/IR/Tree/BlockNode.java
Robust/src/IR/Tree/BuildIR.java
Robust/src/IR/Tree/CastNode.java
Robust/src/IR/Tree/ClassTypeNode.java
Robust/src/IR/Tree/ContinueBreakNode.java
Robust/src/IR/Tree/CreateObjectNode.java
Robust/src/IR/Tree/ExpressionNode.java
Robust/src/IR/Tree/FlagOpNode.java
Robust/src/IR/Tree/GenReachNode.java
Robust/src/IR/Tree/InstanceOfNode.java
Robust/src/IR/Tree/JavaBuilder.java
Robust/src/IR/Tree/LiteralNode.java
Robust/src/IR/Tree/MethodInvokeNode.java
Robust/src/IR/Tree/Modifiers.java
Robust/src/IR/Tree/NameNode.java
Robust/src/IR/Tree/OffsetNode.java
Robust/src/IR/Tree/OpNode.java
Robust/src/IR/Tree/ParseNode.java
Robust/src/IR/Tree/SESENode.java
Robust/src/IR/Tree/SemanticCheck.java
Robust/src/IR/Tree/SwitchBlockNode.java
Robust/src/IR/Tree/SwitchLabelNode.java
Robust/src/IR/Tree/SwitchStatementNode.java
Robust/src/IR/Tree/TertiaryNode.java
Robust/src/IR/Tree/TreeNode.java
Robust/src/IR/TypeDescriptor.java
Robust/src/IR/TypeUtil.java
Robust/src/IR/Virtual.java
Robust/src/Interface/WebInterface.java
Robust/src/Lex/EscapedUnicodeReader.java
Robust/src/Lex/FIFO.java
Robust/src/Lex/Lexer.java
Robust/src/Main/Main.java
Robust/src/Runtime/DSTM/interface/abortreaders.c
Robust/src/Runtime/DSTM/interface/addPrefetchEnhance.c
Robust/src/Runtime/DSTM/interface/addUdpEnhance.c
Robust/src/Runtime/DSTM/interface/altmlookup.c
Robust/src/Runtime/DSTM/interface/altprelookup.c
Robust/src/Runtime/DSTM/interface/altprelookup.h
Robust/src/Runtime/DSTM/interface/clocksyncclient.c
Robust/src/Runtime/DSTM/interface/clocksyncserver.c
Robust/src/Runtime/DSTM/interface/clookup.c
Robust/src/Runtime/DSTM/interface/clookup2.c
Robust/src/Runtime/DSTM/interface/debugmacro.h
Robust/src/Runtime/DSTM/interface/dsmdebug.h
Robust/src/Runtime/DSTM/interface/dsmlock.c
Robust/src/Runtime/DSTM/interface/dsmlock.h
Robust/src/Runtime/DSTM/interface/dstm.h
Robust/src/Runtime/DSTM/interface/dstmserver.c
Robust/src/Runtime/DSTM/interface/gCollect.c
Robust/src/Runtime/DSTM/interface/gCollect.h
Robust/src/Runtime/DSTM/interface/ip.c
Robust/src/Runtime/DSTM/interface/machinepile.c
Robust/src/Runtime/DSTM/interface/main.c
Robust/src/Runtime/DSTM/interface/mlookup.c
Robust/src/Runtime/DSTM/interface/objstr.c
Robust/src/Runtime/DSTM/interface/prefetch.c
Robust/src/Runtime/DSTM/interface/prelookup.c
Robust/src/Runtime/DSTM/interface/queue.c
Robust/src/Runtime/DSTM/interface/sandbox.c
Robust/src/Runtime/DSTM/interface/signal.c
Robust/src/Runtime/DSTM/interface/threadnotify.c
Robust/src/Runtime/DSTM/interface/trans.c
Robust/src/Runtime/GenericHashtable.c
Robust/src/Runtime/ObjectHash.c
Robust/src/Runtime/Queue.c
Robust/src/Runtime/SimpleHash.c
Robust/src/Runtime/affinity.h
Robust/src/Runtime/chash.c
Robust/src/Runtime/deque.c
Robust/src/Runtime/deque.h
Robust/src/Runtime/file.c
Robust/src/Runtime/garbage.c
Robust/src/Runtime/garbage.h
Robust/src/Runtime/mem.c
Robust/src/Runtime/memPool.h
Robust/src/Runtime/mlp_lock.h
Robust/src/Runtime/mlp_runtime.c
Robust/src/Runtime/mlp_runtime.h
Robust/src/Runtime/object.c
Robust/src/Runtime/object.h
Robust/src/Runtime/oojgarbage.c
Robust/src/Runtime/psemaphore.c
Robust/src/Runtime/psemaphore.h
Robust/src/Runtime/runtime.c
Robust/src/Runtime/runtime.h
Robust/src/Runtime/socket.c
Robust/src/Runtime/squeue.h
Robust/src/Runtime/task.c
Robust/src/Runtime/taskgarbage.c
Robust/src/Runtime/thread.c
Robust/src/Runtime/thread.h
Robust/src/Runtime/workschedule.c
Robust/src/Runtime/workschedule.h
Robust/src/Util/CodePrinter.java
Robust/src/Util/GraphNode.java
Robust/src/Util/Lattice.java
Robust/src/Util/MultiHash.java
Robust/src/Util/OptimizedView.java
Robust/src/Util/Pair.java
Robust/src/Util/Tuple.java
Robust/src/Util/Tuples.java
Robust/src/Util/UtilAlgorithms.java
Robust/src/java.cfg

index 6edcfc3..22a8dc6 100644 (file)
@@ -25,7 +25,8 @@ public class BaseCallGraph implements CallGraph {
   // MethodDescriptor maps to HashSet<MethodDescriptor or TaskDescriptor>
   protected Hashtable mapCallee2CallerSet;
 
-  protected BaseCallGraph() {}
+  protected BaseCallGraph() {
+  }
 
   protected TypeUtil typeUtil;
 
@@ -54,7 +55,7 @@ public class BaseCallGraph implements CallGraph {
   //  that call the given method
   public Set getCallerSet(MethodDescriptor md) {
     Set s = (Set) mapCallee2CallerSet.get(md);
-    
+
     if( s == null ) {
       return new HashSet();
     }
@@ -91,18 +92,18 @@ public class BaseCallGraph implements CallGraph {
        Stack<ClassDescriptor> possInterfaces=new Stack<ClassDescriptor>();
        ClassDescriptor tmpcd=cn;
        while(tmpcd!=null) {
-         for(Iterator supit=tmpcd.getSuperInterfaces();supit.hasNext();) {
+         for(Iterator supit=tmpcd.getSuperInterfaces(); supit.hasNext(); ) {
            possInterfaces.add((ClassDescriptor)supit.next());
          }
          tmpcd=tmpcd.getSuperDesc();
        }
        while(!possInterfaces.isEmpty()) {
          ClassDescriptor IFdesc=possInterfaces.pop();
-         for(Iterator supit=IFdesc.getSuperInterfaces();supit.hasNext();) {
+         for(Iterator supit=IFdesc.getSuperInterfaces(); supit.hasNext(); ) {
            possInterfaces.add((ClassDescriptor)supit.next());
          }
          Set possiblematches=IFdesc.getMethodTable().getSet(md.getSymbol());
-         for(Iterator matchit=possiblematches.iterator(); matchit.hasNext();) {
+         for(Iterator matchit=possiblematches.iterator(); matchit.hasNext(); ) {
            MethodDescriptor matchmd=(MethodDescriptor)matchit.next();
            if (md.matches(matchmd)) {
              if (!mapVirtual2ImplementationSet.containsKey(matchmd))
@@ -112,12 +113,12 @@ public class BaseCallGraph implements CallGraph {
            }
          }
        }
-       
+
 
        ClassDescriptor superdesc=cn.getSuperDesc();
        if (superdesc!=null) {
          Set possiblematches=superdesc.getMethodTable().getSet(md.getSymbol());
-         for(Iterator matchit=possiblematches.iterator(); matchit.hasNext();) {
+         for(Iterator matchit=possiblematches.iterator(); matchit.hasNext(); ) {
            MethodDescriptor matchmd=(MethodDescriptor)matchit.next();
            if (md.matches(matchmd)) {
              if (!mapVirtual2ImplementationSet.containsKey(matchmd))
@@ -142,7 +143,7 @@ public class BaseCallGraph implements CallGraph {
     ns.add(md);
     Set s=(Set)mapVirtual2ImplementationSet.get(md);
     if (s!=null)
-      for(Iterator it=s.iterator(); it.hasNext();) {
+      for(Iterator it=s.iterator(); it.hasNext(); ) {
        MethodDescriptor md2=(MethodDescriptor)it.next();
        ns.addAll(getMethods(md2));
       }
@@ -174,7 +175,7 @@ public class BaseCallGraph implements CallGraph {
     found.add(d);
     Set s=(Set)mapCaller2CalleeSet.get(d);
     if (s!=null)
-      for(Iterator it=s.iterator(); it.hasNext();) {
+      for(Iterator it=s.iterator(); it.hasNext(); ) {
        MethodDescriptor md=(MethodDescriptor)it.next();
        if( !found.contains(md) ) {
          ns.addAll(getMoreMethodCalls(found, md));
@@ -199,7 +200,7 @@ public class BaseCallGraph implements CallGraph {
       Set s=(Set)mapCaller2CalleeSet.get(md);
 
       if (s!=null) {
-       for(Iterator it=s.iterator(); it.hasNext();) {
+       for(Iterator it=s.iterator(); it.hasNext(); ) {
          MethodDescriptor md2=(MethodDescriptor)it.next();
          if( !callable.contains(md2) ) {
            callable.add(md2);
@@ -210,11 +211,11 @@ public class BaseCallGraph implements CallGraph {
     }
     return callable;
   }
-  
-  // Returns a set of methods containing SESEs and located at the first   
-  // in transitive call chain starting from d 
+
+  // Returns a set of methods containing SESEs and located at the first
+  // in transitive call chain starting from d
   public Set getFirstReachableMethodContainingSESE(Descriptor d,
-      Set<MethodDescriptor> methodsContainingSESEs) {
+                                                   Set<MethodDescriptor> methodsContainingSESEs) {
     HashSet tovisit = new HashSet();
     tovisit.add(d);
     HashSet callable = new HashSet();
@@ -224,22 +225,22 @@ public class BaseCallGraph implements CallGraph {
       Set s = (Set) mapCaller2CalleeSet.get(md);
 
       if (s != null) {
-        for (Iterator it = s.iterator(); it.hasNext();) {
-          MethodDescriptor md2 = (MethodDescriptor) it.next();
-          if (!callable.contains(md2)) {
-            callable.add(md2);
-            if (!methodsContainingSESEs.contains(md2)) {
-              // if current method has sese, do not need to go down
-              tovisit.add(md2);
-            }
-          }
-        }
+       for (Iterator it = s.iterator(); it.hasNext(); ) {
+         MethodDescriptor md2 = (MethodDescriptor) it.next();
+         if (!callable.contains(md2)) {
+           callable.add(md2);
+           if (!methodsContainingSESEs.contains(md2)) {
+             // if current method has sese, do not need to go down
+             tovisit.add(md2);
+           }
+         }
+       }
       }
     }
 //    callable.retainAll(methodsContainingSESEs);
     return callable;
   }
-  
+
 
   private void buildGraph() {
     Iterator it=state.getClassSymbolTable().getDescriptorsIterator();
@@ -276,9 +277,9 @@ public class BaseCallGraph implements CallGraph {
       if (fn.kind()==FKind.FlatCall) {
        FlatCall fc=(FlatCall)fn;
        MethodDescriptor calledmethod=fc.getMethod();
-       Set methodsthatcouldbecalled=fc.getThis()==null ? getMethods(calledmethod) :
+       Set methodsthatcouldbecalled=fc.getThis()==null?getMethods(calledmethod):
                                      getMethods(calledmethod, fc.getThis().getType());
-       
+
        // add caller -> callee maps
        if( !mapCaller2CalleeSet.containsKey(caller) ) {
          mapCaller2CalleeSet.put(caller, new HashSet() );
index 2dc46ea..5b8a776 100644 (file)
@@ -65,7 +65,7 @@ public class JavaCallGraph extends BaseCallGraph {
       if (fm==null)
        continue;
       analyzeMethod(md, fm);
-      for(Iterator<FlatNode> fnit=fm.getNodeSet().iterator();fnit.hasNext();) {
+      for(Iterator<FlatNode> fnit=fm.getNodeSet().iterator(); fnit.hasNext(); ) {
        FlatNode fn=fnit.next();
        if (fn.kind()==FKind.FlatCall) {
          FlatCall fcall=(FlatCall)fn;
@@ -75,7 +75,7 @@ public class JavaCallGraph extends BaseCallGraph {
            MethodDescriptor methodd=fcall.getMethod();
 
            if (methodd.getClassDesc()==tu.getClass(TypeUtil.ThreadClass)&&
-               methodd.getSymbol().equals("start")&&methodd.numParameters()==0&&!methodd.getModifiers().isStatic()) {
+               methodd.getSymbol().equals("start")&&methodd.numParameters()==0&&!methodd.getModifiers().isStatic()) {
              //Have call to start
              HashSet ns=new HashSet();
              ns.addAll(callees);
@@ -85,7 +85,7 @@ public class JavaCallGraph extends BaseCallGraph {
            }
          }
 
-         for(Iterator mdit=callees.iterator();mdit.hasNext();) {
+         for(Iterator mdit=callees.iterator(); mdit.hasNext(); ) {
            MethodDescriptor callee=(MethodDescriptor)mdit.next();
            if (!discovered.contains(callee)) {
              discovered.add(callee);
index f5e1ca3..7c1961b 100644 (file)
@@ -37,34 +37,34 @@ public class AllocSite extends Canonical implements Alloc {
   public static final int SHADOWAGE_oldest        = -102;
   public static final int SHADOWAGE_summary       = -103;
 
-  protected Integer         id;
-  protected int             allocationDepth;
+  protected Integer id;
+  protected int allocationDepth;
   protected Vector<Integer> ithOldest;
-  protected Integer         summary;
-  protected FlatNew         flatNew;
-  protected String          disjointId;
-  protected boolean         isFlagged;
-
-
-  public static AllocSite factory( int     allocationDepth, 
-                                   FlatNew flatNew, 
-                                   String  disjointId,
-                                   boolean markAsFlagged
-                                   ) {
-    AllocSite out = new AllocSite( allocationDepth,
-                                   flatNew,
-                                   disjointId,
-                                   markAsFlagged );
-    out = (AllocSite) Canonical.makeCanonical( out );
+  protected Integer summary;
+  protected FlatNew flatNew;
+  protected String disjointId;
+  protected boolean isFlagged;
+
+
+  public static AllocSite factory(int allocationDepth,
+                                  FlatNew flatNew,
+                                  String disjointId,
+                                  boolean markAsFlagged
+                                  ) {
+    AllocSite out = new AllocSite(allocationDepth,
+                                  flatNew,
+                                  disjointId,
+                                  markAsFlagged);
+    out = (AllocSite) Canonical.makeCanonical(out);
     return out;
   }
 
 
-  protected AllocSite( int     allocationDepth, 
-                       FlatNew flatNew, 
-                       String  disjointId,
-                       boolean markAsFlagged
-                       ) {
+  protected AllocSite(int allocationDepth,
+                      FlatNew flatNew,
+                      String disjointId,
+                      boolean markAsFlagged
+                      ) {
 
     assert allocationDepth >= 1;
 
@@ -74,9 +74,9 @@ public class AllocSite extends Canonical implements Alloc {
 
     // mark this allocation site as being flagged
     // for the analysis if
-    // 1) we have a non-null disjointID (a named flagged site) 
+    // 1) we have a non-null disjointID (a named flagged site)
     // OR
-    // 2) the type is a class with Bamboo-parameter flags 
+    // 2) the type is a class with Bamboo-parameter flags
     // OR
     // 3) a client wants to programmatically flag this site,
     // such as the OoOJava method effects analysis
@@ -95,13 +95,13 @@ public class AllocSite extends Canonical implements Alloc {
     }
 
 
-    ithOldest = new Vector<Integer>( allocationDepth );
+    ithOldest = new Vector<Integer>(allocationDepth);
     id        = generateUniqueAllocSiteID();
   }
 
   static public Integer generateUniqueAllocSiteID() {
     ++uniqueIDcount;
-    return new Integer( uniqueIDcount );
+    return new Integer(uniqueIDcount);
   }
 
   public int getUniqueAllocSiteID() {
@@ -117,37 +117,37 @@ public class AllocSite extends Canonical implements Alloc {
     return allocationDepth;
   }
 
-  public void setIthOldest( int i, Integer id ) {
+  public void setIthOldest(int i, Integer id) {
     assert i  >= 0;
     assert i  <  allocationDepth;
     assert id != null;
 
-    ithOldest.add( i, id );
+    ithOldest.add(i, id);
   }
 
-  public Integer getIthOldest( int i ) {
+  public Integer getIthOldest(int i) {
     assert i >= 0;
     assert i <  allocationDepth;
 
-    return ithOldest.get( i );
+    return ithOldest.get(i);
   }
 
-  public Integer getIthOldestShadow( int i ) {
+  public Integer getIthOldestShadow(int i) {
     assert i >= 0;
     assert i <  allocationDepth;
 
-    return -ithOldest.get( i );
+    return -ithOldest.get(i);
   }
 
   public Integer getOldest() {
-    return ithOldest.get( allocationDepth - 1 );
+    return ithOldest.get(allocationDepth - 1);
   }
 
   public Integer getOldestShadow() {
-    return -ithOldest.get( allocationDepth - 1 );
+    return -ithOldest.get(allocationDepth - 1);
   }
 
-  public void setSummary( Integer id ) {
+  public void setSummary(Integer id) {
     assert id != null;
     summary = id;
   }
@@ -172,18 +172,18 @@ public class AllocSite extends Canonical implements Alloc {
     return isFlagged;
   }
 
-  public int getAgeCategory( Integer id ) {
+  public int getAgeCategory(Integer id) {
 
-    if( id.equals( summary ) ) {
+    if( id.equals(summary) ) {
       return AGE_summary;
     }
 
-    if( id.equals( getOldest() ) ) {
+    if( id.equals(getOldest() ) ) {
       return AGE_oldest;
     }
 
     for( int i = 0; i < allocationDepth - 1; ++i ) {
-      if( id.equals( ithOldest.get( i ) ) ) {
+      if( id.equals(ithOldest.get(i) ) ) {
        return AGE_in_I;
       }
     }
@@ -191,27 +191,27 @@ public class AllocSite extends Canonical implements Alloc {
     return AGE_notInThisSite;
   }
 
-  public Integer getAge( Integer id ) {
+  public Integer getAge(Integer id) {
     for( int i = 0; i < allocationDepth; ++i ) {
-      if( id.equals( ithOldest.get( i ) ) ) {
-       return new Integer( i );
+      if( id.equals(ithOldest.get(i) ) ) {
+       return new Integer(i);
       }
     }
 
     return null;
   }
 
-  public int getShadowAgeCategory( Integer id ) {
-    if( id.equals( -summary ) ) {
+  public int getShadowAgeCategory(Integer id) {
+    if( id.equals(-summary) ) {
       return SHADOWAGE_summary;
     }
 
-    if( id.equals( getOldestShadow() ) ) {
+    if( id.equals(getOldestShadow() ) ) {
       return SHADOWAGE_oldest;
     }
 
     for( int i = 0; i < allocationDepth - 1; ++i ) {
-      if( id.equals( getIthOldestShadow( i ) ) ) {
+      if( id.equals(getIthOldestShadow(i) ) ) {
        return SHADOWAGE_in_I;
       }
     }
@@ -219,29 +219,29 @@ public class AllocSite extends Canonical implements Alloc {
     return SHADOWAGE_notInThisSite;
   }
 
-  public Integer getShadowAge( Integer id ) {
+  public Integer getShadowAge(Integer id) {
     for( int i = 0; i < allocationDepth - 1; ++i ) {
-      if( id.equals( getIthOldestShadow( i ) ) ) {
-       return new Integer( -i );
+      if( id.equals(getIthOldestShadow(i) ) ) {
+       return new Integer(-i);
       }
     }
 
     return null;
   }
 
-  public Integer getShadowIDfromID( Integer id ) {
-    int ageCat = getAgeCategory( id );
+  public Integer getShadowIDfromID(Integer id) {
+    int ageCat = getAgeCategory(id);
     switch( ageCat ) {
-      
+
     case AGE_summary:
     case AGE_oldest:
     case AGE_in_I:
       return -id;
-      
+
     case AGE_notInThisSite:
     default:
-      System.out.println( toStringWithIDs() );
-      throw new Error( "ID "+id+" not from this site." );
+      System.out.println(toStringWithIDs() );
+      throw new Error("ID "+id+" not from this site.");
     }
   }
 
@@ -259,32 +259,32 @@ public class AllocSite extends Canonical implements Alloc {
   public String toStringVerbose() {
     if( disjointId == null ) {
       return "allocSite"+id+" "+
-        flatNew.getType().toPrettyString();
+             flatNew.getType().toPrettyString();
     }
     return "allocSite "+disjointId+" ("+id+") "+
-      flatNew.getType().toPrettyString();
+           flatNew.getType().toPrettyString();
   }
 
   public String toStringForDOT() {
     if( disjointId != null ) {
       return "disjoint "+disjointId+"\\n"+toString()+
-        "\\n"+getType().toPrettyString();
+             "\\n"+getType().toPrettyString();
     } else {
-      return                              toString()+
-        "\\n"+getType().toPrettyString();
+      return toString()+
+             "\\n"+getType().toPrettyString();
     }
   }
 
   public String toStringWithIDs() {
     String s = "allocSite"+id+" ";
     for( int i = 0; i < ithOldest.size(); ++i ) {
-      s += i+"("+ithOldest.get( i )+") ";
+      s += i+"("+ithOldest.get(i)+") ";
     }
     s += "summary("+summary+")";
     return s;
   }
 
-  public boolean equalsSpecific( Object o ) {
+  public boolean equalsSpecific(Object o) {
     if( o == null ) {
       return false;
     }
@@ -300,5 +300,5 @@ public class AllocSite extends Canonical implements Alloc {
 
   public int hashCodeSpecific() {
     return id.hashCode();
-  }  
+  }
 }
index da7ef43..64b470d 100644 (file)
@@ -26,7 +26,7 @@ public class BuildStateMachines {
   // map a task or stall site (both a FlatNode) to a variable
   // and then finally to a state machine
   protected Hashtable< FlatNode, Hashtable<TempDescriptor, StateMachineForEffects>> fn2var2smfe;
-  
+
   // remember all the FlatNode/TempDescriptor pairs that have a state machines
   // for easy retrieval of all machines
   protected Set<Pair<FlatNode, TempDescriptor>> allMachineNamePairs;
@@ -42,17 +42,17 @@ public class BuildStateMachines {
   }
 
   public StateMachineForEffects getStateMachine(FlatNode fn, TempDescriptor var) {
-    Hashtable<TempDescriptor, StateMachineForEffects> var2smfe = fn2var2smfe.get( fn );
+    Hashtable<TempDescriptor, StateMachineForEffects> var2smfe = fn2var2smfe.get(fn);
     if( var2smfe == null ) {
       var2smfe = new Hashtable<TempDescriptor, StateMachineForEffects>();
-      fn2var2smfe.put( fn, var2smfe );
+      fn2var2smfe.put(fn, var2smfe);
     }
-    
-    StateMachineForEffects smfe = var2smfe.get( var );
+
+    StateMachineForEffects smfe = var2smfe.get(var);
     if( smfe == null ) {
-      smfe = new StateMachineForEffects( fn );
-      var2smfe.put( var, smfe );
-      allMachineNamePairs.add( new Pair<FlatNode, TempDescriptor>( fn, var ) );
+      smfe = new StateMachineForEffects(fn);
+      var2smfe.put(var, smfe);
+      allMachineNamePairs.add(new Pair<FlatNode, TempDescriptor>(fn, var) );
     }
 
     return smfe;
@@ -64,9 +64,9 @@ public class BuildStateMachines {
   }
 
 
-  public void addToStateMachine( Taint t, 
-                                 Effect e, 
-                                 FlatNode currentProgramPoint ) {
+  public void addToStateMachine(Taint t,
+                                Effect e,
+                                FlatNode currentProgramPoint) {
     FlatNode taskOrStallSite;
     if( t.isStallSiteTaint() ) {
       taskOrStallSite = t.getStallSite();
@@ -76,20 +76,20 @@ public class BuildStateMachines {
 
     TempDescriptor var = t.getVar();
 
-    StateMachineForEffects smfe = getStateMachine( taskOrStallSite, var );
+    StateMachineForEffects smfe = getStateMachine(taskOrStallSite, var);
 
     FlatNode whereDefined = t.getWhereDefined();
 
-    smfe.addEffect( whereDefined, e );
+    smfe.addEffect(whereDefined, e);
 
     // reads of pointers make a transition
     if( e.getType() == Effect.read &&
         ((e.getField()!=null && e.getField().getType().isPtr())
-        ||(e.getField()==null && e.getAffectedAllocSite().getFlatNew().getType().dereference().isPtr()))) {
-      
-      smfe.addTransition( whereDefined, 
-                          currentProgramPoint,
-                          e );
+         ||(e.getField()==null && e.getAffectedAllocSite().getFlatNew().getType().dereference().isPtr()))) {
+
+      smfe.addTransition(whereDefined,
+                         currentProgramPoint,
+                         e);
     }
   }
 
@@ -103,21 +103,21 @@ public class BuildStateMachines {
     Iterator<FlatNode> fnItr = fn2var2smfe.keySet().iterator();
     while( fnItr.hasNext() ) {
       FlatNode fn = fnItr.next();
-      
-      Hashtable<TempDescriptor, StateMachineForEffects> 
-        var2smfe = fn2var2smfe.get( fn );
-        
+
+      Hashtable<TempDescriptor, StateMachineForEffects>
+      var2smfe = fn2var2smfe.get(fn);
+
       Iterator<TempDescriptor> varItr = var2smfe.keySet().iterator();
       while( varItr.hasNext() ) {
-        TempDescriptor var = varItr.next();
+       TempDescriptor var = varItr.next();
 
-        StateMachineForEffects smfe = var2smfe.get( var );
+       StateMachineForEffects smfe = var2smfe.get(var);
 
-        smfe.writeAsDOT( prefix+"statemachine_"+fn.toString()+var.toString() );
+       smfe.writeAsDOT(prefix+"statemachine_"+fn.toString()+var.toString() );
       }
     }
   }
-  //TODO JIM! Give me the REAALL number here. 
+  //TODO JIM! Give me the REAALL number here.
   public int getTotalNumOfWeakGroups() {
     // TODO Auto-generated method stub
     return 1;
index 391cdd1..85a5c8a 100644 (file)
@@ -30,23 +30,23 @@ abstract public class Canonical {
 
   // the canon of objects
   private static Hashtable<Canonical, Canonical>
-    canon =  new Hashtable<Canonical, Canonical>();
-  
+  canon =  new Hashtable<Canonical, Canonical>();
 
 
- public static Canonical makeCanonical( Canonical c ) {
 
-    if( canon.containsKey( c ) ) {
-      return canon.get( c );
+  public static Canonical makeCanonical(Canonical c) {
+
+    if( canon.containsKey(c) ) {
+      return canon.get(c);
     }
-    
+
     c.canonicalValue = canonicalCount;
     ++canonicalCount;
-    canon.put( c, c );
+    canon.put(c, c);
     return c;
   }
 
-  
+
   // any Canonical with value still 0 is NOT CANONICAL!
   private int canonicalValue = 0;
 
@@ -61,9 +61,9 @@ abstract public class Canonical {
 
 
 
-  abstract public boolean equalsSpecific( Object o );
+  abstract public boolean equalsSpecific(Object o);
 
-  final public boolean equals( Object o ) {
+  final public boolean equals(Object o) {
     if( o == null ) {
       return false;
     }
@@ -75,15 +75,15 @@ abstract public class Canonical {
     Canonical c = (Canonical) o;
 
     if( this.canonicalValue == 0 ||
-           c.canonicalValue == 0
+        c.canonicalValue == 0
         ) {
-      return equalsSpecific( o );
+      return equalsSpecific(o);
     }
 
     return this.canonicalValue == c.canonicalValue;
   }
 
-  
+
   // canonical objects should never be modified
   // and therefore have changing hash codes, so
   // use a standard canonical hash code method to
@@ -92,9 +92,9 @@ abstract public class Canonical {
   abstract public int hashCodeSpecific();
 
   private boolean hasHash = false;
-  private int     oldHash;
+  private int oldHash;
   final public int hashCode() {
-    
+
     // the quick mode
     if( DisjointAnalysis.releaseMode && hasHash ) {
       return oldHash;
@@ -105,21 +105,21 @@ abstract public class Canonical {
 
     if( hasHash ) {
       if( oldHash != hash ) {
-        throw new Error( "A CANONICAL HASH CHANGED" );
+       throw new Error("A CANONICAL HASH CHANGED");
       }
     } else {
       hasHash = true;
       oldHash = hash;
     }
-    
+
     return hash;
   }
 
 
   // mapping of a non-trivial operation to its result
-  private static    Hashtable<CanonicalOp, Canonical> 
-    op2result = new Hashtable<CanonicalOp, Canonical>();
-  
+  private static Hashtable<CanonicalOp, Canonical>
+  op2result = new Hashtable<CanonicalOp, Canonical>();
+
 
 
   ///////////////////////////////////////////////////////////
@@ -131,10 +131,10 @@ abstract public class Canonical {
   //
   ///////////////////////////////////////////////////////////
 
-  
+
   // not weighty, don't bother with caching
-  public static ReachTuple unionUpArity( ReachTuple rt1,
-                                         ReachTuple rt2 ) {
+  public static ReachTuple unionUpArity(ReachTuple rt1,
+                                        ReachTuple rt2) {
     assert rt1 != null;
     assert rt2 != null;
     assert rt1.isCanonical();
@@ -142,17 +142,17 @@ abstract public class Canonical {
     assert rt1.hrnID          == rt2.hrnID;
     assert rt1.isMultiObject  == rt2.isMultiObject;
     assert rt1.isOutOfContext == rt2.isOutOfContext;
-    
+
     ReachTuple out;
 
     if( rt1.isMultiObject ) {
       // on two non-ZERO arity multi regions, union arity is always
       // ZERO-OR-MORE
-      out = ReachTuple.factory( rt1.hrnID, 
-                                true, 
-                                ReachTuple.ARITY_ZEROORMORE,
-                                rt1.isOutOfContext );
-      
+      out = ReachTuple.factory(rt1.hrnID,
+                               true,
+                               ReachTuple.ARITY_ZEROORMORE,
+                               rt1.isOutOfContext);
+
     } else {
       // a single object region can only be ARITY_ONE (or zero by
       // being absent)
@@ -165,99 +165,99 @@ abstract public class Canonical {
   }
 
   // not weighty, no caching
-  public static ReachTuple changeHrnIDTo( ReachTuple rt,
-                                          Integer    hrnIDToChangeTo ) {
+  public static ReachTuple changeHrnIDTo(ReachTuple rt,
+                                         Integer hrnIDToChangeTo) {
     assert rt              != null;
     assert hrnIDToChangeTo != null;
 
-    ReachTuple out = ReachTuple.factory( hrnIDToChangeTo,
-                                         rt.isMultiObject,
-                                         rt.arity,
-                                         rt.isOutOfContext
-                                         );
+    ReachTuple out = ReachTuple.factory(hrnIDToChangeTo,
+                                        rt.isMultiObject,
+                                        rt.arity,
+                                        rt.isOutOfContext
+                                        );
     assert out.isCanonical();
     return out;
   }
 
 
-  public static ReachState attach( ReachState   rs,
-                                   ExistPredSet preds ) {
+  public static ReachState attach(ReachState rs,
+                                  ExistPredSet preds) {
     assert rs    != null;
     assert preds != null;
     assert rs.isCanonical();
     assert preds.isCanonical();
 
-    CanonicalOp op = 
-      new CanonicalOp( CanonicalOp.REACHSTATE_ATTACH_EXISTPREDSET,
-                       rs, 
-                       preds );
-    
-    Canonical result = op2result.get( op );
+    CanonicalOp op =
+      new CanonicalOp(CanonicalOp.REACHSTATE_ATTACH_EXISTPREDSET,
+                      rs,
+                      preds);
+
+    Canonical result = op2result.get(op);
     if( result != null ) {
       return (ReachState) result;
     }
-    
+
     // otherwise, no cached result...
     ReachState out = new ReachState();
-    out.reachTuples.addAll( rs.reachTuples );
-    out.preds = Canonical.join( rs.preds,
-                                preds );
-    
-    out = (ReachState) makeCanonical( out );
-    op2result.put( op, out );
+    out.reachTuples.addAll(rs.reachTuples);
+    out.preds = Canonical.join(rs.preds,
+                               preds);
+
+    out = (ReachState) makeCanonical(out);
+    op2result.put(op, out);
     return out;
   }
 
 
-  public static ReachState add( ReachState rs,
-                                ReachTuple rt ) {
+  public static ReachState add(ReachState rs,
+                               ReachTuple rt) {
     assert rs != null;
     assert rt != null;
 
     // this is only safe if we are certain the new tuple's
     // ID doesn't already appear in the reach state
-    assert rs.containsHrnID( rt.getHrnID(),
-                             rt.isOutOfContext() ) == null;
-
-    CanonicalOp op = 
-      new CanonicalOp( CanonicalOp.REACHSTATE_ADD_REACHTUPLE,
-                       rs, 
-                       rt );
-    
-    Canonical result = op2result.get( op );
+    assert rs.containsHrnID(rt.getHrnID(),
+                            rt.isOutOfContext() ) == null;
+
+    CanonicalOp op =
+      new CanonicalOp(CanonicalOp.REACHSTATE_ADD_REACHTUPLE,
+                      rs,
+                      rt);
+
+    Canonical result = op2result.get(op);
     if( result != null ) {
       return (ReachState) result;
     }
 
     // otherwise, no cached result...
     ReachState out = new ReachState();
-    out.reachTuples.addAll( rs.reachTuples );
-    out.reachTuples.add( rt );
+    out.reachTuples.addAll(rs.reachTuples);
+    out.reachTuples.add(rt);
     out.preds = rs.preds;
 
-    out = (ReachState) makeCanonical( out );
-    op2result.put( op, out );
+    out = (ReachState) makeCanonical(out);
+    op2result.put(op, out);
     return out;
   }
-  
 
-  public static ReachState unionUpArity( ReachState rs1,
-                                         ReachState rs2 ) {
+
+  public static ReachState unionUpArity(ReachState rs1,
+                                        ReachState rs2) {
     assert rs1 != null;
     assert rs2 != null;
     assert rs1.isCanonical();
     assert rs2.isCanonical();
 
-    CanonicalOp op = 
-      new CanonicalOp( CanonicalOp.REACHSTATE_UNIONUPARITY_REACHSTATE,
-                       rs1, 
-                       rs2 );
-    
-    Canonical result = op2result.get( op );
+    CanonicalOp op =
+      new CanonicalOp(CanonicalOp.REACHSTATE_UNIONUPARITY_REACHSTATE,
+                      rs1,
+                      rs2);
+
+    Canonical result = op2result.get(op);
     if( result != null ) {
       return (ReachState) result;
     }
-    
+
     // otherwise, no cached result...
     ReachState out = new ReachState();
 
@@ -266,13 +266,13 @@ abstract public class Canonical {
     Iterator<ReachTuple> rtItr = rs1.iterator();
     while( rtItr.hasNext() ) {
       ReachTuple rt1 = rtItr.next();
-      ReachTuple rt2 = rs2.containsHrnID( rt1.getHrnID(),
-                                          rt1.isOutOfContext() 
-                                          );
+      ReachTuple rt2 = rs2.containsHrnID(rt1.getHrnID(),
+                                         rt1.isOutOfContext()
+                                         );
       if( rt2 != null ) {
-       out.reachTuples.add( unionUpArity( rt1, rt2 ) );
+       out.reachTuples.add(unionUpArity(rt1, rt2) );
       } else {
-       out.reachTuples.add( rt1 );
+       out.reachTuples.add(rt1);
       }
     }
 
@@ -280,35 +280,35 @@ abstract public class Canonical {
     rtItr = rs2.iterator();
     while( rtItr.hasNext() ) {
       ReachTuple rt2 = rtItr.next();
-      ReachTuple rt1 = rs1.containsHrnID( rt2.getHrnID(),
-                                          rt2.isOutOfContext()
-                                          );
+      ReachTuple rt1 = rs1.containsHrnID(rt2.getHrnID(),
+                                         rt2.isOutOfContext()
+                                         );
       if( rt1 == null ) {
-       out.reachTuples.add( rt2 );
+       out.reachTuples.add(rt2);
       }
     }
 
-    out.preds = Canonical.join( rs1.getPreds(),
-                                rs2.getPreds()
-                                );
-    
-    out = (ReachState) makeCanonical( out );
-    op2result.put( op, out );
+    out.preds = Canonical.join(rs1.getPreds(),
+                               rs2.getPreds()
+                               );
+
+    out = (ReachState) makeCanonical(out);
+    op2result.put(op, out);
     return out;
   }
 
 
-  public static ReachState addUpArity( ReachState rs,
-                                       ReachTuple rt ) {
+  public static ReachState addUpArity(ReachState rs,
+                                      ReachTuple rt) {
     assert rs != null;
     assert rt != null;
 
-    CanonicalOp op = 
-      new CanonicalOp( CanonicalOp.REACHSTATE_ADDUPARITY_REACHTUPLE,
-                       rs, 
-                       rt );
-    
-    Canonical result = op2result.get( op );
+    CanonicalOp op =
+      new CanonicalOp(CanonicalOp.REACHSTATE_ADDUPARITY_REACHTUPLE,
+                      rs,
+                      rt);
+
+    Canonical result = op2result.get(op);
     if( result != null ) {
       return (ReachState) result;
     }
@@ -319,57 +319,57 @@ abstract public class Canonical {
     // the reason for this add is that we are aware a tuple
     // with the same hrnID might already be in the state, so
     // if it is we should combine properly
-    ReachState rtOnly = ReachState.factory( rt );
-    out = Canonical.unionUpArity( rs, rtOnly );
-    
-    op2result.put( op, out );
+    ReachState rtOnly = ReachState.factory(rt);
+    out = Canonical.unionUpArity(rs, rtOnly);
+
+    op2result.put(op, out);
     return out;
   }
 
-  
-  public static ReachState remove( ReachState rs, ReachTuple rt ) {
+
+  public static ReachState remove(ReachState rs, ReachTuple rt) {
     assert rs != null;
     assert rt != null;
 
-    CanonicalOp op = 
-      new CanonicalOp( CanonicalOp.REACHSTATE_REMOVE_REACHTUPLE,
-                       rs, 
-                       rt );
-    
-    Canonical result = op2result.get( op );
+    CanonicalOp op =
+      new CanonicalOp(CanonicalOp.REACHSTATE_REMOVE_REACHTUPLE,
+                      rs,
+                      rt);
+
+    Canonical result = op2result.get(op);
     if( result != null ) {
       return (ReachState) result;
     }
 
-    // otherwise, no cached result...    
+    // otherwise, no cached result...
     ReachState out = new ReachState();
-    out.reachTuples.addAll( rs.reachTuples );
-    out.reachTuples.remove( rt );
+    out.reachTuples.addAll(rs.reachTuples);
+    out.reachTuples.remove(rt);
     out.preds = rs.preds;
 
-    out = (ReachState) makeCanonical( out );
-    op2result.put( op, out );
+    out = (ReachState) makeCanonical(out);
+    op2result.put(op, out);
     return out;
   }
-  
-  
-  public static ReachState ageTuplesFrom( ReachState rs, 
-                                          AllocSite  as ) {
+
+
+  public static ReachState ageTuplesFrom(ReachState rs,
+                                         AllocSite as) {
     assert rs != null;
     assert as != null;
     assert rs.isCanonical();
     assert as.isCanonical();
-    
-    CanonicalOp op = 
-      new CanonicalOp( CanonicalOp.REACHSTATE_AGETUPLESFROM_ALLOCSITE,
-                       rs, 
-                       as );
-    
-    Canonical result = op2result.get( op );
+
+    CanonicalOp op =
+      new CanonicalOp(CanonicalOp.REACHSTATE_AGETUPLESFROM_ALLOCSITE,
+                      rs,
+                      as);
+
+    Canonical result = op2result.get(op);
     if( result != null ) {
       return (ReachState) result;
     }
-    
+
     // otherwise, no cached result...
     ReachState out = new ReachState();
 
@@ -379,8 +379,8 @@ abstract public class Canonical {
     Iterator<ReachTuple> rtItr = rs.iterator();
     while( rtItr.hasNext() ) {
       ReachTuple rt    = rtItr.next();
-      Integer    hrnID = rt.getHrnID();
-      int        age   = as.getAgeCategory( hrnID );
+      Integer hrnID = rt.getHrnID();
+      int age   = as.getAgeCategory(hrnID);
 
       // hrnIDs not associated with
       // the site should be left alone, and
@@ -388,7 +388,7 @@ abstract public class Canonical {
       if( age == AllocSite.AGE_notInThisSite ||
           rt.isOutOfContext()
           ) {
-       out.reachTuples.add( rt );
+       out.reachTuples.add(rt);
 
       } else if( age == AllocSite.AGE_summary ) {
        // remember the summary tuple, but don't add it
@@ -403,15 +403,15 @@ abstract public class Canonical {
       } else {
        assert age == AllocSite.AGE_in_I;
 
-       Integer I = as.getAge( hrnID );
+       Integer I = as.getAge(hrnID);
        assert I != null;
 
        // otherwise, we change this hrnID to the
        // next older hrnID
-       Integer hrnIDToChangeTo = as.getIthOldest( I + 1 );
+       Integer hrnIDToChangeTo = as.getIthOldest(I + 1);
        ReachTuple rtAged =
-          Canonical.changeHrnIDTo( rt, hrnIDToChangeTo );
-       out.reachTuples.add( rtAged );
+         Canonical.changeHrnIDTo(rt, hrnIDToChangeTo);
+       out.reachTuples.add(rtAged);
       }
     }
 
@@ -424,49 +424,49 @@ abstract public class Canonical {
     //    Merge them by arity
     // 4. (not handled) we found neither, do nothing
     if( rtSummary != null && rtOldest == null ) {
-      out.reachTuples.add( rtSummary );
+      out.reachTuples.add(rtSummary);
 
     } else if( rtSummary == null && rtOldest != null ) {
-      out.reachTuples.add( ReachTuple.factory( as.getSummary(),
-                                               true, // multi
-                                               rtOldest.getArity(),
-                                               false // out-of-context
-                                               )
-                           );
-
-    } else if( rtSummary != null && rtOldest != null ) {     
-      out.reachTuples.add( Canonical.unionUpArity( rtSummary,
-                                                   ReachTuple.factory( as.getSummary(),
-                                                                       true, // muli
-                                                                       rtOldest.getArity(),
-                                                                       false // out-of-context
-                                                                       )
-                                                   )
-                           );
+      out.reachTuples.add(ReachTuple.factory(as.getSummary(),
+                                             true,   // multi
+                                             rtOldest.getArity(),
+                                             false   // out-of-context
+                                             )
+                          );
+
+    } else if( rtSummary != null && rtOldest != null ) {
+      out.reachTuples.add(Canonical.unionUpArity(rtSummary,
+                                                 ReachTuple.factory(as.getSummary(),
+                                                                    true,    // muli
+                                                                    rtOldest.getArity(),
+                                                                    false    // out-of-context
+                                                                    )
+                                                 )
+                          );
     }
 
     out.preds = rs.preds;
 
-    out = (ReachState) makeCanonical( out );
-    op2result.put( op, out );
+    out = (ReachState) makeCanonical(out);
+    op2result.put(op, out);
     return out;
   }
 
 
 
-  public static ReachSet unionORpreds( ReachSet rs1,
-                                       ReachSet rs2 ) {
+  public static ReachSet unionORpreds(ReachSet rs1,
+                                      ReachSet rs2) {
     assert rs1 != null;
     assert rs2 != null;
     assert rs1.isCanonical();
     assert rs2.isCanonical();
 
-    CanonicalOp op = 
-      new CanonicalOp( CanonicalOp.REACHSET_UNIONORPREDS_REACHSET,
-                       rs1, 
-                       rs2 );
-    
-    Canonical result = op2result.get( op );
+    CanonicalOp op =
+      new CanonicalOp(CanonicalOp.REACHSET_UNIONORPREDS_REACHSET,
+                      rs1,
+                      rs2);
+
+    Canonical result = op2result.get(op);
     if( result != null ) {
       return (ReachSet) result;
     }
@@ -479,16 +479,16 @@ abstract public class Canonical {
     Iterator<ReachState> stateItr = rs1.iterator();
     while( stateItr.hasNext() ) {
       ReachState state1 = stateItr.next();
-      ReachState state2 = rs2.containsIgnorePreds( state1 );
+      ReachState state2 = rs2.containsIgnorePreds(state1);
 
       if( state2 != null ) {
-       out.reachStates.add( ReachState.factory( state1.reachTuples,
-                                                 Canonical.join( state1.preds,
-                                                                 state2.preds
-                                                                 )
-                                                 ) );
+       out.reachStates.add(ReachState.factory(state1.reachTuples,
+                                              Canonical.join(state1.preds,
+                                                             state2.preds
+                                                             )
+                                              ) );
       } else {
-       out.reachStates.add( state1 );
+       out.reachStates.add(state1);
       }
     }
 
@@ -496,15 +496,15 @@ abstract public class Canonical {
     stateItr = rs2.iterator();
     while( stateItr.hasNext() ) {
       ReachState state2 = stateItr.next();
-      ReachState state1 = rs1.containsIgnorePreds( state2 );
+      ReachState state1 = rs1.containsIgnorePreds(state2);
 
       if( state1 == null ) {
-       out.reachStates.add( state2 );
+       out.reachStates.add(state2);
       }
     }
 
-    out = (ReachSet) makeCanonical( out );
-    op2result.put( op, out );
+    out = (ReachSet) makeCanonical(out);
+    op2result.put(op, out);
     return out;
   }
 
@@ -516,19 +516,19 @@ abstract public class Canonical {
   // avoid eploding states we'll take an overapproximation
   // by preferring the predicates from the state in the FIRST
   // set, so order of arguments matters
-  public static ReachSet intersection( ReachSet rs1,
-                                       ReachSet rs2 ) {
+  public static ReachSet intersection(ReachSet rs1,
+                                      ReachSet rs2) {
     assert rs1 != null;
     assert rs2 != null;
     assert rs1.isCanonical();
     assert rs2.isCanonical();
 
-    CanonicalOp op = 
-      new CanonicalOp( CanonicalOp.REACHSET_INTERSECTION_REACHSET,
-                       rs1, 
-                       rs2 );
-    
-    Canonical result = op2result.get( op );
+    CanonicalOp op =
+      new CanonicalOp(CanonicalOp.REACHSET_INTERSECTION_REACHSET,
+                      rs1,
+                      rs2);
+
+    Canonical result = op2result.get(op);
     if( result != null ) {
       return (ReachSet) result;
     }
@@ -538,64 +538,64 @@ abstract public class Canonical {
     Iterator<ReachState> itr = rs1.iterator();
     while( itr.hasNext() ) {
       ReachState state1 = (ReachState) itr.next();
-      ReachState state2 = rs2.containsIgnorePreds( state1 );
+      ReachState state2 = rs2.containsIgnorePreds(state1);
       if( state2 != null ) {
-        // prefer the predicates on state1, an overapproximation
-        // of state1 preds AND state2 preds
-        out.reachStates.add( state1 );
+       // prefer the predicates on state1, an overapproximation
+       // of state1 preds AND state2 preds
+       out.reachStates.add(state1);
       }
     }
 
-    out = (ReachSet) makeCanonical( out );
-    op2result.put( op, out );
+    out = (ReachSet) makeCanonical(out);
+    op2result.put(op, out);
     return out;
   }
 
 
-  public static ReachSet add( ReachSet   rs, 
-                              ReachState state ) {
-    return unionORpreds( rs, 
-                         ReachSet.factory( state )
-                         );
+  public static ReachSet add(ReachSet rs,
+                             ReachState state) {
+    return unionORpreds(rs,
+                        ReachSet.factory(state)
+                        );
   }
 
-  public static ReachSet remove( ReachSet   rs,
-                                 ReachState state ) {
+  public static ReachSet remove(ReachSet rs,
+                                ReachState state) {
     assert rs    != null;
     assert state != null;
     assert rs.isCanonical();
     assert state.isCanonical();
 
-    CanonicalOp op = 
-      new CanonicalOp( CanonicalOp.REACHSET_REMOVE_REACHSTATE,
-                       rs, 
-                       state );
-    
-    Canonical result = op2result.get( op );
+    CanonicalOp op =
+      new CanonicalOp(CanonicalOp.REACHSET_REMOVE_REACHSTATE,
+                      rs,
+                      state);
+
+    Canonical result = op2result.get(op);
     if( result != null ) {
       return (ReachSet) result;
     }
 
-    // otherwise, no cached result...    
+    // otherwise, no cached result...
     ReachSet out = new ReachSet();
-    out.reachStates.addAll( rs.reachStates );
-    out.reachStates.remove( state );
+    out.reachStates.addAll(rs.reachStates);
+    out.reachStates.remove(state);
 
-    out = (ReachSet) makeCanonical( out );
-    op2result.put( op, out );
+    out = (ReachSet) makeCanonical(out);
+    op2result.put(op, out);
     return out;
   }
 
 
-  public static ReachSet applyChangeSet( ReachSet  rs, 
-                                         ChangeSet cs,
-                                         boolean   keepSourceState ) {
+  public static ReachSet applyChangeSet(ReachSet rs,
+                                        ChangeSet cs,
+                                        boolean keepSourceState) {
     assert rs != null;
     assert cs != null;
     assert rs.isCanonical();
     assert cs.isCanonical();
 
-    // this primitive operand stuff is just a way to 
+    // this primitive operand stuff is just a way to
     // ensure distinct inputs to a CanonicalOp
     int primOperand;
     if( keepSourceState ) {
@@ -604,18 +604,18 @@ abstract public class Canonical {
       primOperand = 0x2b;
     }
 
-    CanonicalOp op = 
-      new CanonicalOp( CanonicalOp.REACHSET_APPLY_CHANGESET,
-                       rs, 
-                       cs,
-                       primOperand );
-    
-    Canonical result = op2result.get( op );
+    CanonicalOp op =
+      new CanonicalOp(CanonicalOp.REACHSET_APPLY_CHANGESET,
+                      rs,
+                      cs,
+                      primOperand);
+
+    Canonical result = op2result.get(op);
     if( result != null ) {
       return (ReachSet) result;
     }
-    
-    // otherwise, no cached result...    
+
+    // otherwise, no cached result...
     ReachSet out = new ReachSet();
 
     Iterator<ReachState> stateItr = rs.iterator();
@@ -628,46 +628,46 @@ abstract public class Canonical {
       while( ctItr.hasNext() ) {
        ChangeTuple ct = ctItr.next();
 
-       if( stateOrig.equalsIgnorePreds( ct.getStateToMatch() ) ) {
-          // use the new state, but the original predicates
-          ReachState stateNew = 
-            ReachState.factory( ct.getStateToAdd().reachTuples,
-                                stateOrig.preds
-                                );
-          out.reachStates.add( stateNew );
+       if( stateOrig.equalsIgnorePreds(ct.getStateToMatch() ) ) {
+         // use the new state, but the original predicates
+         ReachState stateNew =
+           ReachState.factory(ct.getStateToAdd().reachTuples,
+                              stateOrig.preds
+                              );
+         out.reachStates.add(stateNew);
          changeFound = true;
        }
       }
 
       if( keepSourceState || !changeFound ) {
-       out.reachStates.add( stateOrig );
+       out.reachStates.add(stateOrig);
       }
     }
 
-    out = (ReachSet) makeCanonical( out );
-    op2result.put( op, out );
+    out = (ReachSet) makeCanonical(out);
+    op2result.put(op, out);
     return out;
   }
 
 
-  public static ChangeSet unionUpArityToChangeSet( ReachSet rsO,
-                                                   ReachSet rsR ) {
+  public static ChangeSet unionUpArityToChangeSet(ReachSet rsO,
+                                                  ReachSet rsR) {
     assert rsO != null;
     assert rsR != null;
     assert rsO.isCanonical();
     assert rsR.isCanonical();
 
-    CanonicalOp op = 
-      new CanonicalOp( CanonicalOp.REACHSET_UNIONTOCHANGESET_REACHSET,
-                       rsO, 
-                       rsR );
-    
-    Canonical result = op2result.get( op );
+    CanonicalOp op =
+      new CanonicalOp(CanonicalOp.REACHSET_UNIONTOCHANGESET_REACHSET,
+                      rsO,
+                      rsR);
+
+    Canonical result = op2result.get(op);
     if( result != null ) {
       return (ChangeSet) result;
     }
-    
-    // otherwise, no cached result...    
+
+    // otherwise, no cached result...
     ChangeSet out = ChangeSet.factory();
 
     Iterator<ReachState> itrO = rsO.iterator();
@@ -683,102 +683,102 @@ abstract public class Canonical {
        Iterator<ReachTuple> itrRelement = r.iterator();
        while( itrRelement.hasNext() ) {
          ReachTuple rtR = itrRelement.next();
-         ReachTuple rtO = o.containsHrnID( rtR.getHrnID(),
-                                            rtR.isOutOfContext()
-                                            );
+         ReachTuple rtO = o.containsHrnID(rtR.getHrnID(),
+                                          rtR.isOutOfContext()
+                                          );
          if( rtO != null ) {
-            theUnion = Canonical.add( theUnion,
-                                      Canonical.unionUpArity( rtR,
-                                                              rtO
-                                                              )
-                                      );
+           theUnion = Canonical.add(theUnion,
+                                    Canonical.unionUpArity(rtR,
+                                                           rtO
+                                                           )
+                                    );
          } else {
-            theUnion = Canonical.add( theUnion,
-                                      rtR
-                                      );
+           theUnion = Canonical.add(theUnion,
+                                    rtR
+                                    );
          }
        }
 
        Iterator<ReachTuple> itrOelement = o.iterator();
        while( itrOelement.hasNext() ) {
          ReachTuple rtO = itrOelement.next();
-         ReachTuple rtR = theUnion.containsHrnID( rtO.getHrnID(),
-                                                   rtO.isOutOfContext()
-                                                   );
+         ReachTuple rtR = theUnion.containsHrnID(rtO.getHrnID(),
+                                                 rtO.isOutOfContext()
+                                                 );
          if( rtR == null ) {
-            theUnion = Canonical.add( theUnion,
-                                      rtO
-                                      );
+           theUnion = Canonical.add(theUnion,
+                                    rtO
+                                    );
          }
        }
-        
+
        if( !theUnion.isEmpty() ) {
-          out = 
-            Canonical.union( out,
-                             ChangeSet.factory( 
-                                               ChangeTuple.factory( o, theUnion ) 
-                                                )
-                             );
+         out =
+           Canonical.union(out,
+                           ChangeSet.factory(
+                             ChangeTuple.factory(o, theUnion)
+                             )
+                           );
        }
       }
     }
 
     assert out.isCanonical();
-    op2result.put( op, out );
+    op2result.put(op, out);
     return out;
   }
 
 
-  public static ReachSet ageTuplesFrom( ReachSet  rs,
-                                        AllocSite as ) {
+  public static ReachSet ageTuplesFrom(ReachSet rs,
+                                       AllocSite as) {
     assert rs != null;
     assert as != null;
     assert rs.isCanonical();
     assert as.isCanonical();
 
-    CanonicalOp op = 
-      new CanonicalOp( CanonicalOp.REACHSET_AGETUPLESFROM_ALLOCSITE,
-                       rs, 
-                       as );
-    
-    Canonical result = op2result.get( op );
+    CanonicalOp op =
+      new CanonicalOp(CanonicalOp.REACHSET_AGETUPLESFROM_ALLOCSITE,
+                      rs,
+                      as);
+
+    Canonical result = op2result.get(op);
     if( result != null ) {
       return (ReachSet) result;
     }
-    
+
     // otherwise, no cached result...
     ReachSet out = new ReachSet();
 
     Iterator<ReachState> itrS = rs.iterator();
     while( itrS.hasNext() ) {
       ReachState state = itrS.next();
-      out.reachStates.add( Canonical.ageTuplesFrom( state, as ) );
+      out.reachStates.add(Canonical.ageTuplesFrom(state, as) );
     }
-    
-    out = (ReachSet) makeCanonical( out );
-    op2result.put( op, out );
-    return out;    
+
+    out = (ReachSet) makeCanonical(out);
+    op2result.put(op, out);
+    return out;
   }
 
 
-  public static ReachSet pruneBy( ReachSet rsO, 
-                                  ReachSet rsP ) {
+  public static ReachSet pruneBy(ReachSet rsO,
+                                 ReachSet rsP) {
     assert rsO != null;
     assert rsP != null;
     assert rsO.isCanonical();
     assert rsP.isCanonical();
 
-    CanonicalOp op = 
-      new CanonicalOp( CanonicalOp.REACHSET_PRUNEBY_REACHSET,
-                       rsO, 
-                       rsP );
-    
-    Canonical result = op2result.get( op );
+    CanonicalOp op =
+      new CanonicalOp(CanonicalOp.REACHSET_PRUNEBY_REACHSET,
+                      rsO,
+                      rsP);
+
+    Canonical result = op2result.get(op);
     if( result != null ) {
       return (ReachSet) result;
     }
-    
-    // otherwise, no cached result...    
+
+    // otherwise, no cached result...
     ReachSet out = new ReachSet();
 
     Iterator<ReachState> itrO = rsO.iterator();
@@ -791,108 +791,108 @@ abstract public class Canonical {
       while( itrP.hasNext() && !subsetExists ) {
        ReachState stateP = itrP.next();
 
-       if( stateP.isSubset( stateO ) ) {
+       if( stateP.isSubset(stateO) ) {
          subsetExists = true;
        }
       }
-      
+
       if( subsetExists ) {
-       out.reachStates.add( stateO );
+       out.reachStates.add(stateO);
       }
     }
 
-    out = (ReachSet) makeCanonical( out );
-    op2result.put( op, out );
-    return out;    
+    out = (ReachSet) makeCanonical(out);
+    op2result.put(op, out);
+    return out;
   }
 
 
-  public static ChangeSet union( ChangeSet cs1, 
-                                 ChangeSet cs2 ) {
+  public static ChangeSet union(ChangeSet cs1,
+                                ChangeSet cs2) {
     assert cs1 != null;
     assert cs2 != null;
     assert cs1.isCanonical();
     assert cs2.isCanonical();
 
-    CanonicalOp op = 
-      new CanonicalOp( CanonicalOp.CHANGESET_UNION_CHANGESET,
-                       cs1, 
-                       cs2 );
-    
-    Canonical result = op2result.get( op );
+    CanonicalOp op =
+      new CanonicalOp(CanonicalOp.CHANGESET_UNION_CHANGESET,
+                      cs1,
+                      cs2);
+
+    Canonical result = op2result.get(op);
     if( result != null ) {
       return (ChangeSet) result;
     }
-    
-    // otherwise, no cached result...    
+
+    // otherwise, no cached result...
     ChangeSet out = new ChangeSet();
-    out.changeTuples.addAll( cs1.changeTuples );
-    out.changeTuples.addAll( cs2.changeTuples );
+    out.changeTuples.addAll(cs1.changeTuples);
+    out.changeTuples.addAll(cs2.changeTuples);
 
-    out = (ChangeSet) makeCanonical( out );
-    op2result.put( op, out );
-    return out;    
+    out = (ChangeSet) makeCanonical(out);
+    op2result.put(op, out);
+    return out;
   }
 
-  public static ChangeSet add( ChangeSet   cs, 
-                               ChangeTuple ct ) {
+  public static ChangeSet add(ChangeSet cs,
+                              ChangeTuple ct) {
     assert cs != null;
     assert ct != null;
     assert cs.isCanonical();
     assert ct.isCanonical();
 
-    CanonicalOp op = 
-      new CanonicalOp( CanonicalOp.CHANGESET_UNION_CHANGETUPLE,
-                       cs, 
-                       ct );
-    
-    Canonical result = op2result.get( op );
+    CanonicalOp op =
+      new CanonicalOp(CanonicalOp.CHANGESET_UNION_CHANGETUPLE,
+                      cs,
+                      ct);
+
+    Canonical result = op2result.get(op);
     if( result != null ) {
       return (ChangeSet) result;
     }
-    
-    // otherwise, no cached result...    
+
+    // otherwise, no cached result...
     ChangeSet out = new ChangeSet();
-    out.changeTuples.addAll( cs.changeTuples );
-    out.changeTuples.add( ct );
-    
-    out = (ChangeSet) makeCanonical( out );
-    op2result.put( op, out );
-    return out;    
+    out.changeTuples.addAll(cs.changeTuples);
+    out.changeTuples.add(ct);
+
+    out = (ChangeSet) makeCanonical(out);
+    op2result.put(op, out);
+    return out;
   }
 
 
 
-  public static ExistPredSet join( ExistPredSet eps1,
-                                   ExistPredSet eps2 ) {
+  public static ExistPredSet join(ExistPredSet eps1,
+                                  ExistPredSet eps2) {
 
     assert eps1 != null;
     assert eps2 != null;
     assert eps1.isCanonical();
     assert eps2.isCanonical();
 
-    CanonicalOp op = 
-      new CanonicalOp( CanonicalOp.EXISTPREDSET_JOIN_EXISTPREDSET,
-                       eps1, 
-                       eps2 );
-    
-    Canonical result = op2result.get( op );
+    CanonicalOp op =
+      new CanonicalOp(CanonicalOp.EXISTPREDSET_JOIN_EXISTPREDSET,
+                      eps1,
+                      eps2);
+
+    Canonical result = op2result.get(op);
     if( result != null ) {
       return (ExistPredSet) result;
     }
-    
-    // otherwise, no cached result...    
+
+    // otherwise, no cached result...
     ExistPredSet out = new ExistPredSet();
-    out.preds.addAll( eps1.preds );
-    out.preds.addAll( eps2.preds );
+    out.preds.addAll(eps1.preds);
+    out.preds.addAll(eps2.preds);
 
-    out = (ExistPredSet) makeCanonical( out );
-    op2result.put( op, out );
-    return out;    
+    out = (ExistPredSet) makeCanonical(out);
+    op2result.put(op, out);
+    return out;
   }
 
-  public static ExistPredSet add( ExistPredSet eps,
-                                  ExistPred    ep ) {
+  public static ExistPredSet add(ExistPredSet eps,
+                                 ExistPred ep) {
 
 
     assert eps != null;
@@ -900,40 +900,40 @@ abstract public class Canonical {
     assert eps.isCanonical();
     assert ep.isCanonical();
 
-    CanonicalOp op = 
-      new CanonicalOp( CanonicalOp.EXISTPREDSET_ADD_EXISTPRED,
-                       eps, 
-                       ep );
-    
-    Canonical result = op2result.get( op );
+    CanonicalOp op =
+      new CanonicalOp(CanonicalOp.EXISTPREDSET_ADD_EXISTPRED,
+                      eps,
+                      ep);
+
+    Canonical result = op2result.get(op);
     if( result != null ) {
       return (ExistPredSet) result;
     }
-    
-    // otherwise, no cached result...    
+
+    // otherwise, no cached result...
     ExistPredSet out = new ExistPredSet();
-    out.preds.addAll( eps.preds );
-    out.preds.add( ep );
-    
-    out = (ExistPredSet) makeCanonical( out );
-    op2result.put( op, out );
-    return out;    
+    out.preds.addAll(eps.preds);
+    out.preds.add(ep);
+
+    out = (ExistPredSet) makeCanonical(out);
+    op2result.put(op, out);
+    return out;
   }
 
 
-  public static ReachSet toCallerContext( ReachSet  rs,
-                                          AllocSite as ) {
+  public static ReachSet toCallerContext(ReachSet rs,
+                                         AllocSite as) {
     assert rs != null;
     assert as != null;
     assert rs.isCanonical();
     assert as.isCanonical();
 
-    CanonicalOp op = 
-      new CanonicalOp( CanonicalOp.REACHSET_TOCALLERCONTEXT_ALLOCSITE,
-                       rs, 
-                       as );
-    
-    Canonical result = op2result.get( op );
+    CanonicalOp op =
+      new CanonicalOp(CanonicalOp.REACHSET_TOCALLERCONTEXT_ALLOCSITE,
+                      rs,
+                      as);
+
+    Canonical result = op2result.get(op);
     if( result != null ) {
       return (ReachSet) result;
     }
@@ -943,30 +943,30 @@ abstract public class Canonical {
     Iterator<ReachState> itr = rs.iterator();
     while( itr.hasNext() ) {
       ReachState state = itr.next();
-      out = Canonical.unionORpreds( out,
-                                    Canonical.toCallerContext( state, as )
-                                    );
+      out = Canonical.unionORpreds(out,
+                                   Canonical.toCallerContext(state, as)
+                                   );
     }
 
     assert out.isCanonical();
-    op2result.put( op, out );
+    op2result.put(op, out);
     return out;
   }
-  
 
-  public static ReachSet toCallerContext( ReachState state,
-                                          AllocSite  as ) {
+
+  public static ReachSet toCallerContext(ReachState state,
+                                         AllocSite as) {
     assert state != null;
     assert as    != null;
     assert state.isCanonical();
     assert as.isCanonical();
 
-    CanonicalOp op = 
-      new CanonicalOp( CanonicalOp.REACHSTATE_TOCALLERCONTEXT_ALLOCSITE,
-                       state, 
-                       as );
-    
-    Canonical result = op2result.get( op );
+    CanonicalOp op =
+      new CanonicalOp(CanonicalOp.REACHSTATE_TOCALLERCONTEXT_ALLOCSITE,
+                      state,
+                      as);
+
+    Canonical result = op2result.get(op);
     if( result != null ) {
       return (ReachSet) result;
     }
@@ -991,7 +991,7 @@ abstract public class Canonical {
     //      -> 0?
     //      -> 1?
     //      -> 2S?
-    // 2S?* -> {2S*, 2S?*}    
+    // 2S?* -> {2S*, 2S?*}
 
     boolean found2Sooc = false;
 
@@ -1001,79 +1001,79 @@ abstract public class Canonical {
     while( itr.hasNext() ) {
       ReachTuple rt = itr.next();
 
-      int age = as.getAgeCategory( rt.getHrnID() );
+      int age = as.getAgeCategory(rt.getHrnID() );
 
       if( age == AllocSite.AGE_notInThisSite ) {
-        // things not from the site just go back in
-       baseState = Canonical.addUpArity( baseState, rt );
+       // things not from the site just go back in
+       baseState = Canonical.addUpArity(baseState, rt);
 
       } else if( age == AllocSite.AGE_summary ) {
 
-        if( rt.isOutOfContext() ) {
-          // if its out-of-context, we only deal here with the ZERO-OR-MORE
-          // arity, if ARITY-ONE we'll branch the base state after the loop
-          if( rt.getArity() == ReachTuple.ARITY_ZEROORMORE ) {
-            // add two overly conservative symbols to reach state (PUNTING)
-
-            baseState = Canonical.addUpArity( baseState,
-                                              ReachTuple.factory( as.getSummary(),
-                                                                  true, // multi
-                                                                  ReachTuple.ARITY_ZEROORMORE,
-                                                                  false // out-of-context
-                                                                  )
-                                              );            
+       if( rt.isOutOfContext() ) {
+         // if its out-of-context, we only deal here with the ZERO-OR-MORE
+         // arity, if ARITY-ONE we'll branch the base state after the loop
+         if( rt.getArity() == ReachTuple.ARITY_ZEROORMORE ) {
+           // add two overly conservative symbols to reach state (PUNTING)
+
+           baseState = Canonical.addUpArity(baseState,
+                                            ReachTuple.factory(as.getSummary(),
+                                                               true,   // multi
+                                                               ReachTuple.ARITY_ZEROORMORE,
+                                                               false   // out-of-context
+                                                               )
+                                            );
+
+           baseState = Canonical.addUpArity(baseState,
+                                            ReachTuple.factory(as.getSummary(),
+                                                               true,   // multi
+                                                               ReachTuple.ARITY_ZEROORMORE,
+                                                               true    // out-of-context
+                                                               )
+                                            );
+         } else {
+           assert rt.getArity() == ReachTuple.ARITY_ONE;
+           found2Sooc = true;
+         }
 
-            baseState = Canonical.addUpArity( baseState,
-                                              ReachTuple.factory( as.getSummary(),
-                                                                  true, // multi
-                                                                  ReachTuple.ARITY_ZEROORMORE,
-                                                                  true  // out-of-context
-                                                                  )
-                                              );            
-          } else {
-            assert rt.getArity() == ReachTuple.ARITY_ONE;
-            found2Sooc = true;
-          }
-
-        } else {
-          // the in-context just becomes shadow
-          baseState = Canonical.addUpArity( baseState,
-                                            ReachTuple.factory( as.getSummaryShadow(),
-                                                                true, // multi
-                                                                rt.getArity(),
-                                                                false  // out-of-context
-                                                                )
-                                            );
-        }
+       } else {
+         // the in-context just becomes shadow
+         baseState = Canonical.addUpArity(baseState,
+                                          ReachTuple.factory(as.getSummaryShadow(),
+                                                             true,   // multi
+                                                             rt.getArity(),
+                                                             false    // out-of-context
+                                                             )
+                                          );
+       }
 
 
       } else {
-        // otherwise age is in range [0, k]
-        Integer I = as.getAge( rt.getHrnID() );
-        assert I != null;        
-        assert !rt.isMultiObject();
-        assert rt.getArity() == ReachTuple.ARITY_ONE;
-
-        if( rt.isOutOfContext() ) {
-          // becomes the in-context version
-          baseState = Canonical.addUpArity( baseState,
-                                            ReachTuple.factory( rt.getHrnID(),
-                                                                false, // multi
-                                                                ReachTuple.ARITY_ONE,
-                                                                false  // out-of-context
-                                                                )
-                                            );          
-
-        } else {
-          // otherwise the ith symbol becomes shadowed
-          baseState = Canonical.addUpArity( baseState,
-                                            ReachTuple.factory( -rt.getHrnID(),
-                                                                false, // multi
-                                                                ReachTuple.ARITY_ONE,
-                                                                false  // out-of-context
-                                                                )
-                                            );        
-        }
+       // otherwise age is in range [0, k]
+       Integer I = as.getAge(rt.getHrnID() );
+       assert I != null;
+       assert !rt.isMultiObject();
+       assert rt.getArity() == ReachTuple.ARITY_ONE;
+
+       if( rt.isOutOfContext() ) {
+         // becomes the in-context version
+         baseState = Canonical.addUpArity(baseState,
+                                          ReachTuple.factory(rt.getHrnID(),
+                                                             false,   // multi
+                                                             ReachTuple.ARITY_ONE,
+                                                             false    // out-of-context
+                                                             )
+                                          );
+
+       } else {
+         // otherwise the ith symbol becomes shadowed
+         baseState = Canonical.addUpArity(baseState,
+                                          ReachTuple.factory(-rt.getHrnID(),
+                                                             false,   // multi
+                                                             ReachTuple.ARITY_ONE,
+                                                             false    // out-of-context
+                                                             )
+                                          );
+       }
       }
     }
 
@@ -1082,64 +1082,64 @@ abstract public class Canonical {
     if( found2Sooc ) {
       // make a branch with every possibility of the one-to-many
       // mapping for 2S? appended to the baseState
-      out = Canonical.add( out,
-                           Canonical.addUpArity( baseState,
-                                                 ReachTuple.factory( as.getSummary(),
-                                                                     true, // multi
-                                                                     ReachTuple.ARITY_ONE,
-                                                                     false  // out-of-context
-                                                                     )
-                                                 )
-                           );
-
-      out = Canonical.add( out,
-                           Canonical.addUpArity( baseState,
-                                                 ReachTuple.factory( as.getSummary(),
-                                                                     true, // multi
-                                                                     ReachTuple.ARITY_ONE,
-                                                                     true  // out-of-context
-                                                                     )
-                                                 )
-                           );      
+      out = Canonical.add(out,
+                          Canonical.addUpArity(baseState,
+                                               ReachTuple.factory(as.getSummary(),
+                                                                  true,    // multi
+                                                                  ReachTuple.ARITY_ONE,
+                                                                  false     // out-of-context
+                                                                  )
+                                               )
+                          );
+
+      out = Canonical.add(out,
+                          Canonical.addUpArity(baseState,
+                                               ReachTuple.factory(as.getSummary(),
+                                                                  true,    // multi
+                                                                  ReachTuple.ARITY_ONE,
+                                                                  true     // out-of-context
+                                                                  )
+                                               )
+                          );
 
       for( int i = 0; i < as.getAllocationDepth(); ++i ) {
-        out = Canonical.add( out,
-                             Canonical.addUpArity( baseState,
-                                                   ReachTuple.factory( as.getIthOldest( i ),
-                                                                       false, // multi
-                                                                       ReachTuple.ARITY_ONE,
-                                                                       true  // out-of-context
-                                                                       )
-                                                   )
-                             );
+       out = Canonical.add(out,
+                           Canonical.addUpArity(baseState,
+                                                ReachTuple.factory(as.getIthOldest(i),
+                                                                   false,    // multi
+                                                                   ReachTuple.ARITY_ONE,
+                                                                   true     // out-of-context
+                                                                   )
+                                                )
+                           );
       }
 
     } else {
-      // just use current baseState      
-      out = Canonical.add( out,
-                           baseState );
+      // just use current baseState
+      out = Canonical.add(out,
+                          baseState);
     }
 
 
     assert out.isCanonical();
-    op2result.put( op, out );
+    op2result.put(op, out);
     return out;
   }
 
 
-  public static ReachSet unshadow( ReachSet  rs,
-                                   AllocSite as ) {
+  public static ReachSet unshadow(ReachSet rs,
+                                  AllocSite as) {
     assert rs != null;
     assert as != null;
     assert rs.isCanonical();
     assert as.isCanonical();
 
-    CanonicalOp op = 
-      new CanonicalOp( CanonicalOp.REACHSET_UNSHADOW_ALLOCSITE,
-                       rs, 
-                       as );
-    
-    Canonical result = op2result.get( op );
+    CanonicalOp op =
+      new CanonicalOp(CanonicalOp.REACHSET_UNSHADOW_ALLOCSITE,
+                      rs,
+                      as);
+
+    Canonical result = op2result.get(op);
     if( result != null ) {
       return (ReachSet) result;
     }
@@ -1149,29 +1149,29 @@ abstract public class Canonical {
     Iterator<ReachState> itr = rs.iterator();
     while( itr.hasNext() ) {
       ReachState state = itr.next();
-      out = Canonical.add( out,
-                           Canonical.unshadow( state, as )
-                           );
+      out = Canonical.add(out,
+                          Canonical.unshadow(state, as)
+                          );
     }
 
     assert out.isCanonical();
-    op2result.put( op, out );
+    op2result.put(op, out);
     return out;
   }
 
-  public static ReachState unshadow( ReachState state,
-                                     AllocSite  as ) {
+  public static ReachState unshadow(ReachState state,
+                                    AllocSite as) {
     assert state != null;
     assert as    != null;
     assert state.isCanonical();
     assert as.isCanonical();
 
-    CanonicalOp op = 
-      new CanonicalOp( CanonicalOp.REACHSTATE_UNSHADOW_ALLOCSITE,
-                       state, 
-                       as );
-    
-    Canonical result = op2result.get( op );
+    CanonicalOp op =
+      new CanonicalOp(CanonicalOp.REACHSTATE_UNSHADOW_ALLOCSITE,
+                      state,
+                      as);
+
+    Canonical result = op2result.get(op);
     if( result != null ) {
       return (ReachState) result;
     }
@@ -1183,183 +1183,183 @@ abstract public class Canonical {
     // -0   -> 0
     // -1   -> 1
     // -2S  -> 2S
-    
+
     // otherwise, no cached result...
     ReachState out = ReachState.factory();
     Iterator<ReachTuple> itr = state.iterator();
     while( itr.hasNext() ) {
       ReachTuple rt = itr.next();
 
-      int age = as.getShadowAgeCategory( rt.getHrnID() );
-      
+      int age = as.getShadowAgeCategory(rt.getHrnID() );
+
       if( age == AllocSite.SHADOWAGE_notInThisSite ) {
-        // things not from the site just go back in
-       out = Canonical.addUpArity( out, rt );
+       // things not from the site just go back in
+       out = Canonical.addUpArity(out, rt);
 
       } else {
-        assert !rt.isOutOfContext();
-
-        // otherwise unshadow it
-        out = Canonical.addUpArity( out,
-                                    ReachTuple.factory( -rt.getHrnID(),
-                                                        rt.isMultiObject(),
-                                                        rt.getArity(),
-                                                        false
-                                                        )
-                                    );
+       assert !rt.isOutOfContext();
+
+       // otherwise unshadow it
+       out = Canonical.addUpArity(out,
+                                  ReachTuple.factory(-rt.getHrnID(),
+                                                     rt.isMultiObject(),
+                                                     rt.getArity(),
+                                                     false
+                                                     )
+                                  );
       }
     }
 
-    out = Canonical.attach( out,
-                            state.getPreds()
-                            );
+    out = Canonical.attach(out,
+                           state.getPreds()
+                           );
 
     assert out.isCanonical();
-    op2result.put( op, out );
+    op2result.put(op, out);
     return out;
   }
 
 
 
-  public static ReachState changePredsTo( ReachState   rs,
-                                          ExistPredSet preds ) {
+  public static ReachState changePredsTo(ReachState rs,
+                                         ExistPredSet preds) {
     assert rs != null;
     assert rs.isCanonical();
 
-    CanonicalOp op = 
-      new CanonicalOp( CanonicalOp.REACHSTATE_CHANGEPREDSTO_EXISTPREDSET,
-                       rs, 
-                       preds );
-    
-    Canonical result = op2result.get( op );
+    CanonicalOp op =
+      new CanonicalOp(CanonicalOp.REACHSTATE_CHANGEPREDSTO_EXISTPREDSET,
+                      rs,
+                      preds);
+
+    Canonical result = op2result.get(op);
     if( result != null ) {
       return (ReachState) result;
     }
-    
+
     // otherwise, no cached result...
     ReachState out = new ReachState();
 
     // just remake state with the true predicate attached
-    out.reachTuples.addAll( rs.reachTuples );
+    out.reachTuples.addAll(rs.reachTuples);
     out.preds = preds;
-    
-    out = (ReachState) makeCanonical( out );
-    op2result.put( op, out );
+
+    out = (ReachState) makeCanonical(out);
+    op2result.put(op, out);
     return out;
   }
 
 
-  public static ReachSet changePredsTo( ReachSet     rs,
-                                        ExistPredSet preds ) {
+  public static ReachSet changePredsTo(ReachSet rs,
+                                       ExistPredSet preds) {
     assert rs != null;
     assert rs.isCanonical();
 
-    CanonicalOp op = 
-      new CanonicalOp( CanonicalOp.REACHSET_CHANGEPREDSTO_EXISTPREDSET,
-                       rs,
-                       preds );
-    
-    Canonical result = op2result.get( op );
+    CanonicalOp op =
+      new CanonicalOp(CanonicalOp.REACHSET_CHANGEPREDSTO_EXISTPREDSET,
+                      rs,
+                      preds);
+
+    Canonical result = op2result.get(op);
     if( result != null ) {
       return (ReachSet) result;
     }
-    
+
     // otherwise, no cached result...
     ReachSet out = ReachSet.factory();
     Iterator<ReachState> itr = rs.iterator();
     while( itr.hasNext() ) {
       ReachState state = itr.next();
-      out = Canonical.add( out,
-                           Canonical.changePredsTo( state,
-                                                    preds 
-                                                    )
-                           );
+      out = Canonical.add(out,
+                          Canonical.changePredsTo(state,
+                                                  preds
+                                                  )
+                          );
     }
-    
-    out = (ReachSet) makeCanonical( out );
-    op2result.put( op, out );
+
+    out = (ReachSet) makeCanonical(out);
+    op2result.put(op, out);
     return out;
   }
 
 
-  public static Taint attach( Taint        t,
-                              ExistPredSet preds ) {
+  public static Taint attach(Taint t,
+                             ExistPredSet preds) {
     assert t     != null;
     assert preds != null;
     assert t.isCanonical();
     assert preds.isCanonical();
 
-    CanonicalOp op = 
-      new CanonicalOp( CanonicalOp.TAINT_ATTACH_EXISTPREDSET,
-                       t, 
-                       preds );
-    
-    Canonical result = op2result.get( op );
+    CanonicalOp op =
+      new CanonicalOp(CanonicalOp.TAINT_ATTACH_EXISTPREDSET,
+                      t,
+                      preds);
+
+    Canonical result = op2result.get(op);
     if( result != null ) {
       return (Taint) result;
     }
-    
+
     // otherwise, no cached result...
-    Taint out = new Taint( t );
-    out.preds = Canonical.join( t.preds,
-                                preds );
-    
-    out = (Taint) makeCanonical( out );
-    op2result.put( op, out );
+    Taint out = new Taint(t);
+    out.preds = Canonical.join(t.preds,
+                               preds);
+
+    out = (Taint) makeCanonical(out);
+    op2result.put(op, out);
     return out;
   }
 
-  public static TaintSet add( TaintSet ts,
-                              Taint    t ) {
+  public static TaintSet add(TaintSet ts,
+                             Taint t) {
     assert ts != null;
     assert t  != null;
     assert ts.isCanonical();
     assert t.isCanonical();
 
-    CanonicalOp op = 
-      new CanonicalOp( CanonicalOp.TAINTSET_ADD_TAINT,
-                       ts, 
-                       t );
-    
-    Canonical result = op2result.get( op );
+    CanonicalOp op =
+      new CanonicalOp(CanonicalOp.TAINTSET_ADD_TAINT,
+                      ts,
+                      t);
+
+    Canonical result = op2result.get(op);
     if( result != null ) {
       return (TaintSet) result;
     }
-    
-    // otherwise, no cached result...    
+
+    // otherwise, no cached result...
     TaintSet out = new TaintSet();
-    out.taints.addAll( ts.taints );
-    out.taints.add( t );
-    
-    out = (TaintSet) makeCanonical( out );
-    op2result.put( op, out );
-    return out;    
+    out.taints.addAll(ts.taints);
+    out.taints.add(t);
+
+    out = (TaintSet) makeCanonical(out);
+    op2result.put(op, out);
+    return out;
   }
 
 
-  public static TaintSet addPTR( TaintSet ts,
-                              Taint    t ) {
+  public static TaintSet addPTR(TaintSet ts,
+                                Taint t) {
     return add(ts, t);
   }
 
-  public static TaintSet union( TaintSet ts1,
-                                TaintSet ts2 ) {
+  public static TaintSet union(TaintSet ts1,
+                               TaintSet ts2) {
     assert ts1 != null;
     assert ts2 != null;
     assert ts1.isCanonical();
     assert ts2.isCanonical();
-    
-    CanonicalOp op = 
-      new CanonicalOp( CanonicalOp.TAINTSET_UNION_TAINTSET,
-                       ts1, 
-                       ts2 );
-    
-    Canonical result = op2result.get( op );
+
+    CanonicalOp op =
+      new CanonicalOp(CanonicalOp.TAINTSET_UNION_TAINTSET,
+                      ts1,
+                      ts2);
+
+    Canonical result = op2result.get(op);
     if( result != null ) {
       return (TaintSet) result;
     }
-    
-    // otherwise, no cached result...    
+
+    // otherwise, no cached result...
     TaintSet out = new TaintSet();
 
     // first add everything from 1, and if it was also in 2
@@ -1367,76 +1367,76 @@ abstract public class Canonical {
     Iterator<Taint> tItr = ts1.iterator();
     while( tItr.hasNext() ) {
       Taint t1 = tItr.next();
-      Taint t2 = ts2.containsIgnorePreds( t1 );
+      Taint t2 = ts2.containsIgnorePreds(t1);
 
       if( t2 != null ) {
-        Taint tNew = new Taint( t1 );
-        tNew.preds = Canonical.join( t1.preds,
-                                     t2.preds
-                                     );
-        tNew = (Taint) makeCanonical( tNew );
-       out.taints.add( tNew );
+       Taint tNew = new Taint(t1);
+       tNew.preds = Canonical.join(t1.preds,
+                                   t2.preds
+                                   );
+       tNew = (Taint) makeCanonical(tNew);
+       out.taints.add(tNew);
       } else {
-       out.taints.add( t1 );
+       out.taints.add(t1);
       }
     }
-    
+
     // then add everything in 2 that wasn't in 1
     tItr = ts2.iterator();
     while( tItr.hasNext() ) {
       Taint t2 = tItr.next();
-      Taint t1 = ts1.containsIgnorePreds( t2 );
+      Taint t1 = ts1.containsIgnorePreds(t2);
 
       if( t1 == null ) {
-       out.taints.add( t2 );
+       out.taints.add(t2);
       }
     }
 
-    out = (TaintSet) makeCanonical( out );
-    op2result.put( op, out );
-    return out;    
+    out = (TaintSet) makeCanonical(out);
+    op2result.put(op, out);
+    return out;
   }
 
-  public static TaintSet unionPTR( TaintSet ts1,
-                                TaintSet ts2 ) {
+  public static TaintSet unionPTR(TaintSet ts1,
+                                  TaintSet ts2) {
     assert ts1 != null;
     assert ts2 != null;
     assert ts1.isCanonical();
     assert ts2.isCanonical();
-    
-    CanonicalOp op = 
-      new CanonicalOp( CanonicalOp.TAINTSET_UNION_TAINTSET,
-                       ts1, 
-                       ts2 );
-    
-    Canonical result = op2result.get( op );
+
+    CanonicalOp op =
+      new CanonicalOp(CanonicalOp.TAINTSET_UNION_TAINTSET,
+                      ts1,
+                      ts2);
+
+    Canonical result = op2result.get(op);
     if( result != null ) {
       return (TaintSet) result;
     }
-    
-    // otherwise, no cached result...    
+
+    // otherwise, no cached result...
     TaintSet out = new TaintSet();
 
     out.taints.addAll(ts1.taints);
     out.taints.addAll(ts2.taints);
     out= (TaintSet) Canonical.makeCanonical(out);
-    op2result.put( op, out );
-    return out;    
+    op2result.put(op, out);
+    return out;
   }
 
-  public static TaintSet unionORpreds( TaintSet ts1,
-                                       TaintSet ts2 ) {
+  public static TaintSet unionORpreds(TaintSet ts1,
+                                      TaintSet ts2) {
     assert ts1 != null;
     assert ts2 != null;
     assert ts1.isCanonical();
     assert ts2.isCanonical();
 
-    CanonicalOp op = 
-      new CanonicalOp( CanonicalOp.TAINTSET_UNIONORPREDS_TAINTSET,
-                       ts1, 
-                       ts2 );
-    
-    Canonical result = op2result.get( op );
+    CanonicalOp op =
+      new CanonicalOp(CanonicalOp.TAINTSET_UNIONORPREDS_TAINTSET,
+                      ts1,
+                      ts2);
+
+    Canonical result = op2result.get(op);
     if( result != null ) {
       return (TaintSet) result;
     }
@@ -1449,17 +1449,17 @@ abstract public class Canonical {
     Iterator<Taint> tItr = ts1.iterator();
     while( tItr.hasNext() ) {
       Taint t1 = tItr.next();
-      Taint t2 = ts2.containsIgnorePreds( t1 );
-      
+      Taint t2 = ts2.containsIgnorePreds(t1);
+
       if( t2 != null ) {
-        Taint tNew = new Taint( t1 );
-        tNew.preds = Canonical.join( t1.preds,
-                                     t2.preds
-                                     );
-        tNew = (Taint) makeCanonical( tNew );
-       out.taints.add( tNew );
+       Taint tNew = new Taint(t1);
+       tNew.preds = Canonical.join(t1.preds,
+                                   t2.preds
+                                   );
+       tNew = (Taint) makeCanonical(tNew);
+       out.taints.add(tNew);
       } else {
-       out.taints.add( t1 );
+       out.taints.add(t1);
       }
     }
 
@@ -1467,15 +1467,15 @@ abstract public class Canonical {
     tItr = ts2.iterator();
     while( tItr.hasNext() ) {
       Taint t2 = tItr.next();
-      Taint t1 = ts1.containsIgnorePreds( t2 );
-      
+      Taint t1 = ts1.containsIgnorePreds(t2);
+
       if( t1 == null ) {
-       out.taints.add( t2 );
+       out.taints.add(t2);
       }
     }
-    
-    out = (TaintSet) makeCanonical( out );
-    op2result.put( op, out );
+
+    out = (TaintSet) makeCanonical(out);
+    op2result.put(op, out);
     return out;
   }
 
@@ -1483,8 +1483,8 @@ abstract public class Canonical {
   // BOO, HISS! SESE (rblock) operand does NOT extend
   // Canonical, so we can't cache this op by its
   // canonical arguments--THINK ABOUT A BETTER WAY!
-  public static TaintSet removeInContextTaints( TaintSet          ts,
-                                                FlatSESEEnterNode sese ) {
+  public static TaintSet removeInContextTaints(TaintSet ts,
+                                               FlatSESEEnterNode sese) {
     assert ts != null;
     assert ts.isCanonical();
     assert sese != null;
@@ -1501,14 +1501,14 @@ abstract public class Canonical {
       // unaffected, and if the taint has a non-empty predicate
       // it is out of context so it should go through, too
       if( t.getSESE() == null ||
-          !t.getSESE().equals( sese ) ||
+          !t.getSESE().equals(sese) ||
           !t.getPreds().isEmpty()
           ) {
-        out.taints.add( t );
+       out.taints.add(t);
       }
     }
-    
-    out = (TaintSet) makeCanonical( out );
+
+    out = (TaintSet) makeCanonical(out);
     //op2result.put( op, out ); CRY CRY
     return out;
   }
@@ -1516,8 +1516,8 @@ abstract public class Canonical {
   // BOO, HISS! SESE (rblock) operand does NOT extend
   // Canonical, so we can't cache this op by its
   // canonical arguments--THINK ABOUT A BETTER WAY!
-  public static TaintSet removeSESETaints( TaintSet          ts,
-                                          Set<FlatSESEEnterNode> seseSet ) {
+  public static TaintSet removeSESETaints(TaintSet ts,
+                                          Set<FlatSESEEnterNode> seseSet) {
     assert ts != null;
     assert ts.isCanonical();
 
@@ -1534,17 +1534,17 @@ abstract public class Canonical {
       // it is out of context so it should go through, too
       if( t.getSESE() == null ||
           !seseSet.contains(t)) {
-        out.taints.add( t );
+       out.taints.add(t);
       }
     }
-    
-    out = (TaintSet) makeCanonical( out );
+
+    out = (TaintSet) makeCanonical(out);
     //op2result.put( op, out ); CRY CRY
     return out;
   }
 
-  public static TaintSet removeInContextTaintsNP( TaintSet          ts,
-                                                FlatSESEEnterNode sese ) {
+  public static TaintSet removeInContextTaintsNP(TaintSet ts,
+                                                 FlatSESEEnterNode sese) {
     assert ts != null;
     assert ts.isCanonical();
 
@@ -1560,28 +1560,28 @@ abstract public class Canonical {
       // unaffected, and if the taint has a non-empty predicate
       // it is out of context so it should go through, too
       if( t.getSESE()!=null && t.getSESE()!=sese) {
-        out.taints.add( t );
+       out.taints.add(t);
       }
     }
-    
-    out = (TaintSet) makeCanonical( out );
+
+    out = (TaintSet) makeCanonical(out);
     return out;
   }
 
-  public static TaintSet removeStallSiteTaints( TaintSet ts ) {
+  public static TaintSet removeStallSiteTaints(TaintSet ts) {
     assert ts != null;
     assert ts.isCanonical();
 
-    CanonicalOp op = 
-      new CanonicalOp( CanonicalOp.TAINTSET_REMOVESTALLSITETAINTS,
-                       ts, 
-                       ts );
-    
-    Canonical result = op2result.get( op );
+    CanonicalOp op =
+      new CanonicalOp(CanonicalOp.TAINTSET_REMOVESTALLSITETAINTS,
+                      ts,
+                      ts);
+
+    Canonical result = op2result.get(op);
     if( result != null ) {
       return (TaintSet) result;
     }
-    
+
     // otherwise, no cached result...
     TaintSet out = new TaintSet();
 
@@ -1591,73 +1591,73 @@ abstract public class Canonical {
 
       // only take non-stall site taints onward
       if( t.getStallSite() == null ) {
-        out.taints.add( t );
+       out.taints.add(t);
       }
     }
-    
-    out = (TaintSet) makeCanonical( out );
-    op2result.put( op, out );
+
+    out = (TaintSet) makeCanonical(out);
+    op2result.put(op, out);
     return out;
   }
 
 
-  public static Taint changePredsTo( Taint        t, 
-                                     ExistPredSet preds ) {
+  public static Taint changePredsTo(Taint t,
+                                    ExistPredSet preds) {
     assert t != null;
     assert t.isCanonical();
 
-    CanonicalOp op = 
-      new CanonicalOp( CanonicalOp.TAINT_CHANGEPREDSTO_EXISTPREDSET,
-                       t, 
-                       preds );
-    
-    Canonical result = op2result.get( op );
+    CanonicalOp op =
+      new CanonicalOp(CanonicalOp.TAINT_CHANGEPREDSTO_EXISTPREDSET,
+                      t,
+                      preds);
+
+    Canonical result = op2result.get(op);
     if( result != null ) {
       return (Taint) result;
     }
-    
+
     // otherwise, no cached result...
-    Taint out = new Taint( t.sese,
-                           t.stallSite,
-                           t.var,
-                           t.allocSite,
-                           t.fnDefined,
-                           preds
-                           );
-    
-    out = (Taint) makeCanonical( out );
-    op2result.put( op, out );
+    Taint out = new Taint(t.sese,
+                          t.stallSite,
+                          t.var,
+                          t.allocSite,
+                          t.fnDefined,
+                          preds
+                          );
+
+    out = (Taint) makeCanonical(out);
+    op2result.put(op, out);
     return out;
   }
 
 
-  public static TaintSet changePredsTo( TaintSet     ts,
-                                        ExistPredSet preds ) {
+  public static TaintSet changePredsTo(TaintSet ts,
+                                       ExistPredSet preds) {
     assert ts != null;
     assert ts.isCanonical();
 
-    CanonicalOp op = 
-      new CanonicalOp( CanonicalOp.TAINTSET_CHANGEPREDSTO_EXISTPREDSET,
-                       ts,
-                       preds );
-    
-    Canonical result = op2result.get( op );
+    CanonicalOp op =
+      new CanonicalOp(CanonicalOp.TAINTSET_CHANGEPREDSTO_EXISTPREDSET,
+                      ts,
+                      preds);
+
+    Canonical result = op2result.get(op);
     if( result != null ) {
       return (TaintSet) result;
     }
-    
+
     // otherwise, no cached result...
     TaintSet out = TaintSet.factory();
     Iterator<Taint> itr = ts.iterator();
     while( itr.hasNext() ) {
       Taint t = itr.next();
-      out = Canonical.add( out,
-                           Canonical.changePredsTo( t, preds )
-                           );
+      out = Canonical.add(out,
+                          Canonical.changePredsTo(t, preds)
+                          );
     }
-    
-    out = (TaintSet) makeCanonical( out );
-    op2result.put( op, out );
+
+    out = (TaintSet) makeCanonical(out);
+    op2result.put(op, out);
     return out;
   }
 
@@ -1666,21 +1666,21 @@ abstract public class Canonical {
   // BOO, HISS! FlatNode operand does NOT extend
   // Canonical, so we can't cache this op by its
   // canonical arguments--THINK ABOUT A BETTER WAY!
-  public static Taint changeWhereDefined( Taint    t, 
-                                          FlatNode pp ) {
+  public static Taint changeWhereDefined(Taint t,
+                                         FlatNode pp) {
     assert t != null;
     assert t.isCanonical();
 
     // never a cached result...
-    Taint out = new Taint( t.sese,
-                           t.stallSite,
-                           t.var,
-                           t.allocSite,
-                           pp,
-                           t.preds
-                           );
-    
-    out = (Taint) makeCanonical( out );
+    Taint out = new Taint(t.sese,
+                          t.stallSite,
+                          t.var,
+                          t.allocSite,
+                          pp,
+                          t.preds
+                          );
+
+    out = (Taint) makeCanonical(out);
     //op2result.put( op, out ); CRY CRY
     return out;
   }
@@ -1688,8 +1688,8 @@ abstract public class Canonical {
   // BOO, HISS! FlatNode operand does NOT extend
   // Canonical, so we can't cache this op by its
   // canonical arguments--THINK ABOUT A BETTER WAY!
-  public static TaintSet changeWhereDefined( TaintSet ts,
-                                             FlatNode pp ) {
+  public static TaintSet changeWhereDefined(TaintSet ts,
+                                            FlatNode pp) {
     assert ts != null;
     assert ts.isCanonical();
 
@@ -1698,12 +1698,12 @@ abstract public class Canonical {
     Iterator<Taint> itr = ts.iterator();
     while( itr.hasNext() ) {
       Taint t = itr.next();
-      out = Canonical.add( out,
-                           Canonical.changeWhereDefined( t, pp )
-                           );
+      out = Canonical.add(out,
+                          Canonical.changeWhereDefined(t, pp)
+                          );
     }
-    
-    out = (TaintSet) makeCanonical( out );
+
+    out = (TaintSet) makeCanonical(out);
     //op2result.put( op, out ); CRY CRY
     return out;
   }
index 64761bc..26cbd57 100644 (file)
@@ -1,6 +1,6 @@
 package Analysis.Disjoint;
 
-// a CanonicalOperation defines an operation on 
+// a CanonicalOperation defines an operation on
 // Canonical objects.  The Canonical class maps
 // an op to its result, so when you ask the
 // Canonical static methods to do an op that is
@@ -46,18 +46,18 @@ public class CanonicalOp {
   protected int opCode;
   protected Canonical operand1;
   protected Canonical operand2;
-  protected int       operand3;
+  protected int operand3;
 
-  public CanonicalOp( int       opc,
-                      Canonical op1, 
-                      Canonical op2 ) {
+  public CanonicalOp(int opc,
+                     Canonical op1,
+                     Canonical op2) {
     this( opc, op1, op2, PRIM_OP_UNUSED );
   }
 
-  public CanonicalOp( int       opc,
-                      Canonical op1, 
-                      Canonical op2,
-                      int       op3 ) {
+  public CanonicalOp(int opc,
+                     Canonical op1,
+                     Canonical op2,
+                     int op3) {
     assert op1.isCanonical();
     assert op2.isCanonical();
     opCode   = opc;
@@ -65,23 +65,23 @@ public class CanonicalOp {
     operand2 = op2;
     operand3 = op3;
   }
-  
+
   public int hashCode() {
     return opCode ^
-      (operand1.getCanonicalValue() << 2) ^
-      (operand2.getCanonicalValue() << 1) ^
-      (operand3 << 3);
+           (operand1.getCanonicalValue() << 2) ^
+           (operand2.getCanonicalValue() << 1) ^
+           (operand3 << 3);
   }
 
-  public boolean equals( Object o ) {
+  public boolean equals(Object o) {
     if( o == null ) {
       return false;
     }
 
     CanonicalOp co = (CanonicalOp) o;
     return opCode == co.opCode &&
-      (operand1.getCanonicalValue() == co.operand1.getCanonicalValue()) &&
-      (operand2.getCanonicalValue() == co.operand2.getCanonicalValue()) &&
-      operand3 == co.operand3;
+           (operand1.getCanonicalValue() == co.operand1.getCanonicalValue()) &&
+           (operand2.getCanonicalValue() == co.operand2.getCanonicalValue()) &&
+           operand3 == co.operand3;
   }
 }
index 0eeb32e..48dc02d 100644 (file)
@@ -29,18 +29,18 @@ public class ChangeSet extends Canonical {
 
   public static ChangeSet factory() {
     ChangeSet out = new ChangeSet();
-    out = (ChangeSet) Canonical.makeCanonical( out );
+    out = (ChangeSet) Canonical.makeCanonical(out);
     return out;
   }
 
-  public static ChangeSet factory( ChangeTuple ct ) {
+  public static ChangeSet factory(ChangeTuple ct) {
     assert ct != null;
     assert ct.isCanonical();
     ChangeSet out = new ChangeSet();
-    out.changeTuples.add( ct );
-    out = (ChangeSet) Canonical.makeCanonical( out );
+    out.changeTuples.add(ct);
+    out = (ChangeSet) Canonical.makeCanonical(out);
     return out;
-  }  
+  }
 
   protected ChangeSet() {
     changeTuples = new HashSet<ChangeTuple>();
@@ -58,13 +58,13 @@ public class ChangeSet extends Canonical {
     return changeTuples.isEmpty();
   }
 
-  public boolean isSubset( ChangeSet ctsIn ) {
+  public boolean isSubset(ChangeSet ctsIn) {
     assert ctsIn != null;
-    return ctsIn.changeTuples.containsAll( this.changeTuples );
+    return ctsIn.changeTuples.containsAll(this.changeTuples);
   }
 
 
-  public boolean equalsSpecific( Object o ) {
+  public boolean equalsSpecific(Object o) {
     if( o == null ) {
       return false;
     }
@@ -74,7 +74,7 @@ public class ChangeSet extends Canonical {
     }
 
     ChangeSet cts = (ChangeSet) o;
-    return changeTuples.equals( cts.changeTuples );
+    return changeTuples.equals(cts.changeTuples);
   }
 
   public int hashCodeSpecific() {
index ce0383c..9d1b96d 100644 (file)
@@ -32,27 +32,27 @@ public class ChangeTuple extends Canonical
   protected ReachState toMatch;
   protected ReachState toAdd;
 
-  public static ChangeTuple factory( ReachState toMatch,
-                                     ReachState toAdd ) {
+  public static ChangeTuple factory(ReachState toMatch,
+                                    ReachState toAdd) {
     // we don't care about the predicates hanging on
     // change tuple states, so always set them to empty
     // to ensure change tuple sets work out
     ReachState toMatchNoPreds =
-      ReachState.factory( toMatch.reachTuples,
-                          ExistPredSet.factory()
-                          );
+      ReachState.factory(toMatch.reachTuples,
+                         ExistPredSet.factory()
+                         );
     ReachState toAddNoPreds =
-      ReachState.factory( toAdd.reachTuples,
-                          ExistPredSet.factory()
-                          );
-    ChangeTuple out = new ChangeTuple( toMatchNoPreds,
-                                       toAddNoPreds );
-    out = (ChangeTuple) Canonical.makeCanonical( out );
+      ReachState.factory(toAdd.reachTuples,
+                         ExistPredSet.factory()
+                         );
+    ChangeTuple out = new ChangeTuple(toMatchNoPreds,
+                                      toAddNoPreds);
+    out = (ChangeTuple) Canonical.makeCanonical(out);
     return out;
   }
 
-  protected ChangeTuple( ReachState toMatch,
-                         ReachState toAdd ) {
+  protected ChangeTuple(ReachState toMatch,
+                        ReachState toAdd) {
     this.toMatch = toMatch;
     this.toAdd   = toAdd;
   }
@@ -63,21 +63,21 @@ public class ChangeTuple extends Canonical
   public ReachState getStateToAdd() {
     return toAdd;
   }
-  
 
-  public boolean equalsSpecific( Object o ) {
+
+  public boolean equalsSpecific(Object o) {
     if( o == null ) {
       return false;
     }
-    
+
     if( !(o instanceof ChangeTuple) ) {
       return false;
     }
 
     ChangeTuple ct = (ChangeTuple) o;
     return
-      toMatch.equals( ct.toMatch ) &&
-      toAdd.equals( ct.toAdd );
+      toMatch.equals(ct.toMatch) &&
+      toAdd.equals(ct.toAdd);
   }
 
   public int hashCodeSpecific() {
index 9fdc4ab..03b257e 100644 (file)
@@ -7,7 +7,7 @@ import java.io.*;
 
 public class DescriptorComparator implements Comparator {
 
-  public int compare( Object o1, Object o2  ) {
+  public int compare(Object o1, Object o2) {
 
     assert o1 instanceof Descriptor;
     assert o2 instanceof Descriptor;
@@ -17,5 +17,5 @@ public class DescriptorComparator implements Comparator {
 
     return d1.getNum() - d2.getNum();
   }
-  
+
 }
index a459dac..cae5c56 100644 (file)
@@ -10,12 +10,12 @@ public class DescriptorQWrapper implements Comparable {
   private int priority;
   private Descriptor d;
 
-  public DescriptorQWrapper( Integer p, Descriptor d ) {
+  public DescriptorQWrapper(Integer p, Descriptor d) {
     priority = p.intValue();
     this.d   = d;
   }
 
-  public DescriptorQWrapper( int p, Descriptor d ) {
+  public DescriptorQWrapper(int p, Descriptor d) {
     priority = p;
     this.d   = d;
   }
@@ -23,8 +23,8 @@ public class DescriptorQWrapper implements Comparable {
   public Descriptor getDescriptor() {
     return d;
   }
-  public int compareTo( Object o ) throws ClassCastException {
+
+  public int compareTo(Object o) throws ClassCastException {
 
     if( !(o instanceof DescriptorQWrapper) ) {
       throw new ClassCastException();
@@ -42,9 +42,9 @@ public class DescriptorQWrapper implements Comparable {
     if( !( o instanceof DescriptorQWrapper) ) {
       return false;
     }
-    
+
     DescriptorQWrapper dqw = (DescriptorQWrapper) o;
 
-    return d.equals( dqw.d );
-  }  
+    return d.equals(dqw.d);
+  }
 }
index 69abe98..d9c057a 100644 (file)
@@ -13,7 +13,7 @@ import java.io.*;
 
 
 public class DisjointAnalysis implements HeapAnalysis {
-       
+
   ///////////////////////////////////////////
   //
   //  Public interface to discover possible
@@ -24,57 +24,57 @@ public class DisjointAnalysis implements HeapAnalysis {
   // if an object allocated at the target site may be
   // reachable from both an object from root1 and an
   // object allocated at root2, return TRUE
-  public boolean mayBothReachTarget( FlatMethod fm,
-                                     FlatNew fnRoot1,
-                                     FlatNew fnRoot2,
-                                     FlatNew fnTarget ) {
-    
-    AllocSite asr1 = getAllocationSiteFromFlatNew( fnRoot1 );
-    AllocSite asr2 = getAllocationSiteFromFlatNew( fnRoot2 );
+  public boolean mayBothReachTarget(FlatMethod fm,
+                                    FlatNew fnRoot1,
+                                    FlatNew fnRoot2,
+                                    FlatNew fnTarget) {
+
+    AllocSite asr1 = getAllocationSiteFromFlatNew(fnRoot1);
+    AllocSite asr2 = getAllocationSiteFromFlatNew(fnRoot2);
     assert asr1.isFlagged();
     assert asr2.isFlagged();
 
-    AllocSite ast = getAllocationSiteFromFlatNew( fnTarget );
-    ReachGraph rg = getPartial( fm.getMethod() );
+    AllocSite ast = getAllocationSiteFromFlatNew(fnTarget);
+    ReachGraph rg = getPartial(fm.getMethod() );
 
-    return rg.mayBothReachTarget( asr1, asr2, ast );
+    return rg.mayBothReachTarget(asr1, asr2, ast);
   }
 
   // similar to the method above, return TRUE if ever
   // more than one object from the root allocation site
   // may reach an object from the target site
-  public boolean mayManyReachTarget( FlatMethod fm,
-                                     FlatNew fnRoot,
-                                     FlatNew fnTarget ) {
-    
-    AllocSite asr = getAllocationSiteFromFlatNew( fnRoot );
+  public boolean mayManyReachTarget(FlatMethod fm,
+                                    FlatNew fnRoot,
+                                    FlatNew fnTarget) {
+
+    AllocSite asr = getAllocationSiteFromFlatNew(fnRoot);
     assert asr.isFlagged();
-    
-    AllocSite ast = getAllocationSiteFromFlatNew( fnTarget );    
-    ReachGraph rg = getPartial( fm.getMethod() );
-    
-    return rg.mayManyReachTarget( asr, ast );
+
+    AllocSite ast = getAllocationSiteFromFlatNew(fnTarget);
+    ReachGraph rg = getPartial(fm.getMethod() );
+
+    return rg.mayManyReachTarget(asr, ast);
   }
 
 
 
-  
+
   public HashSet<AllocSite>
-    getFlaggedAllocationSitesReachableFromTask(TaskDescriptor td) {
+  getFlaggedAllocationSitesReachableFromTask(TaskDescriptor td) {
     checkAnalysisComplete();
     return getFlaggedAllocationSitesReachableFromTaskPRIVATE(td);
   }
-         
+
   public AllocSite getAllocationSiteFromFlatNew(FlatNew fn) {
     checkAnalysisComplete();
     return getAllocSiteFromFlatNewPRIVATE(fn);
-  }      
-         
+  }
+
   public AllocSite getAllocationSiteFromHeapRegionNodeID(Integer id) {
     checkAnalysisComplete();
     return mapHrnIdToAllocSite.get(id);
   }
-         
+
   public Set<HeapRegionNode> hasPotentialSharing(Descriptor taskOrMethod,
                                                  int paramIndex1,
                                                  int paramIndex2) {
@@ -84,13 +84,13 @@ public class DisjointAnalysis implements HeapAnalysis {
     assert(rg != null);
     return rg.mayReachSharedObjects(fm, paramIndex1, paramIndex2);
   }
-         
+
   public Set<HeapRegionNode> hasPotentialSharing(Descriptor taskOrMethod,
                                                  int paramIndex, AllocSite alloc) {
     checkAnalysisComplete();
     ReachGraph rg = mapDescriptorToCompleteReachGraph.get(taskOrMethod);
     FlatMethod fm=state.getMethodFlat(taskOrMethod);
-    assert (rg != null);
+    assert(rg != null);
     return rg.mayReachSharedObjects(fm, paramIndex, alloc);
   }
 
@@ -99,7 +99,7 @@ public class DisjointAnalysis implements HeapAnalysis {
     checkAnalysisComplete();
     ReachGraph rg  = mapDescriptorToCompleteReachGraph.get(taskOrMethod);
     FlatMethod fm=state.getMethodFlat(taskOrMethod);
-    assert (rg != null);
+    assert(rg != null);
     return rg.mayReachSharedObjects(fm, paramIndex, alloc);
   }
 
@@ -107,10 +107,10 @@ public class DisjointAnalysis implements HeapAnalysis {
                                                  AllocSite alloc1, AllocSite alloc2) {
     checkAnalysisComplete();
     ReachGraph rg  = mapDescriptorToCompleteReachGraph.get(taskOrMethod);
-    assert (rg != null);
+    assert(rg != null);
     return rg.mayReachSharedObjects(alloc1, alloc2);
   }
-       
+
   public String prettyPrintNodeSet(Set<HeapRegionNode> s) {
     checkAnalysisComplete();
 
@@ -122,27 +122,27 @@ public class DisjointAnalysis implements HeapAnalysis {
 
       AllocSite as = n.getAllocSite();
       if (as == null) {
-        out += "  " + n.toString() + ",\n";
+       out += "  " + n.toString() + ",\n";
       } else {
-        out += "  " + n.toString() + ": " + as.toStringVerbose()
-          + ",\n";
+       out += "  " + n.toString() + ": " + as.toStringVerbose()
+              + ",\n";
       }
     }
 
     out += "}\n";
     return out;
   }
-       
+
   // use the methods given above to check every possible sharing class
   // between task parameters and flagged allocation sites reachable
   // from the task
-  public void writeAllSharing(String outputFile, 
+  public void writeAllSharing(String outputFile,
                               String timeReport,
                               String justTime,
                               boolean tabularOutput,
                               int numLines
                               )
-    throws java.io.IOException {
+  throws java.io.IOException {
     checkAnalysisComplete();
 
     BufferedWriter bw = new BufferedWriter(new FileWriter(outputFile));
@@ -161,7 +161,7 @@ public class DisjointAnalysis implements HeapAnalysis {
       TaskDescriptor td = (TaskDescriptor) taskItr.next();
 
       if (!tabularOutput) {
-        bw.write("\n---------" + td + "--------\n");
+       bw.write("\n---------" + td + "--------\n");
       }
 
       HashSet<AllocSite> allocSites = getFlaggedAllocationSitesReachableFromTask(td);
@@ -176,52 +176,52 @@ public class DisjointAnalysis implements HeapAnalysis {
       FlatMethod fm = state.getMethodFlat(td);
       for (int i = 0; i < fm.numParameters(); ++i) {
 
-        // skip parameters with types that cannot reference
-        // into the heap
-        if( !shouldAnalysisTrack( fm.getParameter( i ).getType() ) ) {
-          continue;
-        }
-                          
-        // for the ith parameter check for sharing classes to all
-        // higher numbered parameters
-        for (int j = i + 1; j < fm.numParameters(); ++j) {
-
-          // skip parameters with types that cannot reference
-          // into the heap
-          if( !shouldAnalysisTrack( fm.getParameter( j ).getType() ) ) {
-            continue;
-          }
-
-
-          common = hasPotentialSharing(td, i, j);
-          if (!common.isEmpty()) {
-            foundSomeSharing = true;
-            ++numSharing;
-            if (!tabularOutput) {
-              bw.write("Potential sharing between parameters " + i
-                       + " and " + j + ".\n");
-              bw.write(prettyPrintNodeSet(common) + "\n");
-            }
-          }
-        }
-
-        // for the ith parameter, check for sharing classes against
-        // the set of allocation sites reachable from this
-        // task context
-        Iterator allocItr = allocSites.iterator();
-        while (allocItr.hasNext()) {
-          AllocSite as = (AllocSite) allocItr.next();
-          common = hasPotentialSharing(td, i, as);
-          if (!common.isEmpty()) {
-            foundSomeSharing = true;
-            ++numSharing;
-            if (!tabularOutput) {
-              bw.write("Potential sharing between parameter " + i
-                       + " and " + as.getFlatNew() + ".\n");
-              bw.write(prettyPrintNodeSet(common) + "\n");
-            }
-          }
-        }
+       // skip parameters with types that cannot reference
+       // into the heap
+       if( !shouldAnalysisTrack(fm.getParameter(i).getType() ) ) {
+         continue;
+       }
+
+       // for the ith parameter check for sharing classes to all
+       // higher numbered parameters
+       for (int j = i + 1; j < fm.numParameters(); ++j) {
+
+         // skip parameters with types that cannot reference
+         // into the heap
+         if( !shouldAnalysisTrack(fm.getParameter(j).getType() ) ) {
+           continue;
+         }
+
+
+         common = hasPotentialSharing(td, i, j);
+         if (!common.isEmpty()) {
+           foundSomeSharing = true;
+           ++numSharing;
+           if (!tabularOutput) {
+             bw.write("Potential sharing between parameters " + i
+                      + " and " + j + ".\n");
+             bw.write(prettyPrintNodeSet(common) + "\n");
+           }
+         }
+       }
+
+       // for the ith parameter, check for sharing classes against
+       // the set of allocation sites reachable from this
+       // task context
+       Iterator allocItr = allocSites.iterator();
+       while (allocItr.hasNext()) {
+         AllocSite as = (AllocSite) allocItr.next();
+         common = hasPotentialSharing(td, i, as);
+         if (!common.isEmpty()) {
+           foundSomeSharing = true;
+           ++numSharing;
+           if (!tabularOutput) {
+             bw.write("Potential sharing between parameter " + i
+                      + " and " + as.getFlatNew() + ".\n");
+             bw.write(prettyPrintNodeSet(common) + "\n");
+           }
+         }
+       }
       }
 
       // for each allocation site check for sharing classes with
@@ -230,40 +230,40 @@ public class DisjointAnalysis implements HeapAnalysis {
       HashSet<AllocSite> outerChecked = new HashSet<AllocSite>();
       Iterator allocItr1 = allocSites.iterator();
       while (allocItr1.hasNext()) {
-        AllocSite as1 = (AllocSite) allocItr1.next();
-
-        Iterator allocItr2 = allocSites.iterator();
-        while (allocItr2.hasNext()) {
-          AllocSite as2 = (AllocSite) allocItr2.next();
-
-          if (!outerChecked.contains(as2)) {
-            common = hasPotentialSharing(td, as1, as2);
-
-            if (!common.isEmpty()) {
-              foundSomeSharing = true;
-              ++numSharing;
-              if (!tabularOutput) {
-                bw.write("Potential sharing between "
-                         + as1.getFlatNew() + " and "
-                         + as2.getFlatNew() + ".\n");
-                bw.write(prettyPrintNodeSet(common) + "\n");
-              }
-            }
-          }
-        }
+       AllocSite as1 = (AllocSite) allocItr1.next();
+
+       Iterator allocItr2 = allocSites.iterator();
+       while (allocItr2.hasNext()) {
+         AllocSite as2 = (AllocSite) allocItr2.next();
+
+         if (!outerChecked.contains(as2)) {
+           common = hasPotentialSharing(td, as1, as2);
+
+           if (!common.isEmpty()) {
+             foundSomeSharing = true;
+             ++numSharing;
+             if (!tabularOutput) {
+               bw.write("Potential sharing between "
+                        + as1.getFlatNew() + " and "
+                        + as2.getFlatNew() + ".\n");
+               bw.write(prettyPrintNodeSet(common) + "\n");
+             }
+           }
+         }
+       }
 
-        outerChecked.add(as1);
+       outerChecked.add(as1);
       }
 
       if (!foundSomeSharing) {
-        if (!tabularOutput) {
-          bw.write("No sharing between flagged objects in Task " + td
-                   + ".\n");
-        }
+       if (!tabularOutput) {
+         bw.write("No sharing between flagged objects in Task " + td
+                  + ".\n");
+       }
       }
     }
 
-               
+
     if (tabularOutput) {
       bw.write(" & " + numSharing + " & " + justTime + " & " + numLines
                + " & " + numMethodsAnalyzed() + " \\\\\n");
@@ -275,20 +275,20 @@ public class DisjointAnalysis implements HeapAnalysis {
   }
 
 
-       
+
   // this version of writeAllSharing is for Java programs that have no tasks
   // ***********************************
   // WARNING: THIS DOES NOT DO THE RIGHT THING, REPORTS 0 ALWAYS!
   // It should use mayBothReachTarget and mayManyReachTarget like
   // OoOJava does to query analysis results
   // ***********************************
-  public void writeAllSharingJava(String outputFile, 
+  public void writeAllSharingJava(String outputFile,
                                   String timeReport,
                                   String justTime,
                                   boolean tabularOutput,
                                   int numLines
                                   )
-    throws java.io.IOException {
+  throws java.io.IOException {
     checkAnalysisComplete();
 
     assert !state.TASK;
@@ -296,7 +296,7 @@ public class DisjointAnalysis implements HeapAnalysis {
     int numSharing = 0;
 
     BufferedWriter bw = new BufferedWriter(new FileWriter(outputFile));
-    
+
     bw.write("Conducting disjoint reachability analysis with allocation depth = "
              + allocationDepth + "\n");
     bw.write(timeReport + "\n\n");
@@ -316,21 +316,21 @@ public class DisjointAnalysis implements HeapAnalysis {
 
       Iterator allocItr2 = allocSites.iterator();
       while (allocItr2.hasNext()) {
-        AllocSite as2 = (AllocSite) allocItr2.next();
-
-        if (!outerChecked.contains(as2)) {
-          Set<HeapRegionNode> common = hasPotentialSharing(d,
-                                                           as1, as2);
-
-          if (!common.isEmpty()) {
-            foundSomeSharing = true;
-            bw.write("Potential sharing between "
-                     + as1.getDisjointAnalysisId() + " and "
-                     + as2.getDisjointAnalysisId() + ".\n");
-            bw.write(prettyPrintNodeSet(common) + "\n");
-            ++numSharing;
-          }
-        }
+       AllocSite as2 = (AllocSite) allocItr2.next();
+
+       if (!outerChecked.contains(as2)) {
+         Set<HeapRegionNode> common = hasPotentialSharing(d,
+                                                          as1, as2);
+
+         if (!common.isEmpty()) {
+           foundSomeSharing = true;
+           bw.write("Potential sharing between "
+                    + as1.getDisjointAnalysisId() + " and "
+                    + as2.getDisjointAnalysisId() + ".\n");
+           bw.write(prettyPrintNodeSet(common) + "\n");
+           ++numSharing;
+         }
+       }
       }
 
       outerChecked.add(as1);
@@ -346,7 +346,7 @@ public class DisjointAnalysis implements HeapAnalysis {
 
     bw.close();
   }
-         
+
   ///////////////////////////////////////////
   //
   // end public interface
@@ -359,7 +359,7 @@ public class DisjointAnalysis implements HeapAnalysis {
     if( !analysisComplete ) {
       throw new Error("Warning: public interface method called while analysis is running.");
     }
-  } 
+  }
 
 
 
@@ -373,7 +373,7 @@ public class DisjointAnalysis implements HeapAnalysis {
   // should attempt to be deterministic
   public static boolean determinismDesired;
 
-  // when we want to enforce determinism in the 
+  // when we want to enforce determinism in the
   // analysis we need to sort descriptors rather
   // than toss them in efficient sets, use this
   public static DescriptorComparator dComp =
@@ -381,24 +381,24 @@ public class DisjointAnalysis implements HeapAnalysis {
 
 
   // data from the compiler
-  public State            state;
-  public CallGraph        callGraph;
-  public Liveness         liveness;
+  public State state;
+  public CallGraph callGraph;
+  public Liveness liveness;
   public ArrayReferencees arrayReferencees;
   public RBlockRelationAnalysis rblockRel;
-  public TypeUtil         typeUtil;
-  public int              allocationDepth;
+  public TypeUtil typeUtil;
+  public int allocationDepth;
 
   protected boolean doEffectsAnalysis = false;
   protected EffectsAnalysis effectsAnalysis;
   protected BuildStateMachines buildStateMachines;
 
-  
+
   // data structure for public interface
-  private Hashtable< Descriptor, HashSet<AllocSite> > 
-    mapDescriptorToAllocSiteSet;
+  private Hashtable< Descriptor, HashSet<AllocSite> >
+  mapDescriptorToAllocSiteSet;
+
 
-  
   // for public interface methods to warn that they
   // are grabbing results during analysis
   private boolean analysisComplete;
@@ -422,55 +422,55 @@ public class DisjointAnalysis implements HeapAnalysis {
   // provide the analysis with an explicit
   // top-level context with no parameters
   protected MethodDescriptor mdAnalysisEntry;
-  protected FlatMethod       fmAnalysisEntry;
+  protected FlatMethod fmAnalysisEntry;
 
   // main method defined by source program
   protected MethodDescriptor mdSourceEntry;
 
   // the set of task and/or method descriptors
   // reachable in call graph
-  protected Set<Descriptor> 
-    descriptorsToAnalyze;
+  protected Set<Descriptor>
+  descriptorsToAnalyze;
 
   // current descriptors to visit in fixed-point
   // interprocedural analysis, prioritized by
   // dependency in the call graph
   protected Stack<Descriptor>
-    descriptorsToVisitStack;
-  protected PriorityQueue<DescriptorQWrapper> 
-    descriptorsToVisitQ;
-  
+  descriptorsToVisitStack;
+  protected PriorityQueue<DescriptorQWrapper>
+  descriptorsToVisitQ;
+
   // a duplication of the above structure, but
   // for efficient testing of inclusion
-  protected HashSet<Descriptor> 
-    descriptorsToVisitSet;
+  protected HashSet<Descriptor>
+  descriptorsToVisitSet;
 
   // storage for priorities (doesn't make sense)
   // to add it to the Descriptor class, just in
   // this analysis
-  protected Hashtable<Descriptor, Integer> 
-    mapDescriptorToPriority;
+  protected Hashtable<Descriptor, Integer>
+  mapDescriptorToPriority;
 
   // when analyzing a method and scheduling more:
   // remember set of callee's enqueued for analysis
   // so they can be put on top of the callers in
   // the stack-visit mode
   protected Set<Descriptor>
-    calleesToEnqueue;
+  calleesToEnqueue;
 
   // maps a descriptor to its current partial result
   // from the intraprocedural fixed-point analysis--
   // then the interprocedural analysis settles, this
   // mapping will have the final results for each
   // method descriptor
-  protected Hashtable<Descriptor, ReachGraph> 
-    mapDescriptorToCompleteReachGraph;
+  protected Hashtable<Descriptor, ReachGraph>
+  mapDescriptorToCompleteReachGraph;
 
   // maps a descriptor to its known dependents: namely
   // methods or tasks that call the descriptor's method
   // AND are part of this analysis (reachable from main)
   protected Hashtable< Descriptor, Set<Descriptor> >
-    mapDescriptorToSetDependents;
+  mapDescriptorToSetDependents;
 
   // if the analysis client wants to flag allocation sites
   // programmatically, it should provide a set of FlatNew
@@ -480,13 +480,13 @@ public class DisjointAnalysis implements HeapAnalysis {
   // maps each flat new to one analysis abstraction
   // allocate site object, these exist outside reach graphs
   protected Hashtable<FlatNew, AllocSite>
-    mapFlatNewToAllocSite;
+  mapFlatNewToAllocSite;
 
   // maps intergraph heap region IDs to intergraph
   // allocation sites that created them, a redundant
   // structure for efficiency in some operations
   protected Hashtable<Integer, AllocSite>
-    mapHrnIdToAllocSite;
+  mapHrnIdToAllocSite;
 
   // maps a method to its initial heap model (IHM) that
   // is the set of reachability graphs from every caller
@@ -494,25 +494,25 @@ public class DisjointAnalysis implements HeapAnalysis {
   // them separate is that any one call site's contribution
   // to the IHM may changed along the path to the fixed point
   protected Hashtable< Descriptor, Hashtable< FlatCall, ReachGraph > >
-    mapDescriptorToIHMcontributions;
+  mapDescriptorToIHMcontributions;
 
   // additionally, keep a mapping from descriptors to the
   // merged in-coming initial context, because we want this
   // initial context to be STRICTLY MONOTONIC
   protected Hashtable<Descriptor, ReachGraph>
-    mapDescriptorToInitialContext;
+  mapDescriptorToInitialContext;
 
   // make the result for back edges analysis-wide STRICTLY
   // MONOTONIC as well, but notice we use FlatNode as the
   // key for this map: in case we want to consider other
   // nodes as back edge's in future implementations
   protected Hashtable<FlatNode, ReachGraph>
-    mapBackEdgeToMonotone;
+  mapBackEdgeToMonotone;
 
 
   public static final String arrayElementFieldName = "___element_";
   static protected Hashtable<TypeDescriptor, FieldDescriptor>
-    mapTypeToArrayField;
+  mapTypeToArrayField;
 
 
   protected boolean suppressOutput;
@@ -525,11 +525,11 @@ public class DisjointAnalysis implements HeapAnalysis {
   // partial method result, keep a tally for generating
   // unique filenames
   protected Hashtable<Descriptor, Integer>
-    mapDescriptorToNumUpdates;
-  
-  //map task descriptor to initial task parameter 
+  mapDescriptorToNumUpdates;
+
+  //map task descriptor to initial task parameter
   protected Hashtable<Descriptor, ReachGraph>
-    mapDescriptorToReachGraph;
+  mapDescriptorToReachGraph;
 
   protected PointerMethod pm;
 
@@ -538,17 +538,17 @@ public class DisjointAnalysis implements HeapAnalysis {
   static protected Hashtable<FlatNode, ReachGraph> fn2rgAtEnter =
     new Hashtable<FlatNode, ReachGraph>();
 
-  private Hashtable<FlatCall, Descriptor> fc2enclosing;  
-  
+  private Hashtable<FlatCall, Descriptor> fc2enclosing;
+
   Accessible accessible;
 
   // allocate various structures that are not local
   // to a single class method--should be done once
   protected void allocateStructures() {
-    
+
     if( determinismDesired ) {
       // use an ordered set
-      descriptorsToAnalyze = new TreeSet<Descriptor>( dComp );      
+      descriptorsToAnalyze = new TreeSet<Descriptor>(dComp);
     } else {
       // otherwise use a speedy hashset
       descriptorsToAnalyze = new HashSet<Descriptor>();
@@ -563,26 +563,26 @@ public class DisjointAnalysis implements HeapAnalysis {
     mapDescriptorToSetDependents =
       new Hashtable< Descriptor, Set<Descriptor> >();
 
-    mapFlatNewToAllocSite = 
+    mapFlatNewToAllocSite =
       new Hashtable<FlatNew, AllocSite>();
 
     mapDescriptorToIHMcontributions =
       new Hashtable< Descriptor, Hashtable< FlatCall, ReachGraph > >();
 
     mapDescriptorToInitialContext =
-      new Hashtable<Descriptor, ReachGraph>();    
+      new Hashtable<Descriptor, ReachGraph>();
 
     mapBackEdgeToMonotone =
       new Hashtable<FlatNode, ReachGraph>();
-    
+
     mapHrnIdToAllocSite =
       new Hashtable<Integer, AllocSite>();
 
-    mapTypeToArrayField = 
+    mapTypeToArrayField =
       new Hashtable <TypeDescriptor, FieldDescriptor>();
 
     if( state.DISJOINTDVISITSTACK ||
-        state.DISJOINTDVISITSTACKEESONTOP 
+        state.DISJOINTDVISITSTACKEESONTOP
         ) {
       descriptorsToVisitStack =
         new Stack<Descriptor>();
@@ -598,15 +598,15 @@ public class DisjointAnalysis implements HeapAnalysis {
 
     mapDescriptorToPriority =
       new Hashtable<Descriptor, Integer>();
-    
-    calleesToEnqueue = 
-      new HashSet<Descriptor>();    
+
+    calleesToEnqueue =
+      new HashSet<Descriptor>();
 
     mapDescriptorToAllocSiteSet =
-       new Hashtable<Descriptor,    HashSet<AllocSite> >();
-    
-    mapDescriptorToReachGraph = 
-       new Hashtable<Descriptor, ReachGraph>();
+      new Hashtable<Descriptor,    HashSet<AllocSite> >();
+
+    mapDescriptorToReachGraph =
+      new Hashtable<Descriptor, ReachGraph>();
 
     pm = new PointerMethod();
 
@@ -617,55 +617,55 @@ public class DisjointAnalysis implements HeapAnalysis {
 
   // this analysis generates a disjoint reachability
   // graph for every reachable method in the program
-  public DisjointAnalysis( State            s,
-                          TypeUtil         tu,
-                          CallGraph        cg,
-                          Liveness         l,
-                          ArrayReferencees ar,
-                           Set<FlatNew> sitesToFlag,
-                           RBlockRelationAnalysis rra
-                           ) {
-    init( s, tu, cg, l, ar, sitesToFlag, rra, null, false );
+  public DisjointAnalysis(State s,
+                          TypeUtil tu,
+                          CallGraph cg,
+                          Liveness l,
+                          ArrayReferencees ar,
+                          Set<FlatNew> sitesToFlag,
+                          RBlockRelationAnalysis rra
+                          ) {
+    init(s, tu, cg, l, ar, sitesToFlag, rra, null, false);
   }
 
-  public DisjointAnalysis( State            s,
-                          TypeUtil         tu,
-                          CallGraph        cg,
-                          Liveness         l,
-                          ArrayReferencees ar,
-                           Set<FlatNew> sitesToFlag,
-                           RBlockRelationAnalysis rra,
-                           boolean suppressOutput
-                           ) {
-    init( s, tu, cg, l, ar, sitesToFlag, rra, null, suppressOutput );
+  public DisjointAnalysis(State s,
+                          TypeUtil tu,
+                          CallGraph cg,
+                          Liveness l,
+                          ArrayReferencees ar,
+                          Set<FlatNew> sitesToFlag,
+                          RBlockRelationAnalysis rra,
+                          boolean suppressOutput
+                          ) {
+    init(s, tu, cg, l, ar, sitesToFlag, rra, null, suppressOutput);
   }
 
-  public DisjointAnalysis( State            s,
-                          TypeUtil         tu,
-                          CallGraph        cg,
-                          Liveness         l,
-                          ArrayReferencees ar,
-                           Set<FlatNew> sitesToFlag,
-                           RBlockRelationAnalysis rra,
-                           BuildStateMachines bsm,
-                           boolean suppressOutput
-                           ) {
-    init( s, tu, cg, l, ar, sitesToFlag, rra, bsm, suppressOutput );
+  public DisjointAnalysis(State s,
+                          TypeUtil tu,
+                          CallGraph cg,
+                          Liveness l,
+                          ArrayReferencees ar,
+                          Set<FlatNew> sitesToFlag,
+                          RBlockRelationAnalysis rra,
+                          BuildStateMachines bsm,
+                          boolean suppressOutput
+                          ) {
+    init(s, tu, cg, l, ar, sitesToFlag, rra, bsm, suppressOutput);
   }
-  
-  protected void init( State            state,
-                       TypeUtil         typeUtil,
-                       CallGraph        callGraph,
-                       Liveness         liveness,
-                       ArrayReferencees arrayReferencees,
-                       Set<FlatNew> sitesToFlag,
-                       RBlockRelationAnalysis rra,
-                       BuildStateMachines bsm,
-                       boolean suppressOutput
-                       ) {
-         
+
+  protected void init(State state,
+                      TypeUtil typeUtil,
+                      CallGraph callGraph,
+                      Liveness liveness,
+                      ArrayReferencees arrayReferencees,
+                      Set<FlatNew> sitesToFlag,
+                      RBlockRelationAnalysis rra,
+                      BuildStateMachines bsm,
+                      boolean suppressOutput
+                      ) {
+
     analysisComplete = false;
-    
+
     this.state              = state;
     this.typeUtil           = typeUtil;
     this.callGraph          = callGraph;
@@ -679,13 +679,13 @@ public class DisjointAnalysis implements HeapAnalysis {
     if( rblockRel != null ) {
       doEffectsAnalysis = true;
       effectsAnalysis   = new EffectsAnalysis();
-      
+
       //note: instead of reachgraph's isAccessible, using the result of accessible analysis
       //since accessible gives us more accurate results
       accessible=new Accessible(state, callGraph, rra, liveness);
       accessible.doAnalysis();
     }
-    
+
     this.allocationDepth         = state.DISJOINTALLOCDEPTH;
     this.releaseMode             = state.DISJOINTRELEASEMODE;
     this.determinismDesired      = state.DISJOINTDETERMINISM;
@@ -702,13 +702,13 @@ public class DisjointAnalysis implements HeapAnalysis {
     this.snapNodeCounter         = 0; // count nodes from 0
 
     assert
-      state.DISJOINTDVISITSTACK ||
-      state.DISJOINTDVISITPQUE  ||
-      state.DISJOINTDVISITSTACKEESONTOP;
+    state.DISJOINTDVISITSTACK ||
+    state.DISJOINTDVISITPQUE  ||
+    state.DISJOINTDVISITSTACKEESONTOP;
     assert !(state.DISJOINTDVISITSTACK && state.DISJOINTDVISITPQUE);
     assert !(state.DISJOINTDVISITSTACK && state.DISJOINTDVISITSTACKEESONTOP);
     assert !(state.DISJOINTDVISITPQUE  && state.DISJOINTDVISITSTACKEESONTOP);
-           
+
     // set some static configuration for ReachGraphs
     ReachGraph.allocationDepth = allocationDepth;
     ReachGraph.typeUtil        = typeUtil;
@@ -723,16 +723,16 @@ public class DisjointAnalysis implements HeapAnalysis {
     ReachGraph.debugCallSiteStopAfter
       = state.DISJOINTDEBUGCALLSTOPAFTER;
 
-    ReachGraph.debugCallSiteVisitCounter 
+    ReachGraph.debugCallSiteVisitCounter
       = 0; // count visits from 1, is incremented before first visit
-    
+
 
     EffectsAnalysis.state              = state;
     EffectsAnalysis.buildStateMachines = buildStateMachines;
 
 
     if( suppressOutput ) {
-      System.out.println( "* Running disjoint reachability analysis with output suppressed! *" );
+      System.out.println("* Running disjoint reachability analysis with output suppressed! *");
     }
 
     allocateStructures();
@@ -743,59 +743,59 @@ public class DisjointAnalysis implements HeapAnalysis {
     try {
       analyzeMethods();
     } catch( IOException e ) {
-      throw new Error( "IO Exception while writing disjointness analysis output." );
+      throw new Error("IO Exception while writing disjointness analysis output.");
     }
 
     analysisComplete=true;
 
     double timeEndAnalysis = (double) System.nanoTime();
-    double dt = (timeEndAnalysis - timeStartAnalysis)/(Math.pow( 10.0, 9.0 ) );
+    double dt = (timeEndAnalysis - timeStartAnalysis)/(Math.pow(10.0, 9.0) );
 
     String treport;
     if( sitesToFlag != null ) {
-      treport = String.format( "Disjoint reachability analysis flagged %d sites and took %.3f sec.", sitesToFlag.size(), dt );
-      if(sitesToFlag.size()>0){
-        treport+="\nFlagged sites:"+"\n"+sitesToFlag.toString();
+      treport = String.format("Disjoint reachability analysis flagged %d sites and took %.3f sec.", sitesToFlag.size(), dt);
+      if(sitesToFlag.size()>0) {
+       treport+="\nFlagged sites:"+"\n"+sitesToFlag.toString();
       }
     } else {
-      treport = String.format( "Disjoint reachability analysis took %.3f sec.", dt );
+      treport = String.format("Disjoint reachability analysis took %.3f sec.", dt);
     }
-    String justtime = String.format( "%.2f", dt );
-    System.out.println( treport );
+    String justtime = String.format("%.2f", dt);
+    System.out.println(treport);
 
 
     try {
       if( writeFinalDOTs && !writeAllIncrementalDOTs ) {
-        writeFinalGraphs();      
+       writeFinalGraphs();
       }
 
       if( state.DISJOINTWRITEIHMS && !suppressOutput ) {
-        writeFinalIHMs();
+       writeFinalIHMs();
       }
 
       if( state.DISJOINTWRITEINITCONTEXTS && !suppressOutput ) {
-        writeInitialContexts();
+       writeInitialContexts();
       }
 
       if( state.DISJOINTALIASFILE != null && !suppressOutput ) {
-        if( state.TASK ) {
-          writeAllSharing(state.DISJOINTALIASFILE, treport, justtime, state.DISJOINTALIASTAB, state.lines);
-        } else {
-          writeAllSharingJava(state.DISJOINTALIASFILE, 
-                              treport, 
-                              justtime, 
-                              state.DISJOINTALIASTAB, 
-                              state.lines
-                              );
-        }
+       if( state.TASK ) {
+         writeAllSharing(state.DISJOINTALIASFILE, treport, justtime, state.DISJOINTALIASTAB, state.lines);
+       } else {
+         writeAllSharingJava(state.DISJOINTALIASFILE,
+                             treport,
+                             justtime,
+                             state.DISJOINTALIASTAB,
+                             state.lines
+                             );
+       }
       }
 
       if( state.RCR ) {
-        buildStateMachines.writeStateMachines();
+       buildStateMachines.writeStateMachines();
       }
 
     } catch( IOException e ) {
-      throw new Error( "IO Exception while writing disjointness analysis output." );
+      throw new Error("IO Exception while writing disjointness analysis output.");
     }
   }
 
@@ -810,62 +810,62 @@ public class DisjointAnalysis implements HeapAnalysis {
       return !descriptorsToVisitQ.isEmpty();
     }
 
-    throw new Error( "Neither descriptor visiting mode set" );
+    throw new Error("Neither descriptor visiting mode set");
   }
 
 
   // fixed-point computation over the call graph--when a
   // method's callees are updated, it must be reanalyzed
-  protected void analyzeMethods() throws java.io.IOException {  
+  protected void analyzeMethods() throws java.io.IOException {
 
     // task or non-task (java) mode determines what the roots
     // of the call chain are, and establishes the set of methods
     // reachable from the roots that will be analyzed
-    
+
     if( state.TASK ) {
       if( !suppressOutput ) {
-        System.out.println( "Bamboo mode..." );
+       System.out.println("Bamboo mode...");
       }
-      
-      Iterator taskItr = state.getTaskSymbolTable().getDescriptorsIterator();      
+
+      Iterator taskItr = state.getTaskSymbolTable().getDescriptorsIterator();
       while( taskItr.hasNext() ) {
-        TaskDescriptor td = (TaskDescriptor) taskItr.next();
-        if( !descriptorsToAnalyze.contains( td ) ) {
-          // add all methods transitively reachable from the
-          // tasks as well
-          descriptorsToAnalyze.add( td );
-          descriptorsToAnalyze.addAll( callGraph.getAllMethods( td ) );
-        }        
-      }
-      
+       TaskDescriptor td = (TaskDescriptor) taskItr.next();
+       if( !descriptorsToAnalyze.contains(td) ) {
+         // add all methods transitively reachable from the
+         // tasks as well
+         descriptorsToAnalyze.add(td);
+         descriptorsToAnalyze.addAll(callGraph.getAllMethods(td) );
+       }
+      }
+
     } else {
       if( !suppressOutput ) {
-        System.out.println( "Java mode..." );
+       System.out.println("Java mode...");
       }
 
       // add all methods transitively reachable from the
       // source's main to set for analysis
       mdSourceEntry = typeUtil.getMain();
-      descriptorsToAnalyze.add( mdSourceEntry );
-      descriptorsToAnalyze.addAll( callGraph.getAllMethods( mdSourceEntry ) );
-      
+      descriptorsToAnalyze.add(mdSourceEntry);
+      descriptorsToAnalyze.addAll(callGraph.getAllMethods(mdSourceEntry) );
+
       // fabricate an empty calling context that will call
       // the source's main, but call graph doesn't know
       // about it, so explicitly add it
-      makeAnalysisEntryMethod( mdSourceEntry );
-      descriptorsToAnalyze.add( mdAnalysisEntry );
+      makeAnalysisEntryMethod(mdSourceEntry);
+      descriptorsToAnalyze.add(mdAnalysisEntry);
     }
 
 
-    // now, depending on the interprocedural mode for visiting 
+    // now, depending on the interprocedural mode for visiting
     // methods, set up the needed data structures
 
     if( state.DISJOINTDVISITPQUE ) {
-    
-      // topologically sort according to the call graph so 
+
+      // topologically sort according to the call graph so
       // leaf calls are last, helps build contexts up first
-      LinkedList<Descriptor> sortedDescriptors = 
-        topologicalSort( descriptorsToAnalyze );
+      LinkedList<Descriptor> sortedDescriptors =
+        topologicalSort(descriptorsToAnalyze);
 
       // add sorted descriptors to priority queue, and duplicate
       // the queue as a set for efficiently testing whether some
@@ -876,33 +876,33 @@ public class DisjointAnalysis implements HeapAnalysis {
       // for the priority queue, give items at the head
       // of the sorted list a low number (highest priority)
       while( !sortedDescriptors.isEmpty() ) {
-        Descriptor d = sortedDescriptors.removeFirst();
-        mapDescriptorToPriority.put( d, new Integer( p ) );
-        descriptorsToVisitQ.add( new DescriptorQWrapper( p, d ) );
-        descriptorsToVisitSet.add( d );
-        ++p;
+       Descriptor d = sortedDescriptors.removeFirst();
+       mapDescriptorToPriority.put(d, new Integer(p) );
+       descriptorsToVisitQ.add(new DescriptorQWrapper(p, d) );
+       descriptorsToVisitSet.add(d);
+       ++p;
       }
 
     } else if( state.DISJOINTDVISITSTACK ||
-               state.DISJOINTDVISITSTACKEESONTOP 
+               state.DISJOINTDVISITSTACKEESONTOP
                ) {
       // if we're doing the stack scheme, just throw the root
       // method or tasks on the stack
       if( state.TASK ) {
-        Iterator taskItr = state.getTaskSymbolTable().getDescriptorsIterator();      
-        while( taskItr.hasNext() ) {
+       Iterator taskItr = state.getTaskSymbolTable().getDescriptorsIterator();
+       while( taskItr.hasNext() ) {
          TaskDescriptor td = (TaskDescriptor) taskItr.next();
-          descriptorsToVisitStack.add( td );
-          descriptorsToVisitSet.add( td );
-        }
-        
+         descriptorsToVisitStack.add(td);
+         descriptorsToVisitSet.add(td);
+       }
+
       } else {
-        descriptorsToVisitStack.add( mdAnalysisEntry );
-        descriptorsToVisitSet.add( mdAnalysisEntry );
+       descriptorsToVisitStack.add(mdAnalysisEntry);
+       descriptorsToVisitSet.add(mdAnalysisEntry);
       }
 
     } else {
-      throw new Error( "Unknown method scheduling mode" );
+      throw new Error("Unknown method scheduling mode");
     }
 
 
@@ -913,14 +913,14 @@ public class DisjointAnalysis implements HeapAnalysis {
       if( state.DISJOINTDVISITSTACK ||
           state.DISJOINTDVISITSTACKEESONTOP
           ) {
-        d = descriptorsToVisitStack.pop();
+       d = descriptorsToVisitStack.pop();
 
       } else if( state.DISJOINTDVISITPQUE ) {
-        d = descriptorsToVisitQ.poll().getDescriptor();
+       d = descriptorsToVisitQ.poll().getDescriptor();
       }
 
-      assert descriptorsToVisitSet.contains( d );
-      descriptorsToVisitSet.remove( d );
+      assert descriptorsToVisitSet.contains(d);
+      descriptorsToVisitSet.remove(d);
 
       // because the task or method descriptor just extracted
       // was in the "to visit" set it either hasn't been analyzed
@@ -931,77 +931,77 @@ public class DisjointAnalysis implements HeapAnalysis {
       // that depend on this one to the "to visit" set.
 
       if( !suppressOutput ) {
-        System.out.println( "Analyzing " + d );
+       System.out.println("Analyzing " + d);
       }
 
       if( state.DISJOINTDVISITSTACKEESONTOP ) {
-        assert calleesToEnqueue.isEmpty();
-      }
-
-      ReachGraph rg     = analyzeMethod( d );
-      ReachGraph rgPrev = getPartial( d );
-      
-      if( !rg.equals( rgPrev ) ) {
-        setPartial( d, rg );
-        
-        if( state.DISJOINTDEBUGSCHEDULING ) {
-          System.out.println( "  complete graph changed, scheduling callers for analysis:" );
-        }
-
-        // results for d changed, so enqueue dependents
-        // of d for further analysis
-       Iterator<Descriptor> depsItr = getDependents( d ).iterator();
+       assert calleesToEnqueue.isEmpty();
+      }
+
+      ReachGraph rg     = analyzeMethod(d);
+      ReachGraph rgPrev = getPartial(d);
+
+      if( !rg.equals(rgPrev) ) {
+       setPartial(d, rg);
+
+       if( state.DISJOINTDEBUGSCHEDULING ) {
+         System.out.println("  complete graph changed, scheduling callers for analysis:");
+       }
+
+       // results for d changed, so enqueue dependents
+       // of d for further analysis
+       Iterator<Descriptor> depsItr = getDependents(d).iterator();
        while( depsItr.hasNext() ) {
          Descriptor dNext = depsItr.next();
-          enqueue( dNext );
+         enqueue(dNext);
 
-          if( state.DISJOINTDEBUGSCHEDULING ) {
-            System.out.println( "    "+dNext );
-          }
+         if( state.DISJOINTDEBUGSCHEDULING ) {
+           System.out.println("    "+dNext);
+         }
        }
       }
 
       // whether or not the method under analysis changed,
-      // we may have some callees that are scheduled for 
+      // we may have some callees that are scheduled for
       // more analysis, and they should go on the top of
       // the stack now (in other method-visiting modes they
       // are already enqueued at this point
       if( state.DISJOINTDVISITSTACKEESONTOP ) {
-        Iterator<Descriptor> depsItr = calleesToEnqueue.iterator();
-        while( depsItr.hasNext() ) {
-          Descriptor dNext = depsItr.next();
-          enqueue( dNext );
-        }
-        calleesToEnqueue.clear();
-      }     
-
-    }   
+       Iterator<Descriptor> depsItr = calleesToEnqueue.iterator();
+       while( depsItr.hasNext() ) {
+         Descriptor dNext = depsItr.next();
+         enqueue(dNext);
+       }
+       calleesToEnqueue.clear();
+      }
+
+    }
   }
 
-  protected ReachGraph analyzeMethod( Descriptor d ) 
-    throws java.io.IOException {
+  protected ReachGraph analyzeMethod(Descriptor d)
+  throws java.io.IOException {
 
     // get the flat code for this descriptor
     FlatMethod fm;
     if( d == mdAnalysisEntry ) {
       fm = fmAnalysisEntry;
     } else {
-      fm = state.getMethodFlat( d );
+      fm = state.getMethodFlat(d);
     }
-    pm.analyzeMethod( fm );
+    pm.analyzeMethod(fm);
 
     // intraprocedural work set
     Set<FlatNode> flatNodesToVisit = new HashSet<FlatNode>();
-    flatNodesToVisit.add( fm );
+    flatNodesToVisit.add(fm);
 
     // if determinism is desired by client, shadow the
     // set with a queue to make visit order deterministic
     Queue<FlatNode> flatNodesToVisitQ = null;
     if( determinismDesired ) {
       flatNodesToVisitQ = new LinkedList<FlatNode>();
-      flatNodesToVisitQ.add( fm );
+      flatNodesToVisitQ.add(fm);
     }
-    
+
     // mapping of current partial results
     Hashtable<FlatNode, ReachGraph> mapFlatNodeToReachGraph =
       new Hashtable<FlatNode, ReachGraph>();
@@ -1012,14 +1012,14 @@ public class DisjointAnalysis implements HeapAnalysis {
 
     while( !flatNodesToVisit.isEmpty() ) {
 
-      FlatNode fn;      
+      FlatNode fn;
       if( determinismDesired ) {
-        assert !flatNodesToVisitQ.isEmpty();
-        fn = flatNodesToVisitQ.remove();
+       assert !flatNodesToVisitQ.isEmpty();
+       fn = flatNodesToVisitQ.remove();
       } else {
-        fn = flatNodesToVisit.iterator().next();
+       fn = flatNodesToVisit.iterator().next();
       }
-      flatNodesToVisit.remove( fn );
+      flatNodesToVisit.remove(fn);
 
       // effect transfer function defined by this node,
       // then compare it to the old graph at this node
@@ -1027,61 +1027,61 @@ public class DisjointAnalysis implements HeapAnalysis {
 
       ReachGraph rg = new ReachGraph();
       TaskDescriptor taskDesc;
-      if(fn instanceof FlatMethod && (taskDesc=((FlatMethod)fn).getTask())!=null){
-         if(mapDescriptorToReachGraph.containsKey(taskDesc)){
-                 // retrieve existing reach graph if it is not first time
-                 rg=mapDescriptorToReachGraph.get(taskDesc);
-         }else{
-                 // create initial reach graph for a task
-                 rg=createInitialTaskReachGraph((FlatMethod)fn);
-                 rg.globalSweep();
-                 mapDescriptorToReachGraph.put(taskDesc, rg);
-         }
+      if(fn instanceof FlatMethod && (taskDesc=((FlatMethod)fn).getTask())!=null) {
+       if(mapDescriptorToReachGraph.containsKey(taskDesc)) {
+         // retrieve existing reach graph if it is not first time
+         rg=mapDescriptorToReachGraph.get(taskDesc);
+       } else {
+         // create initial reach graph for a task
+         rg=createInitialTaskReachGraph((FlatMethod)fn);
+         rg.globalSweep();
+         mapDescriptorToReachGraph.put(taskDesc, rg);
+       }
       }
 
       // start by merging all node's parents' graphs
       for( int i = 0; i < pm.numPrev(fn); ++i ) {
        FlatNode pn = pm.getPrev(fn,i);
-       if( mapFlatNodeToReachGraph.containsKey( pn ) ) {
-         ReachGraph rgParent = mapFlatNodeToReachGraph.get( pn );
-         rg.merge( rgParent );
+       if( mapFlatNodeToReachGraph.containsKey(pn) ) {
+         ReachGraph rgParent = mapFlatNodeToReachGraph.get(pn);
+         rg.merge(rgParent);
        }
       }
-      
 
-      if( takeDebugSnapshots && 
-         d.getSymbol().equals( descSymbolDebug ) 
+
+      if( takeDebugSnapshots &&
+          d.getSymbol().equals(descSymbolDebug)
           ) {
-       debugSnapshot( rg, fn, true );
+       debugSnapshot(rg, fn, true);
       }
 
 
       // modify rg with appropriate transfer function
-      rg = analyzeFlatNode( d, fm, fn, setReturns, rg );
+      rg = analyzeFlatNode(d, fm, fn, setReturns, rg);
 
 
-      if( takeDebugSnapshots && 
-         d.getSymbol().equals( descSymbolDebug ) 
+      if( takeDebugSnapshots &&
+          d.getSymbol().equals(descSymbolDebug)
           ) {
-       debugSnapshot( rg, fn, false );
-        ++snapNodeCounter;
+       debugSnapshot(rg, fn, false);
+       ++snapNodeCounter;
       }
-          
+
 
       // if the results of the new graph are different from
       // the current graph at this node, replace the graph
       // with the update and enqueue the children
-      ReachGraph rgPrev = mapFlatNodeToReachGraph.get( fn );
-      if( !rg.equals( rgPrev ) ) {
-       mapFlatNodeToReachGraph.put( fn, rg );
+      ReachGraph rgPrev = mapFlatNodeToReachGraph.get(fn);
+      if( !rg.equals(rgPrev) ) {
+       mapFlatNodeToReachGraph.put(fn, rg);
 
-       for( int i = 0; i < pm.numNext( fn ); i++ ) {
-         FlatNode nn = pm.getNext( fn, i );
+       for( int i = 0; i < pm.numNext(fn); i++ ) {
+         FlatNode nn = pm.getNext(fn, i);
 
-         flatNodesToVisit.add( nn );
-          if( determinismDesired ) {
-            flatNodesToVisitQ.add( nn );
-          }
+         flatNodesToVisit.add(nn);
+         if( determinismDesired ) {
+           flatNodesToVisitQ.add(nn);
+         }
        }
       }
     }
@@ -1097,27 +1097,27 @@ public class DisjointAnalysis implements HeapAnalysis {
     while( retItr.hasNext() ) {
       FlatReturnNode frn = (FlatReturnNode) retItr.next();
 
-      assert mapFlatNodeToReachGraph.containsKey( frn );
-      ReachGraph rgRet = mapFlatNodeToReachGraph.get( frn );
+      assert mapFlatNodeToReachGraph.containsKey(frn);
+      ReachGraph rgRet = mapFlatNodeToReachGraph.get(frn);
 
-      completeGraph.merge( rgRet );
+      completeGraph.merge(rgRet);
     }
 
 
-    if( takeDebugSnapshots && 
-        d.getSymbol().equals( descSymbolDebug ) 
+    if( takeDebugSnapshots &&
+        d.getSymbol().equals(descSymbolDebug)
         ) {
       // increment that we've visited the debug snap
       // method, and reset the node counter
-      System.out.println( "    @@@ debug snap at visit "+snapVisitCounter );
+      System.out.println("    @@@ debug snap at visit "+snapVisitCounter);
       ++snapVisitCounter;
       snapNodeCounter = 0;
 
-      if( snapVisitCounter == visitStartCapture + numVisitsToCapture && 
-          stopAfterCapture 
+      if( snapVisitCounter == visitStartCapture + numVisitsToCapture &&
+          stopAfterCapture
           ) {
-        System.out.println( "!!! Stopping analysis after debug snap captures. !!!" );
-        System.exit( 0 );
+       System.out.println("!!! Stopping analysis after debug snap captures. !!!");
+       System.exit(0);
       }
     }
 
@@ -1125,50 +1125,50 @@ public class DisjointAnalysis implements HeapAnalysis {
     return completeGraph;
   }
 
-  
+
   protected ReachGraph
-    analyzeFlatNode( Descriptor              d,
-                     FlatMethod              fmContaining,
-                     FlatNode                fn,
-                     HashSet<FlatReturnNode> setRetNodes,
-                     ReachGraph              rg
-                     ) throws java.io.IOException {
-
-    
+  analyzeFlatNode(Descriptor d,
+                  FlatMethod fmContaining,
+                  FlatNode fn,
+                  HashSet<FlatReturnNode> setRetNodes,
+                  ReachGraph rg
+                  ) throws java.io.IOException {
+
+
     // any variables that are no longer live should be
     // nullified in the graph to reduce edges
     //rg.nullifyDeadVars( liveness.getLiveInTemps( fmContaining, fn ) );
 
-    TempDescriptor    lhs;
-    TempDescriptor    rhs;
-    FieldDescriptor   fld;
-    TypeDescriptor    tdElement;
-    FieldDescriptor   fdElement;
+    TempDescriptor lhs;
+    TempDescriptor rhs;
+    FieldDescriptor fld;
+    TypeDescriptor tdElement;
+    FieldDescriptor fdElement;
     FlatSESEEnterNode sese;
-    FlatSESEExitNode  fsexn;
+    FlatSESEExitNode fsexn;
 
     //Stores the flatnode's reach graph at enter
     ReachGraph rgOnEnter = new ReachGraph();
-    rgOnEnter.merge( rg );
+    rgOnEnter.merge(rg);
     fn2rgAtEnter.put(fn, rgOnEnter);
-    
+
     // use node type to decide what transfer function
     // to apply to the reachability graph
     switch( fn.kind() ) {
 
     case FKind.FlatGenReachNode: {
       FlatGenReachNode fgrn = (FlatGenReachNode) fn;
-      
-      System.out.println( "  Generating reach graph for program point: "+fgrn.getGraphName() );
-
-      rg.writeGraph( "genReach"+fgrn.getGraphName(),
-                     true,    // write labels (variables)                
-                     true,   // selectively hide intermediate temp vars 
-                     true,    // prune unreachable heap regions          
-                     false,   // hide reachability altogether
-                     true,   // hide subset reachability states         
-                     true,    // hide predicates
-                     true );  // hide edge taints      
+
+      System.out.println("  Generating reach graph for program point: "+fgrn.getGraphName() );
+
+      rg.writeGraph("genReach"+fgrn.getGraphName(),
+                    true,     // write labels (variables)
+                    true,    // selectively hide intermediate temp vars
+                    true,     // prune unreachable heap regions
+                    false,    // hide reachability altogether
+                    true,    // hide subset reachability states
+                    true,     // hide predicates
+                    true);    // hide edge taints
     } break;
 
 
@@ -1177,50 +1177,50 @@ public class DisjointAnalysis implements HeapAnalysis {
       // since we're working on the FlatMethod, we know
       // the incoming ReachGraph 'rg' is empty
 
-      Hashtable<FlatCall, ReachGraph> heapsFromCallers = 
-        getIHMcontributions( d );
+      Hashtable<FlatCall, ReachGraph> heapsFromCallers =
+        getIHMcontributions(d);
 
       Set entrySet = heapsFromCallers.entrySet();
       Iterator itr = entrySet.iterator();
       while( itr.hasNext() ) {
-        Map.Entry  me        = (Map.Entry)  itr.next();
-        FlatCall   fc        = (FlatCall)   me.getKey();
-        ReachGraph rgContrib = (ReachGraph) me.getValue();
+       Map.Entry me        = (Map.Entry)itr.next();
+       FlatCall fc        = (FlatCall)   me.getKey();
+       ReachGraph rgContrib = (ReachGraph) me.getValue();
 
-        assert fc.getMethod().equals( d );
+       assert fc.getMethod().equals(d);
 
-        rg.merge( rgContrib );
+       rg.merge(rgContrib);
       }
 
       // additionally, we are enforcing STRICT MONOTONICITY for the
       // method's initial context, so grow the context by whatever
       // the previously computed context was, and put the most
       // up-to-date context back in the map
-      ReachGraph rgPrevContext = mapDescriptorToInitialContext.get( d );
-      rg.merge( rgPrevContext );      
-      mapDescriptorToInitialContext.put( d, rg );
+      ReachGraph rgPrevContext = mapDescriptorToInitialContext.get(d);
+      rg.merge(rgPrevContext);
+      mapDescriptorToInitialContext.put(d, rg);
 
     } break;
-      
+
     case FKind.FlatOpNode:
       FlatOpNode fon = (FlatOpNode) fn;
       if( fon.getOp().getOp() == Operation.ASSIGN ) {
        lhs = fon.getDest();
        rhs = fon.getLeft();
 
-        // before transfer, do effects analysis support
-        if( doEffectsAnalysis && fmContaining != fmAnalysisEntry ) {
-          if(rblockRel.isPotentialStallSite(fn)){
-            // x gets status of y
+       // before transfer, do effects analysis support
+       if( doEffectsAnalysis && fmContaining != fmAnalysisEntry ) {
+         if(rblockRel.isPotentialStallSite(fn)) {
+           // x gets status of y
 //            if(!rg.isAccessible(rhs)){
-            if(!accessible.isAccessible(fn, rhs)){
-              rg.makeInaccessible(lhs);
-            }
-          }    
-        }
+           if(!accessible.isAccessible(fn, rhs)) {
+             rg.makeInaccessible(lhs);
+           }
+         }
+       }
 
-        // transfer func
-       rg.assignTempXEqualToTempY( lhs, rhs ); 
+       // transfer func
+       rg.assignTempXEqualToTempY(lhs, rhs);
       }
       break;
 
@@ -1234,17 +1234,17 @@ public class DisjointAnalysis implements HeapAnalysis {
 
       // before transfer, do effects analysis support
       if( doEffectsAnalysis && fmContaining != fmAnalysisEntry ) {
-        if(rblockRel.isPotentialStallSite(fn)){
-          // x gets status of y
+       if(rblockRel.isPotentialStallSite(fn)) {
+         // x gets status of y
 //          if(!rg.isAccessible(rhs)){
-          if(!accessible.isAccessible(fn,rhs)){
-            rg.makeInaccessible(lhs);
-          }
-        }    
+         if(!accessible.isAccessible(fn,rhs)) {
+           rg.makeInaccessible(lhs);
+         }
+       }
       }
-      
+
       // transfer func
-      rg.assignTempXEqualToCastedTempY( lhs, rhs, td );
+      rg.assignTempXEqualToCastedTempY(lhs, rhs, td);
       break;
 
     case FKind.FlatFieldNode:
@@ -1258,29 +1258,29 @@ public class DisjointAnalysis implements HeapAnalysis {
       // a stall-site taint
       if( doEffectsAnalysis && fmContaining != fmAnalysisEntry ) {
 
-        if(rblockRel.isPotentialStallSite(fn)){
-          // x=y.f, stall y if not accessible
-          // contributes read effects on stall site of y
+       if(rblockRel.isPotentialStallSite(fn)) {
+         // x=y.f, stall y if not accessible
+         // contributes read effects on stall site of y
 //          if(!rg.isAccessible(rhs)) {
-          if(!accessible.isAccessible(fn,rhs)) {
-            rg.taintStallSite(fn, rhs);
-          }
+         if(!accessible.isAccessible(fn,rhs)) {
+           rg.taintStallSite(fn, rhs);
+         }
 
-          // after this, x and y are accessbile. 
-          rg.makeAccessible(lhs);
-          rg.makeAccessible(rhs);            
-        }
+         // after this, x and y are accessbile.
+         rg.makeAccessible(lhs);
+         rg.makeAccessible(rhs);
+       }
       }
 
-      if( shouldAnalysisTrack( fld.getType() ) ) {       
-        // transfer func
-       rg.assignTempXEqualToTempYFieldF( lhs, rhs, fld, fn );
-      }          
+      if( shouldAnalysisTrack(fld.getType() ) ) {
+       // transfer func
+       rg.assignTempXEqualToTempYFieldF(lhs, rhs, fld, fn);
+      }
 
       // after transfer, use updated graph to
       // do effects analysis
       if( doEffectsAnalysis && fmContaining != fmAnalysisEntry ) {
-        effectsAnalysis.analyzeFlatFieldNode( rg, rhs, fld, fn );          
+       effectsAnalysis.analyzeFlatFieldNode(rg, rhs, fld, fn);
       }
       break;
 
@@ -1297,33 +1297,33 @@ public class DisjointAnalysis implements HeapAnalysis {
       // stall-site taints
       if( doEffectsAnalysis && fmContaining != fmAnalysisEntry ) {
 
-        if(rblockRel.isPotentialStallSite(fn)){
-          // x.y=f , stall x and y if they are not accessible
-          // also contribute write effects on stall site of x
+       if(rblockRel.isPotentialStallSite(fn)) {
+         // x.y=f , stall x and y if they are not accessible
+         // also contribute write effects on stall site of x
 //          if(!rg.isAccessible(lhs)) {
-          if(!accessible.isAccessible(fn,lhs)) {
-            rg.taintStallSite(fn, lhs);
-          }
+         if(!accessible.isAccessible(fn,lhs)) {
+           rg.taintStallSite(fn, lhs);
+         }
 
 //          if(!rg.isAccessible(rhs)) {
-          if(!accessible.isAccessible(fn,rhs)) {
-            rg.taintStallSite(fn, rhs);
-          }
+         if(!accessible.isAccessible(fn,rhs)) {
+           rg.taintStallSite(fn, rhs);
+         }
 
-          // accessible status update
-          rg.makeAccessible(lhs);
-          rg.makeAccessible(rhs);            
-        }
+         // accessible status update
+         rg.makeAccessible(lhs);
+         rg.makeAccessible(rhs);
+       }
       }
 
-      if( shouldAnalysisTrack( fld.getType() ) ) {
-        // transfer func
-        strongUpdate = rg.assignTempXFieldFEqualToTempY( lhs, fld, rhs, fn );
-      }           
+      if( shouldAnalysisTrack(fld.getType() ) ) {
+       // transfer func
+       strongUpdate = rg.assignTempXFieldFEqualToTempY(lhs, fld, rhs, fn);
+      }
 
       // use transformed graph to do effects analysis
       if( doEffectsAnalysis && fmContaining != fmAnalysisEntry ) {
-        effectsAnalysis.analyzeFlatSetFieldNode( rg, lhs, fld, fn, strongUpdate );          
+       effectsAnalysis.analyzeFlatSetFieldNode(rg, lhs, fld, fn, strongUpdate);
       }
       break;
 
@@ -1337,34 +1337,34 @@ public class DisjointAnalysis implements HeapAnalysis {
       assert rhs.getType().isArray();
 
       tdElement = rhs.getType().dereference();
-      fdElement = getArrayField( tdElement );
+      fdElement = getArrayField(tdElement);
 
       // before transfer func, possibly inject
       // stall-site taint
       if( doEffectsAnalysis && fmContaining != fmAnalysisEntry ) {
-        if(rblockRel.isPotentialStallSite(fn)){
-          // x=y.f, stall y if not accessible
-          // contributes read effects on stall site of y
-          // after this, x and y are accessbile. 
+       if(rblockRel.isPotentialStallSite(fn)) {
+         // x=y.f, stall y if not accessible
+         // contributes read effects on stall site of y
+         // after this, x and y are accessbile.
 //          if(!rg.isAccessible(rhs)) {
-          if(!accessible.isAccessible(fn,rhs)) {
-            rg.taintStallSite(fn, rhs);
-          }
+         if(!accessible.isAccessible(fn,rhs)) {
+           rg.taintStallSite(fn, rhs);
+         }
 
-          rg.makeAccessible(lhs);
-          rg.makeAccessible(rhs);            
-        }
+         rg.makeAccessible(lhs);
+         rg.makeAccessible(rhs);
+       }
       }
 
-      if( shouldAnalysisTrack( lhs.getType() ) ) {
-        // transfer func
-       rg.assignTempXEqualToTempYFieldF( lhs, rhs, fdElement, fn );
+      if( shouldAnalysisTrack(lhs.getType() ) ) {
+       // transfer func
+       rg.assignTempXEqualToTempYFieldF(lhs, rhs, fdElement, fn);
       }
 
       // use transformed graph to do effects analysis
       if( doEffectsAnalysis && fmContaining != fmAnalysisEntry ) {
-        effectsAnalysis.analyzeFlatFieldNode( rg, rhs, fdElement, fn );                    
-      }        
+       effectsAnalysis.analyzeFlatFieldNode(rg, rhs, fdElement, fn);
+      }
       break;
 
     case FKind.FlatSetElementNode:
@@ -1374,65 +1374,65 @@ public class DisjointAnalysis implements HeapAnalysis {
       rhs = fsen.getSrc();
 
       assert lhs.getType() != null;
-      assert lhs.getType().isArray();  
+      assert lhs.getType().isArray();
 
       tdElement = lhs.getType().dereference();
-      fdElement = getArrayField( tdElement );
+      fdElement = getArrayField(tdElement);
 
       // before transfer func, possibly inject
       // stall-site taints
       if( doEffectsAnalysis && fmContaining != fmAnalysisEntry ) {
-          
-        if(rblockRel.isPotentialStallSite(fn)){
-          // x.y=f , stall x and y if they are not accessible
-          // also contribute write effects on stall site of x
+
+       if(rblockRel.isPotentialStallSite(fn)) {
+         // x.y=f , stall x and y if they are not accessible
+         // also contribute write effects on stall site of x
 //          if(!rg.isAccessible(lhs)) {
-          if(!accessible.isAccessible(fn,lhs)) {
-            rg.taintStallSite(fn, lhs);
-          }
+         if(!accessible.isAccessible(fn,lhs)) {
+           rg.taintStallSite(fn, lhs);
+         }
 
 //          if(!rg.isAccessible(rhs)) {
-          if(!accessible.isAccessible(fn,rhs)) {
-            rg.taintStallSite(fn, rhs);
-          }
-            
-          // accessible status update
-          rg.makeAccessible(lhs);
-          rg.makeAccessible(rhs);            
-        }
+         if(!accessible.isAccessible(fn,rhs)) {
+           rg.taintStallSite(fn, rhs);
+         }
+
+         // accessible status update
+         rg.makeAccessible(lhs);
+         rg.makeAccessible(rhs);
+       }
       }
 
-      if( shouldAnalysisTrack( rhs.getType() ) ) {
-        // transfer func, BUT
-        // skip this node if it cannot create new reachability paths
-        if( !arrayReferencees.doesNotCreateNewReaching( fsen ) ) {
-          rg.assignTempXFieldFEqualToTempY( lhs, fdElement, rhs, fn );
-        }
+      if( shouldAnalysisTrack(rhs.getType() ) ) {
+       // transfer func, BUT
+       // skip this node if it cannot create new reachability paths
+       if( !arrayReferencees.doesNotCreateNewReaching(fsen) ) {
+         rg.assignTempXFieldFEqualToTempY(lhs, fdElement, rhs, fn);
+       }
       }
 
       // use transformed graph to do effects analysis
       if( doEffectsAnalysis && fmContaining != fmAnalysisEntry ) {
-        effectsAnalysis.analyzeFlatSetFieldNode( rg, lhs, fdElement, fn,
-                                                 false );          
+       effectsAnalysis.analyzeFlatSetFieldNode(rg, lhs, fdElement, fn,
+                                               false);
       }
       break;
-      
+
     case FKind.FlatNew:
       FlatNew fnn = (FlatNew) fn;
       lhs = fnn.getDst();
-      if( shouldAnalysisTrack( lhs.getType() ) ) {
-       AllocSite as = getAllocSiteFromFlatNewPRIVATE( fnn );   
-
-        // before transform, support effects analysis
-        if (doEffectsAnalysis && fmContaining != fmAnalysisEntry) {
-          if (rblockRel.isPotentialStallSite(fn)) {
-            // after creating new object, lhs is accessible
-            rg.makeAccessible(lhs);
-          }
-        } 
+      if( shouldAnalysisTrack(lhs.getType() ) ) {
+       AllocSite as = getAllocSiteFromFlatNewPRIVATE(fnn);
+
+       // before transform, support effects analysis
+       if (doEffectsAnalysis && fmContaining != fmAnalysisEntry) {
+         if (rblockRel.isPotentialStallSite(fn)) {
+           // after creating new object, lhs is accessible
+           rg.makeAccessible(lhs);
+         }
+       }
 
-        // transfer func
-       rg.assignTempEqualToNewAlloc( lhs, as );        
+       // transfer func
+       rg.assignTempEqualToNewAlloc(lhs, as);
       }
       break;
 
@@ -1440,12 +1440,12 @@ public class DisjointAnalysis implements HeapAnalysis {
       sese = (FlatSESEEnterNode) fn;
 
       if( doEffectsAnalysis && fmContaining != fmAnalysisEntry ) {
-        
-        // always remove ALL stall site taints at enter
-        rg.removeAllStallSiteTaints();
 
-        // inject taints for in-set vars      
-        rg.taintInSetVars( sese );
+       // always remove ALL stall site taints at enter
+       rg.removeAllStallSiteTaints();
+
+       // inject taints for in-set vars
+       rg.taintInSetVars(sese);
 
       }
       break;
@@ -1456,75 +1456,75 @@ public class DisjointAnalysis implements HeapAnalysis {
 
       if( doEffectsAnalysis && fmContaining != fmAnalysisEntry ) {
 
-        // @ sese exit make all live variables
-        // inaccessible to later parent statements
-        rg.makeInaccessible( liveness.getLiveInTemps( fmContaining, fn ) );
-        
-        // always remove ALL stall site taints at exit
-        rg.removeAllStallSiteTaints();
-        
-        // remove in-set var taints for the exiting rblock
-        rg.removeInContextTaints( sese );
+       // @ sese exit make all live variables
+       // inaccessible to later parent statements
+       rg.makeInaccessible(liveness.getLiveInTemps(fmContaining, fn) );
+
+       // always remove ALL stall site taints at exit
+       rg.removeAllStallSiteTaints();
+
+       // remove in-set var taints for the exiting rblock
+       rg.removeInContextTaints(sese);
       }
       break;
 
 
     case FKind.FlatCall: {
       Descriptor mdCaller;
-      if( fmContaining.getMethod() != null ){
-        mdCaller = fmContaining.getMethod();
+      if( fmContaining.getMethod() != null ) {
+       mdCaller = fmContaining.getMethod();
       } else {
-        mdCaller = fmContaining.getTask();
-      }      
-      FlatCall         fc       = (FlatCall) fn;
+       mdCaller = fmContaining.getTask();
+      }
+      FlatCall fc       = (FlatCall) fn;
       MethodDescriptor mdCallee = fc.getMethod();
-      FlatMethod       fmCallee = state.getMethodFlat( mdCallee );
+      FlatMethod fmCallee = state.getMethodFlat(mdCallee);
 
 
-      if( mdCallee.getSymbol().equals( "genReach" ) ) {
-        rg.writeGraph( "genReach"+d,
-                       true,    // write labels (variables)                
-                       true,    // selectively hide intermediate temp vars 
-                       true,    // prune unreachable heap regions          
-                       false,   // hide reachability altogether
-                       true,    // hide subset reachability states         
-                       true,    // hide predicates
-                       true );  // hide edge taints      
-        break;
+      if( mdCallee.getSymbol().equals("genReach") ) {
+       rg.writeGraph("genReach"+d,
+                     true,     // write labels (variables)
+                     true,     // selectively hide intermediate temp vars
+                     true,     // prune unreachable heap regions
+                     false,    // hide reachability altogether
+                     true,     // hide subset reachability states
+                     true,     // hide predicates
+                     true);    // hide edge taints
+       break;
       }
 
 
-      
+
       boolean debugCallSite =
-        mdCaller.getSymbol().equals( state.DISJOINTDEBUGCALLER ) &&
-        mdCallee.getSymbol().equals( state.DISJOINTDEBUGCALLEE );
+        mdCaller.getSymbol().equals(state.DISJOINTDEBUGCALLER) &&
+        mdCallee.getSymbol().equals(state.DISJOINTDEBUGCALLEE);
 
       boolean writeDebugDOTs = false;
       boolean stopAfter      = false;
       if( debugCallSite ) {
-        ++ReachGraph.debugCallSiteVisitCounter;
-        System.out.println( "    $$$ Debug call site visit "+
-                            ReachGraph.debugCallSiteVisitCounter+
-                            " $$$"
-                            );
-        if( 
-           (ReachGraph.debugCallSiteVisitCounter >= 
-            ReachGraph.debugCallSiteVisitStartCapture)  &&
-           
-           (ReachGraph.debugCallSiteVisitCounter < 
-            ReachGraph.debugCallSiteVisitStartCapture + 
-            ReachGraph.debugCallSiteNumVisitsToCapture)
-            ) {
-          writeDebugDOTs = true;
-          System.out.println( "      $$$ Capturing this call site visit $$$" );
-          if( ReachGraph.debugCallSiteStopAfter &&
-              (ReachGraph.debugCallSiteVisitCounter == 
-               ReachGraph.debugCallSiteVisitStartCapture + 
-               ReachGraph.debugCallSiteNumVisitsToCapture - 1)
-              ) {
-            stopAfter = true;
-          }
-        }
+       ++ReachGraph.debugCallSiteVisitCounter;
+       System.out.println("    $$$ Debug call site visit "+
+                          ReachGraph.debugCallSiteVisitCounter+
+                          " $$$"
+                          );
+       if(
+         (ReachGraph.debugCallSiteVisitCounter >=
+          ReachGraph.debugCallSiteVisitStartCapture)  &&
+
+         (ReachGraph.debugCallSiteVisitCounter <
+          ReachGraph.debugCallSiteVisitStartCapture +
+          ReachGraph.debugCallSiteNumVisitsToCapture)
+         ) {
+         writeDebugDOTs = true;
+         System.out.println("      $$$ Capturing this call site visit $$$");
+         if( ReachGraph.debugCallSiteStopAfter &&
+             (ReachGraph.debugCallSiteVisitCounter ==
+              ReachGraph.debugCallSiteVisitStartCapture +
+              ReachGraph.debugCallSiteNumVisitsToCapture - 1)
+             ) {
+           stopAfter = true;
+         }
+       }
       }
 
 
@@ -1532,44 +1532,44 @@ public class DisjointAnalysis implements HeapAnalysis {
       // not used for the current call site transform, we are
       // grabbing this heap model for future analysis of the callees,
       // so if different results emerge we will return to this site
-      ReachGraph heapForThisCall_old = 
-        getIHMcontribution( mdCallee, fc );
+      ReachGraph heapForThisCall_old =
+        getIHMcontribution(mdCallee, fc);
 
       // the computation of the callee-reachable heap
       // is useful for making the callee starting point
       // and for applying the call site transfer function
-      Set<Integer> callerNodeIDsCopiedToCallee = 
+      Set<Integer> callerNodeIDsCopiedToCallee =
         new HashSet<Integer>();
 
-      ReachGraph heapForThisCall_cur = 
-        rg.makeCalleeView( fc, 
-                           fmCallee,
-                           callerNodeIDsCopiedToCallee,
-                           writeDebugDOTs
-                           );
+      ReachGraph heapForThisCall_cur =
+        rg.makeCalleeView(fc,
+                          fmCallee,
+                          callerNodeIDsCopiedToCallee,
+                          writeDebugDOTs
+                          );
 
       // enforce that a call site contribution can only
       // monotonically increase
-      heapForThisCall_cur.merge( heapForThisCall_old );
+      heapForThisCall_cur.merge(heapForThisCall_old);
 
-      if( !heapForThisCall_cur.equals( heapForThisCall_old ) ) {        
-        // if heap at call site changed, update the contribution,
-        // and reschedule the callee for analysis
-        addIHMcontribution( mdCallee, fc, heapForThisCall_cur );        
+      if( !heapForThisCall_cur.equals(heapForThisCall_old) ) {
+       // if heap at call site changed, update the contribution,
+       // and reschedule the callee for analysis
+       addIHMcontribution(mdCallee, fc, heapForThisCall_cur);
 
-        // map a FlatCall to its enclosing method/task descriptor 
-        // so we can write that info out later
-        fc2enclosing.put( fc, mdCaller );
+       // map a FlatCall to its enclosing method/task descriptor
+       // so we can write that info out later
+       fc2enclosing.put(fc, mdCaller);
 
-        if( state.DISJOINTDEBUGSCHEDULING ) {
-          System.out.println( "  context changed, scheduling callee: "+mdCallee );
-        }
+       if( state.DISJOINTDEBUGSCHEDULING ) {
+         System.out.println("  context changed, scheduling callee: "+mdCallee);
+       }
 
-        if( state.DISJOINTDVISITSTACKEESONTOP ) {
-          calleesToEnqueue.add( mdCallee );
-        } else {
-          enqueue( mdCallee );
-        }
+       if( state.DISJOINTDVISITSTACKEESONTOP ) {
+         calleesToEnqueue.add(mdCallee);
+       } else {
+         enqueue(mdCallee);
+       }
 
       }
 
@@ -1579,78 +1579,78 @@ public class DisjointAnalysis implements HeapAnalysis {
       // callees, so find the set of callees...
       Set<MethodDescriptor> setPossibleCallees;
       if( determinismDesired ) {
-        // use an ordered set
-        setPossibleCallees = new TreeSet<MethodDescriptor>( dComp );        
+       // use an ordered set
+       setPossibleCallees = new TreeSet<MethodDescriptor>(dComp);
       } else {
-        // otherwise use a speedy hashset
-        setPossibleCallees = new HashSet<MethodDescriptor>();
+       // otherwise use a speedy hashset
+       setPossibleCallees = new HashSet<MethodDescriptor>();
       }
 
-      if( mdCallee.isStatic() ) {        
-        setPossibleCallees.add( mdCallee );
+      if( mdCallee.isStatic() ) {
+       setPossibleCallees.add(mdCallee);
       } else {
        TypeDescriptor typeDesc = fc.getThis().getType();
-       setPossibleCallees.addAll( callGraph.getMethods( mdCallee, 
-                                                         typeDesc )
-                                   );
+       setPossibleCallees.addAll(callGraph.getMethods(mdCallee,
+                                                      typeDesc)
+                                 );
       }
 
       ReachGraph rgMergeOfPossibleCallers = new ReachGraph();
 
       Iterator<MethodDescriptor> mdItr = setPossibleCallees.iterator();
       while( mdItr.hasNext() ) {
-        MethodDescriptor mdPossible = mdItr.next();
-        FlatMethod       fmPossible = state.getMethodFlat( mdPossible );
-
-        addDependent( mdPossible, // callee
-                      d );        // caller
-
-        // don't alter the working graph (rg) until we compute a 
-        // result for every possible callee, merge them all together,
-        // then set rg to that
-        ReachGraph rgPossibleCaller = new ReachGraph();
-        rgPossibleCaller.merge( rg );          
-                
-        ReachGraph rgPossibleCallee = getPartial( mdPossible );
-
-        if( rgPossibleCallee == null ) {
-          // if this method has never been analyzed just schedule it 
-          // for analysis and skip over this call site for now
-          if( state.DISJOINTDVISITSTACKEESONTOP ) {
-            calleesToEnqueue.add( mdPossible );
-          } else {
-            enqueue( mdPossible );
-          }
-          
-          if( state.DISJOINTDEBUGSCHEDULING ) {
-            System.out.println( "  callee hasn't been analyzed, scheduling: "+mdPossible );
-          }
-
-        } else {
-          // calculate the method call transform         
-          rgPossibleCaller.resolveMethodCall( fc, 
-                                              fmPossible, 
-                                              rgPossibleCallee,
-                                              callerNodeIDsCopiedToCallee,
-                                              writeDebugDOTs
-                                              );
-
-          if( doEffectsAnalysis && fmContaining != fmAnalysisEntry ) {
+       MethodDescriptor mdPossible = mdItr.next();
+       FlatMethod fmPossible = state.getMethodFlat(mdPossible);
+
+       addDependent(mdPossible,  // callee
+                    d);          // caller
+
+       // don't alter the working graph (rg) until we compute a
+       // result for every possible callee, merge them all together,
+       // then set rg to that
+       ReachGraph rgPossibleCaller = new ReachGraph();
+       rgPossibleCaller.merge(rg);
+
+       ReachGraph rgPossibleCallee = getPartial(mdPossible);
+
+       if( rgPossibleCallee == null ) {
+         // if this method has never been analyzed just schedule it
+         // for analysis and skip over this call site for now
+         if( state.DISJOINTDVISITSTACKEESONTOP ) {
+           calleesToEnqueue.add(mdPossible);
+         } else {
+           enqueue(mdPossible);
+         }
+
+         if( state.DISJOINTDEBUGSCHEDULING ) {
+           System.out.println("  callee hasn't been analyzed, scheduling: "+mdPossible);
+         }
+
+       } else {
+         // calculate the method call transform
+         rgPossibleCaller.resolveMethodCall(fc,
+                                            fmPossible,
+                                            rgPossibleCallee,
+                                            callerNodeIDsCopiedToCallee,
+                                            writeDebugDOTs
+                                            );
+
+         if( doEffectsAnalysis && fmContaining != fmAnalysisEntry ) {
 //            if( !rgPossibleCallee.isAccessible( ReachGraph.tdReturn ) ) {
-            if( !accessible.isAccessible(fn, ReachGraph.tdReturn ) ) {
-              rgPossibleCaller.makeInaccessible( fc.getReturnTemp() );
-            }
-          }
+           if( !accessible.isAccessible(fn, ReachGraph.tdReturn) ) {
+             rgPossibleCaller.makeInaccessible(fc.getReturnTemp() );
+           }
+         }
+
+       }
 
-        }
-        
-        rgMergeOfPossibleCallers.merge( rgPossibleCaller );        
+       rgMergeOfPossibleCallers.merge(rgPossibleCaller);
       }
 
 
       if( stopAfter ) {
-        System.out.println( "$$$ Exiting after requested captures of call site. $$$" );
-        System.exit( 0 );
+       System.out.println("$$$ Exiting after requested captures of call site. $$$");
+       System.exit(0);
       }
 
 
@@ -1665,14 +1665,14 @@ public class DisjointAnalysis implements HeapAnalysis {
       //need to consider more
       FlatNode nextFN=fmCallee.getNext(0);
       if( nextFN instanceof FlatSESEEnterNode ) {
-        FlatSESEEnterNode calleeSESE=(FlatSESEEnterNode)nextFN;
-        if(!calleeSESE.getIsLeafSESE()){
-          rg.makeInaccessible( liveness.getLiveInTemps( fmContaining, fn ) );
-        }      
+       FlatSESEEnterNode calleeSESE=(FlatSESEEnterNode)nextFN;
+       if(!calleeSESE.getIsLeafSESE()) {
+         rg.makeInaccessible(liveness.getLiveInTemps(fmContaining, fn) );
+       }
       }
-      
+
     } break;
-      
+
 
     case FKind.FlatReturnNode:
       FlatReturnNode frn = (FlatReturnNode) fn;
@@ -1681,21 +1681,21 @@ public class DisjointAnalysis implements HeapAnalysis {
       // before transfer, do effects analysis support
       if( doEffectsAnalysis && fmContaining != fmAnalysisEntry ) {
 //        if(!rg.isAccessible(rhs)){
-        if(!accessible.isAccessible(fn,rhs)){
-          rg.makeInaccessible(ReachGraph.tdReturn);
-        }
+       if(!accessible.isAccessible(fn,rhs)) {
+         rg.makeInaccessible(ReachGraph.tdReturn);
+       }
       }
 
-      if( rhs != null && shouldAnalysisTrack( rhs.getType() ) ) {
-       rg.assignReturnEqualToTemp( rhs );
+      if( rhs != null && shouldAnalysisTrack(rhs.getType() ) ) {
+       rg.assignReturnEqualToTemp(rhs);
       }
 
-      setRetNodes.add( frn );
+      setRetNodes.add(frn);
       break;
 
     } // end switch
 
-    
+
     // dead variables were removed before the above transfer function
     // was applied, so eliminate heap regions and edges that are no
     // longer part of the abstractly-live heap graph, and sweep up
@@ -1705,12 +1705,12 @@ public class DisjointAnalysis implements HeapAnalysis {
 
 
     // back edges are strictly monotonic
-    if( pm.isBackEdge( fn ) ) {
-      ReachGraph rgPrevResult = mapBackEdgeToMonotone.get( fn );
-      rg.merge( rgPrevResult );
-      mapBackEdgeToMonotone.put( fn, rg );
+    if( pm.isBackEdge(fn) ) {
+      ReachGraph rgPrevResult = mapBackEdgeToMonotone.get(fn);
+      rg.merge(rgPrevResult);
+      mapBackEdgeToMonotone.put(fn, rg);
     }
-    
+
     // at this point rg should be the correct update
     // by an above transfer function, or untouched if
     // the flat node type doesn't affect the heap
@@ -1718,79 +1718,79 @@ public class DisjointAnalysis implements HeapAnalysis {
   }
 
 
-  
+
   // this method should generate integers strictly greater than zero!
   // special "shadow" regions are made from a heap region by negating
   // the ID
   static public Integer generateUniqueHeapRegionNodeID() {
     ++uniqueIDcount;
-    return new Integer( uniqueIDcount );
+    return new Integer(uniqueIDcount);
   }
 
 
-  
-  static public FieldDescriptor getArrayField( TypeDescriptor tdElement ) {
-    FieldDescriptor fdElement = mapTypeToArrayField.get( tdElement );
+
+  static public FieldDescriptor getArrayField(TypeDescriptor tdElement) {
+    FieldDescriptor fdElement = mapTypeToArrayField.get(tdElement);
     if( fdElement == null ) {
-      fdElement = new FieldDescriptor( new Modifiers( Modifiers.PUBLIC ),
-                                       tdElement,
-                                       arrayElementFieldName,
-                                       null,
-                                       false );
-      mapTypeToArrayField.put( tdElement, fdElement );
+      fdElement = new FieldDescriptor(new Modifiers(Modifiers.PUBLIC),
+                                      tdElement,
+                                      arrayElementFieldName,
+                                      null,
+                                      false);
+      mapTypeToArrayField.put(tdElement, fdElement);
     }
     return fdElement;
   }
 
-  
-  
+
+
   private void writeFinalGraphs() {
     Set entrySet = mapDescriptorToCompleteReachGraph.entrySet();
     Iterator itr = entrySet.iterator();
     while( itr.hasNext() ) {
-      Map.Entry  me = (Map.Entry)  itr.next();
-      Descriptor  d = (Descriptor) me.getKey();
+      Map.Entry me = (Map.Entry)itr.next();
+      Descriptor d = (Descriptor) me.getKey();
       ReachGraph rg = (ReachGraph) me.getValue();
 
       String graphName;
       if( d instanceof TaskDescriptor ) {
-        graphName = "COMPLETEtask"+d;
+       graphName = "COMPLETEtask"+d;
       } else {
-        graphName = "COMPLETE"+d;
+       graphName = "COMPLETE"+d;
       }
 
-      rg.writeGraph( graphName,
-                     true,    // write labels (variables)                
-                     true,    // selectively hide intermediate temp vars 
-                     true,    // prune unreachable heap regions          
-                     false,   // hide reachability altogether
-                     true,    // hide subset reachability states         
-                     true,    // hide predicates
-                     false ); // hide edge taints                        
+      rg.writeGraph(graphName,
+                    true,     // write labels (variables)
+                    true,     // selectively hide intermediate temp vars
+                    true,     // prune unreachable heap regions
+                    false,    // hide reachability altogether
+                    true,     // hide subset reachability states
+                    true,     // hide predicates
+                    false);   // hide edge taints
     }
   }
 
   private void writeFinalIHMs() {
     Iterator d2IHMsItr = mapDescriptorToIHMcontributions.entrySet().iterator();
     while( d2IHMsItr.hasNext() ) {
-      Map.Entry                        me1 = (Map.Entry)                       d2IHMsItr.next();
-      Descriptor                         d = (Descriptor)                      me1.getKey();
-      Hashtable<FlatCall, ReachGraph> IHMs = (Hashtable<FlatCall, ReachGraph>) me1.getValue();
+      Map.Entry me1 = (Map.Entry)d2IHMsItr.next();
+      Descriptor d = (Descriptor)                      me1.getKey();
+      Hashtable<FlatCall, ReachGraph> IHMs = (Hashtable<FlatCall, ReachGraph>)me1.getValue();
 
       Iterator fc2rgItr = IHMs.entrySet().iterator();
       while( fc2rgItr.hasNext() ) {
-        Map.Entry  me2 = (Map.Entry)  fc2rgItr.next();
-        FlatCall   fc  = (FlatCall)   me2.getKey();
-        ReachGraph rg  = (ReachGraph) me2.getValue();
-                
-        rg.writeGraph( "IHMPARTFOR"+d+"FROM"+fc2enclosing.get( fc )+fc,
-                       true,   // write labels (variables)
-                       true,   // selectively hide intermediate temp vars
-                       true,   // hide reachability altogether
-                       true,   // prune unreachable heap regions
-                       true,   // hide subset reachability states
-                       false,  // hide predicates
-                       true ); // hide edge taints
+       Map.Entry me2 = (Map.Entry)fc2rgItr.next();
+       FlatCall fc  = (FlatCall)   me2.getKey();
+       ReachGraph rg  = (ReachGraph) me2.getValue();
+
+       rg.writeGraph("IHMPARTFOR"+d+"FROM"+fc2enclosing.get(fc)+fc,
+                     true,    // write labels (variables)
+                     true,    // selectively hide intermediate temp vars
+                     true,    // hide reachability altogether
+                     true,    // prune unreachable heap regions
+                     true,    // hide subset reachability states
+                     false,   // hide predicates
+                     true);   // hide edge taints
       }
     }
   }
@@ -1799,28 +1799,28 @@ public class DisjointAnalysis implements HeapAnalysis {
     Set entrySet = mapDescriptorToInitialContext.entrySet();
     Iterator itr = entrySet.iterator();
     while( itr.hasNext() ) {
-      Map.Entry  me = (Map.Entry)  itr.next();
-      Descriptor  d = (Descriptor) me.getKey();
+      Map.Entry me = (Map.Entry)itr.next();
+      Descriptor d = (Descriptor) me.getKey();
       ReachGraph rg = (ReachGraph) me.getValue();
 
-      rg.writeGraph( "INITIAL"+d,
-                     true,   // write labels (variables)                
-                     true,   // selectively hide intermediate temp vars 
-                     true,   // prune unreachable heap regions          
-                     false,  // hide all reachability
-                     true,   // hide subset reachability states         
-                     true,   // hide predicates
-                     false );// hide edge taints                        
+      rg.writeGraph("INITIAL"+d,
+                    true,    // write labels (variables)
+                    true,    // selectively hide intermediate temp vars
+                    true,    // prune unreachable heap regions
+                    false,   // hide all reachability
+                    true,    // hide subset reachability states
+                    true,    // hide predicates
+                    false);  // hide edge taints
     }
   }
-   
 
-  protected ReachGraph getPartial( Descriptor d ) {
-    return mapDescriptorToCompleteReachGraph.get( d );
+
+  protected ReachGraph getPartial(Descriptor d) {
+    return mapDescriptorToCompleteReachGraph.get(d);
   }
 
-  protected void setPartial( Descriptor d, ReachGraph rg ) {
-    mapDescriptorToCompleteReachGraph.put( d, rg );
+  protected void setPartial(Descriptor d, ReachGraph rg) {
+    mapDescriptorToCompleteReachGraph.put(d, rg);
 
     // when the flag for writing out every partial
     // result is set, we should spit out the graph,
@@ -1828,66 +1828,66 @@ public class DisjointAnalysis implements HeapAnalysis {
     // to track how many partial results for this
     // descriptor we've already written out
     if( writeAllIncrementalDOTs ) {
-      if( !mapDescriptorToNumUpdates.containsKey( d ) ) {
-       mapDescriptorToNumUpdates.put( d, new Integer( 0 ) );
+      if( !mapDescriptorToNumUpdates.containsKey(d) ) {
+       mapDescriptorToNumUpdates.put(d, new Integer(0) );
       }
-      Integer n = mapDescriptorToNumUpdates.get( d );
-      
+      Integer n = mapDescriptorToNumUpdates.get(d);
+
       String graphName;
       if( d instanceof TaskDescriptor ) {
-        graphName = d+"COMPLETEtask"+String.format( "%05d", n );
+       graphName = d+"COMPLETEtask"+String.format("%05d", n);
       } else {
-        graphName = d+"COMPLETE"+String.format( "%05d", n );
-      }
-
-      rg.writeGraph( graphName,
-                     true,   // write labels (variables)
-                     true,   // selectively hide intermediate temp vars
-                     true,   // prune unreachable heap regions
-                     false,  // hide all reachability
-                     true,   // hide subset reachability states
-                     false,  // hide predicates
-                     false); // hide edge taints
-      
-      mapDescriptorToNumUpdates.put( d, n + 1 );
+       graphName = d+"COMPLETE"+String.format("%05d", n);
+      }
+
+      rg.writeGraph(graphName,
+                    true,    // write labels (variables)
+                    true,    // selectively hide intermediate temp vars
+                    true,    // prune unreachable heap regions
+                    false,   // hide all reachability
+                    true,    // hide subset reachability states
+                    false,   // hide predicates
+                    false);  // hide edge taints
+
+      mapDescriptorToNumUpdates.put(d, n + 1);
     }
   }
 
 
 
   // return just the allocation site associated with one FlatNew node
-  protected AllocSite getAllocSiteFromFlatNewPRIVATE( FlatNew fnew ) {
+  protected AllocSite getAllocSiteFromFlatNewPRIVATE(FlatNew fnew) {
 
     boolean flagProgrammatically = false;
-    if( sitesToFlag != null && sitesToFlag.contains( fnew ) ) {
+    if( sitesToFlag != null && sitesToFlag.contains(fnew) ) {
       flagProgrammatically = true;
     }
 
-    if( !mapFlatNewToAllocSite.containsKey( fnew ) ) {
-      AllocSite as = AllocSite.factory( allocationDepth, 
-                                        fnew, 
-                                        fnew.getDisjointId(),
-                                        flagProgrammatically
-                                        );
+    if( !mapFlatNewToAllocSite.containsKey(fnew) ) {
+      AllocSite as = AllocSite.factory(allocationDepth,
+                                       fnew,
+                                       fnew.getDisjointId(),
+                                       flagProgrammatically
+                                       );
 
       // the newest nodes are single objects
       for( int i = 0; i < allocationDepth; ++i ) {
        Integer id = generateUniqueHeapRegionNodeID();
-       as.setIthOldest( i, id );
-       mapHrnIdToAllocSite.put( id, as );
+       as.setIthOldest(i, id);
+       mapHrnIdToAllocSite.put(id, as);
       }
 
       // the oldest node is a summary node
-      as.setSummary( generateUniqueHeapRegionNodeID() );
+      as.setSummary(generateUniqueHeapRegionNodeID() );
 
-      mapFlatNewToAllocSite.put( fnew, as );
+      mapFlatNewToAllocSite.put(fnew, as);
     }
 
-    return mapFlatNewToAllocSite.get( fnew );
+    return mapFlatNewToAllocSite.get(fnew);
   }
 
 
-  public static boolean shouldAnalysisTrack( TypeDescriptor type ) {
+  public static boolean shouldAnalysisTrack(TypeDescriptor type) {
     // don't track primitive types, but an array
     // of primitives is heap memory
     if( type.isImmutable() ) {
@@ -1898,97 +1898,97 @@ public class DisjointAnalysis implements HeapAnalysis {
     return true;
   }
 
-  protected int numMethodsAnalyzed() {    
+  protected int numMethodsAnalyzed() {
     return descriptorsToAnalyze.size();
   }
-  
 
-  
-  
-  
+
+
+
+
   // Take in source entry which is the program's compiled entry and
   // create a new analysis entry, a method that takes no parameters
   // and appears to allocate the command line arguments and call the
   // source entry with them.  The purpose of this analysis entry is
   // to provide a top-level method context with no parameters left.
-  protected void makeAnalysisEntryMethod( MethodDescriptor mdSourceEntry ) {
+  protected void makeAnalysisEntryMethod(MethodDescriptor mdSourceEntry) {
 
     Modifiers mods = new Modifiers();
-    mods.addModifier( Modifiers.PUBLIC );
-    mods.addModifier( Modifiers.STATIC );
+    mods.addModifier(Modifiers.PUBLIC);
+    mods.addModifier(Modifiers.STATIC);
 
-    TypeDescriptor returnType = 
-      new TypeDescriptor( TypeDescriptor.VOID );
+    TypeDescriptor returnType =
+      new TypeDescriptor(TypeDescriptor.VOID);
 
-    this.mdAnalysisEntry = 
-      new MethodDescriptor( mods,
-                            returnType,
-                            "analysisEntryMethod"
-                            );
+    this.mdAnalysisEntry =
+      new MethodDescriptor(mods,
+                           returnType,
+                           "analysisEntryMethod"
+                           );
 
-    TempDescriptor cmdLineArgs = 
-      new TempDescriptor( "args",
-                          mdSourceEntry.getParamType( 0 )
-                          );
+    TempDescriptor cmdLineArgs =
+      new TempDescriptor("args",
+                         mdSourceEntry.getParamType(0)
+                         );
+
+    FlatNew fn =
+      new FlatNew(mdSourceEntry.getParamType(0),
+                  cmdLineArgs,
+                  false  // is global
+                  );
 
-    FlatNew fn = 
-      new FlatNew( mdSourceEntry.getParamType( 0 ),
-                   cmdLineArgs,
-                   false // is global 
-                   );
-    
     TempDescriptor[] sourceEntryArgs = new TempDescriptor[1];
     sourceEntryArgs[0] = cmdLineArgs;
-    
-    FlatCall fc = 
-      new FlatCall( mdSourceEntry,
-                    null, // dst temp
-                    null, // this temp
-                    sourceEntryArgs
-                    );
 
-    FlatReturnNode frn = new FlatReturnNode( null );
+    FlatCall fc =
+      new FlatCall(mdSourceEntry,
+                   null,  // dst temp
+                   null,  // this temp
+                   sourceEntryArgs
+                   );
+
+    FlatReturnNode frn = new FlatReturnNode(null);
 
     FlatExit fe = new FlatExit();
 
-    this.fmAnalysisEntry = 
-      new FlatMethod( mdAnalysisEntry, 
-                      fe
-                      );
+    this.fmAnalysisEntry =
+      new FlatMethod(mdAnalysisEntry,
+                     fe
+                     );
 
-    this.fmAnalysisEntry.addNext( fn );
-    fn.addNext( fc );
-    fc.addNext( frn );
-    frn.addNext( fe );
+    this.fmAnalysisEntry.addNext(fn);
+    fn.addNext(fc);
+    fc.addNext(frn);
+    frn.addNext(fe);
   }
 
 
-  protected LinkedList<Descriptor> topologicalSort( Set<Descriptor> toSort ) {
+  protected LinkedList<Descriptor> topologicalSort(Set<Descriptor> toSort) {
 
     Set<Descriptor> discovered;
 
     if( determinismDesired ) {
       // use an ordered set
-      discovered = new TreeSet<Descriptor>( dComp );      
+      discovered = new TreeSet<Descriptor>(dComp);
     } else {
       // otherwise use a speedy hashset
       discovered = new HashSet<Descriptor>();
     }
 
     LinkedList<Descriptor> sorted = new LinkedList<Descriptor>();
-  
+
     Iterator<Descriptor> itr = toSort.iterator();
     while( itr.hasNext() ) {
       Descriptor d = itr.next();
-          
-      if( !discovered.contains( d ) ) {
-       dfsVisit( d, toSort, sorted, discovered );
+
+      if( !discovered.contains(d) ) {
+       dfsVisit(d, toSort, sorted, discovered);
       }
     }
-    
+
     return sorted;
   }
-  
+
   // While we're doing DFS on call graph, remember
   // dependencies for efficient queuing of methods
   // during interprocedural analysis:
@@ -1996,12 +1996,12 @@ public class DisjointAnalysis implements HeapAnalysis {
   // a dependent of a method decriptor d for this analysis is:
   //  1) a method or task that invokes d
   //  2) in the descriptorsToAnalyze set
-  protected void dfsVisit( Descriptor             d,
-                           Set       <Descriptor> toSort,                       
-                           LinkedList<Descriptor> sorted,
-                           Set       <Descriptor> discovered ) {
-    discovered.add( d );
-    
+  protected void dfsVisit(Descriptor d,
+                          Set       <Descriptor> toSort,
+                          LinkedList<Descriptor> sorted,
+                          Set       <Descriptor> discovered) {
+    discovered.add(d);
+
     // only methods have callers, tasks never do
     if( d instanceof MethodDescriptor ) {
 
@@ -2010,56 +2010,56 @@ public class DisjointAnalysis implements HeapAnalysis {
       // the call graph is not aware that we have a fabricated
       // analysis entry that calls the program source's entry
       if( md == mdSourceEntry ) {
-        if( !discovered.contains( mdAnalysisEntry ) ) {
-          addDependent( mdSourceEntry,  // callee
-                        mdAnalysisEntry // caller
-                        );
-          dfsVisit( mdAnalysisEntry, toSort, sorted, discovered );
-        }
+       if( !discovered.contains(mdAnalysisEntry) ) {
+         addDependent(mdSourceEntry,   // callee
+                      mdAnalysisEntry  // caller
+                      );
+         dfsVisit(mdAnalysisEntry, toSort, sorted, discovered);
+       }
       }
 
       // otherwise call graph guides DFS
-      Iterator itr = callGraph.getCallerSet( md ).iterator();
+      Iterator itr = callGraph.getCallerSet(md).iterator();
       while( itr.hasNext() ) {
        Descriptor dCaller = (Descriptor) itr.next();
-       
+
        // only consider callers in the original set to analyze
-        if( !toSort.contains( dCaller ) ) {
+       if( !toSort.contains(dCaller) ) {
          continue;
-        }
-          
-       if( !discovered.contains( dCaller ) ) {
-          addDependent( md,     // callee
-                        dCaller // caller
-                        );
-
-         dfsVisit( dCaller, toSort, sorted, discovered );
+       }
+
+       if( !discovered.contains(dCaller) ) {
+         addDependent(md,      // callee
+                      dCaller  // caller
+                      );
+
+         dfsVisit(dCaller, toSort, sorted, discovered);
        }
       }
     }
-    
+
     // for leaf-nodes last now!
-    sorted.addLast( d );
+    sorted.addLast(d);
   }
 
 
-  protected void enqueue( Descriptor d ) {
+  protected void enqueue(Descriptor d) {
 
-    if( !descriptorsToVisitSet.contains( d ) ) {
+    if( !descriptorsToVisitSet.contains(d) ) {
 
       if( state.DISJOINTDVISITSTACK ||
           state.DISJOINTDVISITSTACKEESONTOP
           ) {
-        descriptorsToVisitStack.add( d );
+       descriptorsToVisitStack.add(d);
 
       } else if( state.DISJOINTDVISITPQUE ) {
-        Integer priority = mapDescriptorToPriority.get( d );
-        descriptorsToVisitQ.add( new DescriptorQWrapper( priority, 
-                                                         d ) 
-                                 );
+       Integer priority = mapDescriptorToPriority.get(d);
+       descriptorsToVisitQ.add(new DescriptorQWrapper(priority,
+                                                      d)
+                               );
       }
 
-      descriptorsToVisitSet.add( d );
+      descriptorsToVisitSet.add(d);
     }
   }
 
@@ -2067,410 +2067,410 @@ public class DisjointAnalysis implements HeapAnalysis {
   // a dependent of a method decriptor d for this analysis is:
   //  1) a method or task that invokes d
   //  2) in the descriptorsToAnalyze set
-  protected void addDependent( Descriptor callee, Descriptor caller ) {
-    Set<Descriptor> deps = mapDescriptorToSetDependents.get( callee );
+  protected void addDependent(Descriptor callee, Descriptor caller) {
+    Set<Descriptor> deps = mapDescriptorToSetDependents.get(callee);
     if( deps == null ) {
       deps = new HashSet<Descriptor>();
     }
-    deps.add( caller );
-    mapDescriptorToSetDependents.put( callee, deps );
+    deps.add(caller);
+    mapDescriptorToSetDependents.put(callee, deps);
   }
-  
-  protected Set<Descriptor> getDependents( Descriptor callee ) {
-    Set<Descriptor> deps = mapDescriptorToSetDependents.get( callee );
+
+  protected Set<Descriptor> getDependents(Descriptor callee) {
+    Set<Descriptor> deps = mapDescriptorToSetDependents.get(callee);
     if( deps == null ) {
       deps = new HashSet<Descriptor>();
-      mapDescriptorToSetDependents.put( callee, deps );
+      mapDescriptorToSetDependents.put(callee, deps);
     }
     return deps;
   }
 
-  
-  public Hashtable<FlatCall, ReachGraph> getIHMcontributions( Descriptor d ) {
 
-    Hashtable<FlatCall, ReachGraph> heapsFromCallers = 
-      mapDescriptorToIHMcontributions.get( d );
-    
+  public Hashtable<FlatCall, ReachGraph> getIHMcontributions(Descriptor d) {
+
+    Hashtable<FlatCall, ReachGraph> heapsFromCallers =
+      mapDescriptorToIHMcontributions.get(d);
+
     if( heapsFromCallers == null ) {