clean up ModFile module, expose decodeModFiles

Author: raehik

CHANGELOG.md

@@ -6,6 +6,8 @@
     * The Happy parsers have fewer dependencies, so should no longer require a
       recompile due to apparently unrelated changes.
   * Remove some deprecated shims (from the restructured modules).
+  * Merge fortran-src-extras `Language.Fortran.Extras.ModFiles.Extras` module
+    into `Language.Fortran.Util.ModFile`.
 
 ### 0.8.0 (Jan 04, 2022)
   * Merge declarator constructors. Now you differentiate between array and

app/Main.hs

@@ -66,7 +66,7 @@ main = do
       -- Build the graph of module dependencies
       mg0 <- genModGraph mvers (includeDirs opts) paths'
       -- Start the list of mods with those from the command line
-      mods0 <- decodeModFiles $ includeDirs opts
+      mods0 <- decodeModFiles' $ includeDirs opts
       -- Loop through the dependency graph until it is empty
       let loop mg mods
             | nxt <- takeNextMods mg
@@ -98,11 +98,11 @@ main = do
         Just f  -> LB.writeFile f $ encodeModFile allMods
 
     (paths, Compile) -> do
-      mods <- decodeModFiles $ includeDirs opts
+      mods <- decodeModFiles' $ includeDirs opts
       mapM_ (\ p -> compileFileToMod (fortranVersion opts) mods p (outputFile opts)) paths
     (path:_, actionOpt) -> do
       contents <- flexReadFile path
-      mods <- decodeModFiles $ includeDirs opts
+      mods <- decodeModFiles' $ includeDirs opts
       let version   = fromMaybe (deduceFortranVersion path) (fortranVersion opts)
           parsedPF  = fromRight' $ (Parser.byVerWithMods mods version) path contents
           outfmt    = outputFormat opts
@@ -250,13 +250,6 @@ compileFileToMod mvers mods path moutfile = do
   LB.writeFile fspath $ encodeModFile [mod]
   return mod
 
-decodeModFiles :: [String] -> IO ModFiles
-decodeModFiles = flip foldM emptyModFiles $ \ modFiles d -> do
-  -- Figure out the camfort mod files and parse them.
-  modFileNames <- filter isModFile `fmap` getDirContents d
-  addedModFiles <- concat <$> mapM (decodeOneModFile . (d </>)) modFileNames
-  return $ addedModFiles ++ modFiles
-
 decodeOneModFile :: FilePath -> IO ModFiles
 decodeOneModFile path = do
   contents <- LB.readFile path
@@ -268,9 +261,7 @@ decodeOneModFile path = do
       hPutStrLn stderr $ path ++ ": successfully parsed summary file."
       return modFiles
 
