[redo library support
John Meacham <john@repetae.net>**20090809133832
 Ignore-this: 224f364ad4f39a4c75515e9610ff40aa
] hunk ./Makefile.am 225
-	./jhc $(RTSOPTS) $(JHC_TEST) -Idata -Ilib/containers/include --ho-dir tmp/libho -ilib/containers  --noauto -L- -L. -p base -p applicative --build-hl lib/containers.cabal -fcpp -o $@
+	./jhc $(RTSOPTS) $(JHC_TEST) -Isrc/data -Ilib/containers/include --ho-dir tmp/libho -ilib/containers  --noauto -L- -L. -p base -p applicative --build-hl lib/containers.cabal -fcpp -o $@
hunk ./Makefile.am 252
-	find . ! -wholename '*/examples/*'  ! -wholename '*/_darcs/*' ! -wholename '*/drift_processed/*'  ! -wholename '*/regress/*'  \( -name '*.hs' -o -name '*.hsc' -o -name '*.mkd' -o -wholename '*/data/rts/*.c' \) | xargs perl utils/stitch.prl > manual.mkd
+	find . ! -wholename '*/examples/*'  ! -wholename '*/_darcs/*' ! -wholename '*/drift_processed/*'  ! -wholename '*/regress/*'  \( -name '*.hs' -o -name '*.hsc' -o -name '*.mkd' -o -wholename '*/src/data/rts/*.c' \) | xargs perl utils/stitch.prl > manual.mkd
hunk ./Makefile.am 256
-	find . ! -wholename '*/examples/*'  ! -wholename '*/_darcs/*' ! -wholename '*/drift_processed/*'  ! -wholename '*/regress/*'  \( -name '*.hs' -o -name '*.hsc' -o -name '*.mkd' -o -wholename '*/data/rts/*.c' \) | xargs perl utils/stitch.prl -h docs/man_header.mkd -c Using,Options > jhc_man.mkd
+	find . ! -wholename '*/examples/*'  ! -wholename '*/_darcs/*' ! -wholename '*/drift_processed/*'  ! -wholename '*/regress/*'  \( -name '*.hs' -o -name '*.hsc' -o -name '*.mkd' -o -wholename '*/src/data/rts/*.c' \) | xargs perl utils/stitch.prl -h docs/man_header.mkd -c Using,Options > jhc_man.mkd
hunk ./src/Ho/Binary.hs 23
-current_version = 2
+current_version = 3
hunk ./src/Ho/Binary.hs 137
-    put (HoIDeps aa ab ac) = do
+    put (HoIDeps aa ab ac ad) = do
hunk ./src/Ho/Binary.hs 141
+	    Data.Binary.put ad
hunk ./src/Ho/Binary.hs 146
-    return (HoIDeps aa ab ac)
+    ad <- get
+    return (HoIDeps aa ab ac ad)
hunk ./src/Ho/Binary.hs 162
-    put (Data.Version.Version a b) = put a >> put b 
+    put (Data.Version.Version a b) = put a >> put b
hunk ./src/Ho/Build.hs 17
+import Data.Version(Version,parseVersion,showVersion)
hunk ./src/Ho/Build.hs 58
-import PackedString(packString)
+import PackedString(PackedString,packString,unpackPS)
hunk ./src/Ho/Build.hs 106
+type LibraryName = PackedString
hunk ./src/Ho/Build.hs 117
-    | ModLibrary String HoHash
+    | ModLibrary ModuleGroup Library
hunk ./src/Ho/Build.hs 121
-    knownSourceMap :: Map.Map SourceHash (Module,[Module]),
-    validSources   :: Set.Set SourceHash,
-    hosEncountered :: Map.Map HoHash     (FilePath,HoHeader,HoIDeps,Ho),
-    modEncountered :: Map.Map Module     ModDone
+    knownSourceMap  :: Map.Map SourceHash (Module,[Module]),
+    validSources    :: Set.Set SourceHash,
+    loadedLibraries :: Map.Map LibraryName Library,
+    hosEncountered  :: Map.Map HoHash     (FilePath,HoHeader,HoIDeps,Ho),
+    modEncountered  :: Map.Map Module     ModDone
hunk ./src/Ho/Build.hs 209
+type LibInfo = (Map.Map Module ModuleGroup, Map.Map ModuleGroup [ModuleGroup], Set.Set Module,Map.Map ModuleGroup HoBuild,Map.Map ModuleGroup HoTcInfo)
+
hunk ./src/Ho/Build.hs 216
---    | CompLinkLib ()
+    | CompLinkLib (ModuleGroup,LibInfo) CompUnit
+
+compLinkCompUnit (CompLinkUnit cu) = cu
+compLinkCompUnit (CompCollected _ cu) = cu
+compLinkCompUnit (CompTcCollected _ cu) = cu
+compLinkCompUnit (CompLinkLib _ cu) = cu
hunk ./src/Ho/Build.hs 249
+instance ProvidesModules HoLib where
+    providesModules hl = Map.keys (hoModuleMap hl)
hunk ./src/Ho/Build.hs 255
+    providesModules (CompLibrary ho libr) = libProvides (hoModuleGroup ho) libr
hunk ./src/Ho/Build.hs 277
+
+libModMap (Library _ libr _ _) = hoModuleMap libr
+
hunk ./src/Ho/Build.hs 282
-    let fs m = maybe (error $ "can't find deps for: " ++ show m) snd (Map.lookup m (knownSourceMap done))
-        gr = G.newGraph  [ ((m,sourceHash sc),fs (sourceHash sc)) | (m,Found sc) <- Map.toList (modEncountered done)] (fst . fst) snd
+    let fs m = map inject $ maybe (error $ "can't find deps for: " ++ show m) snd (Map.lookup m (knownSourceMap done))
+        fs' m (Library _ libr _ _) = fromMaybe (error $ "can't find deps for: " ++ show m) (Map.lookup m (hoModuleDeps libr))
+        foundMods = [ ((m,Left (sourceHash sc)),fs (sourceHash sc)) | (m,Found sc) <- Map.toList (modEncountered done)]
+        foundMods' = Map.elems $ Map.fromList [ (mg,((mg,Right lib),fs' mg lib)) | (_,ModLibrary mg lib) <- Map.toList (modEncountered done)]
+        fullModMap = Map.unions (map libModMap $ Map.elems (loadedLibraries done))
+        inject m = Map.findWithDefault m m fullModMap
+        gr = G.newGraph  (foundMods ++ foundMods') (fst . fst) snd
hunk ./src/Ho/Build.hs 290
-        lmods = Map.mapMaybe ( \ x -> case x of ModLibrary _ h -> Just h ; _ -> Nothing) (modEncountered done)
+        lmods = Map.mapMaybe ( \ x -> case x of ModLibrary mg lib -> Just (mg,lib) ; _ -> Nothing) (modEncountered done)
hunk ./src/Ho/Build.hs 293
+
+   -- mapM_ (putErrLn . show) $ [ (x,y) | ((x,_),y) <- foundMods ++ foundMods' ]
+
hunk ./src/Ho/Build.hs 303
-            r <- newIORef (Left ns)
-            return [ (m,r) | ((m,_),_) <- ns ]
-    let mods = Map.fromList (concat ms)
-    let f m | Just h <- Map.lookup m lmods = hvalid h
-        f m = do
-            rr <- readIORef $ maybe (error $ "toCompUnitGraph: " ++ show m) id (Map.lookup m mods)
+        r <- newIORef (Left ns)
+        return (Map.fromList [ (m,r) | ((m,_),_) <- ns ])
+    let mods = Map.unions ms
+    let f m = do
+            rr <- readIORef (fromJust $ Map.lookup m mods)
hunk ./src/Ho/Build.hs 311
-        g ms@(((m,_),ds):_) = do
+
+        g ms@(((m,Left _),_):_) = do
hunk ./src/Ho/Build.hs 319
-                let cunit = CompSources $ map fs amods
-                modifyIORef cug_ref ((mhash,(deps',cunit)):)
+                modifyIORef cug_ref ((mhash,(deps',CompSources $ map fs amods)):)
hunk ./src/Ho/Build.hs 321
+        g [((mg,Right lib@(Library _ libr mhot mhob)),ds)] = do
+                let Just mgs = Map.lookup mg (hoModuleDeps libr)
+                    Just hob = Map.lookup mg mhob
+                    Just hot = Map.lookup mg mhot
+                    ho = Ho { hoModuleGroup = mg, hoBuild = hob, hoTcInfo = hot }
+                    myHash = libMgHash mg lib
+                deps <- snub `fmap` mapM f ds
+                writeIORef (fromJust $ Map.lookup mg mods) (Right myHash)
+                modifyIORef cug_ref ((myHash,(deps,CompLibrary ho lib)):)
+                return myHash
hunk ./src/Ho/Build.hs 341
-                    let stale = map (show . fst) (hoDepends idep) `intersect` optStale options
-                    good <- catch ( mapM_ cdep (hoDepends idep) >> mapM_ hvalid (hoModDepends idep) >> return True) (\_ -> return False)
-                    if good && null stale then do
-                        putProgressLn $ printf "Fresh: <%s>" fp
-                        modifyIORef cug_ref ((h,(hoModDepends idep,CompHo hoh idep ho)):)
-                        modifyIORef hom_ref (Map.insert h (True,af))
-                        return h
-                     else do
-                        putProgressLn $ if null stale
-                            then printf "Stale: <%s>" fp
-                            else printf "Stale: <%s> (forced)" fp
-                        modifyIORef hom_ref (Map.delete h)
-                        fail "don't know this file"
+                    isGood <- catch ( mapM_ cdep (hoDepends idep) >> mapM_ hvalid (hoModDepends idep) >> return True) (\_ -> return False)
+                    let isStale = not . null $ map (show . fst) (hoDepends idep) `intersect` optStale options
+                        libsGood = all (\ (p,h) -> fmap (libHash) (Map.lookup p (loadedLibraries done)) == Just h) (hohLibDeps hoh)
+                        noGood forced = do
+                            putProgressLn $ printf "Stale: <%s>%s" fp forced
+                            modifyIORef hom_ref (Map.delete h)
+                            fail "stale file"
+                    case (isStale,isGood && libsGood) of
+                        (False,True) -> do
+                            putProgressLn $ printf "Fresh: <%s>" fp
+                            hs <- mapM f (hoModuleGroupNeeds idep)
+                            modifyIORef cug_ref ((h,(hs ++ hoModDepends idep,CompHo hoh idep ho)):)
+                            modifyIORef hom_ref (Map.insert h (True,af))
+                            return h
+                        (True,_) -> noGood " (forced)"
+                        (_,False) -> noGood (show (isGood,libsGood))
hunk ./src/Ho/Build.hs 367
+libHash (Library hoh _ _ _) = hohHash hoh
+libMgHash mg lib = MD5.md5String $ show (libHash lib,mg)
+libProvides mg (Library _ lib _ _) = [ m | (m,mg') <- Map.toList (hoModuleMap lib), mg == mg']
+
hunk ./src/Ho/Build.hs 396
---    forM_ (optHls options) $ \l -> do
---        (n',fn) <- findLibrary l
---        (hoh,_,ho) <- catch (readHoFile fn) $ \_ ->
---            fail $ "Error loading library file: " ++ fn
---        putVerboseLn $ printf "Library: %-15s <%s>" n' fn
---        modifyIORef done_ref (hosEncountered_u $ Map.insert (hohHash hoh) (n',hoh,ho))
---        modifyIORef done_ref (modEncountered_u $ Map.union (Map.fromList [ (m,ModLibrary n' (hohHash hoh)) | m <- providesModules hoh]))
+    forM_ (optHls options) $ \l -> do
+        (n',fn) <- findLibrary l
+        lib@(Library hoh libr _ _)  <- catch (readHlFile fn) $ \_ ->
+            fail $ "Error loading library file: " ++ fn
+        let Right (libName,libVers) = hohName hoh
+        putProgressLn $ printf "Library: %-15s <%s>" n' fn
+        modifyIORef done_ref (modEncountered_u $ Map.union (Map.fromList [ (m,ModLibrary mg lib) | (m,mg) <- Map.toList (hoModuleMap libr) ]))
+        modifyIORef done_ref (loadedLibraries_u $ Map.insert libName lib)
hunk ./src/Ho/Build.hs 411
-    --return (Map.filterWithKey (\k _ -> k `Set.member` validSources done) (knownSourceMap done),needed,cug)
+    --mapM_ print [  (h,hs)| (h,(hs,cu)) <- cug ]
hunk ./src/Ho/Build.hs 484
+                    CompLibrary ho _libr  -> do
+                        let ctc' = hoTcInfo ho `mappend` ctc
+                        writeIORef ref (CompTcCollected ctc' lu)
+                        return ctc'
hunk ./src/Ho/Build.hs 529
-                    cn@(CompHo hoh idep ho) -> do
+                    (CompHo hoh idep ho) -> do
hunk ./src/Ho/Build.hs 531
-                        writeIORef ref (CompCollected cho cn)
+                        writeIORef ref (CompCollected cho cu)
+                        return cho
+                    (CompLibrary ho (Library hoh _ _ _)) -> do
+                        cho <- ifunc cho ho
+                        let Right (ln,_) = hohName hoh
+                            lh = hohHash hoh
+                        writeIORef ref (CompCollected (choLibDeps_u (Map.insert ln lh) cho) cu)
hunk ./src/Ho/Build.hs 540
-                        let hdep = [ h | CompNode h _ _ <- deps]
+                        (hdep,ldep) <- fmap mconcat . forM deps $ \ (CompNode h _ ref) -> do
+                            cl <- readIORef ref
+                            case compLinkCompUnit cl of
+                                CompLibrary ho _ -> return ([],[hoModuleGroup ho])
+                                CompDummy {} -> return ([],[])
+                                _ -> return ([h],[])
hunk ./src/Ho/Build.hs 556
-                                     hohLibDeps   = []
+                                     hohLibDeps   = Map.toList (choLibDeps cho')
hunk ./src/Ho/Build.hs 561
-                                    hoModDepends = hdep
+                                    hoModDepends = hdep,
+                                    hoModuleGroupNeeds = ldep
hunk ./src/Ho/Build.hs 574
-hsModuleRequires x = Module "Jhc.Prim":ans where
+hsModuleRequires x = snub (Module "Jhc.Prim":ans) where
hunk ./src/Ho/Build.hs 576
-    ans = snub $ (if noPrelude then id else  (Module "Prelude":)) [  hsImportDeclModule y | y <- hsModuleImports x]
+    ans = (if noPrelude then id else  (Module "Prelude":)) [  hsImportDeclModule y | y <- hsModuleImports x]
hunk ./src/Ho/Build.hs 656
-        (desc,name,hmods,emods) <- parse fp
+        (desc,name,vers,hmods,emods) <- parse fp
+        vers <- runReadP parseVersion vers
hunk ./src/Ho/Build.hs 660
-        (rnode@(CompNode lhash _ _),_) <- parseFiles (map Left allmods) ifunc func
-        {-
-        (prvds,ho,ldeps) <- let
+        (rnode@(CompNode lhash _ _),cho) <- parseFiles (map Left allmods) ifunc func
+        (_,(mmap,mdeps,prvds,lcor,ldef)) <- let
hunk ./src/Ho/Build.hs 663
-                let g x = case x of
-                    CompLinkLib l -> return l
-                    CompCollected _ y -> g y
-                    CompLinkNone -> return mempty
-
hunk ./src/Ho/Build.hs 664
-                deps <- mconcat `fmap` mapM f cd
-                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
+                case cl of
+                    CompLinkLib l _ -> return l
+                    CompCollected _ y -> g hs cd ref y
+            g hh deps ref cn = do
+                deps <- mapM f deps
+                let (mg,mll) = case cn of
+                        CompDummy -> (error "modgroup of dummy",mempty)
+                        CompLibrary ho lib -> (hoModuleGroup ho,mempty)
+                        CompHo hoh hidep ho -> (mg,(
+                                    Map.fromList $ zip (providesModules hidep) (repeat mg),
+                                    Map.singleton mg (sort $ fsts deps),
+                                    Set.fromList $ providesModules hidep,
+                                    Map.singleton mg (hoBuild ho'),
+                                    Map.singleton mg (hoTcInfo ho')
+                                    )) where
+                                        mg = hoModuleGroup ho
+                                        ho' = mapHoBodies eraseE ho
+                    res = (mg,mconcat (snds deps) `mappend` mll)
+                writeIORef ref (CompLinkLib res cn)
+                return res
hunk ./src/Ho/Build.hs 685
-
--}
-        return ()
-        {-
-
-        (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
hunk ./src/Ho/Build.hs 687
-        let outName = case optOutName options of
-                "hs.out" -> name ++ ".hl"
-                fn -> fn
-        let pdesc = [(n, packString v) | (n,v) <- ("jhc-hl-filename",outName):("jhc-description-file",fp):("jhc-compiled-by",versionString):desc, n /= "exposed-modules" ]
hunk ./src/Ho/Build.hs 689
-                hohDepends = [ (m,MD5.emptyHash) | m <- Set.toList prvds ],
-                hohModDepends = Map.keys ldeps,
-                hohMetaInfo = pdesc
+                hohName = Right (packString name,vers),
+                hohLibDeps = Map.toList (choLibDeps cho),
+                hohArchDeps = [],
+                hohVersion = error "hohVersion"
+                }
+        let outName = case optOutName options of
+                Nothing -> name ++ "-" ++ showVersion vers ++ ".hl"
+                Just fn -> fn
+        let pdesc = [(n, packString v) | (n,v) <- ("jhc-hl-filename",outName):("jhc-description-file",fp):("jhc-compiled-by",versionString):desc, n /= "exposed-modules" ]
+            libr = HoLib {
+                hoMetaInfo = pdesc,
+                hoModuleMap = mmap,
+                hoModuleDeps = mdeps
hunk ./src/Ho/Build.hs 703
-        recordHoFile (mconcat $ Map.elems ho) (HoIDeps Map.empty) [outName] hoh
-        -}
+        putProgressLn $ "Writing Library: " ++ outName
+        recordHlFile (Library hoh libr ldef lcor) outName
hunk ./src/Ho/Build.hs 717
-        return (desc,name ++ "-" ++ vers,hmods,emods)
+        return (desc,name,vers,hmods,emods)
hunk ./src/Ho/Build.hs 729
-{-
-    ans fp = do
-        (desc,name,hmods,emods) <- parse fp
-        let allmods  = sort (emods ++ hmods)
-
-        (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
-        mapM_ ((putStrLn . ("*** Module included in library that is not in export list: " ++)) . show) unknownMods
-        let outName = case optOutName options of
-                "hs.out" -> name ++ ".hl"
-                fn -> fn
-        let pdesc = [(n, packString v) | (n,v) <- ("jhc-hl-filename",outName):("jhc-description-file",fp):("jhc-compiled-by",versionString):desc, n /= "exposed-modules" ]
-        let hoh =  HoHeader {
-                hohHash = lhash,
-                hohDepends = [ (m,MD5.emptyHash) | m <- Set.toList prvds ],
-                hohModDepends = Map.keys ldeps,
-                hohMetaInfo = pdesc
-                }
-        recordHoFile (mconcat $ Map.elems ho) (HoIDeps Map.empty) [outName] hoh
-
--}
hunk ./src/Ho/Build.hs 740
+instance DocLike d => PPrint d Version where
+    pprint sl = text $ showVersion sl
+
+instance DocLike d => PPrint d PackedString where
+    pprint sl = text (unpackPS sl)
hunk ./src/Ho/Build.hs 748
-dumpHoFile fn = do
-    let vindent xs = vcat (map ("    " ++) xs)
-    (hoh,idep,ho) <- readHoFile fn
-    let hoB = hoBuild ho
-        hoE = hoTcInfo ho
-    putStrLn fn
-    putStrLn $ "HoHash:" <+> pprint (hohHash hoh)
-    let showList nm xs = when (not $ null xs) $ putStrLn $ (nm ++ ":\n") <>  vindent xs
-    showList "Dependencies" (map pprint . sortUnder fst $ hoDepends idep)
-    showList "ModDependencies" (map pprint $ hoModDepends idep)
-    showList "IDepCache" (map pprint . sortUnder fst $ Map.toList $ hoIDeps idep)
---    when (not $ Prelude.null (hohMetaInfo hoh)) $ putStrLn $ "MetaInfo:\n" <> vindent (sort [text (' ':' ':k) <> char ':' <+> show v | (k,v) <- hohMetaInfo hoh])
-    putStrLn $ "Modules contained:" <+> tshow (mkeys $ hoExports hoE)
-    putStrLn $ "number of definitions:" <+> tshow (size $ hoDefs hoE)
-    putStrLn $ "hoAssumps:" <+> tshow (size $ hoAssumps hoE)
-    putStrLn $ "hoFixities:" <+> tshow (size $  hoFixities hoE)
-    putStrLn $ "hoKinds:" <+> tshow (size $  hoKinds hoE)
-    putStrLn $ "hoClassHierarchy:" <+> tshow (size $  hoClassHierarchy hoE)
-    putStrLn $ "hoTypeSynonyms:" <+> tshow (size $  hoTypeSynonyms hoE)
-    putStrLn $ "hoDataTable:" <+> tshow (size $  hoDataTable hoB)
-    putStrLn $ "hoEs:" <+> tshow (size $  hoEs hoB)
-    putStrLn $ "hoRules:" <+> tshow (size $  hoRules hoB)
-    wdump FD.Exports $ do
-        putStrLn "---- exports information ----";
-        CharIO.putStrLn $  (pprint $ hoExports hoE :: String)
-    wdump FD.Defs $ do
-        putStrLn "---- defs information ----";
-        CharIO.putStrLn $  (pprint $ hoDefs hoE :: String)
-    when (dump FD.Kind) $ do
-        putStrLn "---- kind information ----";
-        CharIO.putStrLn $  (pprint $ hoKinds hoE :: String)
-    when (dump FD.ClassSummary) $ do
-        putStrLn "---- class summary ---- "
-        printClassSummary (hoClassHierarchy hoE)
-    when (dump FD.Class) $
-         do {putStrLn "---- class hierarchy ---- ";
-             printClassHierarchy (hoClassHierarchy hoE)}
-    let rules = hoRules hoB
-    wdump FD.Rules $ putStrLn "  ---- user rules ---- " >> printRules RuleUser rules
-    wdump FD.Rules $ putStrLn "  ---- user catalysts ---- " >> printRules RuleCatalyst rules
-    wdump FD.RulesSpec $ putStrLn "  ---- specializations ---- " >> printRules RuleSpecialization rules
-    wdump FD.Datatable $ do
-         putStrLn "  ---- data table ---- "
-         putDocM CharIO.putStr (showDataTable (hoDataTable hoB))
-         putChar '\n'
-    wdump FD.Types $ do
-        putStrLn " ---- the types of identifiers ---- "
-        putStrLn $ PPrint.render $ pprint (hoAssumps hoE)
-    wdump FD.Core $ do
-        putStrLn " ---- lambdacube  ---- "
-        mapM_ (\ (v,lc) -> putChar '\n' >> printCheckName'' (hoDataTable hoB) v lc) (hoEs hoB)
-    where
-    printCheckName'' :: DataTable -> TVr -> E -> IO ()
-    printCheckName'' _dataTable tvr e = do
-        when (dump FD.EInfo || verbose2) $ putStrLn (show $ tvrInfo tvr)
-        putStrLn (render $ hang 4 (pprint tvr <+> text "::" <+> pprint (tvrType tvr)))
-        putStrLn (render $ hang 4 (pprint tvr <+> equals <+> pprint e))
+dumpHoFile fn = ans where
+    ans = do
+        putStrLn fn
+        case reverse fn of
+            'l':'h':'.':_ -> doHl fn
+            'o':'h':'.':_ -> doHo fn
+    vindent xs = vcat (map ("    " ++) xs)
+    showList nm xs = when (not $ null xs) $ putStrLn $ (nm ++ ":\n") <>  vindent xs
+    doHoh hoh = do
+        putStrLn $ "Version:" <+> pprint (hohVersion hoh)
+        putStrLn $ "Hash:" <+> pprint (hohHash hoh)
+        putStrLn $ "Name:" <+> pprint (hohName hoh)
+        showList "LibDeps" (map pprint . sortUnder fst $ hohLibDeps hoh)
+        showList "ArchDeps" (map pprint . sortUnder fst $ hohArchDeps hoh)
+
+    doHl fn = do
+        Library hoh libr mhob mhot <- readHlFile fn
+        doHoh hoh
+        showList "MetaInfo" (sort [text k <> char ':' <+> show v | (k,v) <- hoMetaInfo libr])
+        showList "ModuleMap" (map pprint . sortUnder fst $ Map.toList $ hoModuleMap libr)
+        showList "ModuleDeps" (map pprint . sortUnder fst $ Map.toList $ hoModuleDeps libr)
+
+    doHo fn = do
+        (hoh,idep,ho) <- readHoFile fn
+        doHoh hoh
+        let hoB = hoBuild ho
+            hoE = hoTcInfo ho
+        showList "Dependencies" (map pprint . sortUnder fst $ hoDepends idep)
+        showList "ModDependencies" (map pprint $ hoModDepends idep)
+        showList "IDepCache" (map pprint . sortUnder fst $ Map.toList $ hoIDeps idep)
+    --    when (not $ Prelude.null (hohMetaInfo hoh)) $ putStrLn $ "MetaInfo:\n" <> vindent (sort [text (' ':' ':k) <> char ':' <+> show v | (k,v) <- hohMetaInfo hoh])
+        putStrLn $ "Modules contained:" <+> tshow (mkeys $ hoExports hoE)
+        putStrLn $ "number of definitions:" <+> tshow (size $ hoDefs hoE)
+        putStrLn $ "hoAssumps:" <+> tshow (size $ hoAssumps hoE)
+        putStrLn $ "hoFixities:" <+> tshow (size $  hoFixities hoE)
+        putStrLn $ "hoKinds:" <+> tshow (size $  hoKinds hoE)
+        putStrLn $ "hoClassHierarchy:" <+> tshow (size $  hoClassHierarchy hoE)
+        putStrLn $ "hoTypeSynonyms:" <+> tshow (size $  hoTypeSynonyms hoE)
+        putStrLn $ "hoDataTable:" <+> tshow (size $  hoDataTable hoB)
+        putStrLn $ "hoEs:" <+> tshow (size $  hoEs hoB)
+        putStrLn $ "hoRules:" <+> tshow (size $  hoRules hoB)
+        wdump FD.Exports $ do
+            putStrLn "---- exports information ----";
+            CharIO.putStrLn $  (pprint $ hoExports hoE :: String)
+        wdump FD.Defs $ do
+            putStrLn "---- defs information ----";
+            CharIO.putStrLn $  (pprint $ hoDefs hoE :: String)
+        when (dump FD.Kind) $ do
+            putStrLn "---- kind information ----";
+            CharIO.putStrLn $  (pprint $ hoKinds hoE :: String)
+        when (dump FD.ClassSummary) $ do
+            putStrLn "---- class summary ---- "
+            printClassSummary (hoClassHierarchy hoE)
+        when (dump FD.Class) $
+             do {putStrLn "---- class hierarchy ---- ";
+                 printClassHierarchy (hoClassHierarchy hoE)}
+        let rules = hoRules hoB
+        wdump FD.Rules $ putStrLn "  ---- user rules ---- " >> printRules RuleUser rules
+        wdump FD.Rules $ putStrLn "  ---- user catalysts ---- " >> printRules RuleCatalyst rules
+        wdump FD.RulesSpec $ putStrLn "  ---- specializations ---- " >> printRules RuleSpecialization rules
+        wdump FD.Datatable $ do
+             putStrLn "  ---- data table ---- "
+             putDocM CharIO.putStr (showDataTable (hoDataTable hoB))
+             putChar '\n'
+        wdump FD.Types $ do
+            putStrLn " ---- the types of identifiers ---- "
+            putStrLn $ PPrint.render $ pprint (hoAssumps hoE)
+        wdump FD.Core $ do
+            putStrLn " ---- lambdacube  ---- "
+            mapM_ (\ (v,lc) -> putChar '\n' >> printCheckName'' (hoDataTable hoB) v lc) (hoEs hoB)
+        where
+        printCheckName'' :: DataTable -> TVr -> E -> IO ()
+        printCheckName'' _dataTable tvr e = do
+            when (dump FD.EInfo || verbose2) $ putStrLn (show $ tvrInfo tvr)
+            putStrLn (render $ hang 4 (pprint tvr <+> text "::" <+> pprint (tvrType tvr)))
+            putStrLn (render $ hang 4 (pprint tvr <+> equals <+> pprint e))
hunk ./src/Ho/Collected.hs 43
-        choVarMap = mempty
+        choVarMap = mempty,
+        choLibDeps = mempty
hunk ./src/Ho/Collected.hs 51
+        choLibDeps = choLibDeps a `mappend` choLibDeps b,
hunk ./src/Ho/Type.hs 63
-    -- this is a cache
-    choHo :: Ho,
-    choHoMap :: Map.Map ModuleGroup Ho
+    choHo :: Ho, -- this is a cache, it must be updated whenever choHoMap is updated.
+    choHoMap :: Map.Map ModuleGroup Ho,
+    -- libraries depended on
+    choLibDeps :: Map.Map PackedString HoHash
hunk ./src/Ho/Type.hs 97
-    hoModDepends :: [HoHash]
+    hoModDepends :: [HoHash],
+    -- * library module groups needed
+    hoModuleGroupNeeds :: [ModuleGroup]
hunk ./src/Ho/Type.hs 112
+instance Show Library where
+    showsPrec n (Library hoh _ _ _) = showsPrec n (hohHash hoh)
+
hunk ./src/Main.hs 97
-    progressM $ do
+    let darg = progressM $ do
hunk ./src/Main.hs 101
-        BuildHl hl    -> buildLibrary processInitialHo processDecls hl
+        BuildHl hl    -> darg >> buildLibrary processInitialHo processDecls hl
hunk ./src/Main.hs 113
-        _               -> processFiles  (optArgs o)
+        _               -> darg >> processFiles  (optArgs o)
hunk ./src/Util/Gen.hs 12
+import Text.ParserCombinators.ReadP
hunk ./src/Util/Gen.hs 21
+runReadP :: Monad m => ReadP a -> String -> m a
+runReadP rp s = case [ x | (x,t) <- readP_to_S rp s, ("","") <- lex t] of
+    [x] -> return x
+    []  -> fail "runReadP: no parse"
+    _   -> fail "runReadP: ambiguous parse"