[add new library creation subsystem
John Meacham <john@repetae.net>**20080213045234] hunk ./Ho/Build.hs 272
+        lmods = Map.mapMaybe ( \ x -> case x of ModLibrary _ h -> Just h ; _ -> Nothing) (modEncountered done)
hunk ./Ho/Build.hs 284
-    let f m = do
+    let f m | Just h <- Map.lookup m lmods = hvalid h
+        f m = do
hunk ./Ho/Build.hs 313
-                        modifyIORef cug_ref ((h,(hohModDepends hoh,CompHo Nothing hoh ho)):)
+                        let lib = case reverse fp of
+                                'l':'h':'.':_ -> Just fp
+                                _ -> Nothing
+                        modifyIORef cug_ref ((h,(hohModDepends hoh,CompHo lib hoh ho)):)
hunk ./Ho/Build.hs 340
-    (cho,_,_) <- findModule need ifunc func
-    return cho
+    (needed,cug) <- loadModules (optHls options) need
+    processCug cug >>= mkPhonyCompNode needed >>= compileCompNode ifunc func
hunk ./Ho/Build.hs 357
-        putVerboseLn $ printf "%-15s <%s>" n' fn
+        putVerboseLn $ printf "Library: %-15s <%s>" n' fn
hunk ./Ho/Build.hs 359
-        modifyIORef done_ref (modEncountered_u $ Map.union (Map.fromList [ (m,ModLibrary n' (hohHash hoh)) | (m,_) <- hohDepends hoh]))
+        modifyIORef done_ref (modEncountered_u $ Map.union (Map.fromList [ (m,ModLibrary n' (hohHash hoh)) | m <- providesModules hoh]))
hunk ./Ho/Build.hs 388
-findModule :: [Either Module String]                                -- ^ Either a module or filename to find
-              -> (CollectedHo -> Ho -> IO CollectedHo)              -- ^ Process initial ho loaded from file
-              -> (CollectedHo -> [HsModule] -> IO (CollectedHo,Ho)) -- ^ Process set of mutually recursive modules to produce final Ho
-              -> IO (CollectedHo,[(Module,MD5.Hash)],Ho)            -- ^ (Final accumulated ho,just the ho read to satisfy this command)
-findModule need ifunc func  = do
-    (needed,cug) <- loadModules (optHls options) need
-    cnodes <- processCug cug
-    rnode <- mkPhonyCompNode needed cnodes
-
-    let f (CompNode hh deps ref) = readIORef ref >>= \cn -> case cn of
-            CompCollected ch _ -> return ch
-            CompPhony -> do
-                xs <- mconcat `fmap` mapM f deps
-                writeIORef ref (CompCollected xs CompPhony)
-                return xs
-            CompHo _ _ ho -> do
-                cho <- mconcat `fmap` mapM f deps
-                cho <- ifunc cho ho
-                writeIORef ref (CompCollected cho cn)
-                return cho
-            CompSources sc -> do
-                let hdep = [ h | CompNode h _ _ <- deps]
-                cho <- mconcat `fmap` mapM f deps
-                modules <- forM sc $ \x -> case x of
-                    SourceParsed { sourceHash = h,sourceModule = mod } -> return (h,mod)
-                    SourceRaw { sourceHash = h,sourceLBS = lbs, sourceFP = fp } -> do
-                        fp <- shortenPath fp
-                        mod <- parseHsSource fp lbs
-                        return (h,mod)
-                (cho',newHo) <- func cho (snds modules)
-                let hoh = HoHeader {
-                                     hohDepends    = [ (hsModuleName mod,h) | (h,mod) <- modules],
-                                     hohModDepends = hdep,
-                                     hohHash       = hh,
-                                     hohMetaInfo   = []
-                                   }
-                    idep = HoIDeps $ Map.fromList [ (h,(hsModuleName mod,hsModuleRequires mod)) | (h,mod) <- modules]
-                recordHoFile newHo idep (map sourceHoName sc) hoh
-                writeIORef ref (CompCollected cho' cn)
-                return cho'
-
-
-    cho <- f rnode
-    return (cho,undefined,undefined)
-
-{-
-
-
-
-    let f ho libHo [] = processIOErrors >> return (ho,mempty,libHo)
-        f ho libHo ((hh,hdep,sc):scs) = do
+compileCompNode :: (CollectedHo -> Ho -> IO CollectedHo)              -- ^ Process initial ho loaded from file
+                -> (CollectedHo -> [HsModule] -> IO (CollectedHo,Ho)) -- ^ Process set of mutually recursive modules to produce final Ho
+                -> CompNode
+                -> IO CollectedHo
+compileCompNode ifunc func cn = f cn where
+    f (CompNode hh deps ref) = readIORef ref >>= \cn -> case cn of
+        CompCollected ch _ -> return ch
+        CompPhony -> do
+            xs <- mconcat `fmap` mapM f deps
+            writeIORef ref (CompCollected xs CompPhony)
+            return xs
+        CompHo _ _ ho -> do
+            cho <- mconcat `fmap` mapM f deps
+            cho <- ifunc cho ho
+            writeIORef ref (CompCollected cho cn)
+            return cho
+        CompSources sc -> do
+            let hdep = [ h | CompNode h _ _ <- deps]
+            cho <- mconcat `fmap` mapM f deps
hunk ./Ho/Build.hs 413
-            (cho',newHo) <- func ho (snds modules)
+            (cho',newHo) <- func cho (snds modules)
hunk ./Ho/Build.hs 421
+
hunk ./Ho/Build.hs 423
-            f (cho' `mappend` mempty { choFiles = Map.fromList $ hohDepends hoh  }) (libHo `mappend` newHo)  scs
-        mprovides hoh = Map.fromList [ (x,hohHash hoh) | (x,_) <- hohDepends hoh]
+            writeIORef ref (CompCollected cho' (CompHo Nothing hoh newHo))
+            return cho'
hunk ./Ho/Build.hs 426
-    let sccm = G.sccGroups $ G.newGraph cug fst (fst . snd)
-    let readHo = mconcat [ ho | [(_,(_,CompHo _ _ ho))] <- sccm ]
-    cho <- ifunc mempty (mempty { hoBuild = mempty { hoDataTable = dataTablePrims } } `mappend` readHo)
-    f cho mempty [ (hh,hdep,ss) | [(hh,(hdep,CompSources ss))] <- sccm ]
hunk ./Ho/Build.hs 427
--}
+findModule :: [Either Module String]                                -- ^ Either a module or filename to find
+              -> (CollectedHo -> Ho -> IO CollectedHo)              -- ^ Process initial ho loaded from file
+              -> (CollectedHo -> [HsModule] -> IO (CollectedHo,Ho)) -- ^ Process set of mutually recursive modules to produce final Ho
+              -> IO (CollectedHo,[(Module,MD5.Hash)],Ho)            -- ^ (Final accumulated ho,just the ho read to satisfy this command)
+findModule need ifunc func  = do
+    (needed,cug) <- loadModules (optHls options) need
+    cnodes <- processCug cug
+    rnode <- mkPhonyCompNode needed cnodes
+    cho <- compileCompNode ifunc func rnode
+    return (cho,undefined,undefined)
hunk ./Ho/Build.hs 558
-        (cho,libDeps,ho) <- findModule (map Left (emods ++ hmods)) ifunc func
-        let unknownMods = [ m | m <- mkeys (hoExports $ hoExp ho), m `notElem` allmods  ]
+
+        (needed,cug) <- loadModules (optHls options) (map Left allmods)
+        rnode@(CompNode lhash _ _) <- processCug cug >>= mkPhonyCompNode needed
+        compileCompNode ifunc func rnode
+        (prvds,ho,ldeps) <- let
+            f (CompNode hs cd ref) = do
+                deps <- mconcat `fmap` mapM f cd
+                d <- readIORef ref >>= hunit hs
+                return $ d `mappend` deps
+            hunit hs x = case x of
+                    CompHo (Just s) _ _ -> return (mempty,mempty,Map.singleton hs s)
+                    CompHo Nothing hoh ho -> return (Set.fromList $ providesModules hoh,Map.singleton hs ho,mempty)
+                    CompCollected _ u -> hunit hs u
+                    CompPhony -> return mempty
+          in f rnode
+
+        --(cho,libDeps,ho) <- findModule (map Left (emods ++ hmods)) ifunc func
+        let unknownMods = Set.toList $ Set.filter (`notElem` allmods) prvds
hunk ./Ho/Build.hs 581
-        let lhash = MD5.md5String (show $ choFiles cho)
hunk ./Ho/Build.hs 583
-                hohDepends = [ (m,MD5.emptyHash) | m <- mkeys (hoExports $ hoExp ho)],
-                hohModDepends = snds libDeps,
+                hohDepends = [ (m,MD5.emptyHash) | m <- Set.toList prvds ],
+                hohModDepends = Map.keys ldeps,
hunk ./Ho/Build.hs 587
-        recordHoFile ho (HoIDeps Map.empty) [outName] hoh
+        recordHoFile (mconcat $ Map.elems ho) (HoIDeps Map.empty) [outName] hoh