-isModFile :: FilePath -> Bool
-isModFile = (== modFileSuffix) . takeExtension
-
+-- TODO almost replicated at Analysis.DataFlow.showDataFlow
 superGraphDataFlow :: forall a. (Out a, Data a) => ProgramFile (Analysis a) -> SuperBBGr (Analysis a) -> String
 superGraphDataFlow pf sgr = showBBGr (bbgrMap (nmap (map (fmap insLabel))) gr') ++ "\n\n" ++ replicate 50 '-' ++ "\n\n" ++
                             show entries ++ "\n\n" ++ replicate 50 '-' ++ "\n\n" ++

src/Language/Fortran/Analysis/ModGraph.hs

@@ -19,10 +19,7 @@ import Data.Generics.Uniplate.Data
 import Data.Graph.Inductive hiding (version)
 import Data.Maybe
 import Data.Either.Combinators ( fromRight' )
-import qualified Data.ByteString.Lazy.Char8 as LB
 import qualified Data.Map as M
-import System.IO
-import System.FilePath
 
 --------------------------------------------------
 
@@ -124,24 +121,3 @@ delModNodes :: [Node] -> ModGraph -> ModGraph
 delModNodes ns mg@ModGraph { mgGraph = gr } = mg'
   where
     mg' = mg { mgGraph = delNodes ns gr }
-
---------------------------------------------------
-
-decodeModFiles :: [FilePath] -> IO [(FilePath, ModFile)]
-decodeModFiles = foldM (\ modFiles d -> do
-      -- Figure out the camfort mod files and parse them.
-      modFileNames <- filter isModFile `fmap` getDirContents d
-      addedModFiles <- fmap concat . forM modFileNames $ \ modFileName -> do
-        contents <- LB.readFile (d </> modFileName)
-        case decodeModFile contents of
-          Left msg -> do
-            hPutStrLn stderr $ modFileName ++ ": Error: " ++ msg
-            return [(modFileName, emptyModFile)]
-          Right mods -> do
-            hPutStrLn stderr $ modFileName ++ ": successfully parsed precompiled file."
-            return $ map (modFileName,) mods
-      return $ addedModFiles ++ modFiles
-    ) [] -- can't use emptyModFiles
-
-isModFile :: FilePath -> Bool
-isModFile = (== modFileSuffix) . takeExtension

src/Language/Fortran/Util/ModFile.hs

@@ -42,14 +42,35 @@ One typical usage might look like:
 -}
 
 module Language.Fortran.Util.ModFile
-  ( modFileSuffix, ModFile, ModFiles, emptyModFile, emptyModFiles
-  , lookupModFileData, getLabelsModFileData, alterModFileData -- , alterModFileDataF
-  , genModFile, regenModFile, encodeModFile, decodeModFile
-  , StringMap, DeclMap, ParamVarMap, DeclContext(..), extractModuleMap, extractDeclMap
-  , moduleFilename, combinedStringMap, combinedDeclMap, combinedModuleMap, combinedTypeEnv, combinedParamVarMap
+  (
+  -- * Main defitions
+    ModFile, ModFiles, emptyModFile, emptyModFiles, modFileSuffix
+  , lookupModFileData, getLabelsModFileData, alterModFileData, alterModFileDataF
+
+  -- * Creation
+  , genModFile, regenModFile
+
+  -- * En/decoding
+  , encodeModFile, decodeModFile, decodeModFiles, decodeModFiles'
+
+  -- * Operations
+  , moduleFilename
+  , StringMap, extractStringMap, combinedStringMap
+  , DeclContext(..), DeclMap, extractDeclMap, combinedDeclMap
+  , extractModuleMap, combinedModuleMap, combinedTypeEnv
+  , ParamVarMap, extractParamVarMap, combinedParamVarMap
   , genUniqNameToFilenameMap
-  , TimestampStatus(..), checkTimestamps )
-where
+  , TimestampStatus(..), checkTimestamps
+  ) where
+
+import qualified Language.Fortran.AST               as F
+import qualified Language.Fortran.Analysis          as FA
+import qualified Language.Fortran.Analysis.BBlocks  as FAB
+import qualified Language.Fortran.Analysis.DataFlow as FAD
+import qualified Language.Fortran.Analysis.Renaming as FAR
+import qualified Language.Fortran.Analysis.Types    as FAT
+import qualified Language.Fortran.Util.Position     as P
+import           Language.Fortran.Util.Files ( getDirContents )
 
 import Control.Monad.State
 import Data.Binary (Binary, encode, decodeOrFail)
@@ -59,22 +80,22 @@ import Data.Generics.Uniplate.Operations
 import qualified Data.Map.Strict as M
 import Data.Maybe
 import GHC.Generics (Generic)
-import qualified Language.Fortran.AST as F
-import qualified Language.Fortran.Analysis as FA
-import qualified Language.Fortran.Analysis.BBlocks as FAB
-import qualified Language.Fortran.Analysis.DataFlow as FAD
-import qualified Language.Fortran.Analysis.Renaming as FAR
-import qualified Language.Fortran.Analysis.Types as FAT
-import qualified Language.Fortran.Util.Position as P
-import System.Directory
-import System.FilePath
+import System.Directory ( doesFileExist, getModificationTime )
+import qualified System.FilePath
+import System.FilePath ( (-<.>), (</>) )
+import System.IO ( hPutStrLn, stderr )
 
 --------------------------------------------------
 
 -- | Standard ending of fortran-src-format "mod files"
 modFileSuffix :: String
 modFileSuffix = ".fsmod"
 
+-- | Returns 'true' for filepaths with an extension that identifies them as a
+--   mod file.
+isModFile :: FilePath -> Bool
+isModFile = System.FilePath.isExtensionOf modFileSuffix
+
 -- | Context of a declaration: the ProgramUnit where it was declared.
 data DeclContext = DCMain | DCBlockData | DCModule F.ProgramUnitName
                  | DCFunction (F.ProgramUnitName, F.ProgramUnitName)    -- ^ (uniqName, srcName)
@@ -149,9 +170,12 @@ getLabelsModFileData = M.keys . mfOtherData
 alterModFileData :: (Maybe LB.ByteString -> Maybe LB.ByteString) -> String -> ModFile -> ModFile
 alterModFileData f k mf = mf { mfOtherData = M.alter f k . mfOtherData $ mf }
 
--- For when stackage gets containers-0.5.8.1:
--- alterModFileDataF :: Functor f => (Maybe B.ByteString -> f (Maybe B.ByteString)) -> String -> ModFile -> f ModFile
--- alterModFileDataF f k mf = (\ od -> mf { mfOtherData = od }) <$> M.alterF f k (mfOtherData mf)
+alterModFileDataF
+    :: Functor f
+    => (Maybe LB.ByteString -> f (Maybe LB.ByteString)) -> String -> ModFile
+    -> f ModFile
+alterModFileDataF f k mf =
+    (\od -> mf { mfOtherData = od }) <$> M.alterF f k (mfOtherData mf)
 
 -- | Convert ModFiles to a strict ByteString for writing to file.
 encodeModFile :: [ModFile] -> LB.ByteString
@@ -171,6 +195,25 @@ decodeModFile bs = case decodeOrFail bs of
       each mf = (revertStringMap sm mf { mfStringMap = M.empty }) { mfStringMap = sm }
         where sm = mfStringMap mf
 
+decodeModFiles :: [FilePath] -> IO [(FilePath, ModFile)]
+decodeModFiles = foldM (\ modFiles d -> do
+      -- Figure out the camfort mod files and parse them.
+      modFileNames <- filter isModFile `fmap` getDirContents d
+      addedModFiles <- fmap concat . forM modFileNames $ \ modFileName -> do
+        contents <- LB.readFile (d </> modFileName)
+        case decodeModFile contents of
+          Left msg -> do
+            hPutStrLn stderr $ modFileName ++ ": Error: " ++ msg
+            return [(modFileName, emptyModFile)]
+          Right mods -> do
+            hPutStrLn stderr $ modFileName ++ ": successfully parsed precompiled file."
+            return $ map (modFileName,) mods
+      return $ addedModFiles ++ modFiles
+    ) [] -- can't use emptyModFiles
+
+decodeModFiles' :: [FilePath] -> IO ModFiles
+decodeModFiles' = fmap (map snd) . decodeModFiles
+
 -- | Extract the combined module map from a set of ModFiles. Useful
 -- for parsing a Fortran file in a large context of other modules.
 combinedModuleMap :: ModFiles -> FAR.ModuleMap