Commit 1c198086 authored by Ian Lynagh's avatar Ian Lynagh

Make the --info values printable with "ghc --print-foo"; trac #3122

Also, libdir is now part of the --info output, so this subsumes the old
--print-libdir flag.
The mode parsing was getting rather adhoc, so I've tidied it up a bit
in the process.
parent 36dfa351
...@@ -57,6 +57,7 @@ module DynFlags ( ...@@ -57,6 +57,7 @@ module DynFlags (
getStgToDo, getStgToDo,
-- * Compiler configuration suitable for display to the user -- * Compiler configuration suitable for display to the user
Printable(..),
compilerInfo compilerInfo
) where ) where
...@@ -2350,21 +2351,25 @@ can_split = cSplitObjs == "YES" ...@@ -2350,21 +2351,25 @@ can_split = cSplitObjs == "YES"
-- ----------------------------------------------------------------------------- -- -----------------------------------------------------------------------------
-- Compiler Info -- Compiler Info
compilerInfo :: [(String, String)] data Printable = String String
compilerInfo = [("Project name", cProjectName), | FromDynFlags (DynFlags -> String)
("Project version", cProjectVersion),
("Booter version", cBooterVersion), compilerInfo :: [(String, Printable)]
("Stage", cStage), compilerInfo = [("Project name", String cProjectName),
("Interface file version", cHscIfaceFileVersion), ("Project version", String cProjectVersion),
("Have interpreter", cGhcWithInterpreter), ("Booter version", String cBooterVersion),
("Object splitting", cSplitObjs), ("Stage", String cStage),
("Have native code generator", cGhcWithNativeCodeGen), ("Interface file version", String cHscIfaceFileVersion),
("Support SMP", cGhcWithSMP), ("Have interpreter", String cGhcWithInterpreter),
("Unregisterised", cGhcUnregisterised), ("Object splitting", String cSplitObjs),
("Tables next to code", cGhcEnableTablesNextToCode), ("Have native code generator", String cGhcWithNativeCodeGen),
("Win32 DLLs", cEnableWin32DLLs), ("Support SMP", String cGhcWithSMP),
("RTS ways", cGhcRTSWays), ("Unregisterised", String cGhcUnregisterised),
("Leading underscore", cLeadingUnderscore), ("Tables next to code", String cGhcEnableTablesNextToCode),
("Debug on", show debugIsOn) ("Win32 DLLs", String cEnableWin32DLLs),
("RTS ways", String cGhcRTSWays),
("Leading underscore", String cLeadingUnderscore),
("Debug on", String (show debugIsOn)),
("LibDir", FromDynFlags topDir)
] ]
...@@ -51,6 +51,7 @@ import System.Environment ...@@ -51,6 +51,7 @@ import System.Environment
import System.Exit import System.Exit
import System.FilePath import System.FilePath
import Control.Monad import Control.Monad
import Data.Char
import Data.List import Data.List
import Data.Maybe import Data.Maybe
...@@ -68,100 +69,102 @@ import Data.Maybe ...@@ -68,100 +69,102 @@ import Data.Maybe
main :: IO () main :: IO ()
main = main =
GHC.defaultErrorHandler defaultDynFlags $ do
GHC.defaultErrorHandler defaultDynFlags $ do -- 1. extract the -B flag from the args
-- 1. extract the -B flag from the args argv0 <- getArgs
argv0 <- getArgs
let let (minusB_args, argv1) = partition ("-B" `isPrefixOf`) argv0
(minusB_args, argv1) = partition ("-B" `isPrefixOf`) argv0
mbMinusB | null minusB_args = Nothing mbMinusB | null minusB_args = Nothing
| otherwise = Just (drop 2 (last minusB_args)) | otherwise = Just (drop 2 (last minusB_args))
let argv1' = map (mkGeneralLocated "on the commandline") argv1 let argv1' = map (mkGeneralLocated "on the commandline") argv1
(argv2, staticFlagWarnings) <- parseStaticFlags argv1' (argv2, staticFlagWarnings) <- parseStaticFlags argv1'
-- 2. Parse the "mode" flags (--make, --interactive etc.) -- 2. Parse the "mode" flags (--make, --interactive etc.)
(m_uber_mode, cli_mode, argv3, modeFlagWarnings) <- parseModeFlags argv2 (mode, argv3, modeFlagWarnings) <- parseModeFlags argv2
-- If all we want to do is to show the version number then do it let flagWarnings = staticFlagWarnings ++ modeFlagWarnings
-- now, before we start a GHC session etc.
-- If we do it later then bootstrapping gets confused as it tries -- If all we want to do is something like showing the version number
-- to find out what version of GHC it's using before package.conf -- then do it now, before we start a GHC session etc. This makes
-- exists, so starting the session fails. -- getting basic information much more resilient.
case m_uber_mode of
-- ShowUsage currently has to be handled specially, as it needs to -- In particular, if we wait until later before giving the version
-- actually start up GHC so that it can find the usage.txt files -- number then bootstrapping gets confused, as it tries to find out
-- in the libdir. It would be nice to embed the text in the -- what version of GHC it's using before package.conf exists, so
-- executable so that we don't have to do that, and things are more -- starting the session fails.
-- uniform here. case mode of
Just ShowUsage -> return () Left preStartupMode ->
Just um -> do case preStartupMode of
do case um of ShowSupportedLanguages -> showSupportedLanguages
ShowInfo -> showInfo ShowVersion -> showVersion
ShowSupportedLanguages -> showSupportedLanguages ShowNumVersion -> putStrLn cProjectVersion
ShowVersion -> showVersion Print str -> putStrLn str
ShowNumVersion -> putStrLn cProjectVersion Right postStartupMode ->
exitWith ExitSuccess -- start our GHC session
Nothing -> return () GHC.runGhc mbMinusB $ do
-- start our GHC session dflags <- GHC.getSessionDynFlags
GHC.runGhc mbMinusB $ do
case postStartupMode of
dflags0 <- GHC.getSessionDynFlags Left preLoadMode ->
liftIO $ do
case preLoadMode of
ShowInfo -> showInfo dflags
ShowGhcUsage -> showGhcUsage dflags
ShowGhciUsage -> showGhciUsage dflags
PrintWithDynFlags f -> putStrLn (f dflags)
Right postLoadMode ->
main' postLoadMode dflags argv3 flagWarnings
main' :: PostLoadMode -> DynFlags -> [Located String] -> [Located String]
-> Ghc ()
main' postLoadMode dflags0 args flagWarnings = do
-- set the default GhcMode, HscTarget and GhcLink. The HscTarget -- set the default GhcMode, HscTarget and GhcLink. The HscTarget
-- can be further adjusted on a module by module basis, using only -- can be further adjusted on a module by module basis, using only
-- the -fvia-C and -fasm flags. If the default HscTarget is not -- the -fvia-C and -fasm flags. If the default HscTarget is not
-- HscC or HscAsm, -fvia-C and -fasm have no effect. -- HscC or HscAsm, -fvia-C and -fasm have no effect.
let dflt_target = hscTarget dflags0 let dflt_target = hscTarget dflags0
(mode, lang, link) (mode, lang, link)
= case cli_mode of = case postLoadMode of
DoInteractive -> (CompManager, HscInterpreted, LinkInMemory) DoInteractive -> (CompManager, HscInterpreted, LinkInMemory)
DoEval _ -> (CompManager, HscInterpreted, LinkInMemory) DoEval _ -> (CompManager, HscInterpreted, LinkInMemory)
DoMake -> (CompManager, dflt_target, LinkBinary) DoMake -> (CompManager, dflt_target, LinkBinary)
DoMkDependHS -> (MkDepend, dflt_target, LinkBinary) DoMkDependHS -> (MkDepend, dflt_target, LinkBinary)
_ -> (OneShot, dflt_target, LinkBinary) _ -> (OneShot, dflt_target, LinkBinary)
let dflags1 = dflags0{ ghcMode = mode, let dflags1 = dflags0{ ghcMode = mode,
hscTarget = lang, hscTarget = lang,
ghcLink = link, ghcLink = link,
-- leave out hscOutName for now -- leave out hscOutName for now
hscOutName = panic "Main.main:hscOutName not set", hscOutName = panic "Main.main:hscOutName not set",
verbosity = case cli_mode of verbosity = case postLoadMode of
DoEval _ -> 0 DoEval _ -> 0
_other -> 1 _other -> 1
} }
-- turn on -fimplicit-import-qualified for GHCi now, so that it -- turn on -fimplicit-import-qualified for GHCi now, so that it
-- can be overriden from the command-line -- can be overriden from the command-line
dflags1a | DoInteractive <- cli_mode = imp_qual_enabled dflags1a | DoInteractive <- postLoadMode = imp_qual_enabled
| DoEval _ <- cli_mode = imp_qual_enabled | DoEval _ <- postLoadMode = imp_qual_enabled
| otherwise = dflags1 | otherwise = dflags1
where imp_qual_enabled = dflags1 `dopt_set` Opt_ImplicitImportQualified where imp_qual_enabled = dflags1 `dopt_set` Opt_ImplicitImportQualified
-- The rest of the arguments are "dynamic" -- The rest of the arguments are "dynamic"
-- Leftover ones are presumably files -- Leftover ones are presumably files
(dflags2, fileish_args, dynamicFlagWarnings) <- GHC.parseDynamicFlags dflags1a argv3 (dflags2, fileish_args, dynamicFlagWarnings) <- GHC.parseDynamicFlags dflags1a args
-- As noted earlier, currently we hvae to handle ShowUsage down here let flagWarnings' = flagWarnings ++ dynamicFlagWarnings
case m_uber_mode of
Just ShowUsage -> liftIO $ showGhcUsage dflags2 cli_mode
_ -> return ()
let flagWarnings = staticFlagWarnings
++ modeFlagWarnings
++ dynamicFlagWarnings
handleSourceError (\e -> do handleSourceError (\e -> do
GHC.printExceptionAndWarnings e GHC.printExceptionAndWarnings e
liftIO $ exitWith (ExitFailure 1)) $ liftIO $ exitWith (ExitFailure 1)) $
handleFlagWarnings dflags2 flagWarnings handleFlagWarnings dflags2 flagWarnings'
-- make sure we clean up after ourselves -- make sure we clean up after ourselves
GHC.defaultCleanupHandler dflags2 $ do GHC.defaultCleanupHandler dflags2 $ do
liftIO $ showBanner cli_mode dflags2 liftIO $ showBanner postLoadMode dflags2
-- we've finished manipulating the DynFlags, update the session -- we've finished manipulating the DynFlags, update the session
_ <- GHC.setSessionDynFlags dflags2 _ <- GHC.setSessionDynFlags dflags2
...@@ -187,14 +190,13 @@ main = ...@@ -187,14 +190,13 @@ main =
liftIO $ hPutStrLn stderr ("Hsc static flags: " ++ unwords staticFlags) liftIO $ hPutStrLn stderr ("Hsc static flags: " ++ unwords staticFlags)
---------------- Final sanity checking ----------- ---------------- Final sanity checking -----------
liftIO $ checkOptions cli_mode dflags3 srcs objs liftIO $ checkOptions postLoadMode dflags3 srcs objs
---------------- Do the business ----------- ---------------- Do the business -----------
handleSourceError (\e -> do handleSourceError (\e -> do
GHC.printExceptionAndWarnings e GHC.printExceptionAndWarnings e
liftIO $ exitWith (ExitFailure 1)) $ do liftIO $ exitWith (ExitFailure 1)) $ do
case cli_mode of case postLoadMode of
PrintLibdir -> liftIO $ putStrLn (topDir dflags3)
ShowInterface f -> liftIO $ doShowIface dflags3 f ShowInterface f -> liftIO $ doShowIface dflags3 f
DoMake -> doMake srcs DoMake -> doMake srcs
DoMkDependHS -> doMkDependHS (map fst srcs) DoMkDependHS -> doMkDependHS (map fst srcs)
...@@ -203,7 +205,6 @@ main = ...@@ -203,7 +205,6 @@ main =
DoEval exprs -> interactiveUI srcs $ Just $ reverse exprs DoEval exprs -> interactiveUI srcs $ Just $ reverse exprs
liftIO $ dumpFinalStats dflags3 liftIO $ dumpFinalStats dflags3
liftIO $ exitWith ExitSuccess
#ifndef GHCI #ifndef GHCI
interactiveUI :: b -> c -> Ghc () interactiveUI :: b -> c -> Ghc ()
...@@ -258,42 +259,42 @@ looks_like_an_input m = isSourceFilename m ...@@ -258,42 +259,42 @@ looks_like_an_input m = isSourceFilename m
-- | Ensure sanity of options. -- | Ensure sanity of options.
-- --
-- Throws 'UsageError' or 'CmdLineError' if not. -- Throws 'UsageError' or 'CmdLineError' if not.
checkOptions :: CmdLineMode -> DynFlags -> [(String,Maybe Phase)] -> [String] -> IO () checkOptions :: PostLoadMode -> DynFlags -> [(String,Maybe Phase)] -> [String] -> IO ()
-- Final sanity checking before kicking off a compilation (pipeline). -- Final sanity checking before kicking off a compilation (pipeline).
checkOptions cli_mode dflags srcs objs = do checkOptions mode dflags srcs objs = do
-- Complain about any unknown flags -- Complain about any unknown flags
let unknown_opts = [ f | (f@('-':_), _) <- srcs ] let unknown_opts = [ f | (f@('-':_), _) <- srcs ]
when (notNull unknown_opts) (unknownFlagsErr unknown_opts) when (notNull unknown_opts) (unknownFlagsErr unknown_opts)
when (notNull (filter isRTSWay (wayNames dflags)) when (notNull (filter isRTSWay (wayNames dflags))
&& isInterpretiveMode cli_mode) $ && isInterpretiveMode mode) $
hPutStrLn stderr ("Warning: -debug, -threaded and -ticky are ignored by GHCi") hPutStrLn stderr ("Warning: -debug, -threaded and -ticky are ignored by GHCi")
-- -prof and --interactive are not a good combination -- -prof and --interactive are not a good combination
when (notNull (filter (not . isRTSWay) (wayNames dflags)) when (notNull (filter (not . isRTSWay) (wayNames dflags))
&& isInterpretiveMode cli_mode) $ && isInterpretiveMode mode) $
do ghcError (UsageError do ghcError (UsageError
"--interactive can't be used with -prof or -unreg.") "--interactive can't be used with -prof or -unreg.")
-- -ohi sanity check -- -ohi sanity check
if (isJust (outputHi dflags) && if (isJust (outputHi dflags) &&
(isCompManagerMode cli_mode || srcs `lengthExceeds` 1)) (isCompManagerMode mode || srcs `lengthExceeds` 1))
then ghcError (UsageError "-ohi can only be used when compiling a single source file") then ghcError (UsageError "-ohi can only be used when compiling a single source file")
else do else do
-- -o sanity checking -- -o sanity checking
if (srcs `lengthExceeds` 1 && isJust (outputFile dflags) if (srcs `lengthExceeds` 1 && isJust (outputFile dflags)
&& not (isLinkMode cli_mode)) && not (isLinkMode mode))
then ghcError (UsageError "can't apply -o to multiple source files") then ghcError (UsageError "can't apply -o to multiple source files")
else do else do
let not_linking = not (isLinkMode cli_mode) || isNoLink (ghcLink dflags) let not_linking = not (isLinkMode mode) || isNoLink (ghcLink dflags)
when (not_linking && not (null objs)) $ when (not_linking && not (null objs)) $
hPutStrLn stderr ("Warning: the following files would be used as linker inputs, but linking is not being done: " ++ unwords objs) hPutStrLn stderr ("Warning: the following files would be used as linker inputs, but linking is not being done: " ++ unwords objs)
-- Check that there are some input files -- Check that there are some input files
-- (except in the interactive case) -- (except in the interactive case)
if null srcs && (null objs || not_linking) && needsInputsMode cli_mode if null srcs && (null objs || not_linking) && needsInputsMode mode
then ghcError (UsageError "no input files") then ghcError (UsageError "no input files")
else do else do
...@@ -332,38 +333,102 @@ verifyOutputFiles dflags = do ...@@ -332,38 +333,102 @@ verifyOutputFiles dflags = do
----------------------------------------------------------------------------- -----------------------------------------------------------------------------
-- GHC modes of operation -- GHC modes of operation
data UberMode type Mode = Either PreStartupMode PostStartupMode
= ShowUsage -- ghc -? type PostStartupMode = Either PreLoadMode PostLoadMode
| ShowVersion -- ghc -V/--version
data PreStartupMode
= ShowVersion -- ghc -V/--version
| ShowNumVersion -- ghc --numeric-version | ShowNumVersion -- ghc --numeric-version
| ShowSupportedLanguages -- ghc --supported-languages | ShowSupportedLanguages -- ghc --supported-languages
| ShowInfo -- ghc --info | Print String -- ghc --print-foo
deriving (Show)
showVersionMode, showNumVersionMode, showSupportedLanguagesMode :: Mode
showVersionMode = mkPreStartupMode ShowVersion
showNumVersionMode = mkPreStartupMode ShowNumVersion
showSupportedLanguagesMode = mkPreStartupMode ShowSupportedLanguages
printMode :: String -> Mode
printMode str = mkPreStartupMode (Print str)
mkPreStartupMode :: PreStartupMode -> Mode
mkPreStartupMode = Left
isShowVersionMode :: Mode -> Bool
isShowVersionMode (Left ShowVersion) = True
isShowVersionMode _ = False
isShowNumVersionMode :: Mode -> Bool
isShowNumVersionMode (Left ShowNumVersion) = True
isShowNumVersionMode _ = False
data PreLoadMode
= ShowGhcUsage -- ghc -?
| ShowGhciUsage -- ghci -?
| ShowInfo -- ghc --info
| PrintWithDynFlags (DynFlags -> String) -- ghc --print-foo
showGhcUsageMode, showGhciUsageMode, showInfoMode :: Mode
showGhcUsageMode = mkPreLoadMode ShowGhcUsage
showGhciUsageMode = mkPreLoadMode ShowGhciUsage
showInfoMode = mkPreLoadMode ShowInfo
printWithDynFlagsMode :: (DynFlags -> String) -> Mode
printWithDynFlagsMode f = mkPreLoadMode (PrintWithDynFlags f)
mkPreLoadMode :: PreLoadMode -> Mode
mkPreLoadMode = Right . Left
isShowGhcUsageMode :: Mode -> Bool
isShowGhcUsageMode (Right (Left ShowGhcUsage)) = True
isShowGhcUsageMode _ = False
isShowGhciUsageMode :: Mode -> Bool
isShowGhciUsageMode (Right (Left ShowGhciUsage)) = True
isShowGhciUsageMode _ = False
data CmdLineMode data PostLoadMode
= PrintLibdir -- ghc --print-libdir = ShowInterface FilePath -- ghc --show-iface
| ShowInterface String -- ghc --show-iface
| DoMkDependHS -- ghc -M | DoMkDependHS -- ghc -M
| StopBefore Phase -- ghc -E | -C | -S | StopBefore Phase -- ghc -E | -C | -S
-- StopBefore StopLn is the default -- StopBefore StopLn is the default
| DoMake -- ghc --make | DoMake -- ghc --make
| DoInteractive -- ghc --interactive | DoInteractive -- ghc --interactive
| DoEval [String] -- ghc -e foo -e bar => DoEval ["bar", "foo"] | DoEval [String] -- ghc -e foo -e bar => DoEval ["bar", "foo"]
deriving (Show)
doMkDependHSMode, doMakeMode, doInteractiveMode :: Mode
doMkDependHSMode = mkPostLoadMode DoMkDependHS
doMakeMode = mkPostLoadMode DoMake
doInteractiveMode = mkPostLoadMode DoInteractive
showInterfaceMode :: FilePath -> Mode
showInterfaceMode fp = mkPostLoadMode (ShowInterface fp)
stopBeforeMode :: Phase -> Mode
stopBeforeMode phase = mkPostLoadMode (StopBefore phase)
doEvalMode :: String -> Mode
doEvalMode str = mkPostLoadMode (DoEval [str])
mkPostLoadMode :: PostLoadMode -> Mode
mkPostLoadMode = Right . Right
isDoInteractiveMode :: Mode -> Bool
isDoInteractiveMode (Right (Right DoInteractive)) = True
isDoInteractiveMode _ = False
#ifdef GHCI #ifdef GHCI
isInteractiveMode :: CmdLineMode -> Bool isInteractiveMode :: PostLoadMode -> Bool
isInteractiveMode DoInteractive = True isInteractiveMode DoInteractive = True
isInteractiveMode _ = False isInteractiveMode _ = False
#endif #endif
-- isInterpretiveMode: byte-code compiler involved -- isInterpretiveMode: byte-code compiler involved
isInterpretiveMode :: CmdLineMode -> Bool isInterpretiveMode :: PostLoadMode -> Bool
isInterpretiveMode DoInteractive = True isInterpretiveMode DoInteractive = True
isInterpretiveMode (DoEval _) = True isInterpretiveMode (DoEval _) = True
isInterpretiveMode _ = False isInterpretiveMode _ = False
needsInputsMode :: CmdLineMode -> Bool needsInputsMode :: PostLoadMode -> Bool
needsInputsMode DoMkDependHS = True needsInputsMode DoMkDependHS = True
needsInputsMode (StopBefore _) = True needsInputsMode (StopBefore _) = True
needsInputsMode DoMake = True needsInputsMode DoMake = True
...@@ -371,14 +436,14 @@ needsInputsMode _ = False ...@@ -371,14 +436,14 @@ needsInputsMode _ = False
-- True if we are going to attempt to link in this mode. -- True if we are going to attempt to link in this mode.
-- (we might not actually link, depending on the GhcLink flag) -- (we might not actually link, depending on the GhcLink flag)
isLinkMode :: CmdLineMode -> Bool isLinkMode :: PostLoadMode -> Bool
isLinkMode (StopBefore StopLn) = True isLinkMode (StopBefore StopLn) = True
isLinkMode DoMake = True isLinkMode DoMake = True
isLinkMode DoInteractive = True isLinkMode DoInteractive = True
isLinkMode (DoEval _) = True isLinkMode (DoEval _) = True
isLinkMode _ = False isLinkMode _ = False
isCompManagerMode :: CmdLineMode -> Bool isCompManagerMode :: PostLoadMode -> Bool
isCompManagerMode DoMake = True isCompManagerMode DoMake = True
isCompManagerMode DoInteractive = True isCompManagerMode DoInteractive = True
isCompManagerMode (DoEval _) = True isCompManagerMode (DoEval _) = True
...@@ -389,96 +454,125 @@ isCompManagerMode _ = False ...@@ -389,96 +454,125 @@ isCompManagerMode _ = False
-- Parsing the mode flag -- Parsing the mode flag
parseModeFlags :: [Located String] parseModeFlags :: [Located String]
-> IO (Maybe UberMode, -> IO (Mode,
CmdLineMode,
[Located String], [Located String],
[Located String]) [Located String])
parseModeFlags args = do parseModeFlags args = do
let ((leftover, errs, warns), (mUberMode, mode, _, flags')) = let ((leftover, errs1, warns), (mModeFlag, errs2, flags')) =
runCmdLine (processArgs mode_flags args) runCmdLine (processArgs mode_flags args)
(Nothing, StopBefore StopLn, "", []) (Nothing, [], [])
mode = case mModeFlag of
Nothing -> stopBeforeMode StopLn
Just (m, _) -> m
errs = errs1 ++ map (mkGeneralLocated "on the commandline") errs2
when (not (null errs)) $ ghcError $ errorsToGhcException errs when (not (null errs)) $ ghcError $ errorsToGhcException errs
return (mUberMode, mode, flags' ++ leftover, warns) return (mode, flags' ++ leftover, warns)
type ModeM = CmdLineP (Maybe UberMode, CmdLineMode, String, [Located String]) type ModeM = CmdLineP (Maybe (Mode, String), [String], [Located String])
-- mode flags sometimes give rise to new DynFlags (eg. -C, see below) -- mode flags sometimes give rise to new DynFlags (eg. -C, see below)
-- so we collect the new ones and return them. -- so we collect the new ones and return them.
mode_flags :: [Flag ModeM] mode_flags :: [Flag ModeM]
mode_flags = mode_flags =
[ ------- help / version ---------------------------------------------- [ ------- help / version ----------------------------------------------
Flag "?" (NoArg (setUberMode ShowUsage)) Flag "?" (PassFlag (setMode showGhcUsageMode))
Supported Supported
, Flag "-help" (NoArg (setUberMode ShowUsage)) , Flag "-help" (PassFlag (setMode showGhcUsageMode))
Supported Supported
, Flag "V" (NoArg (setUberMode ShowVersion)) , Flag "V" (PassFlag (setMode showVersionMode))
Supported Supported
, Flag "-version" (NoArg (setUberMode ShowVersion)) , Flag "-version" (PassFlag (setMode showVersionMode))
Supported Supported
, Flag "-numeric-version" (NoArg (setUberMode ShowNumVersion)) , Flag "-numeric-version" (PassFlag (setMode showNumVersionMode))
Supported Supported
, Flag "-info" (NoArg (setUberMode ShowInfo)) , Flag "-info" (PassFlag (setMode showInfoMode))
Supported Supported
, Flag "-supported-languages" (NoArg (setUberMode ShowSupportedLanguages)) , Flag "-supported-languages" (PassFlag (setMode showSupportedLanguagesMode))
Supported Supported
, Flag "-print-libdir" (PassFlag (setMode PrintLibdir)) ] ++
[ Flag k' (PassFlag (setMode mode))
Supported Supported
| (k, v) <- compilerInfo,
let k' = "-print-" ++ map (replaceSpace . toLower) k
replaceSpace ' ' = '-'
replaceSpace c = c
mode = case v of
String str -> printMode str
FromDynFlags f -> printWithDynFlagsMode f
] ++
------- interfaces ---------------------------------------------------- ------- interfaces ----------------------------------------------------
, Flag "-show-iface" (HasArg (\f -> setMode (ShowInterface f) [ Flag "-show-iface" (HasArg (\f -> setMode (showInterfaceMode f)
"--show-iface")) "--show-iface"))
Supported Supported
------- primary modes ------------------------------------------------ ------- primary modes ------------------------------------------------
, Flag "M" (PassFlag (setMode DoMkDependHS)) , Flag "M" (PassFlag (setMode doMkDependHSMode))
Supported Supported
, Flag "E" (PassFlag (setMode (StopBefore anyHsc))) , Flag "E" (PassFlag (setMode (stopBeforeMode anyHsc)))