isSourceFilename -- :: FilePath -> Bool
) where
-import Util ( suffixOf )
+#include "HsVersions.h"
+
import Panic ( panic )
+import System.FilePath
-----------------------------------------------------------------------------
-- Phases
isHsBoot :: HscSource -> Bool
isHsBoot HsBootFile = True
-isHsBoot other = False
+isHsBoot _ = False
data Phase
= Unlit HscSource
| Cpp HscSource
| HsPp HscSource
| Hsc HscSource
+ | Ccpp
| Cc
| HCc -- Haskellised C (as opposed to vanilla C) compilation
| Mangle -- assembly mangling, now done by a separate script.
isStopLn :: Phase -> Bool
isStopLn StopLn = True
-isStopLn other = False
+isStopLn _ = False
eqPhase :: Phase -> Phase -> Bool
-- Equality of constructors, ignoring the HscSource field
eqPhase (Cpp _) (Cpp _) = True
eqPhase (HsPp _) (HsPp _) = True
eqPhase (Hsc _) (Hsc _) = True
+eqPhase Ccpp Ccpp = True
eqPhase Cc Cc = True
eqPhase HCc HCc = True
eqPhase Mangle Mangle = True
-- Partial ordering on phases: we want to know which phases will occur before
-- which others. This is used for sanity checking, to ensure that the
-- pipeline will stop at some point (see DriverPipeline.runPipeline).
-StopLn `happensBefore` y = False
+happensBefore :: Phase -> Phase -> Bool
+StopLn `happensBefore` _ = False
x `happensBefore` y = after_x `eqPhase` y || after_x `happensBefore` y
where
after_x = nextPhase x
nextPhase (Unlit sf) = Cpp sf
nextPhase (Cpp sf) = HsPp sf
nextPhase (HsPp sf) = Hsc sf
-nextPhase (Hsc sf) = HCc
+nextPhase (Hsc _) = HCc
nextPhase HCc = Mangle
nextPhase Mangle = SplitMangle
nextPhase SplitMangle = As
nextPhase As = SplitAs
nextPhase SplitAs = StopLn
+nextPhase Ccpp = As
nextPhase Cc = As
nextPhase CmmCpp = Cmm
nextPhase Cmm = HCc
-- the first compilation phase for a given file is determined
-- by its suffix.
+startPhase :: String -> Phase
startPhase "lhs" = Unlit HsSrcFile
startPhase "lhs-boot" = Unlit HsBootFile
startPhase "hs" = Cpp HsSrcFile
startPhase "hcr" = Hsc ExtCoreFile
startPhase "hc" = HCc
startPhase "c" = Cc
-startPhase "cpp" = Cc
+startPhase "cpp" = Ccpp
startPhase "C" = Cc
-startPhase "cc" = Cc
-startPhase "cxx" = Cc
+startPhase "cc" = Ccpp
+startPhase "cxx" = Ccpp
startPhase "raw_s" = Mangle
startPhase "split_s" = SplitMangle
startPhase "s" = As
-- This is used to determine the extension for the output from the
-- current phase (if it generates a new file). The extension depends
-- on the next phase in the pipeline.
+phaseInputExt :: Phase -> String
phaseInputExt (Unlit HsSrcFile) = "lhs"
phaseInputExt (Unlit HsBootFile) = "lhs-boot"
phaseInputExt (Unlit ExtCoreFile) = "lhcr"
-- because runPipeline uses the StopBefore phase to pick the
-- output filename. That could be fixed, but watch out.
phaseInputExt HCc = "hc"
+phaseInputExt Ccpp = "cpp"
phaseInputExt Cc = "c"
phaseInputExt Mangle = "raw_s"
phaseInputExt SplitMangle = "split_s" -- not really generated
phaseInputExt CmmCpp = "cmm"
phaseInputExt Cmm = "cmmcpp"
phaseInputExt StopLn = "o"
-#ifdef ILX
-phaseInputExt Ilx2Il = "ilx"
-phaseInputExt Ilasm = "il"
-#endif
+haskellish_src_suffixes, haskellish_suffixes, cish_suffixes,
+ extcoreish_suffixes, haskellish_user_src_suffixes
+ :: [String]
haskellish_src_suffixes = haskellish_user_src_suffixes ++
- [ "hspp", "hscpp", "hcr", "cmm" ]
+ [ "hspp", "hscpp", "hcr", "cmm" ]
haskellish_suffixes = haskellish_src_suffixes ++ ["hc", "raw_s"]
cish_suffixes = [ "c", "cpp", "C", "cc", "cxx", "s", "S" ]
extcoreish_suffixes = [ "hcr" ]
-haskellish_user_src_suffixes = [ "hs", "lhs", "hs-boot", "lhs-boot" ] -- Will not be deleted as temp files
+-- Will not be deleted as temp files:
+haskellish_user_src_suffixes = [ "hs", "lhs", "hs-boot", "lhs-boot" ]
--- Use the appropriate suffix for the system on which
+objish_suffixes :: [String]
+-- Use the appropriate suffix for the system on which
-- the GHC-compiled code will run
#if mingw32_TARGET_OS || cygwin32_TARGET_OS
objish_suffixes = [ "o", "O", "obj", "OBJ" ]
objish_suffixes = [ "o" ]
#endif
+dynlib_suffixes :: [String]
#ifdef mingw32_TARGET_OS
dynlib_suffixes = ["dll", "DLL"]
#elif defined(darwin_TARGET_OS)
dynlib_suffixes = ["so"]
#endif
+isHaskellishSuffix, isHaskellSrcSuffix, isCishSuffix, isExtCoreSuffix,
+ isObjectSuffix, isHaskellUserSrcSuffix, isDynLibSuffix
+ :: String -> Bool
isHaskellishSuffix s = s `elem` haskellish_suffixes
isHaskellSrcSuffix s = s `elem` haskellish_src_suffixes
isCishSuffix s = s `elem` cish_suffixes
isExtCoreSuffix s = s `elem` extcoreish_suffixes
isObjectSuffix s = s `elem` objish_suffixes
isHaskellUserSrcSuffix s = s `elem` haskellish_user_src_suffixes
-isDynLibSuffix s = s `elem` dynlib_suffixes
+isDynLibSuffix s = s `elem` dynlib_suffixes
+isSourceSuffix :: String -> Bool
isSourceSuffix suff = isHaskellishSuffix suff || isCishSuffix suff
-isHaskellishFilename f = isHaskellishSuffix (suffixOf f)
-isHaskellSrcFilename f = isHaskellSrcSuffix (suffixOf f)
-isCishFilename f = isCishSuffix (suffixOf f)
-isExtCoreFilename f = isExtCoreSuffix (suffixOf f)
-isObjectFilename f = isObjectSuffix (suffixOf f)
-isHaskellUserSrcFilename f = isHaskellUserSrcSuffix (suffixOf f)
-isDynLibFilename f = isDynLibSuffix (suffixOf f)
-isSourceFilename f = isSourceSuffix (suffixOf f)
+isHaskellishFilename, isHaskellSrcFilename, isCishFilename,
+ isExtCoreFilename, isObjectFilename, isHaskellUserSrcFilename,
+ isDynLibFilename, isSourceFilename
+ :: FilePath -> Bool
+-- takeExtension return .foo, so we drop 1 to get rid of the .
+isHaskellishFilename f = isHaskellishSuffix (drop 1 $ takeExtension f)
+isHaskellSrcFilename f = isHaskellSrcSuffix (drop 1 $ takeExtension f)
+isCishFilename f = isCishSuffix (drop 1 $ takeExtension f)
+isExtCoreFilename f = isExtCoreSuffix (drop 1 $ takeExtension f)
+isObjectFilename f = isObjectSuffix (drop 1 $ takeExtension f)
+isHaskellUserSrcFilename f = isHaskellUserSrcSuffix (drop 1 $ takeExtension f)
+isDynLibFilename f = isDynLibSuffix (drop 1 $ takeExtension f)
+isSourceFilename f = isSourceSuffix (drop 1 $ takeExtension f)
projects / ghc-hetmet.git / blobdiff