[new argument treatment
John Meacham <john@repetae.net>**20050913003349] hunk ./Grin/PointsToAnalysis.hs 629
-    let fmp = Map.fromListWith (zipWith mappend) $ appEq eq
---        heaps = [ (Lh x,cp y >>= \z -> getUpdates x >>= return . mappend z ) | (x,(_,y)) <- heapEq eq ] ++ cheaps
---        getUpdates p = do
---            let e (v,x) = do
---                    ns <- cp v
---                    case Set.member p (getHeaps ns) of
---                        True -> cp x
---                        False -> return mempty
---            ep <-  mapM e (updateEq eq)
---            return $ mconcat ep
hunk ./Grin/PointsToAnalysis.hs 682
-                    flip mapM_ (concat [  incp (fromAtom n)  | n <- Set.toList (getNodes v), tagIsPartialAp n ]) $ \n -> do
+                    flip mapM_ (concat [  fmap ((,) n) (incp (fromAtom n))  | n <- (allNodes v), tagIsPartialAp n ]) $ \(on,n) -> do
hunk ./Grin/PointsToAnalysis.hs 684
+                        let mm = Map.fromList $ concat [ Map.lookup (on,i) (getNodeArgs v) >>= return . ((,) (n,i)) |  i <- [0 .. length ts ]]
+                        self `isSuperSetOf` value (pruneNodes $ VsNodes mm mempty)
hunk ./Grin/PointsToAnalysis.hs 687
-                            VsNodes (Map.singleton (n,length ts - 1) x) Set.empty
-                    sequence_ $ concat [  papp' (fromAtom n)  | n <- Set.toList (getNodes v), tagIsPartialAp n ]
+                                pruneNodes $ VsNodes (Map.singleton (n,length ts - 1) x) Set.empty
+                    sequence_ $ concat [  papp'' (fromAtom n) i a | ((n,i),a) <- Map.toList (getNodeArgs v), tagIsPartialAp n ]
+                    sequence_ $ concat [  papp' (fromAtom n) x'  | n <- Set.toList (getNodes v), tagIsPartialAp n ]
hunk ./Grin/PointsToAnalysis.hs 698
-                case Map.lookup a fmp of
-                    Nothing -> return ()
-                    Just ps -> do
-                        --CharIO.print (arg, ps)
-                        pp (ps !! i)
hunk ./Grin/PointsToAnalysis.hs 741
-        --procApp a ps = undefined
+        procApp a ps = do
+            argMap <- readIORef argMap
+            flip mapM_ (zip [0..] ps) $ \ (i,p) -> do
+                case Map.lookup (a,i) argMap of
+                    Just v -> procPos v p
+                    Nothing -> return ()
+
hunk ./Grin/PointsToAnalysis.hs 775
-    --mapM_ (uncurry procApp) (appEq eq)
+    mapM_ (uncurry procApp) (appEq eq)